All steps

Every step Axx understands, one per line: pack | id | expression. {name} is a parameter (see parameter types); [[...]] are optional words, said or left out; (+ .on) marks a step that also has an <id>.on form, for a named service. Search this file instead of inventing step text; with Axx installed, axx steps search <words> finds steps and axx steps show <id> documents one.

rest | rest.service | the {word} service with the following properties:  [+table | property | value |]
rest | rest.openapi.levels | the OpenAPI validation levels[[ on {service}]] are:  [+table | validation key | level |]
rest | rest.request | a(n) {word} request to {word}[[ on {service}]]
rest | rest.request.ordered | a {ordinal} ordered {word} request to {word}[[ on {service}]]
rest | rest.request.header | the request header {word} is {string}[[ for {ordinal} ordered request]]  (+ .on)
rest | rest.request.headers | the request headers[[ for {ordinal} ordered request]] are:  [+table | header | value |]  (+ .on)
rest | rest.request.payload.empty | a request payload using a(n) {mimeType} empty content template[[ for {ordinal} ordered request]]  (+ .on)
rest | rest.request.payload.example | a request payload using a(n) {mimeType} content example[[ named {string}]][[ for {ordinal} ordered request]]  (+ .on)
rest | rest.request.payload.resource | a request payload using a(n) {mimeType} {filepath} resource[[ for {ordinal} ordered request]]  (+ .on)
rest | rest.request.property | the request payload property {word} is {string}[[ for {ordinal} ordered request]]  (+ .on)
rest | rest.request.properties | the request payload properties[[ for {ordinal} ordered request]] are:  [+table | JSONPath | value |]  (+ .on)
rest | rest.request.property.null | the request payload property {word} is null[[ for {ordinal} ordered request]]  (+ .on)
rest | rest.execute | the[[ {ordinal} ordered]] request is executed[[ on {service}]]
rest | rest.response.status | the[[ {ordinal} ordered]] response status code is {int}[[ on {service}]]
rest | rest.response.body.contains | the response body contains {string}[[ for {ordinal} ordered response]]  (+ .on)
rest | rest.response.header.is | the response header {word} is {string}[[ for {ordinal} ordered response]]  (+ .on)
rest | rest.response.header.matches | the response header {word} matches {pattern}[[ for {ordinal} ordered response]]  (+ .on)
rest | rest.response.header.missing | the response header {word} is missing[[ for {ordinal} ordered response]]  (+ .on)
rest | rest.response.headers.are | the response headers[[ for {ordinal} ordered response]] are:  [+table | header | value |]  (+ .on)
rest | rest.response.headers.match | the response headers[[ for {ordinal} ordered response]] match:  [+table | header | regular expression |]  (+ .on)
rest | rest.response.headers.missing | the response headers[[ for {ordinal} ordered response]] are missing:  [+table | header |]  (+ .on)
rest | rest.response.property.is | the response payload property {word} is {string}[[ for {ordinal} ordered response]]  (+ .on)
rest | rest.response.property.null | the response payload property {word} is null[[ for {ordinal} ordered response]]  (+ .on)
rest | rest.response.property.undefined | the response payload property {word} is undefined[[ for {ordinal} ordered response]]  (+ .on)
rest | rest.response.property.matches | the response payload property {word} matches {pattern}[[ for {ordinal} ordered response]]  (+ .on)
rest | rest.response.properties.are | the response payload properties[[ for {ordinal} ordered response]] are:  [+table | JSONPath | value |]  (+ .on)
rest | rest.response.properties.match | the response payload properties[[ for {ordinal} ordered response]] match:  [+table | JSONPath | regular expression |]  (+ .on)
rest | rest.token | the {word} token with the following properties:  [+table | property | value |]
rest | rest.request.token | the request is authorized with the {word} token[[ for {ordinal} ordered request]]  (+ .on)
rest | rest.request.signed | the request is signed in the {word} header[[ for {ordinal} ordered request]] with the following properties:  [+table | property | value |]  (+ .on)
rest | rest.request.webhook | the request is signed as a standard webhook with the key {string}[[ for {ordinal} ordered request]]  (+ .on)
mock | mock.service | the mocked {word} service with the following properties:  [+table | property | value |]
mock | mock.received | the mocked {word} request to {word} named {word} was received by {mockedService}
mock | mock.received.path | the mocked {word} request to path {word} named {word} was received by {mockedService}
mock | mock.openapi.levels | the OpenAPI validation levels for the mocked {mockedService} service are:  [+table | validation key | level |]
mock | mock.count.exactly | the mocked request named {word}[[ on {mockedService}]] was received exactly {int} time(s)
mock | mock.count.atLeast | the mocked request named {word}[[ on {mockedService}]] was received at least {int} time(s)
mock | mock.count.atMost | the mocked request named {word}[[ on {mockedService}]] was received at most {int} time(s)
mock | mock.notReceived | the mocked {word} request to {word} named {word}[[ on {mockedService}]] was not received
mock | mock.notReceived.path | the mocked {word} request to path {word} named {word}[[ on {mockedService}]] was not received
mock | mock.header.is | the header {word} for mocked request named {word}[[ on {mockedService}]] is {string}
mock | mock.headers.are | the headers for mocked request named {word} on {mockedService} are:  [+table | header | value |]
mock | mock.header.matches | the header {word} for mocked request named {word} on {mockedService} matches {pattern}
mock | mock.headers.match | the headers for mocked request named {word} on {mockedService} match:  [+table | header | regular expression |]
mock | mock.header.missing | the header {word} for mocked request named {word} on {mockedService} is missing
mock | mock.headers.missing | the headers for mocked request named {word} on {mockedService} are missing:  [+table | header |]
mock | mock.properties.are | the payload properties for mocked request named {word}[[ on {mockedService}]] are:  [+table | property | value |]
mock | mock.query.are | the query parameters for mocked request named {word}[[ on {mockedService}]] are:  [+table | parameter | value |]
mock | mock.form.are | the form fields for mocked request named {word}[[ on {mockedService}]] are:  [+table | field | value |]
mock | mock.query.none | none of the mocked {word} requests to path {word}[[ on {mockedService}]] have the query parameters:  [+table | parameter | value |]
mock | mock.properties.none | none of the mocked {word} requests to path {word}[[ on {mockedService}]] have the payload properties:  [+table | property | value |]
mock | mock.form.none | none of the mocked {word} requests to path {word}[[ on {mockedService}]] have the form fields:  [+table | field | value |]
mock | mock.signed | the mocked request named {word}[[ on {mockedService}]] is signed in the {word} header with the following properties:  [+table | property | value |]
mock | mock.webhook | the mocked request named {word}[[ on {mockedService}]] is signed as a standard webhook with the key {string}
mock | mock.model.asked | the mocked {mockedService} model was asked about {string}[[ {int} time(s)]]
mock | mock.model.contains | the mocked {mockedService} model's request about {string} contains {string}
mock | mock.model.notContains | the mocked {mockedService} model's request about {string} does not contain {string}
mock | mock.model.tool | the mocked {mockedService} model was offered the {word} tool in the request about {string}
mock | mock.model.schema | the mocked {mockedService} model was asked for the {filepath} schema in the request about {string}
mock | mock.mcp.called | the mocked {mockedService} mcp server's {word} tool was called[[ {int} time(s)]] with the following arguments:  [+table | argument | value |]
mock | mock.a2a.sent | the mocked {mockedService} a2a agent was sent a message containing {string}[[ {int} time(s)]]
grpc | grpc.service | the {word} grpc service with the following properties:  [+table | property | value |]
grpc | grpc.call | the {word} method is called on the {word} grpc service
grpc | grpc.call.fields | the {word} method is called on the {word} grpc service with the following fields:  [+table | path | value |]
grpc | grpc.call.file | the {word} method is called on the {word} grpc service with the {filepath} message[[ and the following fields:]]
grpc | grpc.status | [[within {duration} ]]the {word} grpc service answered {word}[[ with a message containing {string}]]
grpc | grpc.answer | the {word} grpc service's answer has the following fields:  [+table | path | value |]
grpc | grpc.metadata | the {word} grpc service's answer has the following metadata:  [+table | name | value |]
grpc | grpc.streamed | [[within {duration} ]]the {word} grpc service streamed a message where:  [+table | path | value |]
jsonrpc | jsonrpc.service | the {word} jsonrpc service with the following properties:  [+table | property | value |]
jsonrpc | jsonrpc.call | the {word} method is called on the {word} jsonrpc service
jsonrpc | jsonrpc.call.params | the {word} method is called on the {word} jsonrpc service with the following params:  [+table | path | value |]
jsonrpc | jsonrpc.call.doc | the {word} method is called on the {word} jsonrpc service with the params:  [+docstring]
jsonrpc | jsonrpc.result | the {word} jsonrpc service's result has the following properties:  [+table | path | value |]
jsonrpc | jsonrpc.result.is | the {word} jsonrpc service's result is {string}
jsonrpc | jsonrpc.error | the {word} jsonrpc service answered the error {int}[[ with a message containing {string}]]
jsonrpc | jsonrpc.error.properties | the {word} jsonrpc service's error has the following properties:  [+table | path | value |]
jsonrpc | jsonrpc.openrpc.levels | the OpenRPC validation levels are:  [+table | validation key | level |]
graphql | graphql.service | the {word} graphql service with the following properties:  [+table | property | value |]
graphql | graphql.send.file | the {filepath} query/mutation is sent to the {word} graphql service[[ with the following variables:]]
graphql | graphql.send.doc | a query/mutation is sent to the {word} graphql service:  [+docstring]
graphql | graphql.subscribe | the {filepath} subscription is started on the {word} graphql service[[ with the following variables:]]
graphql | graphql.no.errors | the {word} graphql service answered without errors
graphql | graphql.data | the {word} graphql service's data has the following properties:  [+table | path | value |]
graphql | graphql.error | the {word} graphql service answered an error where:  [+table | path | value |]
graphql | graphql.received | [[within {duration} ]]the {word} graphql service's subscription received a message where:  [+table | path | value |]
graphql | graphql.levels | the GraphQL validation levels are:  [+table | validation key | level |]
mcp | mcp.server | the {word} mcp server with the following properties:  [+table | property | value |]
mcp | mcp.tool | the {word} mcp server has the {word} tool[[ with the following properties:]]
mcp | mcp.noTool | the {word} mcp server does not have the {word} tool
mcp | mcp.call | the {word} tool is called on the {word} mcp server[[ with the following arguments:]]
mcp | mcp.call.file | the {word} tool is called on the {word} mcp server with the {filepath} arguments
mcp | mcp.notError | the {word} tool's result[[ on the {word} mcp server]] is not an error
mcp | mcp.error | the {word} tool's result[[ on the {word} mcp server]] is an error
mcp | mcp.contains | the {word} tool's result[[ on the {word} mcp server]] contains {string}
mcp | mcp.properties | the {word} tool's result[[ on the {word} mcp server]] has the following properties:  [+table | property | value |]
mcp | mcp.refused | the {word} tool's call[[ on the {word} mcp server]] failed with the error code {int}
mcp | mcp.resource.read | the {word} resource is read from the {word} mcp server
mcp | mcp.resource.contains | the {word} resource contains {string}
mcp | mcp.resource.properties | the {word} resource has the following properties:  [+table | property | value |]
mcp | mcp.prompt | the {word} prompt is requested from the {word} mcp server[[ with the following arguments:]]
mcp | mcp.prompt.contains | the {word} prompt contains {string}
mcp | mcp.levels | the MCP validation levels are:  [+table | validation key | level |]
a2a | a2a.agent | the {word} a2a agent with the following properties:  [+table | property | value |]
a2a | a2a.card | the {word} a2a agent's card has the following properties:  [+table | property | value |]
a2a | a2a.skill | the {word} a2a agent has the {word} skill
a2a | a2a.send | a message is sent to the {word} a2a agent:  [+docstring]
a2a | a2a.send.file | the {filepath} message is sent to the {word} a2a agent
a2a | a2a.stream | a message is streamed to the {word} a2a agent:  [+docstring]
a2a | a2a.reply | a reply is sent to the {word} a2a agent:  [+docstring]
a2a | a2a.cancel | the {word} a2a agent is asked to cancel its task
a2a | a2a.state | [[within {duration} ]]the {word} a2a agent's task is {word}
a2a | a2a.answer | the {word} a2a agent's answer contains {string}
a2a | a2a.artifact | the {word} a2a agent's task has an artifact where:  [+table | property | value |]
a2a | a2a.update | [[within {duration} ]]the {word} a2a agent's stream received an update where:  [+table | property | value |]
sql | sql.service | a(n) {word} database with the following properties:  [+table | property | value |]
sql | sql.seed | a {filepath} db seed[[ on {dbService}]]
sql | sql.lock | the rows in the {word} table[[ on {dbService}]] are locked where:  [+table | column | value |]
sql | sql.unlock | the row locks[[ on {dbService}]] are released
sql | sql.select | a[[ {ordinal}]] selection of rows is retrieved from the {word} table[[ on {dbService}]] where:  [+table | column | value |]
sql | sql.select.poll | within {duration} a[[ {ordinal}]] selection of at least {int} row(s) is retrieved from the {word} table[[ on {dbService}]] where:  [+table | column | value |]
sql | sql.select.jsonb | a[[ {ordinal}]] selection of rows is retrieved from the {word} table[[ on {dbService}]] where the {word} jsonb column contains:  [+table | property | value |]
sql | sql.json.are | the {ordinal} row {word} property for the[[ {ordinal}]] selection[[ on {dbService}]] json properties are:  [+table | JSONPath | value |]
sql | sql.json.match | the {ordinal} row {word} property for the[[ {ordinal}]] selection[[ on {dbService}]] json properties match:  [+table | JSONPath | pattern |]
sql | sql.column.is | the {ordinal} row {word} column of the[[ {ordinal}]] selection[[ on {dbService}]] is {string}
sql | sql.rows.eq | the[[ {ordinal}]] selection[[ on {dbService}]] has {int} row(s)
sql | sql.rows.gt | the[[ {ordinal}]] selection[[ on {dbService}]] has more than {int} row(s)
sql | sql.rows.lt | the[[ {ordinal}]] selection[[ on {dbService}]] has fewer than {int} row(s)
sql | sql.trigger.raise | a(n)[[ {ordinal} ordered]] before insert trigger on the {word} table[[ on {dbService}]] will raise a(n) {sqlState} exception where:  [+table | column | value |]
sql | sql.trigger.raise.times | a(n)[[ {ordinal} ordered]] before insert trigger on the {word} table[[ on {dbService}]] will raise a(n) {sqlState} exception {int} time(s) where:  [+table | column | value |]
sql | sql.trigger.insertRaise | a(n)[[ {ordinal} ordered]] before insert trigger on the {word} table[[ on {dbService}]] will insert and raise a(n) {sqlState} exception where:  [+table | column | value |]
sql | sql.trigger.insertRaise.times | a(n)[[ {ordinal} ordered]] before insert trigger on the {word} table[[ on {dbService}]] will insert and raise a(n) {sqlState} exception {int} time(s) where:  [+table | column | value |]
sql | sql.trigger.raised | the[[ {ordinal} ordered]] before insert trigger on the {word} table[[ on {dbService}]] was raised {int} time(s)
sql | sql.trigger.update.raise | a(n)[[ {ordinal} ordered]] before update trigger on the {word} table[[ on {dbService}]] will raise a(n) {sqlState} exception where:  [+table | column | value |]
sql | sql.trigger.update.raise.times | a(n)[[ {ordinal} ordered]] before update trigger on the {word} table[[ on {dbService}]] will raise a(n) {sqlState} exception {int} time(s) where:  [+table | column | value |]
sql | sql.trigger.update.raised | the[[ {ordinal} ordered]] before update trigger on the {word} table[[ on {dbService}]] was raised {int} time(s)
sql | sql.trigger.delete.raise | a(n)[[ {ordinal} ordered]] before delete trigger on the {word} table[[ on {dbService}]] will raise a(n) {sqlState} exception where:  [+table | column | value |]
sql | sql.trigger.delete.raise.times | a(n)[[ {ordinal} ordered]] before delete trigger on the {word} table[[ on {dbService}]] will raise a(n) {sqlState} exception {int} time(s) where:  [+table | column | value |]
sql | sql.trigger.delete.raised | the[[ {ordinal} ordered]] before delete trigger on the {word} table[[ on {dbService}]] was raised {int} time(s)
mongo | mongo.service | a(n) {word} mongo database with the following properties:  [+table | property | value |]
mongo | mongo.seed | a {filepath} mongo db seed
mongo | mongo.seed.named | a {filepath} MongoDB seed for {word}
mongo | mongo.seed.named.alt | a {filepath} mongo db seed for {word}
mongo | mongo.find | a[[ {ordinal}]] selection of documents is retrieved from the {word} collection[[ on {mongoService}]] where:  [+table | field | value |]
mongo | mongo.find.poll | within {duration} a[[ {ordinal}]] selection of at least {int} document(s) is retrieved from the {word} collection[[ on {mongoService}]] where:  [+table | field | value |]
mongo | mongo.docs.eq | the[[ {ordinal}]] selection[[ on {mongoService}]] has {int} document(s)
mongo | mongo.docs.gt | the[[ {ordinal}]] selection[[ on {mongoService}]] has more than {int} document(s)
mongo | mongo.docs.lt | the[[ {ordinal}]] selection[[ on {mongoService}]] has fewer than {int} document(s)
mongo | mongo.doc.are | the {ordinal} document for the[[ {ordinal}]] selection[[ on {mongoService}]] properties are:  [+table | JSONPath | value |]
mongo | mongo.doc.match | the {ordinal} document for the[[ {ordinal}]] selection[[ on {mongoService}]] properties match:  [+table | JSONPath | pattern |]
redis | redis.server | the {word} redis server with the following properties:  [+table | property | value |]
redis | redis.seed | a {filepath} redis seed
redis | redis.value | [[within {duration} ]]the {word} redis key has the value {string}
redis | redis.properties | [[within {duration} ]]the {word} redis key has the following properties:  [+table | path | value |]
redis | redis.absent | [[within {duration} ]]the {word} redis key does not exist
kafka | kafka.service | the {word} kafka service with the following properties:  [+table | property | value |]
kafka | kafka.client | the {word} kafka topic client
kafka | kafka.client.props | a(n) {word} kafka topic client[[ on the {word} kafka service]] with the following properties:  [+table | property | value |]
kafka | kafka.event | a(n)[[ {ordinal} ordered]] {word} kafka event[[ on {word} kafka service]]
kafka | kafka.event.key | the[[ {ordinal} ordered]] {word} kafka event key is {word}[[ on the {word} kafka service]]
kafka | kafka.event.headers | the[[ {ordinal} ordered]] {word} kafka event headers[[ on the {word} kafka service]] are:  [+table | header | value |]
kafka | kafka.event.payload.resource | the[[ {ordinal} ordered]] {word} kafka event payload is a(n) {filepath} resource[[ on the {word} kafka service]]
kafka | kafka.event.properties.first | the[[ {ordinal} ordered]] kafka event payload properties[[ on the {word} kafka service]] are:  [+table | JSONPath | value |]
kafka | kafka.event.properties | the {word} kafka event payload properties[[ on the {word} kafka service]] are:  [+table | JSONPath | value |]
kafka | kafka.event.properties.ordinal | the {ordinal} ordered {word} kafka event payload properties[[ on the {word} kafka service]] are:  [+table | JSONPath | value |]
kafka | kafka.event.property.null | the[[ {ordinal} ordered]] {word} kafka event payload property {word} is null[[ on the {word} kafka service]]
kafka | kafka.event.publish.schema | the[[ {ordinal} ordered]] {word} kafka event is published using schema {filepath}[[ on the {word} kafka service]]
kafka | kafka.event.publish | the[[ {ordinal} ordered]] {word} kafka event is published[[ on the {word} kafka service]]
kafka | kafka.consumed.key | the {word} kafka event named {word} key is {word}[[ on the {word} kafka service]]
kafka | kafka.consumed.properties | the {word} kafka event named {word} payload properties[[ on the {word} kafka service]] are:  [+table | JSONPath | value |]
kafka | kafka.consumed.headers | the {word} kafka event named {word} headers[[ on the {word} kafka service]] are:  [+table | header | value |]
kafka | kafka.consumed.headers.match | the {word} kafka event named {word} headers match:  [+table | header | pattern |]
kafka | kafka.consumed.headers.match.service | the {word} kafka event named {word} headers on the {word} kafka service match:  [+table | header | pattern |]
amqp | amqp.broker | the {word} amqp broker with the following properties:  [+table | property | value |]
amqp | amqp.queue.send | a message is sent to the {word} amqp queue:  [+docstring]
amqp | amqp.queue.send.file | the {filepath} message is sent to the {word} amqp queue[[ with the following properties:]]
amqp | amqp.queue.received | [[within {duration} ]]the {word} amqp queue has a message where:  [+table | path | value |]
amqp | amqp.exchange.send | a message is published to the {word} amqp exchange[[ with the routing key {string}]]:  [+docstring]
amqp | amqp.exchange.send.file | the {filepath} message is published to the {word} amqp exchange[[ with the following properties:]]
amqp | amqp.exchange.received | [[within {duration} ]]the {word} amqp exchange has a message where:  [+table | path | value |]
mqtt | mqtt.broker | the {word} mqtt broker with the following properties:  [+table | property | value |]
mqtt | mqtt.send | a message is published to the {word} mqtt topic:  [+docstring]
mqtt | mqtt.send.file | the {filepath} message is published to the {word} mqtt topic[[ with the following properties:]]
mqtt | mqtt.received | [[within {duration} ]]the {word} mqtt topic has a message where:  [+table | path | value |]
nats | nats.server | the {word} nats server with the following properties:  [+table | property | value |]
nats | nats.subject.send | a message is published to the {word} nats subject:  [+docstring]
nats | nats.subject.send.file | the {filepath} message is published to the {word} nats subject[[ with the following headers:]]
nats | nats.subject.received | [[within {duration} ]]the {word} nats subject has a message where:  [+table | path | value |]
nats | nats.stream.received | [[within {duration} ]]the {word} nats stream has a message where:  [+table | path | value |]
logs | logs.log | the {word} log with the following properties:  [+table | property | value |]
logs | logs.entry | [[within {duration} ]]the {word} log has an entry matching {string}
logs | logs.entries | [[within {duration} ]]the {word} log has entries matching:  [+table | pattern |]
logs | logs.count | [[within {duration} ]]the {word} log has {int} entry/entries matching {string}
logs | logs.across | [[within {duration} ]]the logs have entries matching:  [+table | log | pattern |]
files | files.folder | the {word} folder with the following properties:  [+table | property | value |]
files | files.copy | the {path} file in the {word} folder is a copy of the {filepath} file
files | files.content | the {path} file in the {word} folder has the content:  [+docstring]
files | files.emptied | the {word} folder is emptied
files | files.has | [[within {duration} ]]the {word} folder has a(n) file named {path}
files | files.identical | [[within {duration} ]]the {path} file in the {word} folder is identical to the {filepath} file
files | files.properties | [[within {duration} ]]the {path} file in the {word} folder has the following properties:  [+table | path | value |]
files | files.contains | [[within {duration} ]]the {path} file in the {word} folder contains {string}
files | files.row | [[within {duration} ]]the {path} file in the {word} folder has a row where:  [+table | column | value |]
files | files.absent | [[within {duration} ]]the {word} folder has no file named {path}
files | files.empty | [[within {duration} ]]the {word} folder is empty
files | files.screenshot | [[within {duration} ]]the {path} file in the {word} folder looks like the {string} screenshot
mail | mail.mailbox | the {word} mailbox with the following properties:  [+table | property | value |]
mail | mail.received | [[within {duration} ]]the {word} mailbox has an email where:  [+table | field | value |]
faults | faults.proxy | the {word} fault proxy with the following properties:  [+table | property | value |]
faults | faults.cutoff | the {connection} connection is cut off[[ for {duration}]]
faults | faults.slowed | the {connection} connection is slowed by {duration}[[ {dataDirection}]][[ on {int}% of connections]][[ for {duration}]]
faults | faults.limited | the {connection} connection is limited to {int} KB\/s[[ {dataDirection}]][[ on {int}% of connections]][[ for {duration}]]
faults | faults.hangs | the {connection} connection hangs[[ {dataDirection}]][[ on {int}% of connections]][[ for {duration}]]
faults | faults.hangs.closes | the {connection} connection hangs for {duration}, then closes[[ {dataDirection}]][[ on {int}% of connections]][[ for {duration}]]
faults | faults.reset | the {connection} connection is reset[[ {dataDirection}]][[ on {int}% of connections]][[ for {duration}]]
faults | faults.reset.after | the {connection} connection is reset after {duration}[[ {dataDirection}]][[ on {int}% of connections]][[ for {duration}]]
faults | faults.slowclose | the {connection} connection takes {duration} to close[[ {dataDirection}]][[ on {int}% of connections]][[ for {duration}]]
faults | faults.pieces | the {connection} connection breaks into {int}-byte pieces, {duration} apart[[ {dataDirection}]][[ on {int}% of connections]][[ for {duration}]]
faults | faults.closes.after | the {connection} connection closes after {int} KB[[ {dataDirection}]][[ on {int}% of connections]][[ for {duration}]]
faults | faults.closes.after.bytes | the {connection} connection closes after {int} bytes[[ {dataDirection}]][[ on {int}% of connections]][[ for {duration}]]
faults | faults.loses | the {connection} connection loses {int}% of its data[[ {dataDirection}]][[ on {int}% of connections]][[ for {duration}]]
faults | faults.toxic | the {connection} connection has a(n) {word} toxic with the following attributes:  [+table | attribute | value |]
faults | faults.restored | the {connection} connection is restored
otel | otel.telemetry | the {word} telemetry with the following properties:  [+table | property | value |]
otel | otel.trace.span | [[within {duration} ]]the trace has a span where:  [+table | field | value |]
otel | otel.trace.nospan | the trace has no span where:  [+table | field | value |]
otel | otel.trace.child | the {string} span is a child of the {string} span
otel | otel.trace.took | the {string} span took less than {duration}
otel | otel.trace.log | [[within {duration} ]]the trace has a log where:  [+table | field | value |]
otel | otel.counted | [[within {duration} ]]the {telemetry} telemetry counted {int} {word}[[ where:]]
otel | otel.recorded | [[within {duration} ]]the {telemetry} telemetry recorded {int} {word} values[[ where:]]
otel | otel.gauge | [[within {duration} ]]the {telemetry} telemetry's {word} gauge is {gaugeValue}[[ where:]]
otel | otel.contains.not | the telemetry does not contain {string}
cli | cli.command | the {word} command with the following properties:  [+table | property | value |]
cli | cli.run | the {word} command is run[[ with {string}]]
cli | cli.run.input | the {word} command is run with[[ {string} and]] the input:  [+docstring]
cli | cli.exit | the {word} command's exit code is {int}
cli | cli.output.contains | the {word} command's[[ error]] output contains {string}
cli | cli.output.line | the {word} command's[[ error]] output has a line matching {string}
cli | cli.output.is | the {word} command's[[ error]] output is:  [+docstring]
cli | cli.output.empty | the {word} command's[[ error]] output is empty
cli | cli.output.properties | the {word} command's output has the following properties:  [+table | path | value |]
cli | cli.output.identical | the {word} command's output is identical to the {filepath} file
websocket | websocket.connect | the {word} websocket with the following properties:  [+table | property | value |]
websocket | websocket.send | a message is sent to the {word} websocket:  [+docstring]
websocket | websocket.send.file | the {filepath} message is sent to the {word} websocket
websocket | websocket.received | [[within {duration} ]]the {word} websocket received a message where:  [+table | path | value |]
websocket | websocket.received.text | [[within {duration} ]]the {word} websocket received a message containing {string}
websocket | websocket.closed | [[within {duration} ]]the {word} websocket was closed with code {int}
sse | sse.stream | the {word} event stream with the following properties:  [+table | property | value |]
sse | sse.event | [[within {duration} ]]the {word} event stream has an event where:  [+table | path | value |]
sse | sse.event.text | [[within {duration} ]]the {word} event stream has an event containing {string}
asyncapi | asyncapi.levels | the AsyncAPI validation levels are:  [+table | validation key | level |]
web-core | web-core.app | the {word} web app with the following properties:  [+table | property | value |]
web-core | web-core.open | the {string} page[[ of the {word} web app]] is opened
web-core | web-core.fill | the {string} field is filled with {string}
web-core | web-core.select | {string} is chosen in the {string} field
web-core | web-core.option | the {string} option is chosen
web-core | web-core.check | the {string} checkbox is checked
web-core | web-core.uncheck | the {string} checkbox is unchecked
web-core | web-core.upload | the {filepath} file is uploaded in the {string} field
web-core | web-core.button | the {string} button is clicked
web-core | web-core.link | the {string} link is clicked
web-core | web-core.tab | the {string} tab is clicked
web-core | web-core.menuitem | the {string} menu item is clicked
web-core | web-core.element.click | the {string} element is clicked
web-core | web-core.key | the {word} key is pressed[[ in the {string} field]]
web-core | web-core.hover | the pointer is moved over {string}
web-core | web-core.reload | the page is reloaded
web-core | web-core.back | the browser's back button is clicked
web-core | web-core.closetab | the browser tab is closed
web-core | web-core.accept | the dialog is accepted
web-core | web-core.dismiss | the dialog is dismissed
web-core | web-core.answer | the dialog is answered with {string}
web-core | web-core.dialog | [[within {duration} ]]the dialog shows {string}
web-core | web-core.shows | [[within {duration} ]]the page shows {string}
web-core | web-core.hides | [[within {duration} ]]the page does not show {string}
web-core | web-core.url | [[within {duration} ]]the {string} page is shown
web-core | web-core.value | [[within {duration} ]]the {string} field has the value {string}
web-core | web-core.disabled | [[within {duration} ]]the {string} button is disabled
web-core | web-core.enabled | [[within {duration} ]]the {string} button is enabled
web-core | web-core.row | [[within {duration} ]]the page shows a table row where:  [+table | column | value |]
web-core | web-core.downloaded | [[within {duration} ]]the {string} file is downloaded
web-core | web-core.download.contains | the downloaded {string} file contains {string}
web-core | web-core.download.row | the downloaded {string} file has a row where:  [+table | column | value |]
web-core | web-core.download.identical | the downloaded {string} file is identical to the {filepath} file
web-core | web-core.element.shown | [[within {duration} ]]the {string} {element} is shown
web-core | web-core.element.hidden | [[within {duration} ]]the {string} {element} is not shown
web-core | web-core.element.text | [[within {duration} ]]the {string} {element} shows {string}
web-core | web-core.element.attribute | [[within {duration} ]]the {string} {element} has the {word} attribute {string}
web-core | web-core.element.focus | [[within {duration} ]]the {string} {element} has the focus
web-core | web-core.checkbox.ticked | [[within {duration} ]]the {string} checkbox is ticked
web-core | web-core.checkbox.unticked | [[within {duration} ]]the {string} checkbox is not ticked
web-core | web-core.option.selected | [[within {duration} ]]the {string} option is selected
web-core | web-core.option.unselected | [[within {duration} ]]the {string} option is not selected
web-core | web-core.field.disabled | [[within {duration} ]]the {string} field is disabled
web-core | web-core.field.enabled | [[within {duration} ]]the {string} field is enabled
web-core | web-core.element.count | [[within {duration} ]]the page shows {int} {string} {element}
web-core | web-core.row.count | [[within {duration} ]]the page shows {int} table row(s) where:  [+table | column | value |]
web-core | web-core.title | [[within {duration} ]]the page title is {string}
web-core | web-core.errors.none | the page has no script errors
web-core | web-core.request.sent | [[within {duration} ]]the browser sent a {word} request to {string}
web-core | web-core.element.dblclick | the {string} {element} is double-clicked
web-core | web-core.element.rightclick | the {string} {element} is right-clicked
web-core | web-core.element.tap | the {string} {element} is tapped
web-core | web-core.element.scroll | the {string} {element} is scrolled into view
web-core | web-core.element.drag | the {string} {element} is dragged onto the {string} {element}
web-core | web-core.scroll.bottom | the page is scrolled to the bottom
web-core | web-core.scroll.top | the page is scrolled to the top
web-core | web-core.select.many | the following options are chosen in the {string} field:  [+table | option |]
web-core | web-core.clock.set | the browser's clock is set to {string}
web-core | web-core.clock.forward | the browser's clock is moved forward by {duration}
web-core | web-core.connection.offline | the browser is offline
web-core | web-core.connection.online | the browser is online
web-screenshots | web-screenshots.page | [[within {duration} ]]the page looks like the {string} screenshot
web-screenshots | web-screenshots.page.masked | [[within {duration} ]]the page looks like the {string} screenshot, apart from:  [+table | element |]
web-screenshots | web-screenshots.element | [[within {duration} ]]the {string} {element} looks like the {string} screenshot
web-a11y | web-a11y.page | the page has no accessibility violations
web-a11y | web-a11y.element | the {string} {element} has no accessibility violations
web-a11y | web-a11y.structure | [[within {duration} ]]the page's accessible structure is:  [+docstring]
web-a11y | web-a11y.element.structure | [[within {duration} ]]the {string} {element}'s accessible structure is:  [+docstring]
web-network | web-network.fail | the page's requests to {string} fail
web-network | web-network.status | the page's requests to {string} answer with status {int}
web-network | web-network.file | the page's requests to {string} answer with the {filepath} file
web-network | web-network.slow | the page's requests to {string} take {duration}
web-network | web-network.connection.slow | the browser's connection is slow
web-network | web-network.recording | the page's requests are answered from the {filepath} recording
web-network | web-network.ws.sent | [[within {duration} ]]the page sent a websocket message containing {string}
web-network | web-network.ws.received | [[within {duration} ]]the page received a websocket message containing {string}
web-lighthouse | web-lighthouse.scores | the {string} page scores at least:  [+table | category | score |]
web-lighthouse | web-lighthouse.loads | the {string} page loads within:  [+table | metric | limit |]
app-core | app-core.launch | the {word} app is launched
app-core | app-core.restart | the {word} app is restarted
app-core | app-core.tapped | the {string} {control} is tapped in the {word} app
app-core | app-core.clicked | the {string} {control} is clicked in the {word} app
app-core | app-core.fill | the {string} field in the {word} app is filled with {string}
app-core | app-core.scroll | the {string} {control} is scrolled into view in the {word} app
app-core | app-core.shows | [[within {duration} ]]the {word} app shows {string}
app-core | app-core.hides | [[within {duration} ]]the {word} app does not show {string}
app-core | app-core.control.shown | [[within {duration} ]]the {string} {control} is shown in the {word} app
app-core | app-core.control.enabled | [[within {duration} ]]the {string} {control} is enabled in the {word} app
app-core | app-core.control.disabled | [[within {duration} ]]the {string} {control} is disabled in the {word} app
app-core | app-core.field.value | [[within {duration} ]]the {string} field in the {word} app has the value {string}
app-core | app-core.screenshot | [[within {duration} ]]the {word} app looks like the {string} screenshot
mobile-core | mobile-core.link | the {word} app is opened with the {string} link
mobile-core | mobile-core.background | the {word} app is sent to the background
mobile-core | mobile-core.foreground | the {word} app is brought back
mobile-core | mobile-core.swipe | the {word} app is swiped {direction}
mobile-core | mobile-core.dialog.accepted | the {word} app's dialog is accepted
mobile-core | mobile-core.dialog.dismissed | the {word} app's dialog is dismissed
mobile-core | mobile-core.dialog.shows | [[within {duration} ]]the {word} app's dialog shows {string}
mobile-core | mobile-core.camera-sees | the {word} app's camera sees {filepath}
mobile-core | mobile-core.phone-to-camera | the {word} app's phone moves to the scene's {string} camera
mobile-core | mobile-core.phone-path | the {word} app's phone {travel} the scene's {string} path[[ at {speed}]]
mobile-core | mobile-core.phone-move | the {word} app's phone moves {float} m {direction}
mobile-core | mobile-core.phone-turn | the {word} app's phone turns {int} degrees {direction}
mobile-core | mobile-core.camera-tap | the {string} in the {word} app's camera view is tapped
mobile-core | mobile-core.notification | [[within {duration} ]]the {word} app shows a notification {string}
mobile-core | mobile-core.notification-action | the {string} action of the {string} notification is tapped in the {word} app
mobile-core | mobile-core.background-task | the {string} background task is run in the {word} app
mobile-core | mobile-core.travel-through | the {word} app's phone {travel} at {speed} through:  [+table | latitude | longitude |]
mobile-core | mobile-core.travel-route | the {word} app's phone {travel} the {filepath} route[[ at {speed}]]
mobile-core | mobile-core.route-end | [[within {duration} ]]the {word} app's phone reaches the end of its route
mobile-android | mobile-android.app | the {word} android app with the following properties:  [+table | property | value |]
mobile-android | mobile-android.back | the {word} app's back button is pressed
mobile-ios | mobile-ios.app | the {word} ios app with the following properties:  [+table | property | value |]
desktop-core | desktop-core.key | the {word} key is pressed in the {word} app
desktop-core | desktop-core.click-at | the {string} {control} in the {word} app is clicked at {int}, {int}
desktop-core | desktop-core.click-at-anchor | the {string} {control} in the {word} app is clicked at {int}, {int} from its {anchor}
desktop-core | desktop-core.drag | the pointer is dragged from {int}, {int} to {int}, {int} on the {string} {control} in the {word} app
desktop-core | desktop-core.drag-from-anchor | the pointer is dragged from {int}, {int} to {int}, {int} from the {anchor} of the {string} {control} in the {word} app
desktop-macos | desktop-macos.app | the {word} macos app with the following properties:  [+table | property | value |]
desktop-windows | desktop-windows.app | the {word} windows app with the following properties:  [+table | property | value |]
desktop-linux | desktop-linux.app | the {word} linux app with the following properties:  [+table | property | value |]
models-core | models-core.microphone | the {word} app's microphone hears the {string} file
models-core | models-core.speaker | [[within {duration} ]]the {word} app's speaker plays the {string} file
aws-core | aws-core.account | the {word} aws account with the following properties:  [+table | property | value |]
aws-s3 | aws-s3.upload | the {filepath} file is uploaded to the {word} s3 bucket[[ as {path}]]
aws-s3 | aws-s3.has | [[within {duration} ]]the {word} s3 bucket has a(n) object named {path}
aws-s3 | aws-s3.identical | [[within {duration} ]]the {path} object in the {word} s3 bucket is identical to the {filepath} file
aws-s3 | aws-s3.properties | [[within {duration} ]]the {path} object in the {word} s3 bucket has the following properties:  [+table | path | value |]
aws-s3 | aws-s3.contains | [[within {duration} ]]the {path} object in the {word} s3 bucket contains {string}
aws-s3 | aws-s3.row | [[within {duration} ]]the {path} object in the {word} s3 bucket has a row where:  [+table | column | value |]
aws-sqs | aws-sqs.send | a message is sent to the {word} sqs queue:  [+docstring]
aws-sqs | aws-sqs.send.file | the {filepath} message is sent to the {word} sqs queue[[ with the following attributes:]]
aws-sqs | aws-sqs.received | [[within {duration} ]]the {word} sqs queue has a message where:  [+table | path | value |]
aws-sns | aws-sns.send | a message is published to the {word} sns topic:  [+docstring]
aws-sns | aws-sns.send.file | the {filepath} message is published to the {word} sns topic[[ with the following attributes:]]
aws-sns | aws-sns.received | [[within {duration} ]]the {word} sns topic has a message where:  [+table | path | value |]
aws-eventbridge | aws-eventbridge.put | a(n) {string} event from {word} is put on the {word} eventbridge bus:  [+docstring]
aws-eventbridge | aws-eventbridge.received | [[within {duration} ]]the {word} eventbridge bus has an event where:  [+table | path | value |]
aws-dynamodb | aws-dynamodb.seed | a {filepath} dynamodb seed
aws-dynamodb | aws-dynamodb.item | [[within {duration} ]]the {word} dynamodb table has an item where:  [+table | attribute | value |]
aws-dynamodb | aws-dynamodb.items | [[within {duration} ]]the {word} dynamodb table has {int} item(s) where:  [+table | attribute | value |]
gcp-core | gcp-core.project | the {word} gcp project with the following properties:  [+table | property | value |]
gcp-storage | gcp-storage.upload | the {filepath} file is uploaded to the {word} gcs bucket[[ as {path}]]
gcp-storage | gcp-storage.has | [[within {duration} ]]the {word} gcs bucket has a(n) object named {path}
gcp-storage | gcp-storage.identical | [[within {duration} ]]the {path} object in the {word} gcs bucket is identical to the {filepath} file
gcp-storage | gcp-storage.properties | [[within {duration} ]]the {path} object in the {word} gcs bucket has the following properties:  [+table | path | value |]
gcp-storage | gcp-storage.contains | [[within {duration} ]]the {path} object in the {word} gcs bucket contains {string}
gcp-storage | gcp-storage.row | [[within {duration} ]]the {path} object in the {word} gcs bucket has a row where:  [+table | column | value |]
gcp-pubsub | gcp-pubsub.send | a message is published to the {word} pubsub topic:  [+docstring]
gcp-pubsub | gcp-pubsub.send.file | the {filepath} message is published to the {word} pubsub topic[[ with the following attributes:]]
gcp-pubsub | gcp-pubsub.received | [[within {duration} ]]the {word} pubsub topic has a message where:  [+table | path | value |]
gcp-bigquery | gcp-bigquery.seed | a {filepath} bigquery seed
gcp-bigquery | gcp-bigquery.row | [[within {duration} ]]the {word} bigquery table has a row where:  [+table | column | value |]
gcp-bigquery | gcp-bigquery.rows | [[within {duration} ]]the {word} bigquery table has {int} row(s) where:  [+table | column | value |]
gcp-firestore | gcp-firestore.seed | a {filepath} firestore seed
gcp-firestore | gcp-firestore.document | [[within {duration} ]]the {word} firestore document has the following properties:  [+table | field | value |]
gcp-firestore | gcp-firestore.collection | [[within {duration} ]]the {word} firestore collection has a document where:  [+table | field | value |]
azure-blob | azure-blob.account | the {word} azure storage account with the following properties:  [+table | property | value |]
azure-blob | azure-blob.upload | the {filepath} file is uploaded to the {word} blob container[[ as {path}]]
azure-blob | azure-blob.has | [[within {duration} ]]the {word} blob container has a(n) blob named {path}
azure-blob | azure-blob.identical | [[within {duration} ]]the {path} blob in the {word} blob container is identical to the {filepath} file
azure-blob | azure-blob.properties | [[within {duration} ]]the {path} blob in the {word} blob container has the following properties:  [+table | path | value |]
azure-blob | azure-blob.contains | [[within {duration} ]]the {path} blob in the {word} blob container contains {string}
azure-blob | azure-blob.row | [[within {duration} ]]the {path} blob in the {word} blob container has a row where:  [+table | column | value |]
azure-servicebus | azure-servicebus.namespace | the {word} service bus namespace with the following properties:  [+table | property | value |]
azure-servicebus | azure-servicebus.send | a message is sent to the {word} service bus queue:/topic:  [+docstring]
azure-servicebus | azure-servicebus.send.file | the {filepath} message is sent to the {word} service bus queue/topic[[ with the following properties:]]
azure-servicebus | azure-servicebus.received | [[within {duration} ]]the {word} service bus queue/topic has a message where:  [+table | path | value |]