generated: '2026-08-29'
method: derived
source: >-
  openapi/fusio-backend.json, openapi/fusio-consumer.json, openapi/fusio-system.json,
  openapi/fusio-authorization.json (all harvested live from the Fusio reference instance)
  bound to the MCP tool surface defined in
  https://github.com/apioo/fusio-impl/blob/master/src/Service/Mcp/ToolLoader.php
provider: Fusio
providerId: fusio
title: Fusio MCP tool <-> REST operation crosswalk
description: >-
  Fusio's MCP server does not ship a hand-written tool list. Fusio\'s ToolLoader walks every
  ACTIVE operation registered in the instance and registers one MCP tool per operation, taking
  the tool name from the operation name, the tool inputSchema from the operation\'s generated
  input schema and the outputSchema from its response schema. The binding is therefore
  one-to-one and mechanical: every REST operation in the instance becomes exactly one MCP tool,
  and there are no MCP-only tools. The rows below bind the 275 operations Fusio\'s own reference
  instance exposes to the tool names its MCP server would register for them.
binding_rule:
  tool_name: operationId with "." replaced by "-" (Fusio\\Impl\\Service\\Agent\\ToolName::toToolName)
  tool_title: the operation name, verbatim
  input_schema: generated by Fusio\\Impl\\Service\\Agent\\InputSchemaBuilder from the operation parameters + request body
  output_schema: generated by Fusio\\Impl\\Service\\Agent\\OutputSchemaBuilder from the operation response
  annotations:
    readOnlyHint: true when the operation HTTP method is GET
    destructiveHint: true when the operation HTTP method is DELETE
    idempotentHint: true when the operation HTTP method is GET, PUT or DELETE
  caveat: >-
    ToolLoader skips any operation whose generated input schema is empty, so a small number of
    zero-argument operations may not appear as tools on a given instance. Which ones are skipped
    can only be established by an authenticated tools/list call against a running instance;
    Fusio's public demo has the HTTP MCP transport disabled (503 "MCP service is not enabled").
  evidence: https://docs.fusio-project.org/docs/protocol/mcp
surfaces:
  openapi:
    - openapi/fusio-backend.json
    - openapi/fusio-consumer.json
    - openapi/fusio-system.json
    - openapi/fusio-authorization.json
  mcp:
    url: https://{your-fusio-instance}/mcp
    transport: streamable-http
    gated: true
    note: >-
      HTTP transport is disabled by default (fusio_mcp config flag) and is marked experimental
      by the provider; STDIO transport via "php bin/fusio mcp" is the supported default.
  graphql:
    url: https://{your-fusio-instance}/graphql
    gated: true
    note: >-
      Fusio ships a GraphQL server (added in 6.1.0) but it is disabled by default; the reference
      instance answers 503 "GraphQL service is not enabled", so no SDL could be introspected.
  jsonrpc:
    url: https://{your-fusio-instance}/jsonrpc
    note: JSON-RPC server added in 6.1.0; not routed on the reference instance (404).
  openrpc: typeapi/fusio-backend-openrpc.json
coverage:
  rest_operations: 275
  mcp_tools_bound: 275
  mcp_only: 0
  rest_only: 0
  confidence: high
crosswalk:
  - tool: backend-account-changePassword
    category: backend
    rest:
      - backend.account.changePassword
    http: PUT "/backend/account/change_password"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true }
    note: "Changes the password of the authenticated user"
  - tool: backend-account-get
    category: backend
    rest:
      - backend.account.get
    http: GET "/backend/account"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns user data of the authenticated user"
  - tool: backend-account-update
    category: backend
    rest:
      - backend.account.update
    http: PUT "/backend/account"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true }
    note: "Updates user data of the authenticated user"
  - tool: backend-action-getAll
    category: backend
    rest:
      - backend.action.getAll
    http: GET "/backend/action"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a paginated list of actions"
  - tool: backend-action-create
    category: backend
    rest:
      - backend.action.create
    http: POST "/backend/action"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
    note: "Creates a new action"
  - tool: backend-action-get
    category: backend
    rest:
      - backend.action.get
    http: GET "/backend/action/{action_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a specific action"
  - tool: backend-action-update
    category: backend
    rest:
      - backend.action.update
    http: PUT "/backend/action/{action_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true }
    note: "Updates an existing action"
  - tool: backend-action-delete
    category: backend
    rest:
      - backend.action.delete
    http: DELETE "/backend/action/{action_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true }
    note: "Deletes an existing action"
  - tool: backend-action-execute
    category: backend
    rest:
      - backend.action.execute
    http: POST "/backend/action/execute/{action_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
    note: "Executes a specific action. This method should be used to test an action configuration"
  - tool: backend-action-getClasses
    category: backend
    rest:
      - backend.action.getClasses
    http: GET "/backend/action/list"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns all available action classes"
  - tool: backend-action-getCommits
    category: backend
    rest:
      - backend.action.getCommits
    http: GET "/backend/action/{action_id}/commit"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a paginated list of action commits"
  - tool: backend-action-getForm
    category: backend
    rest:
      - backend.action.getForm
    http: GET "/backend/action/form"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns the action config form"
  - tool: backend-agent-getAll
    category: backend
    rest:
      - backend.agent.getAll
    http: GET "/backend/agent"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a paginated list of agents"
  - tool: backend-agent-create
    category: backend
    rest:
      - backend.agent.create
    http: POST "/backend/agent"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
    note: "Creates a new agent"
  - tool: backend-agent-get
    category: backend
    rest:
      - backend.agent.get
    http: GET "/backend/agent/{agent_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a specific agent"
  - tool: backend-agent-update
    category: backend
    rest:
      - backend.agent.update
    http: PUT "/backend/agent/{agent_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true }
    note: "Updates an existing agent"
  - tool: backend-agent-delete
    category: backend
    rest:
      - backend.agent.delete
    http: DELETE "/backend/agent/{agent_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true }
    note: "Deletes an existing agent"
  - tool: backend-agent-getTools
    category: backend
    rest:
      - backend.agent.getTools
    http: GET "/backend/agent/tools"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns available tools for an agent"
  - tool: backend-agent-message-getAll
    category: backend
    rest:
      - backend.agent.message.getAll
    http: GET "/backend/agent/{agent_id}/message"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a paginated list of agent messages"
  - tool: backend-agent-message-submit
    category: backend
    rest:
      - backend.agent.message.submit
    http: POST "/backend/agent/{agent_id}/message"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
    note: "Submits a new agent message"
  - tool: backend-app-getAll
    category: backend
    rest:
      - backend.app.getAll
    http: GET "/backend/app"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a paginated list of apps"
  - tool: backend-app-create
    category: backend
    rest:
      - backend.app.create
    http: POST "/backend/app"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
    note: "Creates a new app"
  - tool: backend-app-get
    category: backend
    rest:
      - backend.app.get
    http: GET "/backend/app/{app_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a specific app"
  - tool: backend-app-update
    category: backend
    rest:
      - backend.app.update
    http: PUT "/backend/app/{app_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true }
    note: "Updates an existing app"
  - tool: backend-app-delete
    category: backend
    rest:
      - backend.app.delete
    http: DELETE "/backend/app/{app_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true }
    note: "Deletes an existing app"
  - tool: backend-app-deleteToken
    category: backend
    rest:
      - backend.app.deleteToken
    http: DELETE "/backend/app/{app_id}/token/{token_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true }
    note: "Deletes an existing token from an app"
  - tool: backend-audit-get
    category: backend
    rest:
      - backend.audit.get
    http: GET "/backend/audit/{audit_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a specific audit"
  - tool: backend-audit-getAll
    category: backend
    rest:
      - backend.audit.getAll
    http: GET "/backend/audit"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a paginated list of audits"
  - tool: backend-backup-export
    category: backend
    rest:
      - backend.backup.export
    http: POST "/backend/backup/export"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
    note: "Generates an backup of the current system"
  - tool: backend-backup-import
    category: backend
    rest:
      - backend.backup.import
    http: POST "/backend/backup/import"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
    note: "Imports an backup to the current system"
  - tool: backend-bundle-getAll
    category: backend
    rest:
      - backend.bundle.getAll
    http: GET "/backend/bundle"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a paginated list of bundles"
  - tool: backend-bundle-create
    category: backend
    rest:
      - backend.bundle.create
    http: POST "/backend/bundle"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
    note: "Creates a new bundle"
  - tool: backend-bundle-get
    category: backend
    rest:
      - backend.bundle.get
    http: GET "/backend/bundle/{bundle_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a specific bundle"
  - tool: backend-bundle-update
    category: backend
    rest:
      - backend.bundle.update
    http: PUT "/backend/bundle/{bundle_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true }
    note: "Updates an existing bundle"
  - tool: backend-bundle-delete
    category: backend
    rest:
      - backend.bundle.delete
    http: DELETE "/backend/bundle/{bundle_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true }
    note: "Deletes an existing bundle"
  - tool: backend-bundle-publish
    category: backend
    rest:
      - backend.bundle.publish
    http: POST "/backend/bundle/{bundle_id}/publish"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
    note: "Publish an existing bundle to the marketplace"
  - tool: backend-category-getAll
    category: backend
    rest:
      - backend.category.getAll
    http: GET "/backend/category"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a paginated list of categories"
  - tool: backend-category-create
    category: backend
    rest:
      - backend.category.create
    http: POST "/backend/category"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
    note: "Creates a new category"
  - tool: backend-category-get
    category: backend
    rest:
      - backend.category.get
    http: GET "/backend/category/{category_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a specific category"
  - tool: backend-category-update
    category: backend
    rest:
      - backend.category.update
    http: PUT "/backend/category/{category_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true }
    note: "Updates an existing category"
  - tool: backend-category-delete
    category: backend
    rest:
      - backend.category.delete
    http: DELETE "/backend/category/{category_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true }
    note: "Deletes an existing category"
  - tool: backend-config-get
    category: backend
    rest:
      - backend.config.get
    http: GET "/backend/config/{config_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a specific config"
  - tool: backend-config-update
    category: backend
    rest:
      - backend.config.update
    http: PUT "/backend/config/{config_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true }
    note: "Updates an existing config value"
  - tool: backend-config-getAll
    category: backend
    rest:
      - backend.config.getAll
    http: GET "/backend/config"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a paginated list of configuration values"
  - tool: backend-connection-agent-send
    category: backend
    rest:
      - backend.connection.agent.send
    http: POST "/backend/connection/{connection_id}/agent"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
    note: "Sends a message to an agent"
  - tool: backend-connection-getAll
    category: backend
    rest:
      - backend.connection.getAll
    http: GET "/backend/connection"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a paginated list of connections"
  - tool: backend-connection-create
    category: backend
    rest:
      - backend.connection.create
    http: POST "/backend/connection"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
    note: "Creates a new connection"
  - tool: backend-connection-database-getRows
    category: backend
    rest:
      - backend.connection.database.getRows
    http: GET "/backend/connection/{connection_id}/database/{table_name}/rows"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns paginated rows at a table on a database"
  - tool: backend-connection-database-createRow
    category: backend
    rest:
      - backend.connection.database.createRow
    http: POST "/backend/connection/{connection_id}/database/{table_name}/rows"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
    note: "Creates a new row at a table on a database"
  - tool: backend-connection-database-getTables
    category: backend
    rest:
      - backend.connection.database.getTables
    http: GET "/backend/connection/{connection_id}/database"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns all available tables on a database"
  - tool: backend-connection-database-createTable
    category: backend
    rest:
      - backend.connection.database.createTable
    http: POST "/backend/connection/{connection_id}/database"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
    note: "Creates a new table on a database"
  - tool: backend-connection-database-getRow
    category: backend
    rest:
      - backend.connection.database.getRow
    http: GET "/backend/connection/{connection_id}/database/{table_name}/rows/{id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a specific row at a table on a database"
  - tool: backend-connection-database-updateRow
    category: backend
    rest:
      - backend.connection.database.updateRow
    http: PUT "/backend/connection/{connection_id}/database/{table_name}/rows/{id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true }
    note: "Updates an existing row at a table on a database"
  - tool: backend-connection-database-deleteRow
    category: backend
    rest:
      - backend.connection.database.deleteRow
    http: DELETE "/backend/connection/{connection_id}/database/{table_name}/rows/{id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true }
    note: "Deletes an existing row at a table on a database"
  - tool: backend-connection-database-getTable
    category: backend
    rest:
      - backend.connection.database.getTable
    http: GET "/backend/connection/{connection_id}/database/{table_name}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns the schema of a specific table on a database"
  - tool: backend-connection-database-updateTable
    category: backend
    rest:
      - backend.connection.database.updateTable
    http: PUT "/backend/connection/{connection_id}/database/{table_name}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true }
    note: "Updates an existing table on a database"
  - tool: backend-connection-database-deleteTable
    category: backend
    rest:
      - backend.connection.database.deleteTable
    http: DELETE "/backend/connection/{connection_id}/database/{table_name}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true }
    note: "Deletes an existing table on a database"
  - tool: backend-connection-get
    category: backend
    rest:
      - backend.connection.get
    http: GET "/backend/connection/{connection_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a specific connection"
  - tool: backend-connection-update
    category: backend
    rest:
      - backend.connection.update
    http: PUT "/backend/connection/{connection_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true }
    note: "Updates an existing connection"
  - tool: backend-connection-delete
    category: backend
    rest:
      - backend.connection.delete
    http: DELETE "/backend/connection/{connection_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true }
    note: "Deletes an existing connection"
  - tool: backend-connection-filesystem-getAll
    category: backend
    rest:
      - backend.connection.filesystem.getAll
    http: GET "/backend/connection/{connection_id}/filesystem"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns all available files on the filesystem connection"
  - tool: backend-connection-filesystem-create
    category: backend
    rest:
      - backend.connection.filesystem.create
    http: POST "/backend/connection/{connection_id}/filesystem"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
    note: "Uploads one or more files on the filesystem connection"
  - tool: backend-connection-filesystem-get
    category: backend
    rest:
      - backend.connection.filesystem.get
    http: GET "/backend/connection/{connection_id}/filesystem/{file_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns the content of the provided file id on the filesystem connection"
  - tool: backend-connection-filesystem-update
    category: backend
    rest:
      - backend.connection.filesystem.update
    http: PUT "/backend/connection/{connection_id}/filesystem/{file_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true }
    note: "Updates an existing file on the filesystem connection"
  - tool: backend-connection-filesystem-delete
    category: backend
    rest:
      - backend.connection.filesystem.delete
    http: DELETE "/backend/connection/{connection_id}/filesystem/{file_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true }
    note: "Deletes an existing file on the filesystem connection"
  - tool: backend-connection-getClasses
    category: backend
    rest:
      - backend.connection.getClasses
    http: GET "/backend/connection/list"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns all available connection classes"
  - tool: backend-connection-getForm
    category: backend
    rest:
      - backend.connection.getForm
    http: GET "/backend/connection/form"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns the connection config form"
  - tool: backend-connection-getRedirect
    category: backend
    rest:
      - backend.connection.getRedirect
    http: GET "/backend/connection/{connection_id}/redirect"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a redirect url to start the OAuth2 authorization flow for the given connection"
  - tool: backend-connection-http-execute
    category: backend
    rest:
      - backend.connection.http.execute
    http: POST "/backend/connection/{connection_id}/http"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
    note: "Sends an arbitrary HTTP request to the connection"
  - tool: backend-connection-sdk-get
    category: backend
    rest:
      - backend.connection.sdk.get
    http: GET "/backend/connection/{connection_id}/sdk"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns the SDK specification"
  - tool: backend-cronjob-getAll
    category: backend
    rest:
      - backend.cronjob.getAll
    http: GET "/backend/cronjob"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a paginated list of cronjobs"
  - tool: backend-cronjob-create
    category: backend
    rest:
      - backend.cronjob.create
    http: POST "/backend/cronjob"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
    note: "Creates a new cronjob"
  - tool: backend-cronjob-get
    category: backend
    rest:
      - backend.cronjob.get
    http: GET "/backend/cronjob/{cronjob_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a specific cronjob"
  - tool: backend-cronjob-update
    category: backend
    rest:
      - backend.cronjob.update
    http: PUT "/backend/cronjob/{cronjob_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true }
    note: "Updates an existing cronjob"
  - tool: backend-cronjob-delete
    category: backend
    rest:
      - backend.cronjob.delete
    http: DELETE "/backend/cronjob/{cronjob_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true }
    note: "Deletes an existing cronjob"
  - tool: backend-dashboard-getAll
    category: backend
    rest:
      - backend.dashboard.getAll
    http: GET "/backend/dashboard"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns all available dashboard widgets"
  - tool: backend-event-getAll
    category: backend
    rest:
      - backend.event.getAll
    http: GET "/backend/event"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a paginated list of events"
  - tool: backend-event-create
    category: backend
    rest:
      - backend.event.create
    http: POST "/backend/event"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
    note: "Creates a new event"
  - tool: backend-event-get
    category: backend
    rest:
      - backend.event.get
    http: GET "/backend/event/{event_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a specific event"
  - tool: backend-event-update
    category: backend
    rest:
      - backend.event.update
    http: PUT "/backend/event/{event_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true }
    note: "Updates an existing event"
  - tool: backend-event-delete
    category: backend
    rest:
      - backend.event.delete
    http: DELETE "/backend/event/{event_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true }
    note: "Deletes an existing event"
  - tool: backend-firewall-getAll
    category: backend
    rest:
      - backend.firewall.getAll
    http: GET "/backend/firewall"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a paginated list of firewall rules"
  - tool: backend-firewall-create
    category: backend
    rest:
      - backend.firewall.create
    http: POST "/backend/firewall"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
    note: "Creates a new firewall rule"
  - tool: backend-firewall-get
    category: backend
    rest:
      - backend.firewall.get
    http: GET "/backend/firewall/{firewall_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a specific firewall rule"
  - tool: backend-firewall-update
    category: backend
    rest:
      - backend.firewall.update
    http: PUT "/backend/firewall/{firewall_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true }
    note: "Updates an existing firewall rule"
  - tool: backend-firewall-delete
    category: backend
    rest:
      - backend.firewall.delete
    http: DELETE "/backend/firewall/{firewall_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true }
    note: "Deletes an existing firewall rule"
  - tool: backend-form-getAll
    category: backend
    rest:
      - backend.form.getAll
    http: GET "/backend/form"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a paginated list of forms"
  - tool: backend-form-create
    category: backend
    rest:
      - backend.form.create
    http: POST "/backend/form"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
    note: "Creates a new form"
  - tool: backend-form-get
    category: backend
    rest:
      - backend.form.get
    http: GET "/backend/form/{form_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a specific form"
  - tool: backend-form-update
    category: backend
    rest:
      - backend.form.update
    http: PUT "/backend/form/{form_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true }
    note: "Updates an existing form"
  - tool: backend-form-delete
    category: backend
    rest:
      - backend.form.delete
    http: DELETE "/backend/form/{form_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true }
    note: "Deletes an existing form"
  - tool: backend-generator-getForm
    category: backend
    rest:
      - backend.generator.getForm
    http: GET "/backend/generator/{provider}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns the generator config form"
  - tool: backend-generator-getChangelog
    category: backend
    rest:
      - backend.generator.getChangelog
    http: PUT "/backend/generator/{provider}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true }
    note: "Generates a changelog of all potential changes if you execute this generator with the provided config"
  - tool: backend-generator-executeProvider
    category: backend
    rest:
      - backend.generator.executeProvider
    http: POST "/backend/generator/{provider}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
    note: "Executes a generator with the provided config"
  - tool: backend-generator-getClasses
    category: backend
    rest:
      - backend.generator.getClasses
    http: GET "/backend/generator"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns all available generator classes"
  - tool: backend-identity-getAll
    category: backend
    rest:
      - backend.identity.getAll
    http: GET "/backend/identity"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a paginated list of identities"
  - tool: backend-identity-create
    category: backend
    rest:
      - backend.identity.create
    http: POST "/backend/identity"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
    note: "Creates a new identity"
  - tool: backend-identity-get
    category: backend
    rest:
      - backend.identity.get
    http: GET "/backend/identity/{identity_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a specific identity"
  - tool: backend-identity-update
    category: backend
    rest:
      - backend.identity.update
    http: PUT "/backend/identity/{identity_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true }
    note: "Updates an existing identity"
  - tool: backend-identity-delete
    category: backend
    rest:
      - backend.identity.delete
    http: DELETE "/backend/identity/{identity_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true }
    note: "Deletes an existing identity"
  - tool: backend-identity-getClasses
    category: backend
    rest:
      - backend.identity.getClasses
    http: GET "/backend/identity/list"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns all available identity classes"
  - tool: backend-identity-getForm
    category: backend
    rest:
      - backend.identity.getForm
    http: GET "/backend/identity/form"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns the identity config form"
  - tool: backend-log-get
    category: backend
    rest:
      - backend.log.get
    http: GET "/backend/log/{log_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a specific log"
  - tool: backend-log-getAll
    category: backend
    rest:
      - backend.log.getAll
    http: GET "/backend/log"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a paginated list of logs"
  - tool: backend-log-getAllErrors
    category: backend
    rest:
      - backend.log.getAllErrors
    http: GET "/backend/log/error"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a paginated list of log errors"
  - tool: backend-log-getError
    category: backend
    rest:
      - backend.log.getError
    http: GET "/backend/log/error/{error_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a specific error"
  - tool: backend-marketplace-action-get
    category: backend
    rest:
      - backend.marketplace.action.get
    http: GET "/backend/marketplace/action/{user}/{name}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a specific marketplace action"
  - tool: backend-marketplace-action-upgrade
    category: backend
    rest:
      - backend.marketplace.action.upgrade
    http: PUT "/backend/marketplace/action/{user}/{name}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true }
    note: "Upgrades an action from the marketplace"
  - tool: backend-marketplace-action-getAll
    category: backend
    rest:
      - backend.marketplace.action.getAll
    http: GET "/backend/marketplace/action"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a paginated list of marketplace actions"
  - tool: backend-marketplace-action-install
    category: backend
    rest:
      - backend.marketplace.action.install
    http: POST "/backend/marketplace/action"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
    note: "Installs an action from the marketplace"
  - tool: backend-marketplace-app-get
    category: backend
    rest:
      - backend.marketplace.app.get
    http: GET "/backend/marketplace/app/{user}/{name}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a specific marketplace app"
  - tool: backend-marketplace-app-upgrade
    category: backend
    rest:
      - backend.marketplace.app.upgrade
    http: PUT "/backend/marketplace/app/{user}/{name}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true }
    note: "Upgrades an app from the marketplace"
  - tool: backend-marketplace-app-getAll
    category: backend
    rest:
      - backend.marketplace.app.getAll
    http: GET "/backend/marketplace/app"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a paginated list of marketplace apps"
  - tool: backend-marketplace-app-install
    category: backend
    rest:
      - backend.marketplace.app.install
    http: POST "/backend/marketplace/app"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
    note: "Installs an app from the marketplace"
  - tool: backend-marketplace-bundle-get
    category: backend
    rest:
      - backend.marketplace.bundle.get
    http: GET "/backend/marketplace/bundle/{user}/{name}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a specific marketplace bundle"
  - tool: backend-marketplace-bundle-upgrade
    category: backend
    rest:
      - backend.marketplace.bundle.upgrade
    http: PUT "/backend/marketplace/bundle/{user}/{name}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true }
    note: "Upgrades an bundle from the marketplace"
  - tool: backend-marketplace-bundle-getAll
    category: backend
    rest:
      - backend.marketplace.bundle.getAll
    http: GET "/backend/marketplace/bundle"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a paginated list of marketplace bundles"
  - tool: backend-marketplace-bundle-install
    category: backend
    rest:
      - backend.marketplace.bundle.install
    http: POST "/backend/marketplace/bundle"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
    note: "Installs an bundle from the marketplace"
  - tool: backend-operation-getAll
    category: backend
    rest:
      - backend.operation.getAll
    http: GET "/backend/operation"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a paginated list of operations"
  - tool: backend-operation-create
    category: backend
    rest:
      - backend.operation.create
    http: POST "/backend/operation"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
    note: "Creates a new operation"
  - tool: backend-operation-get
    category: backend
    rest:
      - backend.operation.get
    http: GET "/backend/operation/{operation_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a specific operation"
  - tool: backend-operation-update
    category: backend
    rest:
      - backend.operation.update
    http: PUT "/backend/operation/{operation_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true }
    note: "Updates an existing operation"
  - tool: backend-operation-delete
    category: backend
    rest:
      - backend.operation.delete
    http: DELETE "/backend/operation/{operation_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true }
    note: "Deletes an existing operation"
  - tool: backend-page-getAll
    category: backend
    rest:
      - backend.page.getAll
    http: GET "/backend/page"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a paginated list of pages"
  - tool: backend-page-create
    category: backend
    rest:
      - backend.page.create
    http: POST "/backend/page"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
    note: "Creates a new page"
  - tool: backend-page-get
    category: backend
    rest:
      - backend.page.get
    http: GET "/backend/page/{page_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a specific page"
  - tool: backend-page-update
    category: backend
    rest:
      - backend.page.update
    http: PUT "/backend/page/{page_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true }
    note: "Updates an existing page"
  - tool: backend-page-delete
    category: backend
    rest:
      - backend.page.delete
    http: DELETE "/backend/page/{page_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true }
    note: "Deletes an existing page"
  - tool: backend-plan-getAll
    category: backend
    rest:
      - backend.plan.getAll
    http: GET "/backend/plan"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a paginated list of plans"
  - tool: backend-plan-create
    category: backend
    rest:
      - backend.plan.create
    http: POST "/backend/plan"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
    note: "Creates a new plan"
  - tool: backend-plan-get
    category: backend
    rest:
      - backend.plan.get
    http: GET "/backend/plan/{plan_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a specific plan"
  - tool: backend-plan-update
    category: backend
    rest:
      - backend.plan.update
    http: PUT "/backend/plan/{plan_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true }
    note: "Updates an existing plan"
  - tool: backend-plan-delete
    category: backend
    rest:
      - backend.plan.delete
    http: DELETE "/backend/plan/{plan_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true }
    note: "Deletes an existing plan"
  - tool: backend-rate-getAll
    category: backend
    rest:
      - backend.rate.getAll
    http: GET "/backend/rate"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a paginated list of rate limitations"
  - tool: backend-rate-create
    category: backend
    rest:
      - backend.rate.create
    http: POST "/backend/rate"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
    note: "Creates a new rate limitation"
  - tool: backend-rate-get
    category: backend
    rest:
      - backend.rate.get
    http: GET "/backend/rate/{rate_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a specific rate"
  - tool: backend-rate-update
    category: backend
    rest:
      - backend.rate.update
    http: PUT "/backend/rate/{rate_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true }
    note: "Updates an existing rate"
  - tool: backend-rate-delete
    category: backend
    rest:
      - backend.rate.delete
    http: DELETE "/backend/rate/{rate_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true }
    note: "Deletes an existing rate"
  - tool: backend-role-getAll
    category: backend
    rest:
      - backend.role.getAll
    http: GET "/backend/role"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a paginated list of roles"
  - tool: backend-role-create
    category: backend
    rest:
      - backend.role.create
    http: POST "/backend/role"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
    note: "Creates a new role"
  - tool: backend-role-get
    category: backend
    rest:
      - backend.role.get
    http: GET "/backend/role/{role_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a specific role"
  - tool: backend-role-update
    category: backend
    rest:
      - backend.role.update
    http: PUT "/backend/role/{role_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true }
    note: "Updates an existing role"
  - tool: backend-role-delete
    category: backend
    rest:
      - backend.role.delete
    http: DELETE "/backend/role/{role_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true }
    note: "Deletes an existing role"
  - tool: backend-schema-getAll
    category: backend
    rest:
      - backend.schema.getAll
    http: GET "/backend/schema"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a paginated list of schemas"
  - tool: backend-schema-create
    category: backend
    rest:
      - backend.schema.create
    http: POST "/backend/schema"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
    note: "Creates a new schema"
  - tool: backend-schema-get
    category: backend
    rest:
      - backend.schema.get
    http: GET "/backend/schema/{schema_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a specific schema"
  - tool: backend-schema-update
    category: backend
    rest:
      - backend.schema.update
    http: PUT "/backend/schema/{schema_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true }
    note: "Updates an existing schema"
  - tool: backend-schema-delete
    category: backend
    rest:
      - backend.schema.delete
    http: DELETE "/backend/schema/{schema_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true }
    note: "Deletes an existing schema"
  - tool: backend-schema-getCommits
    category: backend
    rest:
      - backend.schema.getCommits
    http: GET "/backend/schema/{schema_id}/commit"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a paginated list of schema commits"
  - tool: backend-schema-getPreview
    category: backend
    rest:
      - backend.schema.getPreview
    http: POST "/backend/schema/preview/{schema_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
    note: "Returns a HTML preview of the provided schema"
  - tool: backend-scope-getAll
    category: backend
    rest:
      - backend.scope.getAll
    http: GET "/backend/scope"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a paginated list of scopes"
  - tool: backend-scope-create
    category: backend
    rest:
      - backend.scope.create
    http: POST "/backend/scope"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
    note: "Creates a new scope"
  - tool: backend-scope-get
    category: backend
    rest:
      - backend.scope.get
    http: GET "/backend/scope/{scope_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a specific scope"
  - tool: backend-scope-update
    category: backend
    rest:
      - backend.scope.update
    http: PUT "/backend/scope/{scope_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true }
    note: "Updates an existing scope"
  - tool: backend-scope-delete
    category: backend
    rest:
      - backend.scope.delete
    http: DELETE "/backend/scope/{scope_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true }
    note: "Deletes an existing scope"
  - tool: backend-scope-getCategories
    category: backend
    rest:
      - backend.scope.getCategories
    http: GET "/backend/scope/categories"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns all available scopes grouped by category"
  - tool: backend-sdk-getAll
    category: backend
    rest:
      - backend.sdk.getAll
    http: GET "/backend/sdk"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a paginated list of SDKs"
  - tool: backend-sdk-generate
    category: backend
    rest:
      - backend.sdk.generate
    http: POST "/backend/sdk"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
    note: "Generates a specific SDK"
  - tool: backend-specification-get
    category: backend
    rest:
      - backend.specification.get
    http: GET "/backend/specification"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns the TypeHub specification"
  - tool: backend-specification-publish
    category: backend
    rest:
      - backend.specification.publish
    http: POST "/backend/specification"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
    note: "Publish the specification"
  - tool: backend-specification-getChangelog
    category: backend
    rest:
      - backend.specification.getChangelog
    http: GET "/backend/specification/changelog"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns the changelog between your current specification and the last tag"
  - tool: backend-specification-tag
    category: backend
    rest:
      - backend.specification.tag
    http: POST "/backend/specification/tag"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
    note: "Creates a new tag of your specification"
  - tool: backend-statistic-getActivitiesPerUser
    category: backend
    rest:
      - backend.statistic.getActivitiesPerUser
    http: GET "/backend/statistic/activities_per_user"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a statistic containing the activities per user"
  - tool: backend-statistic-getCountRequests
    category: backend
    rest:
      - backend.statistic.getCountRequests
    http: GET "/backend/statistic/count_requests"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a statistic containing the request count"
  - tool: backend-statistic-getErrorsPerOperation
    category: backend
    rest:
      - backend.statistic.getErrorsPerOperation
    http: GET "/backend/statistic/errors_per_operation"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a statistic containing the errors per operation"
  - tool: backend-statistic-getIncomingRequests
    category: backend
    rest:
      - backend.statistic.getIncomingRequests
    http: GET "/backend/statistic/incoming_requests"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a statistic containing the incoming requests"
  - tool: backend-statistic-getIncomingTransactions
    category: backend
    rest:
      - backend.statistic.getIncomingTransactions
    http: GET "/backend/statistic/incoming_transactions"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a statistic containing the incoming transactions"
  - tool: backend-statistic-getIssuedTokens
    category: backend
    rest:
      - backend.statistic.getIssuedTokens
    http: GET "/backend/statistic/issued_tokens"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a statistic containing the issues tokens"
  - tool: backend-statistic-getMostUsedActivities
    category: backend
    rest:
      - backend.statistic.getMostUsedActivities
    http: GET "/backend/statistic/most_used_activities"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a statistic containing the most used activities"
  - tool: backend-statistic-getMostUsedApps
    category: backend
    rest:
      - backend.statistic.getMostUsedApps
    http: GET "/backend/statistic/most_used_apps"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a statistic containing the most used apps"
  - tool: backend-statistic-getMostUsedOperations
    category: backend
    rest:
      - backend.statistic.getMostUsedOperations
    http: GET "/backend/statistic/most_used_operations"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a statistic containing the most used operations"
  - tool: backend-statistic-getRequestsPerIP
    category: backend
    rest:
      - backend.statistic.getRequestsPerIP
    http: GET "/backend/statistic/requests_per_ip"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a statistic containing the requests per ip"
  - tool: backend-statistic-getRequestsPerOperation
    category: backend
    rest:
      - backend.statistic.getRequestsPerOperation
    http: GET "/backend/statistic/requests_per_operation"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a statistic containing the requests per operation"
  - tool: backend-statistic-getRequestsPerUser
    category: backend
    rest:
      - backend.statistic.getRequestsPerUser
    http: GET "/backend/statistic/requests_per_user"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a statistic containing the requests per user"
  - tool: backend-statistic-getTestCoverage
    category: backend
    rest:
      - backend.statistic.getTestCoverage
    http: GET "/backend/statistic/test_coverage"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a statistic containing the test coverage"
  - tool: backend-statistic-getTimeAverage
    category: backend
    rest:
      - backend.statistic.getTimeAverage
    http: GET "/backend/statistic/time_average"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a statistic containing the time average"
  - tool: backend-statistic-getTimePerOperation
    category: backend
    rest:
      - backend.statistic.getTimePerOperation
    http: GET "/backend/statistic/time_per_operation"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a statistic containing the time per operation"
  - tool: backend-statistic-getUsedPoints
    category: backend
    rest:
      - backend.statistic.getUsedPoints
    http: GET "/backend/statistic/used_points"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a statistic containing the used points"
  - tool: backend-statistic-getUserRegistrations
    category: backend
    rest:
      - backend.statistic.getUserRegistrations
    http: GET "/backend/statistic/user_registrations"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a statistic containing the user registrations"
  - tool: backend-taxonomy-getAll
    category: backend
    rest:
      - backend.taxonomy.getAll
    http: GET "/backend/taxonomy"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a paginated list of taxonomies"
  - tool: backend-taxonomy-create
    category: backend
    rest:
      - backend.taxonomy.create
    http: POST "/backend/taxonomy"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
    note: "Creates a new taxonomy"
  - tool: backend-taxonomy-get
    category: backend
    rest:
      - backend.taxonomy.get
    http: GET "/backend/taxonomy/{taxonomy_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a specific taxonomy"
  - tool: backend-taxonomy-update
    category: backend
    rest:
      - backend.taxonomy.update
    http: PUT "/backend/taxonomy/{taxonomy_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true }
    note: "Updates an existing taxonomy"
  - tool: backend-taxonomy-move
    category: backend
    rest:
      - backend.taxonomy.move
    http: POST "/backend/taxonomy/{taxonomy_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
    note: "Moves the provided ids to the taxonomy"
  - tool: backend-taxonomy-delete
    category: backend
    rest:
      - backend.taxonomy.delete
    http: DELETE "/backend/taxonomy/{taxonomy_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true }
    note: "Deletes an existing taxonomy"
  - tool: backend-tenant-setup
    category: backend
    rest:
      - backend.tenant.setup
    http: PUT "/backend/tenant/{tenant_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true }
    note: "Setup a new tenant"
  - tool: backend-tenant-remove
    category: backend
    rest:
      - backend.tenant.remove
    http: DELETE "/backend/tenant/{tenant_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true }
    note: "Removes an existing tenant"
  - tool: backend-test-get
    category: backend
    rest:
      - backend.test.get
    http: GET "/backend/test/{test_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a specific test"
  - tool: backend-test-update
    category: backend
    rest:
      - backend.test.update
    http: PUT "/backend/test/{test_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true }
    note: "Updates an existing test"
  - tool: backend-test-getAll
    category: backend
    rest:
      - backend.test.getAll
    http: GET "/backend/test"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a paginated list of tests"
  - tool: backend-test-refresh
    category: backend
    rest:
      - backend.test.refresh
    http: PUT "/backend/test"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true }
    note: "Refresh all tests"
  - tool: backend-test-run
    category: backend
    rest:
      - backend.test.run
    http: POST "/backend/test"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
    note: "Run all tests"
  - tool: backend-token-get
    category: backend
    rest:
      - backend.token.get
    http: GET "/backend/token/{token_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a specific token"
  - tool: backend-token-getAll
    category: backend
    rest:
      - backend.token.getAll
    http: GET "/backend/token"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a paginated list of tokens"
  - tool: backend-transaction-get
    category: backend
    rest:
      - backend.transaction.get
    http: GET "/backend/transaction/{transaction_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a specific transaction"
  - tool: backend-transaction-getAll
    category: backend
    rest:
      - backend.transaction.getAll
    http: GET "/backend/transaction"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a paginated list of transactions"
  - tool: backend-trash-getAllByType
    category: backend
    rest:
      - backend.trash.getAllByType
    http: GET "/backend/trash/{type}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns all deleted records by trash type"
  - tool: backend-trash-restore
    category: backend
    rest:
      - backend.trash.restore
    http: POST "/backend/trash/{type}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
    note: "Restores a previously deleted record"
  - tool: backend-trash-getTypes
    category: backend
    rest:
      - backend.trash.getTypes
    http: GET "/backend/trash"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns all trash types"
  - tool: backend-trigger-getAll
    category: backend
    rest:
      - backend.trigger.getAll
    http: GET "/backend/trigger"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a paginated list of triggers"
  - tool: backend-trigger-create
    category: backend
    rest:
      - backend.trigger.create
    http: POST "/backend/trigger"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
    note: "Creates a new trigger"
  - tool: backend-trigger-get
    category: backend
    rest:
      - backend.trigger.get
    http: GET "/backend/trigger/{trigger_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a specific trigger"
  - tool: backend-trigger-update
    category: backend
    rest:
      - backend.trigger.update
    http: PUT "/backend/trigger/{trigger_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true }
    note: "Updates an existing trigger"
  - tool: backend-trigger-delete
    category: backend
    rest:
      - backend.trigger.delete
    http: DELETE "/backend/trigger/{trigger_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true }
    note: "Deletes an existing trigger"
  - tool: backend-user-getAll
    category: backend
    rest:
      - backend.user.getAll
    http: GET "/backend/user"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a paginated list of users"
  - tool: backend-user-create
    category: backend
    rest:
      - backend.user.create
    http: POST "/backend/user"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
    note: "Creates a new user"
  - tool: backend-user-get
    category: backend
    rest:
      - backend.user.get
    http: GET "/backend/user/{user_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a specific user"
  - tool: backend-user-update
    category: backend
    rest:
      - backend.user.update
    http: PUT "/backend/user/{user_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true }
    note: "Updates an existing user"
  - tool: backend-user-delete
    category: backend
    rest:
      - backend.user.delete
    http: DELETE "/backend/user/{user_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true }
    note: "Deletes an existing user"
  - tool: backend-user-resend
    category: backend
    rest:
      - backend.user.resend
    http: POST "/backend/user/{user_id}/resend"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
    note: "Resend the activation mail to the provided user"
  - tool: backend-webhook-getAll
    category: backend
    rest:
      - backend.webhook.getAll
    http: GET "/backend/webhook"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a paginated list of webhooks"
  - tool: backend-webhook-create
    category: backend
    rest:
      - backend.webhook.create
    http: POST "/backend/webhook"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
    note: "Creates a new webhook"
  - tool: backend-webhook-get
    category: backend
    rest:
      - backend.webhook.get
    http: GET "/backend/webhook/{webhook_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a specific webhook"
  - tool: backend-webhook-update
    category: backend
    rest:
      - backend.webhook.update
    http: PUT "/backend/webhook/{webhook_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true }
    note: "Updates an existing webhook"
  - tool: backend-webhook-delete
    category: backend
    rest:
      - backend.webhook.delete
    http: DELETE "/backend/webhook/{webhook_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true }
    note: "Deletes an existing webhook"
  - tool: consumer-account-activate
    category: consumer
    rest:
      - consumer.account.activate
    http: POST "/consumer/activate"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
    note: "Activates an previously registered account through a token which was provided to the user via email"
  - tool: consumer-account-getApp
    category: consumer
    rest:
      - consumer.account.getApp
    http: GET "/consumer/authorize"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns information about a specific app to start the OAuth2 authorization code flow"
  - tool: consumer-account-authorize
    category: consumer
    rest:
      - consumer.account.authorize
    http: POST "/consumer/authorize"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
    note: "Authorizes the access of a specific app for the authenticated user"
  - tool: consumer-account-changePassword
    category: consumer
    rest:
      - consumer.account.changePassword
    http: PUT "/consumer/account/change_password"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true }
    note: "Change the password for the authenticated user"
  - tool: consumer-account-executePasswordReset
    category: consumer
    rest:
      - consumer.account.executePasswordReset
    http: PUT "/consumer/password_reset"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true }
    note: "Change the password after the password reset flow was started"
  - tool: consumer-account-requestPasswordReset
    category: consumer
    rest:
      - consumer.account.requestPasswordReset
    http: POST "/consumer/password_reset"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
    note: "Start the password reset flow"
  - tool: consumer-account-get
    category: consumer
    rest:
      - consumer.account.get
    http: GET "/consumer/account"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a user data for the authenticated user"
  - tool: consumer-account-update
    category: consumer
    rest:
      - consumer.account.update
    http: PUT "/consumer/account"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true }
    note: "Updates user data for the authenticated user"
  - tool: consumer-account-refresh
    category: consumer
    rest:
      - consumer.account.refresh
    http: PUT "/consumer/login"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true }
    note: "Refresh a previously obtained access token"
  - tool: consumer-account-login
    category: consumer
    rest:
      - consumer.account.login
    http: POST "/consumer/login"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
    note: "User login by providing a username and password"
  - tool: consumer-account-register
    category: consumer
    rest:
      - consumer.account.register
    http: POST "/consumer/register"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
    note: "Register a new user account"
  - tool: consumer-agent-get
    category: consumer
    rest:
      - consumer.agent.get
    http: GET "/consumer/agent/{agent_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a specific agent"
  - tool: consumer-agent-getAll
    category: consumer
    rest:
      - consumer.agent.getAll
    http: GET "/consumer/agent"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a paginated list of agents"
  - tool: consumer-agent-message-getAll
    category: consumer
    rest:
      - consumer.agent.message.getAll
    http: GET "/consumer/agent/{agent_id}/message"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a paginated list of agent messages"
  - tool: consumer-agent-message-submit
    category: consumer
    rest:
      - consumer.agent.message.submit
    http: POST "/consumer/agent/{agent_id}/message"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
    note: "Submits a new agent message"
  - tool: consumer-app-getAll
    category: consumer
    rest:
      - consumer.app.getAll
    http: GET "/consumer/app"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a paginated list of apps which are assigned to the authenticated user"
  - tool: consumer-app-create
    category: consumer
    rest:
      - consumer.app.create
    http: POST "/consumer/app"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
    note: "Creates a new app for the authenticated user"
  - tool: consumer-app-get
    category: consumer
    rest:
      - consumer.app.get
    http: GET "/consumer/app/{app_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a specific app for the authenticated user"
  - tool: consumer-app-update
    category: consumer
    rest:
      - consumer.app.update
    http: PUT "/consumer/app/{app_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true }
    note: "Updates an existing app for the authenticated user"
  - tool: consumer-app-delete
    category: consumer
    rest:
      - consumer.app.delete
    http: DELETE "/consumer/app/{app_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true }
    note: "Deletes an existing app for the authenticated user"
  - tool: consumer-event-get
    category: consumer
    rest:
      - consumer.event.get
    http: GET "/consumer/event/{event_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a specific event for the authenticated user"
  - tool: consumer-event-getAll
    category: consumer
    rest:
      - consumer.event.getAll
    http: GET "/consumer/event"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a paginated list of apps which are assigned to the authenticated user"
  - tool: consumer-form-get
    category: consumer
    rest:
      - consumer.form.get
    http: GET "/consumer/form/{form_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a specific form for the authenticated user"
  - tool: consumer-form-getAll
    category: consumer
    rest:
      - consumer.form.getAll
    http: GET "/consumer/form"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a paginated list of forms which are relevant to the authenticated user"
  - tool: consumer-grant-delete
    category: consumer
    rest:
      - consumer.grant.delete
    http: DELETE "/consumer/grant/{grant_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true }
    note: "Deletes an existing grant for an app which was created by the authenticated user"
  - tool: consumer-grant-getAll
    category: consumer
    rest:
      - consumer.grant.getAll
    http: GET "/consumer/grant"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a paginated list of grants which are assigned to the authenticated user"
  - tool: consumer-identity-exchange
    category: consumer
    rest:
      - consumer.identity.exchange
    http: GET "/consumer/identity/{identity}/exchange"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Identity callback endpoint to exchange an access token"
  - tool: consumer-identity-getAll
    category: consumer
    rest:
      - consumer.identity.getAll
    http: GET "/consumer/identity"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a paginated list of identities which are relevant to the authenticated user"
  - tool: consumer-identity-redirect
    category: consumer
    rest:
      - consumer.identity.redirect
    http: GET "/consumer/identity/{identity}/redirect"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Redirect the user to the configured identity provider"
  - tool: consumer-log-get
    category: consumer
    rest:
      - consumer.log.get
    http: GET "/consumer/log/{log_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a specific log for the authenticated user"
  - tool: consumer-log-getAll
    category: consumer
    rest:
      - consumer.log.getAll
    http: GET "/consumer/log"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a paginated list of logs which are assigned to the authenticated user"
  - tool: consumer-page-get
    category: consumer
    rest:
      - consumer.page.get
    http: GET "/consumer/page/{page_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a specific page for the authenticated user"
  - tool: consumer-page-getAll
    category: consumer
    rest:
      - consumer.page.getAll
    http: GET "/consumer/page"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a paginated list of pages which are relevant to the authenticated user"
  - tool: consumer-payment-checkout
    category: consumer
    rest:
      - consumer.payment.checkout
    http: POST "/consumer/payment/{provider}/checkout"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
    note: "Start the checkout process for a specific plan"
  - tool: consumer-payment-portal
    category: consumer
    rest:
      - consumer.payment.portal
    http: POST "/consumer/payment/{provider}/portal"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
    note: "Generates a payment portal link for the authenticated user"
  - tool: consumer-plan-get
    category: consumer
    rest:
      - consumer.plan.get
    http: GET "/consumer/plan/{plan_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a specific plan for the authenticated user"
  - tool: consumer-plan-getAll
    category: consumer
    rest:
      - consumer.plan.getAll
    http: GET "/consumer/plan"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a paginated list of plans which are relevant to the authenticated user"
  - tool: consumer-scope-getAll
    category: consumer
    rest:
      - consumer.scope.getAll
    http: GET "/consumer/scope"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a paginated list of scopes which are assigned to the authenticated user"
  - tool: consumer-scope-getCategories
    category: consumer
    rest:
      - consumer.scope.getCategories
    http: GET "/consumer/scope/categories"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns all scopes by category"
  - tool: consumer-token-getAll
    category: consumer
    rest:
      - consumer.token.getAll
    http: GET "/consumer/token"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a paginated list of tokens which are assigned to the authenticated user"
  - tool: consumer-token-create
    category: consumer
    rest:
      - consumer.token.create
    http: POST "/consumer/token"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
    note: "Creates a new token for the authenticated user"
  - tool: consumer-token-get
    category: consumer
    rest:
      - consumer.token.get
    http: GET "/consumer/token/{token_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a specific token for the authenticated user"
  - tool: consumer-token-update
    category: consumer
    rest:
      - consumer.token.update
    http: PUT "/consumer/token/{token_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true }
    note: "Updates an existing token for the authenticated user"
  - tool: consumer-token-delete
    category: consumer
    rest:
      - consumer.token.delete
    http: DELETE "/consumer/token/{token_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true }
    note: "Deletes an existing token for the authenticated user"
  - tool: consumer-transaction-get
    category: consumer
    rest:
      - consumer.transaction.get
    http: GET "/consumer/transaction/{transaction_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a specific transaction for the authenticated user"
  - tool: consumer-transaction-getAll
    category: consumer
    rest:
      - consumer.transaction.getAll
    http: GET "/consumer/transaction"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a paginated list of transactions which are assigned to the authenticated user"
  - tool: consumer-webhook-getAll
    category: consumer
    rest:
      - consumer.webhook.getAll
    http: GET "/consumer/webhook"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a paginated list of webhooks which are assigned to the authenticated user"
  - tool: consumer-webhook-create
    category: consumer
    rest:
      - consumer.webhook.create
    http: POST "/consumer/webhook"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
    note: "Creates a new webhook for the authenticated user"
  - tool: consumer-webhook-get
    category: consumer
    rest:
      - consumer.webhook.get
    http: GET "/consumer/webhook/{webhook_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns a specific webhook for the authenticated user"
  - tool: consumer-webhook-update
    category: consumer
    rest:
      - consumer.webhook.update
    http: PUT "/consumer/webhook/{webhook_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true }
    note: "Updates an existing webhook for the authenticated user"
  - tool: consumer-webhook-delete
    category: consumer
    rest:
      - consumer.webhook.delete
    http: DELETE "/consumer/webhook/{webhook_id}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true }
    note: "Deletes an existing webhook for the authenticated user"
  - tool: system-connection-callback
    category: system
    rest:
      - system.connection.callback
    http: GET "/system/connection/{name}/callback"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Connection OAuth2 callback to authorize a connection"
  - tool: system-meta-getAbout
    category: system
    rest:
      - system.meta.getAbout
    http: GET "/system/about"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns meta information and links about the current installed Fusio version"
  - tool: system-meta-getDebug
    category: system
    rest:
      - system.meta.getDebug
    http: POST "/system/debug"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
    note: "Debug endpoint which returns the provided data"
  - tool: system-meta-getHealth
    category: system
    rest:
      - system.meta.getHealth
    http: GET "/system/health"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Health check endpoint which returns information about the health status of the system"
  - tool: system-meta-getRoutes
    category: system
    rest:
      - system.meta.getRoutes
    http: GET "/system/route"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns all available routes"
  - tool: system-meta-getSchema
    category: system
    rest:
      - system.meta.getSchema
    http: GET "/system/schema/{name}"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns details of a specific schema"
  - tool: system-payment-webhook
    category: system
    rest:
      - system.payment.webhook
    http: POST "/system/payment/{provider}/webhook"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
    note: "Payment webhook endpoint after successful purchase of a plan"
  - tool: authorization-getWhoami
    category: authorization
    rest:
      - authorization.getWhoami
    http: GET "/authorization/whoami"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
    note: "Returns user data of the current authenticated user"
  - tool: authorization-revoke
    category: authorization
    rest:
      - authorization.revoke
    http: POST "/authorization/revoke"
    binding: one-to-one
    confidence: high
    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
    note: "Revoke the access token of the current authenticated user"
mcp_only: []
rest_only: []
maintainers:
  - FN: Kin Lane
    email: kin@apievangelist.com