Acronis Event Manager API

The Acronis Event Manager API allows users to monitor and manage events across their entire Acronis ecosystem with real-time access to event data.

Operations 6

GET /topics #
GET /topics/offsets #
GET /types #
POST /subscriptions #
GET /subscriptions/offset #
GET /events #

Work with this as data

Every API here is available over the APIs.io API and to AI agents over MCP.

MCP server

One button, every client — Claude, Cursor, VS Code and the rest.

https://apis.io/mcp

Tools for apis

7 MCP tools reach this
  • find_apisBrowse and filter every API in the catalog.
  • get_api_artifactsOne API's artifacts, grouped by type.
  • get_openapiThe primary OpenAPI for this API.
  • find_similar_apisAPIs that look like this one.
  • apis_io_searchSTART HERE — APIs, providers and tags for one query, each with its total.
  • resolveTurn a domain, URL or GitHub org into the provider it belongs to.
  • find_cohortsEvery scored population of providers in the catalog.
All 92 tools →

Call it yourself

curl for this page
This API
curl "https://apis.io/api/v1/apis/event-manager-api"
All apis
curl "https://apis.io/api/v1/apis?limit=25"

Discovery needs no key. Ratings and market analysis are Pro.

Get an API key

Free tier, no form to fill in. Signing in shares your email address with us — we store it to create your key and to recognise you if you sign in with another provider. See our Privacy Policy and Terms.

A second provider on the same verified email joins the account you already have.

OpenAPI Specification

acronis-events-v1-openapi.json Raw ↑
{
  "openapi": "3.0.0",
  "info": {
    "title": "Event Manager API",
    "description": "Event Manager API describes the interface for event publishing and subscription management.",
    "version": "v1"
  },
  "paths": {
    "/topics": {
      "get": {
        "operationId": "Fetch topics",
        "description": "Fetch a list of all available topics that client is allowed to publish or subscribe to.",
        "parameters": [
          {
            "name": "topic_id",
            "description": "Optional. Specific topic ID to fetch. Wildcard is not supported.",
            "in": "query",
            "schema": {
              "description": "Optional. Specific topic ID to fetch. Wildcard is not supported.",
              "x-cti.reference": "cti.a.p.em.topic.v1.0",
              "type": "string",
              "pattern": "^cti\\.([a-z][a-z0-9_]*\\.[a-z][a-z0-9_]*\\.[a-z_][a-z0-9_.]*\\.v[\\d]+\\.[\\d]+)(~([a-z][a-z0-9_]*\\.[a-z][a-z0-9_]*\\.[a-z_][a-z0-9_.]*\\.v[\\d]+\\.[\\d]+))*(~[0-9a-f]{8}\\b-[0-9a-f]{4}\\b-[0-9a-f]{4}\\b-[0-9a-f]{4}\\b-[0-9a-f]{12})?$",
              "maxLength": 1024
            },
            "x-cti.reference": "cti.a.p.em.topic.v1.0"
          }
        ],
        "responses": {
          "200": {
            "description": "List of topics",
            "content": {
              "application/json": {
                "schema": {
                  "type": "array",
                  "items": {
                    "$ref": "#/components/schemas/Topic"
                  }
                }
              }
            }
          },
          "401": {
            "description": "Method required an authenticated user",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorMessage"
                }
              }
            }
          },
          "403": {
            "description": "Current user has no permissions for this URL/method",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorMessage"
                }
              }
            }
          },
          "500": {
            "description": "Internal service error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorMessage"
                }
              }
            }
          }
        },
        "security": [
          {
            "oauth2": [
              "urn:acronis.com:event_manager:{cti_query}:publisher",
              "urn:acronis.com:event_manager:{cti_query}:subscriber"
            ]
          }
        ]
      }
    },
    "/topics/offsets": {
      "get": {
        "operationId": "Fetch topic offsets",
        "description": "Fetch the latest offset for a specific topic, providing a global view of the current stream state.",
        "parameters": [
          {
            "name": "topic_id",
            "description": "Required, Topic ID to fetch the offset for.",
            "required": true,
            "in": "query",
            "schema": {
              "description": "Required, Topic ID to fetch the offset for.",
              "x-cti.reference": "cti.a.p.em.topic.v1.0",
              "type": "string",
              "pattern": "^cti\\.([a-z][a-z0-9_]*\\.[a-z][a-z0-9_]*\\.[a-z_][a-z0-9_.]*\\.v[\\d]+\\.[\\d]+)(~([a-z][a-z0-9_]*\\.[a-z][a-z0-9_]*\\.[a-z_][a-z0-9_.]*\\.v[\\d]+\\.[\\d]+))*(~[0-9a-f]{8}\\b-[0-9a-f]{4}\\b-[0-9a-f]{4}\\b-[0-9a-f]{4}\\b-[0-9a-f]{12})?$",
              "maxLength": 1024
            },
            "x-cti.reference": "cti.a.p.em.topic.v1.0"
          },
          {
            "name": "position",
            "description": "Required, the position to fetch the offset for.\n",
            "required": true,
            "in": "query",
            "schema": {
              "description": "Required, the position to fetch the offset for.\n",
              "enum": [
                "EARLIEST",
                "TIMESTAMP",
                "CURRENT"
              ],
              "type": "string"
            }
          },
          {
            "name": "timestamp",
            "description": "Required for timestamp positions. Fetch the offset position to the neares future from a specific time. The timestamp is specified in ISO 8601 format using the RFC 3339 profile.\n",
            "in": "query",
            "schema": {
              "description": "Required for timestamp positions. Fetch the offset position to the neares future from a specific time. The timestamp is specified in ISO 8601 format using the RFC 3339 profile.\n",
              "type": "string",
              "format": "date-time"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/GetTopicsOffsetResponse"
                }
              }
            }
          },
          "401": {
            "description": "Method required an authenticated user",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorMessage"
                }
              }
            }
          },
          "403": {
            "description": "Current user has no permissions for this URL/method",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorMessage"
                }
              }
            }
          },
          "500": {
            "description": "Internal service error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorMessage"
                }
              }
            }
          }
        },
        "security": [
          {
            "oauth2": [
              "urn:acronis.com:event_manager:{cti_query}:publisher",
              "urn:acronis.com:event_manager:{cti_query}:subscriber"
            ]
          }
        ]
      }
    },
    "/types": {
      "get": {
        "operationId": "Fetch event types",
        "description": "Fetch a list of all available event types that client is allowed to publish or subscribe to.",
        "parameters": [
          {
            "name": "topic_id",
            "description": "Optional. Topic ID to fetch the event types for.",
            "in": "query",
            "schema": {
              "description": "Optional. Topic ID to fetch the event types for.",
              "x-cti.reference": "cti.a.p.em.topic.v1.0",
              "type": "string",
              "pattern": "^cti\\.([a-z][a-z0-9_]*\\.[a-z][a-z0-9_]*\\.[a-z_][a-z0-9_.]*\\.v[\\d]+\\.[\\d]+)(~([a-z][a-z0-9_]*\\.[a-z][a-z0-9_]*\\.[a-z_][a-z0-9_.]*\\.v[\\d]+\\.[\\d]+))*(~[0-9a-f]{8}\\b-[0-9a-f]{4}\\b-[0-9a-f]{4}\\b-[0-9a-f]{4}\\b-[0-9a-f]{12})?$",
              "maxLength": 1024
            },
            "x-cti.reference": "cti.a.p.em.topic.v1.0"
          },
          {
            "name": "type_id",
            "description": "Optional. Specific event type ID to fetch.",
            "in": "query",
            "schema": {
              "description": "Optional. Specific event type ID to fetch.",
              "x-cti.reference": "cti.a.p.em.event.v1.0",
              "type": "string",
              "pattern": "^cti\\.([a-z][a-z0-9_]*\\.[a-z][a-z0-9_]*\\.[a-z_][a-z0-9_.]*\\.v[\\d]+\\.[\\d]+)(~([a-z][a-z0-9_]*\\.[a-z][a-z0-9_]*\\.[a-z_][a-z0-9_.]*\\.v[\\d]+\\.[\\d]+))*(~[0-9a-f]{8}\\b-[0-9a-f]{4}\\b-[0-9a-f]{4}\\b-[0-9a-f]{4}\\b-[0-9a-f]{12})?$",
              "maxLength": 1024
            },
            "x-cti.reference": "cti.a.p.em.event.v1.0"
          },
          {
            "name": "include_schema",
            "description": "Optional. Include the schema of the event type.",
            "in": "query",
            "schema": {
              "description": "Optional. Include the schema of the event type.",
              "default": false,
              "type": "boolean"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "",
            "content": {
              "application/json": {
                "schema": {
                  "type": "array",
                  "items": {
                    "$ref": "#/components/schemas/EventType"
                  }
                }
              }
            }
          },
          "401": {
            "description": "Method required an authenticated user",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorMessage"
                }
              }
            }
          },
          "403": {
            "description": "Current user has no permissions for this URL/method",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorMessage"
                }
              }
            }
          },
          "500": {
            "description": "Internal service error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorMessage"
                }
              }
            }
          }
        },
        "security": [
          {
            "oauth2": [
              "urn:acronis.com:event_manager:{cti_query}:publisher",
              "urn:acronis.com:event_manager:{cti_query}:subscriber"
            ]
          }
        ]
      }
    },
    "/subscriptions": {
      "post": {
        "operationId": "Create event subscription",
        "description": "Create a new event subscription based on the provided criteria, such as topic, cti filter, and optional filters.",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/PostSubscriptionRequest"
              }
            }
          }
        },
        "responses": {
          "201": {
            "description": "Subscription was successfully created.",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/GetSubscriptionResponse"
                }
              }
            }
          },
          "401": {
            "description": "Method required an authenticated user",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorMessage"
                }
              }
            }
          },
          "403": {
            "description": "Current user has no permissions for this URL/method",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorMessage"
                }
              }
            }
          },
          "409": {
            "description": "Another object of the same type already exists",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorMessage"
                }
              }
            }
          },
          "500": {
            "description": "Internal service error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorMessage"
                }
              }
            }
          }
        },
        "security": [
          {
            "oauth2": [
              "urn:acronis.com:event_manager:{cti_query}:subscriber"
            ]
          }
        ]
      }
    },
    "/subscriptions/offset": {
      "get": {
        "operationId": "Fetch subscription offset",
        "description": "Fetch the current offset for a subscriber, indicating the position up to which events have been acknowledged.",
        "parameters": [
          {
            "name": "subscription_id",
            "description": "Required. Identifier of the subscription.",
            "required": true,
            "in": "query",
            "schema": {
              "description": "Required. Identifier of the subscription.",
              "type": "string",
              "pattern": "^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/GetSubscriptionOffsetResponse"
                }
              }
            }
          },
          "401": {
            "description": "Method required an authenticated user",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorMessage"
                }
              }
            }
          },
          "403": {
            "description": "Current user has no permissions for this URL/method",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorMessage"
                }
              }
            }
          },
          "500": {
            "description": "Internal service error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorMessage"
                }
              }
            }
          }
        },
        "security": [
          {
            "oauth2": [
              "urn:acronis.com:event_manager:{cti_query}:subscriber"
            ]
          }
        ]
      }
    },
    "/events": {
      "get": {
        "operationId": "Fetch events",
        "description": "Fetch a batch of events starting from a specified cursor position, supporting real-time event consumption with optional limits and timeouts.",
        "parameters": [
          {
            "name": "subscription_id",
            "description": "Required. Identifier of the subscription under which events are being consumed.  Used in conjunction with instance_id to manage event distribution.\n",
            "required": true,
            "in": "query",
            "schema": {
              "description": "Required. Identifier of the subscription under which events are being consumed.  Used in conjunction with instance_id to manage event distribution.\n",
              "type": "string",
              "pattern": "^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$"
            }
          },
          {
            "name": "consumer_id",
            "description": "Required. Unique identifier for the consumer instance, ensuring event distribution among multiple instances.",
            "required": true,
            "in": "query",
            "schema": {
              "description": "Required. Unique identifier for the consumer instance, ensuring event distribution among multiple instances.",
              "type": "string",
              "pattern": "^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$"
            }
          },
          {
            "name": "offset",
            "description": "Required. Specifies the starting point for event fetching, allowing instances to resume from a precise position.",
            "required": true,
            "in": "query",
            "schema": {
              "description": "Required. Specifies the starting point for event fetching, allowing instances to resume from a precise position.",
              "type": "integer",
              "format": "int64"
            }
          },
          {
            "name": "limit",
            "description": "Optional. Limits the number of events returned in one response. Helps manage processing load.",
            "in": "query",
            "schema": {
              "description": "Optional. Limits the number of events returned in one response. Helps manage processing load.",
              "default": 100,
              "type": "integer"
            }
          },
          {
            "name": "timeout",
            "description": "Optional. Time to wait for events to become available in ISO 8601 duration format. Can be decreased by the server to the session timeout of the subscription.\n",
            "in": "query",
            "schema": {
              "description": "Optional. Time to wait for events to become available in ISO 8601 duration format. Can be decreased by the server to the session timeout of the subscription.\n",
              "default": "PT30S",
              "type": "string",
              "pattern": "^P(?:(\\d+)Y)?(?:(\\d+)M)?(?:(\\d+)W)?(?:(\\d+)D)?(?:T(?:(\\d+)H)?(?:(\\d+)M)?(?:(\\d+)S)?)?$"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/GetEventsResponse"
                }
              }
            }
          },
          "401": {
            "description": "Method required an authenticated user",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorMessage"
                }
              }
            }
          },
          "403": {
            "description": "Current user has no permissions for this URL/method",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorMessage"
                }
              }
            }
          },
          "429": {
            "description": "This response indicates that the client must retry the request later. There are two possible reasons:\n  1. **Non-leader consumer instance**: The client is attempting to consume events as a non-leader instance. \n    Only the leader instance is allowed to consume events. \n    The client should retry after the time specified in the `Retry-After` header to attempt to become the leader.\n  2. **Rate limiting**: The client has exceeded the allowed rate of event consumption, either by sending too many poll requests or consuming too many events in a given period. \n    The client should wait before retrying, as specified in the `Retry-After` header.\n",
            "headers": {
              "Retry-After": {
                "description": "The time in seconds to wait before retrying the poll request.",
                "required": true,
                "schema": {
                  "description": "The time in seconds to wait before retrying the poll request.",
                  "type": "integer"
                }
              }
            },
            "content": {}
          },
          "500": {
            "description": "Internal service error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorMessage"
                }
              }
            }
          }
        },
        "security": [
          {
            "oauth2": [
              "urn:acronis.com:event_manager:{cti_query}:subscriber"
            ]
          }
        ]
      }
    }
  },
  "components": {
    "schemas": {
      "Topic": {
        "description": "Event topic is a stream of events of the same or different types sharing the same delivery, ordering, consolidation & retention rules.\n",
        "x-cti.cti": "cti.a.p.em.topic.v1.0",
        "x-cti.final": false,
        "type": "object",
        "additionalProperties": false,
        "required": [
          "id",
          "description",
          "persistency",
          "ordering",
          "producer_consolidation",
          "archive_consolidation",
          "retention"
        ],
        "properties": {
          "id": {
            "description": "The topic id is an identifier of a stream of events in publishing and subscribe semantics",
            "x-cti.id": true,
            "type": "string",
            "pattern": "^cti\\.([a-z][a-z0-9_]*\\.[a-z][a-z0-9_]*\\.[a-z_][a-z0-9_.]*\\.v[\\d]+\\.[\\d]+)(~([a-z][a-z0-9_]*\\.[a-z][a-z0-9_]*\\.[a-z_][a-z0-9_.]*\\.v[\\d]+\\.[\\d]+))*(~[0-9a-f]{8}\\b-[0-9a-f]{4}\\b-[0-9a-f]{4}\\b-[0-9a-f]{4}\\b-[0-9a-f]{12})?$",
            "maxLength": 1024
          },
          "description": {
            "description": "description of topic purpose and usage",
            "x-cti.description": true,
            "type": "string"
          },
          "persistency": {
            "description": "true - events are persisted by Event Manager, Consumers will be able to fetch events that happened before the subscription\n       (see the `archive_consolidation` and retention parameters)\nfalse - events are not persisted and ordering is not strict. Consumers will see only events that happened\n        after consumer created subscription in the Event Manager (Delivery Manager service).\n        Events can be lost in Event Manager in case of restarts or if consumer was not able to receive events within\n        some reasonable time interval and events retention happened in the Event Delivery manager\n",
            "type": "boolean"
          },
          "ordering": {
            "description": "PRODUCER     - Events must be ordered by Producer, Ingest Manager only validates event sequence id and ensures there are no lost events in the stream.\n               The 'producer' mode is supposed to be used if producer can fully control events sequence, typically it means all the 'producer'\n               instances are sharing the same database.\n\nEVENTMANAGER - events are ordered by Event Manager (Ingest Manager). This mode is useful for multi-Producer case\n               when there is no single Producer' database and so there is no way to guarantee events ordering across multiple Producers\n\nNONE         - No events ordering. Suitable for audit-kind events from different sources\n",
            "enum": [
              "NONE",
              "PRODUCER",
              "EVENTMANAGER"
            ],
            "type": "string"
          },
          "producer_consolidation": {
            "description": "The `producer_consolidation` attribute reflects events consolidation mode on the Producer side, i.e. actual behavior\nof the service rather than configurable parameter:\n\nNONE - no consolidation happens and events are stored independently only\n\nTTS - in addition to raw independent events there will be one more stream of events consolidated by type, tenantid\n      and subject so the latest event with the same type, tenantid and subject will be stored without any retention\n\nFor topics that contain notification events reflecting state changes of long-lived objects (such as tenants, users,\nsettings, workloads, policies, etc.), it is typical ho have `producer_consolidation` set to `TTS`. Such configuration\nallows the event stream to serve dual purposes: notifying state changes and enabling full event stream replay\n(reconciliation) by clients.\n\nFor short-lived objects that have their own retention policies, such as tasks, activities, alerts and such,\nit is typical to have `producer_consolidation` set to `NONE` and `retention` similar to the retention time\nof the event origin object.\n",
            "default": "NONE",
            "enum": [
              "NONE",
              "TTS"
            ],
            "type": "string"
          },
          "archive_consolidation": {
            "description": "The `archive_consolidation` attribute defines events consolidation mode on the Event Archive side:\n\nNONE - no consolidation happens and events are stored independently only with appropriate retention\n\nTTS  - event with the same type (T), tenantid (T) and subject (S) will be stored without any retention\n       (i.e. will overwrite prev event with the same type, tenantid and subject eventually)\n\nThe `TTS` `archive_consolidation` can be typically used for topics that contain notification events reflecting\nstate changes of long-lived objects (such as tenants, users, settings, workloads, policies, etc.). It would\nallow the event stream to serve dual purposes: notifying state changes and enabling full event stream replay\n(reconciliation) by clients.\n\nFor short-lived objects that have their own retention policies, such as tasks, activities, alerts and such,\nit is advisable to set `archive_consolidation` to `NONE` and `retention` similar to the retention time\nof the event origin object.\n",
            "default": "NONE",
            "enum": [
              "NONE",
              "TTS"
            ],
            "type": "string"
          },
          "retention": {
            "description": "Specifies the retention period for events within this topic on event archive side.\n\nThe retention duration begins from the moment an event is received by the Event Manager. Events older than the\nspecified duration are eligible for deletion by the retention job. Must be a valid ISO 8601 duration or\n'INFINITE'.\n\nThis property is ignored if `archive_consolidation` is set to `TTS`, in this case retention effectively is\nequal to 'INFINITE'\n\nIt's recommended to have retention period comparable to the object's lifetime to enable clients to use a single\nmechanism for both change state notifications and full event stream replay (reconciliation).\n",
            "anyOf": [
              {
                "$ref": "#/components/schemas/duration_iso"
              },
              {
                "$ref": "#/components/schemas/INFINITE"
              }
            ]
          }
        }
      },
      "ErrorMessage": {
        "type": "object",
        "additionalProperties": false,
        "required": [
          "error"
        ],
        "properties": {
          "error": {
            "$ref": "#/components/schemas/error"
          }
        }
      },
      "GetTopicsOffsetResponse": {
        "type": "object",
        "required": [
          "topic_id",
          "offset"
        ],
        "properties": {
          "topic_id": {
            "description": "Identifier of the topic.",
            "x-cti.reference": "cti.a.p.em.topic.v1.0",
            "example": "cti.a.p.em.topic.v1.0~a.p.tenant.v1.0",
            "type": "string",
            "pattern": "^cti\\.([a-z][a-z0-9_]*\\.[a-z][a-z0-9_]*\\.[a-z_][a-z0-9_.]*\\.v[\\d]+\\.[\\d]+)(~([a-z][a-z0-9_]*\\.[a-z][a-z0-9_]*\\.[a-z_][a-z0-9_.]*\\.v[\\d]+\\.[\\d]+))*(~[0-9a-f]{8}\\b-[0-9a-f]{4}\\b-[0-9a-f]{4}\\b-[0-9a-f]{4}\\b-[0-9a-f]{12})?$",
            "maxLength": 1024
          },
          "offset": {
            "description": "Requested offset sequence number.",
            "type": "integer",
            "format": "int64"
          }
        }
      },
      "EventType": {
        "description": "Defines the structure of the event type. It is used to define the structure of the event and to validate the event data.\n",
        "type": "object",
        "additionalProperties": false,
        "required": [
          "id",
          "topic_id",
          "description"
        ],
        "properties": {
          "allowed_subject_types": {
            "description": "List of allowed subject types for the event type. If the subject type is not in the list, the event will be rejected.\n",
            "x-cti.reference": true,
            "type": "array",
            "maxItems": 32,
            "items": {
              "$ref": "#/components/schemas/CTIWildcard"
            }
          },
          "data_schema": {
            "description": "A JSON schema that describes the structure of the event.\n",
            "example": "{\n  \"$schema\": \"http://json-schema.org/draft-07/schema\",\n  \"$id\": \"http://acronis.com/tenant-undeleted.json\",\n  \"type\": \"object\",\n  \"title\": \"The schema of tenant.undeleted event.\",\n  \"description\": \"The root schema comprises the entire JSON document.\",\n  \"properties\": {\n    \"subject\": {\n      \"type\": \"string\",\n      \"format\": \"uuid\",\n    },\n    \"data\": {\n      \"type\": \"object\",\n      \"properties\": {\n        \"name\": {\n          \"type\": \"string\",\n          \"examples\": [\n            \"My Tenant\"\n          ]\n        }\n      },\n      \"additionalProperties\": false\n    }\n  },\n  \"required\": [\"subject\",\"data\"],\n  \"additionalProperties\": false\n}\n",
            "type": "string"
          },
          "id": {
            "description": "The specific event type.",
            "x-cti.reference": "cti.a.p.em.event.v1.0",
            "type": "string",
            "pattern": "^cti\\.([a-z][a-z0-9_]*\\.[a-z][a-z0-9_]*\\.[a-z_][a-z0-9_.]*\\.v[\\d]+\\.[\\d]+)(~([a-z][a-z0-9_]*\\.[a-z][a-z0-9_]*\\.[a-z_][a-z0-9_.]*\\.v[\\d]+\\.[\\d]+))*(~[0-9a-f]{8}\\b-[0-9a-f]{4}\\b-[0-9a-f]{4}\\b-[0-9a-f]{4}\\b-[0-9a-f]{12})?$",
            "maxLength": 1024
          },
          "topic_id": {
            "description": "Topic unique id",
            "x-cti.reference": "cti.a.p.em.topic.v1.0",
            "type": "string",
            "pattern": "^cti\\.([a-z][a-z0-9_]*\\.[a-z][a-z0-9_]*\\.[a-z_][a-z0-9_.]*\\.v[\\d]+\\.[\\d]+)(~([a-z][a-z0-9_]*\\.[a-z][a-z0-9_]*\\.[a-z_][a-z0-9_.]*\\.v[\\d]+\\.[\\d]+))*(~[0-9a-f]{8}\\b-[0-9a-f]{4}\\b-[0-9a-f]{4}\\b-[0-9a-f]{4}\\b-[0-9a-f]{12})?$",
            "maxLength": 1024
          },
          "subject_ref_template": {
            "description": "API endpoint URL to fetch subject details, so the client can\nautomate subject retrieval for given type of events\n",
            "example": "/api/v2/tenants/{{subjectId}}",
            "type": "string",
            "maxLength": 1024
          },
          "description": {
            "description": "Description of the type purpose and usage",
            "type": "string"
          }
        }
      },
      "PostSubscriptionRequest": {
        "type": "object",
        "additionalProperties": false,
        "required": [
          "subscription_id",
          "tenant_depth",
          "types",
          "topic_id"
        ],
        "properties": {
          "cel": {
            "description": "Optional. CEL expression to filter events by.",
            "type": "string",
            "maxLength": 4096
          },
          "subscription_id": {
            "description": "Unique identifier of the subscription.",
            "example": "fd02a25c-fcb0-42a0-a5ce-56c1131db356",
            "type": "string",
            "pattern": "^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$"
          },
          "tenant_depth": {
            "description": "Required. Specifies the required tenancy depth\n`CURRENT` - return all the events with the tenant_id equal to the tenant_id specified in the subscription.\n`DIRECT` - return events for the tenant_id specified in the subscription and its direct children.\n`ALL` - return all the events for the tenant_id specified in the subscription and all its children.\n",
            "enum": [
              "CURRENT",
              "DIRECT",
              "ALL"
            ],
            "type": "string"
          },
          "auto_commit_interval": {
            "description": "Optional. Interval at which to auto-commit offsets. The interval is specified in ISO 8601 format.\n",
            "default": "PT5M",
            "type": "string",
            "pattern": "^P(?:(\\d+)Y)?(?:(\\d+)M)?(?:(\\d+)W)?(?:(\\d+)D)?(?:T(?:(\\d+)H)?(?:(\\d+)M)?(?:(\\d+)S)?)?$"
          },
          "auto_commit": {
            "description": "Optional. Keep track of the last offset acknowledged by this consumer and automatically commit it. Auto-commit will potentially be made at the beginning of each and every poll request and on subscription eviction. This is useful when the subscriber does not have an external storage to keep track of the last offset committed.",
            "default": false,
            "type": "boolean"
          },
          "types": {
            "description": "Required. List of event types this subscription delivers.\n\nAllowed CTI prefixes:\n  - `cti.a.p.em.event.v1.0~`\n  - `cti.a.p.em.msg.v1.0~`\n\nSupported forms (right side of `~` only):\n  - Exact type:\n      `cti.a.p.em.event.v1.0~a.p.tenant.created.v1.0`\n  - All types prefixed with a spec

# --- truncated at 32 KB (54 KB total) ---
# Full source: https://raw.githubusercontent.com/api-evangelist/acronis/refs/heads/main/openapi/_original/acronis-events-v1-openapi.json