# All steps

> Every step Axx understands, one per line: pack, id and expression. Search it before writing a step.

Source: https://axx.nimbusxr.us/next/references/step-index/

Every step Axx understands, one per line: `pack | id | expression`. `{name}` is a parameter; see [parameter types](https://axx.nimbusxr.us/next/references/steps/#parameter-types). Search this file instead of inventing step text.

```text
rest | rest.service | the {word} service with the following properties:  [+table]
rest | rest.openapi.levels | the OpenAPI validation levels are:  [+table]
rest | rest.openapi.levels | the OpenAPI validation levels on {service} are:  [+table]
rest | rest.request | a(n) {word} request to {word}
rest | rest.request | a(n) {word} request to {word} on {service}
rest | rest.request.ordered | a {ordinal} ordered {word} request to {word}
rest | rest.request.ordered | a {ordinal} ordered {word} request to {word} on {service}
rest | rest.request.header | the request header {word} is {string}
rest | rest.request.header | the request header {word} is {string} for {ordinal} ordered request
rest | rest.request.header.on | the request header {word} is {string} for request on {service}
rest | rest.request.header.on | the request header {word} is {string} for {ordinal} ordered request on {service}
rest | rest.request.headers | the request headers are:  [+table]
rest | rest.request.headers | the request headers for {ordinal} ordered request are:  [+table]
rest | rest.request.headers.on | the request headers for request on {service} are:  [+table]
rest | rest.request.headers.on | the request headers for {ordinal} ordered request on {service} are:  [+table]
rest | rest.request.payload.empty | a request payload using a(n) {mimeType} empty content template
rest | rest.request.payload.empty | a request payload using a(n) {mimeType} empty content template for {ordinal} ordered request
rest | rest.request.payload.empty.on | a request payload using a(n) {mimeType} empty content template for request on {service}
rest | rest.request.payload.empty.on | a request payload using a(n) {mimeType} empty content template for {ordinal} ordered request on {service}
rest | rest.request.payload.example | a request payload using a(n) {mimeType} content example
rest | rest.request.payload.example | a request payload using a(n) {mimeType} content example named {string}
rest | rest.request.payload.example | a request payload using a(n) {mimeType} content example for {ordinal} ordered request
rest | rest.request.payload.example | a request payload using a(n) {mimeType} content example named {string} for {ordinal} ordered request
rest | rest.request.payload.example.on | a request payload using a(n) {mimeType} content example for request on {service}
rest | rest.request.payload.example.on | a request payload using a(n) {mimeType} content example named {string} for request on {service}
rest | rest.request.payload.example.on | a request payload using a(n) {mimeType} content example for {ordinal} ordered request on {service}
rest | rest.request.payload.example.on | a request payload using a(n) {mimeType} content example named {string} for {ordinal} ordered request on {service}
rest | rest.request.payload.resource | a request payload using a(n) {mimeType} {filepath} resource
rest | rest.request.payload.resource | a request payload using a(n) {mimeType} {filepath} resource for {ordinal} ordered request
rest | rest.request.payload.resource.on | a request payload using a(n) {mimeType} {filepath} resource for request on {service}
rest | rest.request.payload.resource.on | a request payload using a(n) {mimeType} {filepath} resource for {ordinal} ordered request on {service}
rest | rest.request.property | the request payload property {word} is {string}
rest | rest.request.property | the request payload property {word} is {string} for {ordinal} ordered request
rest | rest.request.property.on | the request payload property {word} is {string} for request on {service}
rest | rest.request.property.on | the request payload property {word} is {string} for {ordinal} ordered request on {service}
rest | rest.request.properties | the request payload properties are:  [+table]
rest | rest.request.properties | the request payload properties for {ordinal} ordered request are:  [+table]
rest | rest.request.properties.on | the request payload properties for request on {service} are:  [+table]
rest | rest.request.properties.on | the request payload properties for {ordinal} ordered request on {service} are:  [+table]
rest | rest.request.property.null | the request payload property {word} is null
rest | rest.request.property.null | the request payload property {word} is null for {ordinal} ordered request
rest | rest.request.property.null.on | the request payload property {word} is null for request on {service}
rest | rest.request.property.null.on | the request payload property {word} is null for {ordinal} ordered request on {service}
rest | rest.execute | the request is executed
rest | rest.execute | the {ordinal} ordered request is executed
rest | rest.execute | the request is executed on {service}
rest | rest.execute | the {ordinal} ordered request is executed on {service}
rest | rest.response.status | the response status code is {int}
rest | rest.response.status | the {ordinal} ordered response status code is {int}
rest | rest.response.status | the response status code is {int} 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}
rest | rest.response.body.contains | the response body contains {string} for {ordinal} ordered response
rest | rest.response.body.contains.on | the response body contains {string} for response on {service}
rest | rest.response.body.contains.on | the response body contains {string} for {ordinal} ordered response on {service}
rest | rest.response.header.is | the response header {word} is {string}
rest | rest.response.header.is | the response header {word} is {string} for {ordinal} ordered response
rest | rest.response.header.is.on | the response header {word} is {string} for response on {service}
rest | rest.response.header.is.on | the response header {word} is {string} for {ordinal} ordered response on {service}
rest | rest.response.header.matches | the response header {word} matches {pattern}
rest | rest.response.header.matches | the response header {word} matches {pattern} for {ordinal} ordered response
rest | rest.response.header.matches.on | the response header {word} matches {pattern} for response on {service}
rest | rest.response.header.matches.on | the response header {word} matches {pattern} for {ordinal} ordered response on {service}
rest | rest.response.header.missing | the response header {word} is missing
rest | rest.response.header.missing | the response header {word} is missing for {ordinal} ordered response
rest | rest.response.header.missing.on | the response header {word} is missing for response on {service}
rest | rest.response.header.missing.on | the response header {word} is missing for {ordinal} ordered response on {service}
rest | rest.response.headers.are | the response headers are:  [+table]
rest | rest.response.headers.are | the response headers for {ordinal} ordered response are:  [+table]
rest | rest.response.headers.are.on | the response headers for response on {service} are:  [+table]
rest | rest.response.headers.are.on | the response headers for {ordinal} ordered response on {service} are:  [+table]
rest | rest.response.headers.match | the response headers match:  [+table]
rest | rest.response.headers.match | the response headers for {ordinal} ordered response match:  [+table]
rest | rest.response.headers.match.on | the response headers for response on {service} match:  [+table]
rest | rest.response.headers.match.on | the response headers for {ordinal} ordered response on {service} match:  [+table]
rest | rest.response.headers.missing | the response headers are missing:  [+table]
rest | rest.response.headers.missing | the response headers for {ordinal} ordered response are missing:  [+table]
rest | rest.response.headers.missing.on | the response headers for response on {service} are missing:  [+table]
rest | rest.response.headers.missing.on | the response headers for {ordinal} ordered response on {service} are missing:  [+table]
rest | rest.response.property.is | the response payload property {word} is {string}
rest | rest.response.property.is | the response payload property {word} is {string} for {ordinal} ordered response
rest | rest.response.property.is.on | the response payload property {word} is {string} for response on {service}
rest | rest.response.property.is.on | the response payload property {word} is {string} for {ordinal} ordered response on {service}
rest | rest.response.property.null | the response payload property {word} is null
rest | rest.response.property.null | the response payload property {word} is null for {ordinal} ordered response
rest | rest.response.property.null.on | the response payload property {word} is null for response on {service}
rest | rest.response.property.null.on | the response payload property {word} is null for {ordinal} ordered response on {service}
rest | rest.response.property.undefined | the response payload property {word} is undefined
rest | rest.response.property.undefined | the response payload property {word} is undefined for {ordinal} ordered response
rest | rest.response.property.undefined.on | the response payload property {word} is undefined for response on {service}
rest | rest.response.property.undefined.on | the response payload property {word} is undefined for {ordinal} ordered response on {service}
rest | rest.response.property.matches | the response payload property {word} matches {pattern}
rest | rest.response.property.matches | the response payload property {word} matches {pattern} for {ordinal} ordered response
rest | rest.response.property.matches.on | the response payload property {word} matches {pattern} for response on {service}
rest | rest.response.property.matches.on | the response payload property {word} matches {pattern} for {ordinal} ordered response on {service}
rest | rest.response.properties.are | the response payload properties are:  [+table]
rest | rest.response.properties.are | the response payload properties for {ordinal} ordered response are:  [+table]
rest | rest.response.properties.are.on | the response payload properties for response on {service} are:  [+table]
rest | rest.response.properties.are.on | the response payload properties for {ordinal} ordered response on {service} are:  [+table]
rest | rest.response.properties.match | the response payload properties match:  [+table]
rest | rest.response.properties.match | the response payload properties for {ordinal} ordered response match:  [+table]
rest | rest.response.properties.match.on | the response payload properties for response on {service} match:  [+table]
rest | rest.response.properties.match.on | the response payload properties for {ordinal} ordered response on {service} match:  [+table]
rest | rest.token | the {word} token with the following properties:  [+table]
rest | rest.request.token | the request is authorized with the {word} token
rest | rest.request.token | the request is authorized with the {word} token for {ordinal} ordered request
rest | rest.request.token.on | the request is authorized with the {word} token for request on {service}
rest | rest.request.token.on | the request is authorized with the {word} token for {ordinal} ordered request on {service}
rest | rest.request.signed | the request is signed in the {word} header with the following properties:  [+table]
rest | rest.request.signed | the request is signed in the {word} header for {ordinal} ordered request with the following properties:  [+table]
rest | rest.request.signed.on | the request is signed in the {word} header for request on {service} with the following properties:  [+table]
rest | rest.request.signed.on | the request is signed in the {word} header for {ordinal} ordered request on {service} with the following properties:  [+table]
rest | rest.request.webhook | the request is signed as a standard webhook with the key {string}
rest | rest.request.webhook | the request is signed as a standard webhook with the key {string} for {ordinal} ordered request
rest | rest.request.webhook.on | the request is signed as a standard webhook with the key {string} for request on {service}
rest | rest.request.webhook.on | the request is signed as a standard webhook with the key {string} for {ordinal} ordered request on {service}
mock | mock.service | the mocked {word} service with the following properties:  [+table]
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]
mock | mock.count.exactly | the mocked request named {word} was received exactly {int} time(s)
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} was received at least {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} was received at most {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} was not received
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} 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} is {string}
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]
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]
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]
mock | mock.properties.are | the payload properties for mocked request named {word} are:  [+table]
mock | mock.properties.are | the payload properties for mocked request named {word} on {mockedService} are:  [+table]
mock | mock.query.are | the query parameters for mocked request named {word} are:  [+table]
mock | mock.query.are | the query parameters for mocked request named {word} on {mockedService} are:  [+table]
mock | mock.form.are | the form fields for mocked request named {word} are:  [+table]
mock | mock.form.are | the form fields for mocked request named {word} on {mockedService} are:  [+table]
mock | mock.query.none | none of the mocked {word} requests to path {word} have the query parameters:  [+table]
mock | mock.query.none | none of the mocked {word} requests to path {word} on {mockedService} have the query parameters:  [+table]
mock | mock.properties.none | none of the mocked {word} requests to path {word} have the payload properties:  [+table]
mock | mock.properties.none | none of the mocked {word} requests to path {word} on {mockedService} have the payload properties:  [+table]
mock | mock.form.none | none of the mocked {word} requests to path {word} have the form fields:  [+table]
mock | mock.form.none | none of the mocked {word} requests to path {word} on {mockedService} have the form fields:  [+table]
mock | mock.signed | the mocked request named {word} is signed in the {word} header with the following properties:  [+table]
mock | mock.signed | the mocked request named {word} on {mockedService} is signed in the {word} header with the following properties:  [+table]
mock | mock.webhook | the mocked request named {word} is signed as a standard webhook with the key {string}
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}
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 with the following arguments:  [+table]
mock | mock.mcp.called | the mocked {mockedService} mcp server's {word} tool was called {int} time(s) with the following arguments:  [+table]
mock | mock.a2a.sent | the mocked {mockedService} a2a agent was sent a message containing {string}
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]
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]
grpc | grpc.call.file | the {word} method is called on the {word} grpc service with the {filepath} message
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 | the {word} grpc service answered {word}
grpc | grpc.status | within {duration} the {word} grpc service answered {word}
grpc | grpc.status | the {word} grpc service answered {word} with a message containing {string}
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]
grpc | grpc.metadata | the {word} grpc service's answer has the following metadata:  [+table]
grpc | grpc.streamed | the {word} grpc service streamed a message where:  [+table]
grpc | grpc.streamed | within {duration} the {word} grpc service streamed a message where:  [+table]
jsonrpc | jsonrpc.service | the {word} jsonrpc service with the following properties:  [+table]
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]
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]
jsonrpc | jsonrpc.result.is | the {word} jsonrpc service's result is {string}
jsonrpc | jsonrpc.error | the {word} jsonrpc service answered the error {int}
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]
jsonrpc | jsonrpc.openrpc.levels | the OpenRPC validation levels are:  [+table]
graphql | graphql.service | the {word} graphql service with the following properties:  [+table]
graphql | graphql.send.file | the {filepath} query/mutation is sent to the {word} graphql service
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
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]
graphql | graphql.error | the {word} graphql service answered an error where:  [+table]
graphql | graphql.received | the {word} graphql service's subscription received a message where:  [+table]
graphql | graphql.received | within {duration} the {word} graphql service's subscription received a message where:  [+table]
graphql | graphql.levels | the GraphQL validation levels are:  [+table]
mcp | mcp.server | the {word} mcp server with the following properties:  [+table]
mcp | mcp.tool | the {word} mcp server has the {word} tool
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
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 is not an error
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 is 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 contains {string}
mcp | mcp.contains | the {word} tool's result on the {word} mcp server contains {string}
mcp | mcp.properties | the {word} tool's result has the following properties:  [+table]
mcp | mcp.properties | the {word} tool's result on the {word} mcp server has the following properties:  [+table]
mcp | mcp.refused | the {word} tool's call failed with the error code {int}
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]
mcp | mcp.prompt | the {word} prompt is requested from the {word} mcp server
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]
a2a | a2a.agent | the {word} a2a agent with the following properties:  [+table]
a2a | a2a.card | the {word} a2a agent's card has the following properties:  [+table]
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 | the {word} a2a agent's task is {word}
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]
a2a | a2a.update | the {word} a2a agent's stream received an update where:  [+table]
a2a | a2a.update | within {duration} the {word} a2a agent's stream received an update where:  [+table]
sql | sql.service | a(n) {word} database with the following properties:  [+table]
sql | sql.seed | a {filepath} db seed
sql | sql.seed | a {filepath} db seed on {dbService}
sql | sql.lock | the rows in the {word} table are locked where:  [+table]
sql | sql.lock | the rows in the {word} table on {dbService} are locked where:  [+table]
sql | sql.unlock | the row locks are released
sql | sql.unlock | the row locks on {dbService} are released
sql | sql.select | a selection of rows is retrieved from the {word} table where:  [+table]
sql | sql.select | a {ordinal} selection of rows is retrieved from the {word} table where:  [+table]
sql | sql.select | a selection of rows is retrieved from the {word} table on {dbService} where:  [+table]
sql | sql.select | a {ordinal} selection of rows is retrieved from the {word} table on {dbService} where:  [+table]
sql | sql.select.poll | within {duration} a selection of at least {int} row(s) is retrieved from the {word} table where:  [+table]
sql | sql.select.poll | within {duration} a {ordinal} selection of at least {int} row(s) is retrieved from the {word} table where:  [+table]
sql | sql.select.poll | within {duration} a selection of at least {int} row(s) is retrieved from the {word} table on {dbService} where:  [+table]
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]
sql | sql.select.jsonb | a selection of rows is retrieved from the {word} table where the {word} jsonb column contains:  [+table]
sql | sql.select.jsonb | a {ordinal} selection of rows is retrieved from the {word} table where the {word} jsonb column contains:  [+table]
sql | sql.select.jsonb | a selection of rows is retrieved from the {word} table on {dbService} where the {word} jsonb column contains:  [+table]
sql | sql.select.jsonb | a {ordinal} selection of rows is retrieved from the {word} table on {dbService} where the {word} jsonb column contains:  [+table]
sql | sql.json.are | the {ordinal} row {word} property for the selection json properties are:  [+table]
sql | sql.json.are | the {ordinal} row {word} property for the {ordinal} selection json properties are:  [+table]
sql | sql.json.are | the {ordinal} row {word} property for the selection on {dbService} json properties are:  [+table]
sql | sql.json.are | the {ordinal} row {word} property for the {ordinal} selection on {dbService} json properties are:  [+table]
sql | sql.json.match | the {ordinal} row {word} property for the selection json properties match:  [+table]
sql | sql.json.match | the {ordinal} row {word} property for the {ordinal} selection json properties match:  [+table]
sql | sql.json.match | the {ordinal} row {word} property for the selection on {dbService} json properties match:  [+table]
sql | sql.json.match | the {ordinal} row {word} property for the {ordinal} selection on {dbService} json properties match:  [+table]
sql | sql.rows.eq | the selection has {int} row(s)
sql | sql.rows.eq | the {ordinal} selection has {int} row(s)
sql | sql.rows.eq | the selection on {dbService} has {int} row(s)
sql | sql.rows.eq | the {ordinal} selection on {dbService} has {int} row(s)
sql | sql.rows.gt | the selection has more than {int} row(s)
sql | sql.rows.gt | the {ordinal} selection has more than {int} row(s)
sql | sql.rows.gt | the selection on {dbService} has more than {int} row(s)
sql | sql.rows.gt | the {ordinal} selection on {dbService} has more than {int} row(s)
sql | sql.rows.lt | the selection has fewer than {int} row(s)
sql | sql.rows.lt | the {ordinal} selection has fewer than {int} row(s)
sql | sql.rows.lt | the selection on {dbService} has fewer 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) before insert trigger on the {word} table will raise a(n) {sqlState} exception where:  [+table]
sql | sql.trigger.raise | a(n) {ordinal} ordered before insert trigger on the {word} table will raise a(n) {sqlState} exception where:  [+table]
sql | sql.trigger.raise | a(n) before insert trigger on the {word} table on {dbService} will raise a(n) {sqlState} exception where:  [+table]
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]
sql | sql.trigger.raise.times | a(n) before insert trigger on the {word} table will raise a(n) {sqlState} exception {int} time(s) where:  [+table]
sql | sql.trigger.raise.times | a(n) {ordinal} ordered before insert trigger on the {word} table will raise a(n) {sqlState} exception {int} time(s) where:  [+table]
sql | sql.trigger.raise.times | a(n) before insert trigger on the {word} table on {dbService} will raise a(n) {sqlState} exception {int} time(s) where:  [+table]
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]
sql | sql.trigger.insertRaise | a(n) before insert trigger on the {word} table will insert and raise a(n) {sqlState} exception where:  [+table]
sql | sql.trigger.insertRaise | a(n) {ordinal} ordered before insert trigger on the {word} table will insert and raise a(n) {sqlState} exception where:  [+table]
sql | sql.trigger.insertRaise | a(n) before insert trigger on the {word} table on {dbService} will insert and raise a(n) {sqlState} exception where:  [+table]
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]
sql | sql.trigger.insertRaise.times | a(n) before insert trigger on the {word} table will insert and raise a(n) {sqlState} exception {int} time(s) where:  [+table]
sql | sql.trigger.insertRaise.times | a(n) {ordinal} ordered before insert trigger on the {word} table will insert and raise a(n) {sqlState} exception {int} time(s) where:  [+table]
sql | sql.trigger.insertRaise.times | a(n) before insert trigger on the {word} table on {dbService} will insert and raise a(n) {sqlState} exception {int} time(s) where:  [+table]
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]
sql | sql.trigger.raised | the before insert trigger on the {word} table was raised {int} time(s)
sql | sql.trigger.raised | the {ordinal} ordered before insert trigger on the {word} table was raised {int} time(s)
sql | sql.trigger.raised | the before insert trigger on the {word} table on {dbService} was raised {int} time(s)
sql | sql.trigger.raised | the {ordinal} ordered before insert 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]
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 selection of documents is retrieved from the {word} collection where:  [+table]
mongo | mongo.find | a {ordinal} selection of documents is retrieved from the {word} collection where:  [+table]
mongo | mongo.find | a selection of documents is retrieved from the {word} collection on {mongoService} where:  [+table]
mongo | mongo.find | a {ordinal} selection of documents is retrieved from the {word} collection on {mongoService} where:  [+table]
mongo | mongo.find.poll | within {duration} a selection of at least {int} document(s) is retrieved from the {word} collection where:  [+table]
mongo | mongo.find.poll | within {duration} a {ordinal} selection of at least {int} document(s) is retrieved from the {word} collection where:  [+table]
mongo | mongo.find.poll | within {duration} a selection of at least {int} document(s) is retrieved from the {word} collection on {mongoService} where:  [+table]
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]
mongo | mongo.docs.eq | the selection has {int} document(s)
mongo | mongo.docs.eq | the {ordinal} selection has {int} document(s)
mongo | mongo.docs.eq | the selection on {mongoService} has {int} document(s)
mongo | mongo.docs.eq | the {ordinal} selection on {mongoService} has {int} document(s)
mongo | mongo.docs.gt | the selection has more than {int} document(s)
mongo | mongo.docs.gt | the {ordinal} selection has more than {int} document(s)
mongo | mongo.docs.gt | the selection on {mongoService} has more than {int} document(s)
mongo | mongo.docs.gt | the {ordinal} selection on {mongoService} has more than {int} document(s)
mongo | mongo.docs.lt | the selection has fewer than {int} document(s)
mongo | mongo.docs.lt | the {ordinal} selection has fewer than {int} document(s)
mongo | mongo.docs.lt | the selection on {mongoService} has fewer 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 selection properties are:  [+table]
mongo | mongo.doc.are | the {ordinal} document for the {ordinal} selection properties are:  [+table]
mongo | mongo.doc.are | the {ordinal} document for the selection on {mongoService} properties are:  [+table]
mongo | mongo.doc.are | the {ordinal} document for the {ordinal} selection on {mongoService} properties are:  [+table]
mongo | mongo.doc.match | the {ordinal} document for the selection properties match:  [+table]
mongo | mongo.doc.match | the {ordinal} document for the {ordinal} selection properties match:  [+table]
mongo | mongo.doc.match | the {ordinal} document for the selection on {mongoService} properties match:  [+table]
mongo | mongo.doc.match | the {ordinal} document for the {ordinal} selection on {mongoService} properties match:  [+table]
redis | redis.server | the {word} redis server with the following properties:  [+table]
redis | redis.seed | a {filepath} redis seed
redis | redis.value | the {word} redis key has the value {string}
redis | redis.value | within {duration} the {word} redis key has the value {string}
redis | redis.properties | the {word} redis key has the following properties:  [+table]
redis | redis.properties | within {duration} the {word} redis key has the following properties:  [+table]
redis | redis.absent | the {word} redis key does not exist
redis | redis.absent | within {duration} the {word} redis key does not exist
kafka | kafka.service | the {word} kafka service with the following properties:  [+table]
kafka | kafka.client | the {word} kafka topic client
kafka | kafka.client.props | a(n) {word} kafka topic client with the following properties:  [+table]
kafka | kafka.client.props | a(n) {word} kafka topic client on the {word} kafka service with the following properties:  [+table]
kafka | kafka.event | a(n) {word} kafka event
kafka | kafka.event | a(n) {ordinal} ordered {word} kafka event
kafka | kafka.event | a(n) {word} kafka event on {word} kafka service
kafka | kafka.event | a(n) {ordinal} ordered {word} kafka event on {word} kafka service
kafka | kafka.event.key | the {word} kafka event key is {word}
kafka | kafka.event.key | the {ordinal} ordered {word} kafka event key is {word}
kafka | kafka.event.key | the {word} kafka event key is {word} on the {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 {word} kafka event headers are:  [+table]
kafka | kafka.event.headers | the {ordinal} ordered {word} kafka event headers are:  [+table]
kafka | kafka.event.headers | the {word} kafka event headers on the {word} kafka service are:  [+table]
kafka | kafka.event.headers | the {ordinal} ordered {word} kafka event headers on the {word} kafka service are:  [+table]
kafka | kafka.event.payload.resource | the {word} kafka event payload is a(n) {filepath} resource
kafka | kafka.event.payload.resource | the {ordinal} ordered {word} kafka event payload is a(n) {filepath} resource
kafka | kafka.event.payload.resource | the {word} kafka event payload is a(n) {filepath} resource on the {word} kafka service
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 kafka event payload properties are:  [+table]
kafka | kafka.event.properties.first | the {ordinal} ordered kafka event payload properties are:  [+table]
kafka | kafka.event.properties.first | the kafka event payload properties on the {word} kafka service are:  [+table]
kafka | kafka.event.properties.first | the {ordinal} ordered kafka event payload properties on the {word} kafka service are:  [+table]
kafka | kafka.event.properties | the {word} kafka event payload properties are:  [+table]
kafka | kafka.event.properties | the {word} kafka event payload properties on the {word} kafka service are:  [+table]
kafka | kafka.event.properties.ordinal | the {ordinal} ordered {word} kafka event payload properties are:  [+table]
kafka | kafka.event.properties.ordinal | the {ordinal} ordered {word} kafka event payload properties on the {word} kafka service are:  [+table]
kafka | kafka.event.property.null | the {word} kafka event payload property {word} is null
kafka | kafka.event.property.null | the {ordinal} ordered {word} kafka event payload property {word} is null
kafka | kafka.event.property.null | the {word} kafka event payload property {word} is null on the {word} kafka service
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 {word} kafka event is published using schema {filepath}
kafka | kafka.event.publish.schema | the {ordinal} ordered {word} kafka event is published using schema {filepath}
kafka | kafka.event.publish.schema | the {word} kafka event is published using schema {filepath} 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 {word} kafka event is published
kafka | kafka.event.publish | the {ordinal} ordered {word} kafka event is published
kafka | kafka.event.publish | the {word} kafka event is published 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}
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 are:  [+table]
kafka | kafka.consumed.properties | the {word} kafka event named {word} payload properties on the {word} kafka service are:  [+table]
kafka | kafka.consumed.headers | the {word} kafka event named {word} headers are:  [+table]
kafka | kafka.consumed.headers | the {word} kafka event named {word} headers on the {word} kafka service are:  [+table]
kafka | kafka.consumed.headers.match | the {word} kafka event named {word} headers match:  [+table]
kafka | kafka.consumed.headers.match.service | the {word} kafka event named {word} headers on the {word} kafka service match:  [+table]
amqp | amqp.broker | the {word} amqp broker with the following properties:  [+table]
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
amqp | amqp.queue.send.file | the {filepath} message is sent to the {word} amqp queue with the following properties:
amqp | amqp.queue.received | the {word} amqp queue has a message where:  [+table]
amqp | amqp.queue.received | within {duration} the {word} amqp queue has a message where:  [+table]
amqp | amqp.exchange.send | a message is published to the {word} amqp exchange:  [+docstring]
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
amqp | amqp.exchange.send.file | the {filepath} message is published to the {word} amqp exchange with the following properties:
amqp | amqp.exchange.received | the {word} amqp exchange has a message where:  [+table]
amqp | amqp.exchange.received | within {duration} the {word} amqp exchange has a message where:  [+table]
mqtt | mqtt.broker | the {word} mqtt broker with the following properties:  [+table]
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
mqtt | mqtt.send.file | the {filepath} message is published to the {word} mqtt topic with the following properties:
mqtt | mqtt.received | the {word} mqtt topic has a message where:  [+table]
mqtt | mqtt.received | within {duration} the {word} mqtt topic has a message where:  [+table]
nats | nats.server | the {word} nats server with the following properties:  [+table]
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
nats | nats.subject.send.file | the {filepath} message is published to the {word} nats subject with the following headers:
nats | nats.subject.received | the {word} nats subject has a message where:  [+table]
nats | nats.subject.received | within {duration} the {word} nats subject has a message where:  [+table]
nats | nats.stream.received | the {word} nats stream has a message where:  [+table]
nats | nats.stream.received | within {duration} the {word} nats stream has a message where:  [+table]
logs | logs.log | the {word} log with the following properties:  [+table]
logs | logs.entry | the {word} log has an entry matching {string}
logs | logs.entry | within {duration} the {word} log has an entry matching {string}
logs | logs.entries | the {word} log has entries matching:  [+table]
logs | logs.entries | within {duration} the {word} log has entries matching:  [+table]
logs | logs.count | the {word} log has {int} entry/entries matching {string}
logs | logs.count | within {duration} the {word} log has {int} entry/entries matching {string}
logs | logs.across | the logs have entries matching:  [+table]
logs | logs.across | within {duration} the logs have entries matching:  [+table]
files | files.folder | the {word} folder with the following properties:  [+table]
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 | the {word} folder has a(n) file named {path}
files | files.has | within {duration} the {word} folder has a(n) file named {path}
files | files.identical | the {path} file in the {word} folder is identical to the {filepath} file
files | files.identical | within {duration} the {path} file in the {word} folder is identical to the {filepath} file
files | files.properties | the {path} file in the {word} folder has the following properties:  [+table]
files | files.properties | within {duration} the {path} file in the {word} folder has the following properties:  [+table]
files | files.contains | the {path} file in the {word} folder contains {string}
files | files.contains | within {duration} the {path} file in the {word} folder contains {string}
files | files.row | the {path} file in the {word} folder has a row where:  [+table]
files | files.row | within {duration} the {path} file in the {word} folder has a row where:  [+table]
files | files.absent | the {word} folder has no file named {path}
files | files.absent | within {duration} the {word} folder has no file named {path}
files | files.empty | the {word} folder is empty
files | files.empty | within {duration} the {word} folder is empty
files | files.screenshot | the {path} file in the {word} folder looks like the {string} screenshot
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]
mail | mail.received | the {word} mailbox has an email where:  [+table]
mail | mail.received | within {duration} the {word} mailbox has an email where:  [+table]
cli | cli.command | the {word} command with the following properties:  [+table]
cli | cli.run | the {word} command is run
cli | cli.run | the {word} command is run with {string}
cli | cli.run.input | the {word} command is run with the input:  [+docstring]
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 output contains {string}
cli | cli.output.contains | the {word} command's error output contains {string}
cli | cli.output.line | the {word} command's output has a line matching {string}
cli | cli.output.line | the {word} command's error output has a line matching {string}
cli | cli.output.is | the {word} command's output is:  [+docstring]
cli | cli.output.is | the {word} command's error output is:  [+docstring]
cli | cli.output.empty | the {word} command's output is empty
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]
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]
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 | the {word} websocket received a message where:  [+table]
websocket | websocket.received | within {duration} the {word} websocket received a message where:  [+table]
websocket | websocket.received.text | the {word} websocket received a message containing {string}
websocket | websocket.received.text | within {duration} the {word} websocket received a message containing {string}
websocket | websocket.closed | the {word} websocket was closed with code {int}
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]
sse | sse.event | the {word} event stream has an event where:  [+table]
sse | sse.event | within {duration} the {word} event stream has an event where:  [+table]
sse | sse.event.text | the {word} event stream has an event containing {string}
sse | sse.event.text | within {duration} the {word} event stream has an event containing {string}
asyncapi | asyncapi.levels | the AsyncAPI validation levels are:  [+table]
web-core | web-core.app | the {word} web app with the following properties:  [+table]
web-core | web-core.open | the {string} page is opened
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
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 | the dialog shows {string}
web-core | web-core.dialog | within {duration} the dialog shows {string}
web-core | web-core.shows | the page shows {string}
web-core | web-core.shows | within {duration} the page shows {string}
web-core | web-core.hides | the page does not show {string}
web-core | web-core.hides | within {duration} the page does not show {string}
web-core | web-core.url | the {string} page is shown
web-core | web-core.url | within {duration} the {string} page is shown
web-core | web-core.value | the {string} field has the value {string}
web-core | web-core.value | within {duration} the {string} field has the value {string}
web-core | web-core.disabled | the {string} button is disabled
web-core | web-core.disabled | within {duration} the {string} button is disabled
web-core | web-core.enabled | the {string} button is enabled
web-core | web-core.enabled | within {duration} the {string} button is enabled
web-core | web-core.row | the page shows a table row where:  [+table]
web-core | web-core.row | within {duration} the page shows a table row where:  [+table]
web-core | web-core.downloaded | the {string} file is downloaded
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]
web-core | web-core.download.identical | the downloaded {string} file is identical to the {filepath} file
web-core | web-core.element.shown | the {string} {element} is shown
web-core | web-core.element.shown | within {duration} the {string} {element} is shown
web-core | web-core.element.hidden | the {string} {element} is not shown
web-core | web-core.element.hidden | within {duration} the {string} {element} is not shown
web-core | web-core.element.text | the {string} {element} shows {string}
web-core | web-core.element.text | within {duration} the {string} {element} shows {string}
web-core | web-core.element.attribute | the {string} {element} has the {word} attribute {string}
web-core | web-core.element.attribute | within {duration} the {string} {element} has the {word} attribute {string}
web-core | web-core.element.focus | the {string} {element} has the focus
web-core | web-core.element.focus | within {duration} the {string} {element} has the focus
web-core | web-core.checkbox.ticked | the {string} checkbox is ticked
web-core | web-core.checkbox.ticked | within {duration} the {string} checkbox is ticked
web-core | web-core.checkbox.unticked | the {string} checkbox is not ticked
web-core | web-core.checkbox.unticked | within {duration} the {string} checkbox is not ticked
web-core | web-core.option.selected | the {string} option is selected
web-core | web-core.option.selected | within {duration} the {string} option is selected
web-core | web-core.option.unselected | the {string} option is not selected
web-core | web-core.option.unselected | within {duration} the {string} option is not selected
web-core | web-core.field.disabled | the {string} field is disabled
web-core | web-core.field.disabled | within {duration} the {string} field is disabled
web-core | web-core.field.enabled | the {string} field is enabled
web-core | web-core.field.enabled | within {duration} the {string} field is enabled
web-core | web-core.element.count | the page shows {int} {string} {element}
web-core | web-core.element.count | within {duration} the page shows {int} {string} {element}
web-core | web-core.row.count | the page shows {int} table row(s) where:  [+table]
web-core | web-core.row.count | within {duration} the page shows {int} table row(s) where:  [+table]
web-core | web-core.title | the page title is {string}
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 | the browser sent a {word} request to {string}
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]
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 | the page looks like the {string} screenshot
web-screenshots | web-screenshots.page | within {duration} the page looks like the {string} screenshot
web-screenshots | web-screenshots.page.masked | the page looks like the {string} screenshot, apart from:  [+table]
web-screenshots | web-screenshots.page.masked | within {duration} the page looks like the {string} screenshot, apart from:  [+table]
web-screenshots | web-screenshots.element | the {string} {element} looks like the {string} screenshot
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 | the page's accessible structure is:  [+docstring]
web-a11y | web-a11y.structure | within {duration} the page's accessible structure is:  [+docstring]
web-a11y | web-a11y.element.structure | the {string} {element}'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 | the page sent a websocket message containing {string}
web-network | web-network.ws.sent | within {duration} the page sent a websocket message containing {string}
web-network | web-network.ws.received | the page received 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]
web-lighthouse | web-lighthouse.loads | the {string} page loads within:  [+table]
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 | the {word} app shows {string}
app-core | app-core.shows | within {duration} the {word} app shows {string}
app-core | app-core.hides | the {word} app does not show {string}
app-core | app-core.hides | within {duration} the {word} app does not show {string}
app-core | app-core.control.shown | the {string} {control} is shown in the {word} app
app-core | app-core.control.shown | within {duration} the {string} {control} is shown in the {word} app
app-core | app-core.control.enabled | the {string} {control} is enabled 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 | the {string} {control} is disabled 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 | the {string} field in the {word} app has the value {string}
app-core | app-core.field.value | within {duration} the {string} field in the {word} app has the value {string}
app-core | app-core.screenshot | the {word} app looks like the {string} screenshot
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 | the {word} app's dialog shows {string}
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
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 | the {word} app shows a notification {string}
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]
mobile-core | mobile-core.travel-route | the {word} app's phone {travel} the {filepath} route
mobile-core | mobile-core.travel-route | the {word} app's phone {travel} the {filepath} route at {speed}
mobile-core | mobile-core.route-end | the {word} app's phone reaches the end of its route
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]
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]
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]
desktop-windows | desktop-windows.app | the {word} windows app with the following properties:  [+table]
desktop-linux | desktop-linux.app | the {word} linux app with the following properties:  [+table]
models-core | models-core.microphone | the {word} app's microphone hears the {string} file
models-core | models-core.speaker | the {word} app's speaker plays 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]
aws-s3 | aws-s3.upload | the {filepath} file is uploaded to the {word} s3 bucket
aws-s3 | aws-s3.upload | the {filepath} file is uploaded to the {word} s3 bucket as {path}
aws-s3 | aws-s3.has | the {word} s3 bucket has a(n) object named {path}
aws-s3 | aws-s3.has | within {duration} the {word} s3 bucket has a(n) object named {path}
aws-s3 | aws-s3.identical | the {path} object in the {word} s3 bucket is identical to the {filepath} file
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 | the {path} object in the {word} s3 bucket has the following properties:  [+table]
aws-s3 | aws-s3.properties | within {duration} the {path} object in the {word} s3 bucket has the following properties:  [+table]
aws-s3 | aws-s3.contains | the {path} object in the {word} s3 bucket contains {string}
aws-s3 | aws-s3.contains | within {duration} the {path} object in the {word} s3 bucket contains {string}
aws-s3 | aws-s3.row | the {path} object in the {word} s3 bucket has a row where:  [+table]
aws-s3 | aws-s3.row | within {duration} the {path} object in the {word} s3 bucket has a row where:  [+table]
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
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 | the {word} sqs queue has a message where:  [+table]
aws-sqs | aws-sqs.received | within {duration} the {word} sqs queue has a message where:  [+table]
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
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 | the {word} sns topic has a message where:  [+table]
aws-sns | aws-sns.received | within {duration} the {word} sns topic has a message where:  [+table]
aws-eventbridge | aws-eventbridge.put | a(n) {string} event from {word} is put on the {word} eventbridge bus:  [+docstring]
aws-eventbridge | aws-eventbridge.received | the {word} eventbridge bus has an event where:  [+table]
aws-eventbridge | aws-eventbridge.received | within {duration} the {word} eventbridge bus has an event where:  [+table]
aws-dynamodb | aws-dynamodb.seed | a {filepath} dynamodb seed
aws-dynamodb | aws-dynamodb.item | the {word} dynamodb table has an item where:  [+table]
aws-dynamodb | aws-dynamodb.item | within {duration} the {word} dynamodb table has an item where:  [+table]
aws-dynamodb | aws-dynamodb.items | the {word} dynamodb table has {int} item(s) where:  [+table]
aws-dynamodb | aws-dynamodb.items | within {duration} the {word} dynamodb table has {int} item(s) where:  [+table]
gcp-core | gcp-core.project | the {word} gcp project with the following properties:  [+table]
gcp-storage | gcp-storage.upload | the {filepath} file is uploaded to the {word} gcs bucket
gcp-storage | gcp-storage.upload | the {filepath} file is uploaded to the {word} gcs bucket as {path}
gcp-storage | gcp-storage.has | the {word} gcs bucket has a(n) object named {path}
gcp-storage | gcp-storage.has | within {duration} the {word} gcs bucket has a(n) object named {path}
gcp-storage | gcp-storage.identical | the {path} object in the {word} gcs bucket is identical to the {filepath} file
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 | the {path} object in the {word} gcs bucket has the following properties:  [+table]
gcp-storage | gcp-storage.properties | within {duration} the {path} object in the {word} gcs bucket has the following properties:  [+table]
gcp-storage | gcp-storage.contains | the {path} object in the {word} gcs bucket contains {string}
gcp-storage | gcp-storage.contains | within {duration} the {path} object in the {word} gcs bucket contains {string}
gcp-storage | gcp-storage.row | the {path} object in the {word} gcs bucket has a row where:  [+table]
gcp-storage | gcp-storage.row | within {duration} the {path} object in the {word} gcs bucket has a row where:  [+table]
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
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 | the {word} pubsub topic has a message where:  [+table]
gcp-pubsub | gcp-pubsub.received | within {duration} the {word} pubsub topic has a message where:  [+table]
gcp-bigquery | gcp-bigquery.seed | a {filepath} bigquery seed
gcp-bigquery | gcp-bigquery.row | the {word} bigquery table has a row where:  [+table]
gcp-bigquery | gcp-bigquery.row | within {duration} the {word} bigquery table has a row where:  [+table]
gcp-bigquery | gcp-bigquery.rows | the {word} bigquery table has {int} row(s) where:  [+table]
gcp-bigquery | gcp-bigquery.rows | within {duration} the {word} bigquery table has {int} row(s) where:  [+table]
gcp-firestore | gcp-firestore.seed | a {filepath} firestore seed
gcp-firestore | gcp-firestore.document | the {word} firestore document has the following properties:  [+table]
gcp-firestore | gcp-firestore.document | within {duration} the {word} firestore document has the following properties:  [+table]
gcp-firestore | gcp-firestore.collection | the {word} firestore collection has a document where:  [+table]
gcp-firestore | gcp-firestore.collection | within {duration} the {word} firestore collection has a document where:  [+table]
azure-blob | azure-blob.account | the {word} azure storage account with the following properties:  [+table]
azure-blob | azure-blob.upload | the {filepath} file is uploaded to the {word} blob container
azure-blob | azure-blob.upload | the {filepath} file is uploaded to the {word} blob container as {path}
azure-blob | azure-blob.has | the {word} blob container has a(n) blob named {path}
azure-blob | azure-blob.has | within {duration} the {word} blob container has a(n) blob named {path}
azure-blob | azure-blob.identical | the {path} blob in the {word} blob container is identical to the {filepath} file
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 | the {path} blob in the {word} blob container has the following properties:  [+table]
azure-blob | azure-blob.properties | within {duration} the {path} blob in the {word} blob container has the following properties:  [+table]
azure-blob | azure-blob.contains | the {path} blob in the {word} blob container contains {string}
azure-blob | azure-blob.contains | within {duration} the {path} blob in the {word} blob container contains {string}
azure-blob | azure-blob.row | the {path} blob in the {word} blob container has a row where:  [+table]
azure-blob | azure-blob.row | within {duration} the {path} blob in the {word} blob container has a row where:  [+table]
azure-servicebus | azure-servicebus.namespace | the {word} service bus namespace with the following properties:  [+table]
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
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 | the {word} service bus queue/topic has a message where:  [+table]
azure-servicebus | azure-servicebus.received | within {duration} the {word} service bus queue/topic has a message where:  [+table]
```