@lap v0.3
# Machine-readable API spec. Each @endpoint block is one API call.
@api Svix API
@base https://api.eu.svix.com/
@version 1.84.0
@auth Bearer bearer
@endpoints 128
@hint download_for_search
@toc api(110), ingest(18)

@group api
@endpoint GET /api/v1/app
@optional {exclude_apps_with_no_endpoints: bool=false, exclude_apps_with_disabled_endpoints: bool=false, exclude_apps_with_svix_play_endpoints: bool=false, limit: int(uint64), iterator: str, order: str}
@returns(200) {data: [map], done: bool, iterator: str?, prevIterator: str?}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint POST /api/v1/app
@required {name: str}
@optional {get_if_exists: bool=false, idempotency-key: str, idempotency-key: str, metadata: map=[object Object], rateLimit: int(uint16), throttleRate: int(uint16), uid: str}
@returns(200) {createdAt: str(date-time), id: str, metadata: map, name: str, rateLimit: int(uint16)?, throttleRate: int(uint16)?, uid: str?, updatedAt: str(date-time)}
@returns(201) {createdAt: str(date-time), id: str, metadata: map, name: str, rateLimit: int(uint16)?, throttleRate: int(uint16)?, uid: str?, updatedAt: str(date-time)}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint GET /api/v1/app/{app_id}
@required {app_id: str}
@returns(200) {createdAt: str(date-time), id: str, metadata: map, name: str, rateLimit: int(uint16)?, throttleRate: int(uint16)?, uid: str?, updatedAt: str(date-time)}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint PUT /api/v1/app/{app_id}
@required {app_id: str, name: str}
@optional {metadata: map=[object Object], rateLimit: int(uint16), throttleRate: int(uint16), uid: str}
@returns(200) {createdAt: str(date-time), id: str, metadata: map, name: str, rateLimit: int(uint16)?, throttleRate: int(uint16)?, uid: str?, updatedAt: str(date-time)}
@returns(201) {createdAt: str(date-time), id: str, metadata: map, name: str, rateLimit: int(uint16)?, throttleRate: int(uint16)?, uid: str?, updatedAt: str(date-time)}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint DELETE /api/v1/app/{app_id}
@required {app_id: str}
@returns(204)
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint PATCH /api/v1/app/{app_id}
@required {app_id: str}
@optional {metadata: map, name: str, rateLimit: int(uint16), uid: str}
@returns(200) {createdAt: str(date-time), id: str, metadata: map, name: str, rateLimit: int(uint16)?, throttleRate: int(uint16)?, uid: str?, updatedAt: str(date-time)}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint GET /api/v1/app/{app_id}/attempt/endpoint/{endpoint_id}
@required {app_id: str, endpoint_id: str}
@optional {limit: int(uint64), iterator: str, status: int, status_code_class: int, channel: str, tag: str, before: str(date-time), after: str(date-time), with_content: bool=true, with_msg: bool=false, event_types: [str]}
@returns(200) {data: [map], done: bool, iterator: str?, prevIterator: str?}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint GET /api/v1/app/{app_id}/attempt/msg/{msg_id}
@required {app_id: str, msg_id: str}
@optional {limit: int(uint64), iterator: str, status: int, status_code_class: int, channel: str, tag: str, endpoint_id: str, before: str(date-time), after: str(date-time), with_content: bool=true, event_types: [str]}
@returns(200) {data: [map], done: bool, iterator: str?, prevIterator: str?}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint GET /api/v1/app/{app_id}/endpoint
@required {app_id: str}
@optional {limit: int(uint64), iterator: str, order: str}
@returns(200) {data: [map], done: bool, iterator: str?, prevIterator: str?}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint POST /api/v1/app/{app_id}/endpoint
@required {app_id: str, url: str(uri)}
@optional {idempotency-key: str, idempotency-key: str, channels: [str], description: str=, disabled: bool=false, filterTypes: [str], headers: map, metadata: map=[object Object], rateLimit: int(uint16), secret: str, throttleRate: int(uint16), uid: str}
@returns(201) {channels: [str]?, createdAt: str(date-time), description: str, disabled: bool, filterTypes: [str]?, id: str, metadata: map, rateLimit: int(uint16)?, throttleRate: int(uint16)?, uid: str?, updatedAt: str(date-time), url: str(uri), version: int(int32)}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint GET /api/v1/app/{app_id}/endpoint/{endpoint_id}
@required {app_id: str, endpoint_id: str}
@returns(200) {channels: [str]?, createdAt: str(date-time), description: str, disabled: bool, filterTypes: [str]?, id: str, metadata: map, rateLimit: int(uint16)?, throttleRate: int(uint16)?, uid: str?, updatedAt: str(date-time), url: str(uri), version: int(int32)}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint PUT /api/v1/app/{app_id}/endpoint/{endpoint_id}
@required {app_id: str, endpoint_id: str, url: str(uri)}
@optional {channels: [str], description: str=, disabled: bool=false, filterTypes: [str], metadata: map=[object Object], rateLimit: int(uint16), throttleRate: int(uint16), uid: str}
@returns(200) {channels: [str]?, createdAt: str(date-time), description: str, disabled: bool, filterTypes: [str]?, id: str, metadata: map, rateLimit: int(uint16)?, throttleRate: int(uint16)?, uid: str?, updatedAt: str(date-time), url: str(uri), version: int(int32)}
@returns(201) {channels: [str]?, createdAt: str(date-time), description: str, disabled: bool, filterTypes: [str]?, id: str, metadata: map, rateLimit: int(uint16)?, throttleRate: int(uint16)?, uid: str?, updatedAt: str(date-time), url: str(uri), version: int(int32)}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint DELETE /api/v1/app/{app_id}/endpoint/{endpoint_id}
@required {app_id: str, endpoint_id: str}
@returns(204)
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint PATCH /api/v1/app/{app_id}/endpoint/{endpoint_id}
@required {app_id: str, endpoint_id: str}
@optional {channels: [str], description: str, disabled: bool, filterTypes: [str], metadata: map, rateLimit: int(uint16), url: str(uri), throttleRate: int(uint16), uid: str}
@returns(200) {channels: [str]?, createdAt: str(date-time), description: str, disabled: bool, filterTypes: [str]?, id: str, metadata: map, rateLimit: int(uint16)?, throttleRate: int(uint16)?, uid: str?, updatedAt: str(date-time), url: str(uri), version: int(int32)}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint POST /api/v1/app/{app_id}/endpoint/{endpoint_id}/bulk-replay
@required {app_id: str, endpoint_id: str, since: str(date-time)}
@optional {idempotency-key: str, idempotency-key: str, channel: str, eventTypes: [str], status: int(0/1/2/3), statusCodeClass: int(0/100/200/300/400/500), tag: str, until: str(date-time)}
@returns(202) {id: str, status: str, task: str, updatedAt: str(date-time)}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint GET /api/v1/app/{app_id}/endpoint/{endpoint_id}/headers
@required {app_id: str, endpoint_id: str}
@returns(200) {headers: map, sensitive: [str]}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint PUT /api/v1/app/{app_id}/endpoint/{endpoint_id}/headers
@required {app_id: str, endpoint_id: str, headers: map}
@returns(204)
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint PATCH /api/v1/app/{app_id}/endpoint/{endpoint_id}/headers
@required {app_id: str, endpoint_id: str, headers: map}
@optional {deleteHeaders: [str]=}
@returns(204)
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint GET /api/v1/app/{app_id}/endpoint/{endpoint_id}/msg
@required {app_id: str, endpoint_id: str}
@optional {limit: int(uint64), iterator: str, channel: str, tag: str, status: int, before: str(date-time), after: str(date-time), with_content: bool=true, event_types: [str]}
@returns(200) {data: [map], done: bool, iterator: str?, prevIterator: str?}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint POST /api/v1/app/{app_id}/endpoint/{endpoint_id}/recover
@required {app_id: str, endpoint_id: str, since: str(date-time)}
@optional {idempotency-key: str, idempotency-key: str, until: str(date-time)}
@returns(202) {id: str, status: str, task: str, updatedAt: str(date-time)}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint POST /api/v1/app/{app_id}/endpoint/{endpoint_id}/replay-missing
@required {app_id: str, endpoint_id: str, since: str(date-time)}
@optional {idempotency-key: str, idempotency-key: str, until: str(date-time)}
@returns(202) {id: str, status: str, task: str, updatedAt: str(date-time)}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint GET /api/v1/app/{app_id}/endpoint/{endpoint_id}/secret
@required {app_id: str, endpoint_id: str}
@returns(200) {key: str}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint POST /api/v1/app/{app_id}/endpoint/{endpoint_id}/secret/rotate
@required {app_id: str, endpoint_id: str}
@optional {idempotency-key: str, idempotency-key: str, key: str=null}
@returns(204)
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint POST /api/v1/app/{app_id}/endpoint/{endpoint_id}/send-example
@required {app_id: str, endpoint_id: str, eventType: str}
@optional {idempotency-key: str, idempotency-key: str, exampleIndex: int(uint)=0}
@returns(202) {channels: [str]?, deliverAt: str(date-time)?, eventId: str?, eventType: str, id: str, payload: map, tags: [str]?, timestamp: str(date-time)}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint GET /api/v1/app/{app_id}/endpoint/{endpoint_id}/stats
@required {app_id: str, endpoint_id: str}
@optional {since: str(date-time), until: str(date-time)}
@returns(200) {fail: int(int64), pending: int(int64), sending: int(int64), success: int(int64)}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint GET /api/v1/app/{app_id}/endpoint/{endpoint_id}/transformation
@required {app_id: str, endpoint_id: str}
@returns(200) {code: str?, enabled: bool, updatedAt: str(date-time)?}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint PATCH /api/v1/app/{app_id}/endpoint/{endpoint_id}/transformation
@required {app_id: str, endpoint_id: str}
@optional {code: str, enabled: bool}
@returns(204)
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint GET /api/v1/app/{app_id}/integration
@required {app_id: str}
@optional {limit: int(uint64), iterator: str, order: str}
@returns(200) {data: [map], done: bool, iterator: str?, prevIterator: str?}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint POST /api/v1/app/{app_id}/integration
@required {app_id: str, name: str}
@optional {idempotency-key: str, idempotency-key: str, featureFlags: [str]}
@returns(201) {createdAt: str(date-time), featureFlags: [str], id: str, name: str, updatedAt: str(date-time)}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint GET /api/v1/app/{app_id}/integration/{integ_id}
@required {app_id: str, integ_id: str}
@returns(200) {createdAt: str(date-time), featureFlags: [str], id: str, name: str, updatedAt: str(date-time)}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint PUT /api/v1/app/{app_id}/integration/{integ_id}
@required {app_id: str, integ_id: str, name: str}
@optional {featureFlags: [str]}
@returns(200) {createdAt: str(date-time), featureFlags: [str], id: str, name: str, updatedAt: str(date-time)}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint DELETE /api/v1/app/{app_id}/integration/{integ_id}
@required {app_id: str, integ_id: str}
@returns(204)
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint GET /api/v1/app/{app_id}/integration/{integ_id}/key
@required {app_id: str, integ_id: str}
@returns(200) {key: str}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint POST /api/v1/app/{app_id}/integration/{integ_id}/key/rotate
@required {app_id: str, integ_id: str}
@optional {idempotency-key: str, idempotency-key: str}
@returns(200) {key: str}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint GET /api/v1/app/{app_id}/msg
@required {app_id: str}
@optional {limit: int(uint64), iterator: str, channel: str, before: str(date-time), after: str(date-time), with_content: bool=true, tag: str, event_types: [str]}
@returns(200) {data: [map], done: bool, iterator: str?, prevIterator: str?}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint POST /api/v1/app/{app_id}/msg
@required {app_id: str, eventType: str, payload: map}
@optional {with_content: bool=true, idempotency-key: str, idempotency-key: str, application: map{metadata: map, name!: str, rateLimit: int(uint16), throttleRate: int(uint16), uid: str}, channels: [str], deliverAt: str(date-time), eventId: str, payloadRetentionHours: int(int64)=null, payloadRetentionPeriod: int(int64)=90, tags: [str], transformationsParams: map}
@returns(202) {channels: [str]?, deliverAt: str(date-time)?, eventId: str?, eventType: str, id: str, payload: map, tags: [str]?, timestamp: str(date-time)}
@errors {400, 401, 403, 404, 409, 413, 422, 429}

@endpoint POST /api/v1/app/{app_id}/msg/expunge-all-contents
@required {app_id: str}
@optional {idempotency-key: str, idempotency-key: str}
@returns(202) {id: str, status: str, task: str, updatedAt: str(date-time)}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint POST /api/v1/app/{app_id}/msg/precheck/active
@required {app_id: str, eventType: str}
@optional {idempotency-key: str, idempotency-key: str, channels: [str]}
@returns(200) {active: bool}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint GET /api/v1/app/{app_id}/msg/{msg_id}
@required {app_id: str, msg_id: str}
@optional {with_content: bool=true}
@returns(200) {channels: [str]?, deliverAt: str(date-time)?, eventId: str?, eventType: str, id: str, payload: map, tags: [str]?, timestamp: str(date-time)}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint GET /api/v1/app/{app_id}/msg/{msg_id}/attempt/{attempt_id}
@required {app_id: str, msg_id: str, attempt_id: str}
@returns(200) {endpointId: str, id: str, msg: map{channels: [str]?, deliverAt: str(date-time)?, eventId: str?, eventType: str, id: str, payload: map, tags: [str]?, timestamp: str(date-time)}, msgId: str, response: str, responseDurationMs: int(int64), responseStatusCode: int(int16), status: int, statusText: str, timestamp: str(date-time), triggerType: int, url: str(uri)}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint DELETE /api/v1/app/{app_id}/msg/{msg_id}/attempt/{attempt_id}/content
@required {app_id: str, msg_id: str, attempt_id: str}
@returns(204)
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint DELETE /api/v1/app/{app_id}/msg/{msg_id}/content
@required {app_id: str, msg_id: str}
@returns(204)
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint GET /api/v1/app/{app_id}/msg/{msg_id}/endpoint
@required {app_id: str, msg_id: str}
@optional {limit: int(uint64), iterator: str}
@returns(200) {data: [map], done: bool, iterator: str?, prevIterator: str?}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint POST /api/v1/app/{app_id}/msg/{msg_id}/endpoint/{endpoint_id}/resend
@required {app_id: str, msg_id: str, endpoint_id: str}
@optional {idempotency-key: str, idempotency-key: str}
@returns(202)
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint GET /api/v1/app/{app_id}/poller/{sink_id}
@required {app_id: str, sink_id: str}
@optional {limit: int(uint64), iterator: str, event_type: str, channel: str, after: str(date-time)}
@returns(200) {data: [map], done: bool, iterator: str}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint GET /api/v1/app/{app_id}/poller/{sink_id}/consumer/{consumer_id}
@required {app_id: str, sink_id: str, consumer_id: str}
@optional {limit: int(uint64), iterator: str}
@returns(200) {data: [map], done: bool, iterator: str}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint POST /api/v1/app/{app_id}/poller/{sink_id}/consumer/{consumer_id}/seek
@required {app_id: str, sink_id: str, consumer_id: str, after: str(date-time)}
@optional {idempotency-key: str, idempotency-key: str}
@returns(200) {iterator: str}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint POST /api/v1/auth/app-portal-access/{app_id}
@required {app_id: str}
@optional {idempotency-key: str, idempotency-key: str, application: map{metadata: map, name!: str, rateLimit: int(uint16), throttleRate: int(uint16), uid: str}, capabilities: [str], expiry: int(uint64)=604800, featureFlags: [str], readOnly: bool, sessionId: str}
@returns(200) {token: str, url: str(uri)}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint POST /api/v1/auth/app/{app_id}/expire-all
@required {app_id: str}
@optional {idempotency-key: str, idempotency-key: str, expiry: int(int64), sessionIds: [str]}
@returns(204)
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint POST /api/v1/auth/logout
@optional {idempotency-key: str, idempotency-key: str}
@returns(204)
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint POST /api/v1/auth/stream-logout
@optional {idempotency-key: str, idempotency-key: str}
@returns(204)
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint POST /api/v1/auth/stream-portal-access/{stream_id}
@required {stream_id: str}
@optional {idempotency-key: str, idempotency-key: str, expiry: int(uint64)=604800, featureFlags: [str], sessionId: str}
@returns(200) {token: str, url: str(uri)}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint POST /api/v1/auth/stream/{stream_id}/expire-all
@required {stream_id: str}
@optional {idempotency-key: str, idempotency-key: str, expiry: int(int64), sessionIds: [str]}
@returns(204)
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint GET /api/v1/auth/stream/{stream_id}/sink/{sink_id}/poller/token
@required {stream_id: str, sink_id: str}
@returns(200) {createdAt: str(date-time), expiresAt: str(date-time)?, id: str, name: str?, scopes: [str]?, token: str}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint POST /api/v1/auth/stream/{stream_id}/sink/{sink_id}/poller/token/rotate
@required {stream_id: str, sink_id: str}
@optional {idempotency-key: str, idempotency-key: str, expiry: int(int64), oldTokenExpiry: int(int64)=300}
@returns(201) {createdAt: str(date-time), expiresAt: str(date-time)?, id: str, name: str?, scopes: [str]?, token: str}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint GET /api/v1/background-task
@optional {status: str, task: str, limit: int(uint64), iterator: str, order: str}
@returns(200) {data: [map], done: bool, iterator: str?, prevIterator: str?}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint GET /api/v1/background-task/{task_id}
@required {task_id: str}
@returns(200) {data: map, id: str, status: str, task: str, updatedAt: str(date-time)}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint GET /api/v1/connector
@optional {limit: int(uint64), iterator: str, order: str, product_type: str}
@returns(200) {data: [map], done: bool, iterator: str?, prevIterator: str?}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint POST /api/v1/connector
@required {name: str, transformation: str}
@optional {idempotency-key: str, idempotency-key: str, allowedEventTypes: [str], description: str=, featureFlags: [str]=null, instructions: str=, kind: str(Custom/AgenticCommerceProtocol/CloseCRM/CustomerIO/Discord/Hubspot/Inngest/Loops/Otel/Resend/Salesforce/Segment/Sendgrid/Slack/Teams/TriggerDev/Windmill/Zapier), logo: str(uri), productType: str(Dispatch/Stream), uid: str}
@returns(201) {allowedEventTypes: [str]?, createdAt: str(date-time), description: str, featureFlags: [str]?, id: str, instructions: str, kind: str, logo: str(uri)?, name: str, orgId: str, productType: str, transformation: str, transformationUpdatedAt: str(date-time), uid: str?, updatedAt: str(date-time)}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint GET /api/v1/connector/{connector_id}
@required {connector_id: str}
@returns(200) {allowedEventTypes: [str]?, createdAt: str(date-time), description: str, featureFlags: [str]?, id: str, instructions: str, kind: str, logo: str(uri)?, name: str, orgId: str, productType: str, transformation: str, transformationUpdatedAt: str(date-time), uid: str?, updatedAt: str(date-time)}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint PUT /api/v1/connector/{connector_id}
@required {connector_id: str, transformation: str}
@optional {allowedEventTypes: [str], description: str=, featureFlags: [str]=null, instructions: str=, kind: str(Custom/AgenticCommerceProtocol/CloseCRM/CustomerIO/Discord/Hubspot/Inngest/Loops/Otel/Resend/Salesforce/Segment/Sendgrid/Slack/Teams/TriggerDev/Windmill/Zapier), logo: str(uri), name: str=}
@returns(200) {allowedEventTypes: [str]?, createdAt: str(date-time), description: str, featureFlags: [str]?, id: str, instructions: str, kind: str, logo: str(uri)?, name: str, orgId: str, productType: str, transformation: str, transformationUpdatedAt: str(date-time), uid: str?, updatedAt: str(date-time)}
@returns(201) {allowedEventTypes: [str]?, createdAt: str(date-time), description: str, featureFlags: [str]?, id: str, instructions: str, kind: str, logo: str(uri)?, name: str, orgId: str, productType: str, transformation: str, transformationUpdatedAt: str(date-time), uid: str?, updatedAt: str(date-time)}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint DELETE /api/v1/connector/{connector_id}
@required {connector_id: str}
@returns(204)
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint PATCH /api/v1/connector/{connector_id}
@required {connector_id: str}
@optional {allowedEventTypes: [str], description: str, featureFlags: [str], instructions: str, kind: str(Custom/AgenticCommerceProtocol/CloseCRM/CustomerIO/Discord/Hubspot/Inngest/Loops/Otel/Resend/Salesforce/Segment/Sendgrid/Slack/Teams/TriggerDev/Windmill/Zapier), logo: str(uri), name: str, transformation: str}
@returns(200) {allowedEventTypes: [str]?, createdAt: str(date-time), description: str, featureFlags: [str]?, id: str, instructions: str, kind: str, logo: str(uri)?, name: str, orgId: str, productType: str, transformation: str, transformationUpdatedAt: str(date-time), uid: str?, updatedAt: str(date-time)}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint POST /api/v1/environment/export
@optional {idempotency-key: str, idempotency-key: str}
@returns(200) {connectors: [map], createdAt: str(date-time), eventTypes: [map], settings: map?, version: int(int)}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint POST /api/v1/environment/import
@optional {idempotency-key: str, idempotency-key: str, connectors: [map{allowedEventTypes: [str], description: str, featureFlags: [str], instructions: str, kind: str, logo: str(uri), name!: str, productType: str, transformation!: str, uid: str}], eventTypes: [map{archived: bool, deprecated: bool, description!: str, featureFlag: str, featureFlags: [str], groupName: str, name!: str, schemas: map}], settings: map}
@returns(204)
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint GET /api/v1/event-type
@optional {limit: int(uint64), iterator: str, order: str, include_archived: bool=false, with_content: bool=false}
@returns(200) {data: [map], done: bool, iterator: str?, prevIterator: str?}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint POST /api/v1/event-type
@required {description: str, name: str}
@optional {idempotency-key: str, idempotency-key: str, archived: bool=false, deprecated: bool=false, featureFlag: str=null, featureFlags: [str]=null, groupName: str, schemas: map}
@returns(201) {archived: bool, createdAt: str(date-time), deprecated: bool, description: str, featureFlag: str?, featureFlags: [str]?, groupName: str?, name: str, schemas: map?, updatedAt: str(date-time)}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint POST /api/v1/event-type/import/openapi
@optional {idempotency-key: str, idempotency-key: str, dryRun: bool=false, replaceAll: bool=false, spec: map, specRaw: str}
@returns(200) {data: map{modified: [str], to_modify: [map]?}}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint GET /api/v1/event-type/{event_type_name}
@required {event_type_name: str}
@returns(200) {archived: bool, createdAt: str(date-time), deprecated: bool, description: str, featureFlag: str?, featureFlags: [str]?, groupName: str?, name: str, schemas: map?, updatedAt: str(date-time)}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint PUT /api/v1/event-type/{event_type_name}
@required {event_type_name: str, description: str}
@optional {archived: bool=false, deprecated: bool=false, featureFlag: str=null, featureFlags: [str], groupName: str=null, schemas: map}
@returns(200) {archived: bool, createdAt: str(date-time), deprecated: bool, description: str, featureFlag: str?, featureFlags: [str]?, groupName: str?, name: str, schemas: map?, updatedAt: str(date-time)}
@returns(201) {archived: bool, createdAt: str(date-time), deprecated: bool, description: str, featureFlag: str?, featureFlags: [str]?, groupName: str?, name: str, schemas: map?, updatedAt: str(date-time)}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint DELETE /api/v1/event-type/{event_type_name}
@required {event_type_name: str}
@optional {expunge: bool=false}
@returns(204)
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint PATCH /api/v1/event-type/{event_type_name}
@required {event_type_name: str}
@optional {archived: bool, deprecated: bool, description: str, featureFlag: str, featureFlags: [str], groupName: str, schemas: map}
@returns(200) {archived: bool, createdAt: str(date-time), deprecated: bool, description: str, featureFlag: str?, featureFlags: [str]?, groupName: str?, name: str, schemas: map?, updatedAt: str(date-time)}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint GET /api/v1/health
@returns(204)
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint GET /api/v1/operational-webhook/endpoint
@optional {limit: int(uint64), iterator: str, order: str}
@returns(200) {data: [map], done: bool, iterator: str?, prevIterator: str?}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint POST /api/v1/operational-webhook/endpoint
@required {url: str(uri)}
@optional {idempotency-key: str, idempotency-key: str, description: str=, disabled: bool=false, filterTypes: [str], metadata: map=[object Object], rateLimit: int(uint16), secret: str, uid: str}
@returns(201) {createdAt: str(date-time), description: str, disabled: bool, filterTypes: [str]?, id: str, metadata: map, rateLimit: int(uint16)?, uid: str?, updatedAt: str(date-time), url: str(uri)}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint GET /api/v1/operational-webhook/endpoint/{endpoint_id}
@required {endpoint_id: str}
@returns(200) {createdAt: str(date-time), description: str, disabled: bool, filterTypes: [str]?, id: str, metadata: map, rateLimit: int(uint16)?, uid: str?, updatedAt: str(date-time), url: str(uri)}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint PUT /api/v1/operational-webhook/endpoint/{endpoint_id}
@required {endpoint_id: str, url: str(uri)}
@optional {description: str=, disabled: bool=false, filterTypes: [str], metadata: map=[object Object], rateLimit: int(uint16), uid: str}
@returns(200) {createdAt: str(date-time), description: str, disabled: bool, filterTypes: [str]?, id: str, metadata: map, rateLimit: int(uint16)?, uid: str?, updatedAt: str(date-time), url: str(uri)}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint DELETE /api/v1/operational-webhook/endpoint/{endpoint_id}
@required {endpoint_id: str}
@returns(204)
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint GET /api/v1/operational-webhook/endpoint/{endpoint_id}/headers
@required {endpoint_id: str}
@returns(200) {headers: map, sensitive: [str]}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint PUT /api/v1/operational-webhook/endpoint/{endpoint_id}/headers
@required {endpoint_id: str, headers: map}
@returns(204)
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint GET /api/v1/operational-webhook/endpoint/{endpoint_id}/secret
@required {endpoint_id: str}
@returns(200) {key: str}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint POST /api/v1/operational-webhook/endpoint/{endpoint_id}/secret/rotate
@required {endpoint_id: str}
@optional {idempotency-key: str, idempotency-key: str, key: str=null}
@returns(204)
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint POST /api/v1/stats/usage/app
@required {since: str(date-time), until: str(date-time)}
@optional {idempotency-key: str, idempotency-key: str, appIds: [str]}
@returns(202) {id: str, status: str, task: str, unresolvedAppIds: [str], updatedAt: str(date-time)}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint PUT /api/v1/stats/usage/event-types
@returns(202) {id: str, status: str, task: str, updatedAt: str(date-time)}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint GET /api/v1/stream
@optional {limit: int(uint64), iterator: str, order: str}
@returns(200) {data: [map], done: bool, iterator: str?, prevIterator: str?}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint POST /api/v1/stream
@required {name: str}
@optional {idempotency-key: str, idempotency-key: str, metadata: map=[object Object], uid: str}
@returns(201) {createdAt: str(date-time), id: str, metadata: map, name: str?, uid: str?, updatedAt: str(date-time)}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint GET /api/v1/stream/event-type
@optional {limit: int(uint64), iterator: str, order: str, include_archived: bool=false}
@returns(200) {data: [map], done: bool, iterator: str?, prevIterator: str?}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint POST /api/v1/stream/event-type
@required {name: str}
@optional {idempotency-key: str, idempotency-key: str, archived: bool=false, deprecated: bool=false, description: str, featureFlags: [str]=null}
@returns(201) {archived: bool, createdAt: str(date-time), deprecated: bool, description: str?, featureFlags: [str]?, name: str, updatedAt: str(date-time)}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint GET /api/v1/stream/event-type/{name}
@required {name: str}
@returns(200) {archived: bool, createdAt: str(date-time), deprecated: bool, description: str?, featureFlags: [str]?, name: str, updatedAt: str(date-time)}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint PUT /api/v1/stream/event-type/{name}
@required {name: str, name: str}
@optional {archived: bool=false, deprecated: bool=false, description: str, featureFlags: [str]=null}
@returns(200) {archived: bool, createdAt: str(date-time), deprecated: bool, description: str?, featureFlags: [str]?, name: str, updatedAt: str(date-time)}
@returns(201) {archived: bool, createdAt: str(date-time), deprecated: bool, description: str?, featureFlags: [str]?, name: str, updatedAt: str(date-time)}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint DELETE /api/v1/stream/event-type/{name}
@required {name: str}
@optional {expunge: bool=false}
@returns(204)
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint PATCH /api/v1/stream/event-type/{name}
@required {name: str}
@optional {archived: bool, deprecated: bool, description: str, featureFlags: [str], name: str}
@returns(200) {archived: bool, createdAt: str(date-time), deprecated: bool, description: str?, featureFlags: [str]?, name: str, updatedAt: str(date-time)}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint GET /api/v1/stream/{stream_id}
@required {stream_id: str}
@returns(200) {createdAt: str(date-time), id: str, metadata: map, name: str?, uid: str?, updatedAt: str(date-time)}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint PUT /api/v1/stream/{stream_id}
@required {stream_id: str, name: str}
@optional {metadata: map=[object Object], uid: str}
@returns(200) {createdAt: str(date-time), id: str, metadata: map, name: str?, uid: str?, updatedAt: str(date-time)}
@returns(201) {createdAt: str(date-time), id: str, metadata: map, name: str?, uid: str?, updatedAt: str(date-time)}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint DELETE /api/v1/stream/{stream_id}
@required {stream_id: str}
@returns(204)
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint PATCH /api/v1/stream/{stream_id}
@required {stream_id: str}
@optional {description: str, metadata: map, uid: str}
@returns(200) {createdAt: str(date-time), id: str, metadata: map, name: str?, uid: str?, updatedAt: str(date-time)}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint POST /api/v1/stream/{stream_id}/events
@required {stream_id: str, events: [map{eventType!: str, payload!: str}]}
@optional {idempotency-key: str, idempotency-key: str, stream: map{metadata: map, name!: str, uid: str}}
@returns(202)
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint GET /api/v1/stream/{stream_id}/sink
@required {stream_id: str}
@optional {limit: int(uint64), iterator: str, order: str}
@returns(200) {data: [map], done: bool, iterator: str?, prevIterator: str?}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint POST /api/v1/stream/{stream_id}/sink
@required {stream_id: str}
@optional {idempotency-key: str, idempotency-key: str, batchSize: int(uint16)=100, eventTypes: [str]=, maxWaitSecs: int(uint16)=0, metadata: map=[object Object], status: str(enabled/disabled), uid: str}
@returns(201) {batchSize: int(int32), createdAt: str(date-time), currentIterator: str, eventTypes: [str], failureReason: str?, id: str, maxWaitSecs: int(int32), metadata: map, nextRetryAt: str(date-time)?, status: str, uid: str?, updatedAt: str(date-time)}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint GET /api/v1/stream/{stream_id}/sink/{sink_id}
@required {stream_id: str, sink_id: str}
@returns(200) {batchSize: int(int32), createdAt: str(date-time), currentIterator: str, eventTypes: [str], failureReason: str?, id: str, maxWaitSecs: int(int32), metadata: map, nextRetryAt: str(date-time)?, status: str, uid: str?, updatedAt: str(date-time)}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint PUT /api/v1/stream/{stream_id}/sink/{sink_id}
@required {stream_id: str, sink_id: str}
@optional {batchSize: int(uint16)=100, eventTypes: [str]=, maxWaitSecs: int(uint16)=0, metadata: map=[object Object], status: str(enabled/disabled), uid: str}
@returns(200) {batchSize: int(int32), createdAt: str(date-time), currentIterator: str, eventTypes: [str], failureReason: str?, id: str, maxWaitSecs: int(int32), metadata: map, nextRetryAt: str(date-time)?, status: str, uid: str?, updatedAt: str(date-time)}
@returns(201) {batchSize: int(int32), createdAt: str(date-time), currentIterator: str, eventTypes: [str], failureReason: str?, id: str, maxWaitSecs: int(int32), metadata: map, nextRetryAt: str(date-time)?, status: str, uid: str?, updatedAt: str(date-time)}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint DELETE /api/v1/stream/{stream_id}/sink/{sink_id}
@required {stream_id: str, sink_id: str}
@returns(204)
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint PATCH /api/v1/stream/{stream_id}/sink/{sink_id}
@required {stream_id: str, sink_id: str}
@optional {batchSize: int(uint16)=null, eventTypes: [str], maxWaitSecs: int(uint16)=null, metadata: map, status: str(enabled/disabled), uid: str}
@returns(200) {batchSize: int(int32), createdAt: str(date-time), currentIterator: str, eventTypes: [str], failureReason: str?, id: str, maxWaitSecs: int(int32), metadata: map, nextRetryAt: str(date-time)?, status: str, uid: str?, updatedAt: str(date-time)}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint GET /api/v1/stream/{stream_id}/sink/{sink_id}/events
@required {stream_id: str, sink_id: str}
@optional {limit: int(uint64), iterator: str, after: str(date-time)}
@returns(200) {data: [map], done: bool, iterator: str}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint GET /api/v1/stream/{stream_id}/sink/{sink_id}/headers
@required {stream_id: str, sink_id: str}
@returns(200) {headers: map, sensitive: [str]}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint PATCH /api/v1/stream/{stream_id}/sink/{sink_id}/headers
@required {stream_id: str, sink_id: str, headers: map}
@returns(200) {headers: map, sensitive: [str]}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint GET /api/v1/stream/{stream_id}/sink/{sink_id}/secret
@required {stream_id: str, sink_id: str}
@returns(200) {key: str?}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint POST /api/v1/stream/{stream_id}/sink/{sink_id}/secret/rotate
@required {stream_id: str, sink_id: str}
@optional {idempotency-key: str, idempotency-key: str, key: str=null}
@returns(200)
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint GET /api/v1/stream/{stream_id}/sink/{sink_id}/transformation
@required {stream_id: str, sink_id: str}
@returns(200) {code: str?, enabled: bool}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint PATCH /api/v1/stream/{stream_id}/sink/{sink_id}/transformation
@required {stream_id: str, sink_id: str}
@optional {code: str}
@returns(200)
@errors {400, 401, 403, 404, 409, 422, 429}

@endgroup

@group ingest
@endpoint GET /ingest/api/v1/source
@optional {limit: int(uint64), iterator: str, order: str}
@returns(200) {data: [map], done: bool, iterator: str?, prevIterator: str?}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint POST /ingest/api/v1/source
@required {name: str}
@optional {idempotency-key: str, idempotency-key: str, metadata: map=[object Object], uid: str}
@returns(201) {createdAt: str(date-time), id: str, ingestUrl: str(uri)?, metadata: map, name: str, uid: str?, updatedAt: str(date-time)}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint GET /ingest/api/v1/source/{source_id}
@required {source_id: str}
@returns(200) {createdAt: str(date-time), id: str, ingestUrl: str(uri)?, metadata: map, name: str, uid: str?, updatedAt: str(date-time)}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint PUT /ingest/api/v1/source/{source_id}
@required {source_id: str, name: str}
@optional {metadata: map=[object Object], uid: str}
@returns(200) {createdAt: str(date-time), id: str, ingestUrl: str(uri)?, metadata: map, name: str, uid: str?, updatedAt: str(date-time)}
@returns(201) {createdAt: str(date-time), id: str, ingestUrl: str(uri)?, metadata: map, name: str, uid: str?, updatedAt: str(date-time)}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint DELETE /ingest/api/v1/source/{source_id}
@required {source_id: str}
@returns(204)
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint POST /ingest/api/v1/source/{source_id}/dashboard
@required {source_id: str}
@optional {idempotency-key: str, idempotency-key: str, expiry: int(uint64), readOnly: bool}
@returns(200) {token: str, url: str(uri)}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint GET /ingest/api/v1/source/{source_id}/endpoint
@required {source_id: str}
@optional {limit: int(uint64), iterator: str, order: str}
@returns(200) {data: [map], done: bool, iterator: str?, prevIterator: str?}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint POST /ingest/api/v1/source/{source_id}/endpoint
@required {source_id: str, url: str(uri)}
@optional {idempotency-key: str, idempotency-key: str, description: str=, disabled: bool=false, metadata: map=[object Object], rateLimit: int(uint16), secret: str, uid: str}
@returns(201) {createdAt: str(date-time), description: str, disabled: bool, id: str, metadata: map, rateLimit: int(uint16)?, uid: str?, updatedAt: str(date-time), url: str(uri)}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint GET /ingest/api/v1/source/{source_id}/endpoint/{endpoint_id}
@required {source_id: str, endpoint_id: str}
@returns(200) {createdAt: str(date-time), description: str, disabled: bool, id: str, metadata: map, rateLimit: int(uint16)?, uid: str?, updatedAt: str(date-time), url: str(uri)}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint PUT /ingest/api/v1/source/{source_id}/endpoint/{endpoint_id}
@required {source_id: str, endpoint_id: str, url: str(uri)}
@optional {description: str=, disabled: bool=false, metadata: map=[object Object], rateLimit: int(uint16), uid: str}
@returns(200) {createdAt: str(date-time), description: str, disabled: bool, id: str, metadata: map, rateLimit: int(uint16)?, uid: str?, updatedAt: str(date-time), url: str(uri)}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint DELETE /ingest/api/v1/source/{source_id}/endpoint/{endpoint_id}
@required {source_id: str, endpoint_id: str}
@returns(204)
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint GET /ingest/api/v1/source/{source_id}/endpoint/{endpoint_id}/headers
@required {source_id: str, endpoint_id: str}
@returns(200) {headers: map, sensitive: [str]}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint PUT /ingest/api/v1/source/{source_id}/endpoint/{endpoint_id}/headers
@required {source_id: str, endpoint_id: str, headers: map}
@returns(204)
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint GET /ingest/api/v1/source/{source_id}/endpoint/{endpoint_id}/secret
@required {source_id: str, endpoint_id: str}
@returns(200) {key: str}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint POST /ingest/api/v1/source/{source_id}/endpoint/{endpoint_id}/secret/rotate
@required {source_id: str, endpoint_id: str}
@optional {idempotency-key: str, idempotency-key: str, key: str=null}
@returns(204)
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint GET /ingest/api/v1/source/{source_id}/endpoint/{endpoint_id}/transformation
@required {source_id: str, endpoint_id: str}
@returns(200) {code: str?, enabled: bool}
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint PATCH /ingest/api/v1/source/{source_id}/endpoint/{endpoint_id}/transformation
@required {source_id: str, endpoint_id: str}
@optional {code: str, enabled: bool}
@returns(204)
@errors {400, 401, 403, 404, 409, 422, 429}

@endpoint POST /ingest/api/v1/source/{source_id}/token/rotate
@required {source_id: str}
@optional {idempotency-key: str, idempotency-key: str}
@returns(200) {ingestUrl: str}
@errors {400, 401, 403, 404, 409, 422, 429}

@endgroup

@end