@epilot/sdk 2.15.2 → 2.15.3

package/dist/{integration-toolkit.d-7q19qDTD.d.cts → integration-toolkit.d-BUCHo8ZQ.d.cts}

@@ -1798,6 +1798,13 @@ declare namespace Components {
              * evt-2025-05-01-12345-create-bp
              */
             deduplication_id?: string; // ^[a-zA-Z0-9_-]+$
+            /**
+             * Optional per-event trace id for cross-system tracing (unique per business operation). Overrides the request-level meta.correlation_id for THIS event. When absent, the event inherits the request-level correlation_id; when both are absent, epilot mints its own event_id and the trace is epilot-only. Orthogonal to deduplication_id (idempotency).
+             *
+             * example:
+             * bp-8f3a2c-7d4e-4b1a-9c2f-1e6d5a4b3c21
+             */
+            correlation_id?: string;
             /**
              * Resolved use case ID for the inbound event. Null when no use case matched or for events ingested before this field was introduced. Server-populated only — ignored if supplied on inbound requests.
              *
@@ -1851,6 +1858,13 @@ declare namespace Components {
              * evt-2025-05-01-12345-bp
              */
             deduplication_id?: string; // ^[a-zA-Z0-9_-]+$
+            /**
+             * Optional per-event ordering group. Overrides the request-level `group_id` for THIS event; when absent, the event inherits the request-level `group_id` (or the default strict per-integration ordering). Use it when a single batch carries events for unrelated business objects that may be processed in parallel. See the request-level `group_id` for semantics.
+             *
+             * example:
+             * customer-42
+             */
+            group_id?: string;
         } | {
             /**
              * Event name from integration mapping (e.g., business_partner, contract_account). Required when use_case_slug is not provided.
@@ -1898,6 +1912,13 @@ declare namespace Components {
              * evt-2025-05-01-12345-bp
              */
             deduplication_id?: string; // ^[a-zA-Z0-9_-]+$
+            /**
+             * Optional per-event ordering group. Overrides the request-level `group_id` for THIS event; when absent, the event inherits the request-level `group_id` (or the default strict per-integration ordering). Use it when a single batch carries events for unrelated business objects that may be processed in parallel. See the request-level `group_id` for semantics.
+             *
+             * example:
+             * customer-42
+             */
+            group_id?: string;
         };
         export interface ErpUpdatesEventsV2Request {
             /**
@@ -1939,6 +1960,8 @@ declare namespace Components {
              * objects are processed concurrently.
              *
              * Notes:
+             * - Individual events may set their own `group_id`, which overrides this
+             *   request-level value for that event only.
              * - Up to 20 groups per integration are processed concurrently. Using
              *   more distinct values than that yields no additional parallelism.
              * - Omit this field if strict per-integration ordering is required.
@@ -1962,6 +1985,41 @@ declare namespace Components {
              */
             message?: string;
         }
+        /**
+         * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+         *
+         */
+        export interface ExternalMonitoringSpan {
+            /**
+             * Trace id — links this span to the epilot trace. Unique per business operation. Required.
+             */
+            correlation_id?: string;
+            /**
+             * Span outcome level — one of success | error | warning | info. Drives the server-assigned EXTERNAL_* code, coloring, and alerting. Required.
+             *
+             */
+            level?: string;
+            /**
+             * Business use case slug (e.g. "business_partner"). Resolved server-side against the integration's configured use cases to a use_case_id/use_case_type; stored as the grouping dimension. Portable — no epilot-internal UUIDs required.
+             *
+             */
+            use_case_slug?: string;
+            /**
+             * External clock time the span occurred; stored as created_at.
+             */
+            occurred_at?: string; // date-time
+            /**
+             * Human-readable line shown in the trace and event tables.
+             */
+            message?: string;
+            /**
+             * Free-form context (step, http_status, reason, …). The place for external-system specificity — the taxonomy code stays clean (EXTERNAL_*).
+             *
+             */
+            detail?: {
+                [name: string]: any;
+            } | null;
+        }
         export interface FileProxyAuth {
             /**
              * Authentication type
@@ -2212,11 +2270,12 @@ declare namespace Components {
             ];
             response: FileProxyResponseConfig;
             /**
-             * When `true`, files that are too large to be served directly in the proxy response
-             * (and would otherwise be served indirectly via a temporary S3 redirect) are not served.
-             * Instead the proxy responds with an error and logs a warning. Use this when files must
-             * never transit epilot's temporary S3 storage. Defaults to `false` (large files are
-             * transparently served via S3).
+             * When `true`, this use case is served via the streaming endpoint: mapped file URLs
+             * are built as `/stream/download`, files of any size are streamed inline over HTTP
+             * response streaming, and buffered `/download` requests for oversize files are
+             * 307-redirected to `/stream`. Files never transit epilot's temporary S3 storage on
+             * the streaming path. Defaults to `false` (small files are served directly and large
+             * files are transparently served via a temporary S3 redirect).
              *
              */
             prevent_indirect_serving?: boolean;
@@ -2621,6 +2680,537 @@ declare namespace Components {
             type: "inbound";
             configuration?: /* Configuration for inbound use cases (ERP to epilot) */ InboundIntegrationEventConfiguration;
         }
+        export interface IngestExternalMonitoringEventsRequest {
+            /**
+             * Batch of external monitoring spans (max 100 per request).
+             */
+            events: [
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?,
+                /**
+                 * A single monitoring span produced by an external system. `correlation_id`, `level`, `use_case_slug`, `occurred_at` and `message` are all required and `level` must be one of success|error|warning|info — but these are validated PER SPAN at ingest and reported in the per-item `results[]`, so one malformed span never fails the whole batch (the fields are intentionally not marked `required`/`enum` at the schema level to preserve that partial-acceptance behavior). The client does NOT send a `code` (server-assigned from `level`), a `source` (origin is the EXTERNAL_* code prefix), or span/event ids (the external system owns its own identity and dedup).
+                 *
+                 */
+                ExternalMonitoringSpan?
+            ];
+        }
+        export interface IngestExternalMonitoringEventsResponse {
+            /**
+             * Number of spans accepted and republished onto the monitoring bus.
+             */
+            accepted: number;
+            /**
+             * Number of spans rejected in validation. See `results` for reasons.
+             */
+            rejected: number;
+            /**
+             * Per-span results; present for rejections in a mixed batch.
+             */
+            results?: {
+                /**
+                 * Zero-based index of the span in the request `events` array.
+                 */
+                index: number;
+                status: "accepted" | "rejected";
+                /**
+                 * Rejection reason (present when status is rejected).
+                 */
+                reason?: string;
+            }[];
+        }
         export interface Integration {
             /**
              * Unique identifier for the integration
@@ -3532,6 +4122,44 @@ declare namespace Components {
                 [name: string]: any;
             }[];
         }
+        export interface MonitoringTraceResponse {
+            /**
+             * The trace id these spans share.
+             */
+            correlation_id: string;
+            /**
+             * Rolled-up status across all spans (error > warning > success > info).
+             */
+            status: "success" | "error" | "warning" | "info";
+            /**
+             * created_at of the earliest span (null when the trace is empty).
+             */
+            started_at?: string | null; // date-time
+            /**
+             * created_at of the latest returned span (null when the trace is empty).
+             */
+            ended_at?: string | null; // date-time
+            /**
+             * Number of spans RETURNED (== spans.length; capped).
+             */
+            span_count: number;
+            /**
+             * True when the trace has more spans than the cap; the returned window is the earliest spans, so ended_at/status reflect only that window.
+             *
+             */
+            truncated: boolean;
+            /**
+             * All spans sharing the correlation_id, chronological. External-origin spans carry an EXTERNAL_* code; epilot spans carry an epilot code or empty (success).
+             *
+             */
+            spans: MonitoringEventV2[];
+            /**
+             * The epilot inbound event "head" (raw payload), when present.
+             */
+            inbound_event?: {
+                [name: string]: any;
+            } | null;
+        }
         /**
          * Delivery channel toggles. New channels added in svc-notification-api inherit here.
          */
@@ -6134,6 +6762,23 @@ declare namespace Paths {
             export type $500 = Components.Responses.InternalServerError;
         }
     }
+    namespace GetMonitoringTraceByCorrelation {
+        namespace Parameters {
+            export type CorrelationId = string;
+            export type IntegrationId = string; // uuid
+        }
+        export interface PathParameters {
+            integrationId: Parameters.IntegrationId /* uuid */;
+            correlationId: Parameters.CorrelationId;
+        }
+        namespace Responses {
+            export type $200 = Components.Schemas.MonitoringTraceResponse;
+            export type $400 = Components.Responses.BadRequest;
+            export type $401 = Components.Responses.Unauthorized;
+            export type $404 = Components.Responses.NotFound;
+            export type $500 = Components.Responses.InternalServerError;
+        }
+    }
     namespace GetNotificationStatus {
         namespace Parameters {
             export type Include = "baseline_series";
@@ -6208,6 +6853,23 @@ declare namespace Paths {
             export type $500 = Components.Responses.InternalServerError;
         }
     }
+    namespace IngestExternalMonitoringEvents {
+        namespace Parameters {
+            export type IntegrationId = string; // uuid
+        }
+        export interface PathParameters {
+            integrationId: Parameters.IntegrationId /* uuid */;
+        }
+        export type RequestBody = Components.Schemas.IngestExternalMonitoringEventsRequest;
+        namespace Responses {
+            export type $202 = Components.Schemas.IngestExternalMonitoringEventsResponse;
+            export type $400 = Components.Responses.BadRequest;
+            export type $401 = Components.Responses.Unauthorized;
+            export type $403 = Components.Responses.Forbidden;
+            export type $404 = Components.Responses.NotFound;
+            export type $500 = Components.Responses.InternalServerError;
+        }
+    }
     namespace ListIntegrations {
         namespace Responses {
             export interface $200 {
@@ -6438,6 +7100,7 @@ declare namespace Paths {
             export type $200 = Components.Responses.ERPUpdatesResponse;
             export type $400 = Components.Responses.BadRequest;
             export type $401 = Components.Responses.Unauthorized;
+            export type $404 = Components.Responses.NotFound;
             export type $500 = Components.Responses.InternalServerError;
         }
     }
@@ -6447,6 +7110,7 @@ declare namespace Paths {
             export type $200 = Components.Responses.ERPUpdatesResponse;
             export type $400 = Components.Responses.BadRequest;
             export type $401 = Components.Responses.Unauthorized;
+            export type $404 = Components.Responses.NotFound;
             export type $500 = Components.Responses.InternalServerError;
         }
     }
@@ -7376,6 +8040,49 @@ interface OperationMethods {
     data?: any,
     config?: AxiosRequestConfig  
   ): OperationResponse<Paths.GetAssociatedMonitoringEvents.Responses.$200>
+  /**
+   * ingestExternalMonitoringEvents - ingestExternalMonitoringEvents
+   * 
+   * Ingest monitoring spans produced by an EXTERNAL system (e.g. an integration
+   * middleware), so the Integration Hub is the central monitoring point and the
+   * cross-system event trace spans both the external system and epilot's own
+   * processing.
+   * 
+   * Each span is validated, assigned a server-controlled `EXTERNAL_*` taxonomy code
+   * derived from its `level` (the client never supplies a code — this marks
+   * provenance and prevents spoofing an epilot code), has its `use_case_slug`
+   * resolved against the integration's configured use cases, and is republished onto
+   * the same monitoring event bus as epilot's own spans — so external spans are
+   * first-class to the trace view, stats, alerting and digests.
+   * 
+   * Spans link to the epilot trace via `correlation_id` (the trace id): the middleware
+   * must stamp the same `correlation_id` here and on the event it forwards to the
+   * inbound endpoint. Invalid spans in a batch are reported per-item and do not fail
+   * the whole batch.
+   * 
+   */
+  'ingestExternalMonitoringEvents'(
+    parameters?: Parameters<Paths.IngestExternalMonitoringEvents.PathParameters> | null,
+    data?: Paths.IngestExternalMonitoringEvents.RequestBody,
+    config?: AxiosRequestConfig  
+  ): OperationResponse<Paths.IngestExternalMonitoringEvents.Responses.$202>
+  /**
+   * getMonitoringTraceByCorrelation - getMonitoringTraceByCorrelation
+   * 
+   * Returns the cross-system event trace for a `correlation_id`: every monitoring
+   * span sharing it — external spans (middleware) plus epilot's own processing spans
+   * — ordered chronologically, with a rolled-up status and the epilot inbound event
+   * "head" attached. This is the correlation-grouped counterpart to
+   * `…/events/{eventId}/associated` (which groups a single epilot event's fan-out by
+   * event_id). Origin is distinguished by the `EXTERNAL_*` code prefix on external
+   * spans. Freshness is near-real-time (spans land as they are produced/ingested).
+   * 
+   */
+  'getMonitoringTraceByCorrelation'(
+    parameters?: Parameters<Paths.GetMonitoringTraceByCorrelation.PathParameters> | null,
+    data?: any,
+    config?: AxiosRequestConfig  
+  ): OperationResponse<Paths.GetMonitoringTraceByCorrelation.Responses.$200>
   /**
    * listSecureProxies - List all secure proxy use cases
    * 
@@ -8137,6 +8844,53 @@ interface PathsDictionary {
       config?: AxiosRequestConfig  
     ): OperationResponse<Paths.GetAssociatedMonitoringEvents.Responses.$200>
   }
+  ['/v2/integrations/{integrationId}/monitoring/external-events']: {
+    /**
+     * ingestExternalMonitoringEvents - ingestExternalMonitoringEvents
+     * 
+     * Ingest monitoring spans produced by an EXTERNAL system (e.g. an integration
+     * middleware), so the Integration Hub is the central monitoring point and the
+     * cross-system event trace spans both the external system and epilot's own
+     * processing.
+     * 
+     * Each span is validated, assigned a server-controlled `EXTERNAL_*` taxonomy code
+     * derived from its `level` (the client never supplies a code — this marks
+     * provenance and prevents spoofing an epilot code), has its `use_case_slug`
+     * resolved against the integration's configured use cases, and is republished onto
+     * the same monitoring event bus as epilot's own spans — so external spans are
+     * first-class to the trace view, stats, alerting and digests.
+     * 
+     * Spans link to the epilot trace via `correlation_id` (the trace id): the middleware
+     * must stamp the same `correlation_id` here and on the event it forwards to the
+     * inbound endpoint. Invalid spans in a batch are reported per-item and do not fail
+     * the whole batch.
+     * 
+     */
+    'post'(
+      parameters?: Parameters<Paths.IngestExternalMonitoringEvents.PathParameters> | null,
+      data?: Paths.IngestExternalMonitoringEvents.RequestBody,
+      config?: AxiosRequestConfig  
+    ): OperationResponse<Paths.IngestExternalMonitoringEvents.Responses.$202>
+  }
+  ['/v2/integrations/{integrationId}/monitoring/traces/{correlationId}']: {
+    /**
+     * getMonitoringTraceByCorrelation - getMonitoringTraceByCorrelation
+     * 
+     * Returns the cross-system event trace for a `correlation_id`: every monitoring
+     * span sharing it — external spans (middleware) plus epilot's own processing spans
+     * — ordered chronologically, with a rolled-up status and the epilot inbound event
+     * "head" attached. This is the correlation-grouped counterpart to
+     * `…/events/{eventId}/associated` (which groups a single epilot event's fan-out by
+     * event_id). Origin is distinguished by the `EXTERNAL_*` code prefix on external
+     * spans. Freshness is near-real-time (spans land as they are produced/ingested).
+     * 
+     */
+    'get'(
+      parameters?: Parameters<Paths.GetMonitoringTraceByCorrelation.PathParameters> | null,
+      data?: any,
+      config?: AxiosRequestConfig  
+    ): OperationResponse<Paths.GetMonitoringTraceByCorrelation.Responses.$200>
+  }
   ['/v1/integrations/secure-proxies']: {
     /**
      * listSecureProxies - List all secure proxy use cases
@@ -8257,6 +9011,7 @@ type ErpEventV3 = Components.Schemas.ErpEventV3;
 type ErpUpdatesEventsV2Request = Components.Schemas.ErpUpdatesEventsV2Request;
 type ErpUpdatesEventsV3Request = Components.Schemas.ErpUpdatesEventsV3Request;
 type ErrorResponseBase = Components.Schemas.ErrorResponseBase;
+type ExternalMonitoringSpan = Components.Schemas.ExternalMonitoringSpan;
 type FileProxyAuth = Components.Schemas.FileProxyAuth;
 type FileProxyParam = Components.Schemas.FileProxyParam;
 type FileProxyResponseConfig = Components.Schemas.FileProxyResponseConfig;
@@ -8279,6 +9034,8 @@ type InboundIntegrationEventConfiguration = Components.Schemas.InboundIntegratio
 type InboundMonitoringEvent = Components.Schemas.InboundMonitoringEvent;
 type InboundUseCase = Components.Schemas.InboundUseCase;
 type InboundUseCaseHistoryEntry = Components.Schemas.InboundUseCaseHistoryEntry;
+type IngestExternalMonitoringEventsRequest = Components.Schemas.IngestExternalMonitoringEventsRequest;
+type IngestExternalMonitoringEventsResponse = Components.Schemas.IngestExternalMonitoringEventsResponse;
 type Integration = Components.Schemas.Integration;
 type IntegrationAppMapping = Components.Schemas.IntegrationAppMapping;
 type IntegrationConfigurationV1 = Components.Schemas.IntegrationConfigurationV1;
@@ -8310,6 +9067,7 @@ type MeterUniqueIdsConfig = Components.Schemas.MeterUniqueIdsConfig;
 type MonitoringEventV2 = Components.Schemas.MonitoringEventV2;
 type MonitoringStats = Components.Schemas.MonitoringStats;
 type MonitoringStatsV2 = Components.Schemas.MonitoringStatsV2;
+type MonitoringTraceResponse = Components.Schemas.MonitoringTraceResponse;
 type NotificationChannelSet = Components.Schemas.NotificationChannelSet;
 type NotificationDigestConfig = Components.Schemas.NotificationDigestConfig;
 type NotificationHistoryItem = Components.Schemas.NotificationHistoryItem;
@@ -8393,4 +9151,4 @@ type UseCaseTypePreview = Components.Schemas.UseCaseTypePreview;
 type WebhookDeliveryConfig = Components.Schemas.WebhookDeliveryConfig;
 type WebhookStatus = Components.Schemas.WebhookStatus;
 
-export { type GetMonitoringStatsV2Request as $, type AccessLogEntry as A, type EnvironmentFieldConfig as B, type Client as C, type DeleteIntegrationAppMappingRequest as D, type EmbeddedFileProxyUseCaseRequest as E, type ErpEvent as F, type ErpEventV3 as G, type ErpUpdatesEventsV2Request as H, type ErpUpdatesEventsV3Request as I, type ErrorResponseBase as J, type FileProxyAuth as K, type FileProxyParam as L, type FileProxyResponseConfig as M, type FileProxySecureProxyAttachment as N, type OperationMethods as O, Paths as P, type FileProxyStep as Q, type FileProxyUrlConfig as R, type FileProxyUrlParam as S, type FileProxyUrlParams as T, type FileProxyUseCase as U, type FileProxyUseCaseConfiguration as V, type FileProxyUseCaseHistoryEntry as W, type GenerateTypesPreviewResponse as X, type GenerateTypesRequest as Y, type GenerateTypesResponse as Z, type GetMonitoringStatsRequest as _, Components as a, type PruneScopeConfig as a$, type GetMonitoringTimeSeriesRequest as a0, type GetMonitoringTimeSeriesV2Request as a1, type InboundIntegrationEventConfiguration as a2, type InboundMonitoringEvent as a3, type InboundUseCase as a4, type InboundUseCaseHistoryEntry as a5, type Integration as a6, type IntegrationAppMapping as a7, type IntegrationConfigurationV1 as a8, type IntegrationConfigurationV2 as a9, type MonitoringStatsV2 as aA, type NotificationChannelSet as aB, type NotificationDigestConfig as aC, type NotificationHistoryItem as aD, type NotificationHistoryResponse as aE, type NotificationRecipient as aF, type NotificationRule as aG, type NotificationRuleStatus as aH, type NotificationStatusResponse as aI, type OutboundConflict as aJ, type OutboundDlqListResponse as aK, type OutboundDlqMessage as aL, type OutboundIntegrationEventConfiguration as aM, type OutboundMapping as aN, type OutboundMessage as aO, type OutboundMonitoringEvent as aP, type OutboundPollStatus as aQ, type OutboundStatusResponse as aR, type OutboundUseCase as aS, type OutboundUseCaseHistoryEntry as aT, type OutboundUseCaseStatus as aU, type PollDeliveryConfig as aV, type PollOutboundMessagesRequest as aW, type PollOutboundMessagesResponse as aX, type PortalOrigin as aY, type PortalRefConfig as aZ, type PortalRefFilter as a_, type IntegrationEditableFields as aa, type IntegrationEntity as ab, type IntegrationEntityField as ac, type IntegrationFieldV1 as ad, type IntegrationMeterReading as ae, type IntegrationNotificationConfig as af, type IntegrationObjectV1 as ag, type IntegrationSettings as ah, type IntegrationWithUseCases as ai, type ManagedCallAuth as aj, type ManagedCallErrorResponse as ak, type ManagedCallExecuteRequest as al, type ManagedCallExecuteResponse as am, type ManagedCallOperation as an, type ManagedCallOperationConfig as ao, type ManagedCallUseCase as ap, type ManagedCallUseCaseHistoryEntry as aq, type MappingSimulationRequest as ar, type MappingSimulationResponse as as, type MappingSimulationV2Request as at, type MappingSimulationWarning as au, type MeterReadingPruneScopeConfig as av, type MeterReadingUpdate as aw, type MeterUniqueIdsConfig as ax, type MonitoringEventV2 as ay, type MonitoringStats as az, type PathsDictionary as b, type QueryAccessLogsRequest as b0, type QueryEventsRequest as b1, type QueryInboundMonitoringEventsRequest as b2, type QueryMonitoringEventsV2Request as b3, type QueryOutboundMonitoringEventsRequest as b4, type RedriveOutboundDlqRequest as b5, type RedriveOutboundDlqResponse as b6, type RedriveOutboundDlqResult as b7, type RelationConfig as b8, type RelationItemConfig as b9, type TypeDescriptor as bA, type UnblockOutboundStreamRequest as bB, type UnblockOutboundStreamResponse as bC, type UpdateFileProxyUseCaseRequest as bD, type UpdateInboundUseCaseRequest as bE, type UpdateIntegrationRequest as bF, type UpdateManagedCallUseCaseRequest as bG, type UpdateOutboundUseCaseRequest as bH, type UpdateSecureProxyUseCaseRequest as bI, type UpdateUseCaseRequest as bJ, type UpdateUseCaseRequestBase as bK, type UpsertIntegrationWithUseCasesRequest as bL, type UseCase as bM, type UseCaseBase as bN, type UseCaseHistoryEntry as bO, type UseCaseHistoryEntryBase as bP, type UseCaseTypePreview as bQ, type WebhookDeliveryConfig as bR, type WebhookStatus as bS, type RelationRefItemConfig as ba, type RelationRefValueConfig as bb, type RelationRefsConfig as bc, type RelationUniqueIdField as bd, type RepeatableFieldType as be, type ReplayEventsRequest as bf, type RuleBaselineBucket as bg, type RuleBaselineStatus as bh, type SecureProxyRequest as bi, type SecureProxyResponse as bj, type SecureProxySummary as bk, type SecureProxyUpstreamError as bl, type SecureProxyUseCase as bm, type SecureProxyUseCaseConfiguration as bn, type SecureProxyUseCaseHistoryEntry as bo, type SecureProxyWhitelist as bp, type SecureProxyWhitelistUpdate as bq, type SetIntegrationAppMappingRequest as br, type TestNotificationRequest as bs, type TestNotificationResponse as bt, type TimeSeriesBreakdownItemV2 as bu, type TimeSeriesBucket as bv, type TimeSeriesBucketV2 as bw, type TriggerErpActionRequest as bx, type TriggerWebhookResp as by, type TypeAnnotations as bz, type AckOutboundMessagesRequest as c, type AckOutboundMessagesResponse as d, type AckResult as e, type AutoRefreshSettings as f, type CommitTypesRequest as g, type CommitTypesResponse as h, type ConnectorConfig as i, type CreateFileProxyUseCaseRequest as j, type CreateInboundUseCaseRequest as k, type CreateIntegrationRequest as l, type CreateManagedCallUseCaseRequest as m, type CreateOutboundUseCaseRequest as n, type CreateSecureProxyUseCaseRequest as o, type CreateUseCaseRequest as p, type CreateUseCaseRequestBase as q, type DeliveryConfig as r, type EmbeddedInboundUseCaseRequest as s, type EmbeddedManagedCallUseCaseRequest as t, type EmbeddedOutboundUseCaseRequest as u, type EmbeddedSecureProxyUseCaseRequest as v, type EmbeddedUseCaseRequest as w, type EmbeddedUseCaseRequestBase as x, type EntityUpdate as y, type EnvVarRefConfig as z };
+export { type GetMonitoringStatsRequest as $, type AccessLogEntry as A, type EnvironmentFieldConfig as B, type Client as C, type DeleteIntegrationAppMappingRequest as D, type EmbeddedFileProxyUseCaseRequest as E, type ErpEvent as F, type ErpEventV3 as G, type ErpUpdatesEventsV2Request as H, type ErpUpdatesEventsV3Request as I, type ErrorResponseBase as J, type ExternalMonitoringSpan as K, type FileProxyAuth as L, type FileProxyParam as M, type FileProxyResponseConfig as N, type OperationMethods as O, Paths as P, type FileProxySecureProxyAttachment as Q, type FileProxyStep as R, type FileProxyUrlConfig as S, type FileProxyUrlParam as T, type FileProxyUrlParams as U, type FileProxyUseCase as V, type FileProxyUseCaseConfiguration as W, type FileProxyUseCaseHistoryEntry as X, type GenerateTypesPreviewResponse as Y, type GenerateTypesRequest as Z, type GenerateTypesResponse as _, Components as a, type PollOutboundMessagesResponse as a$, type GetMonitoringStatsV2Request as a0, type GetMonitoringTimeSeriesRequest as a1, type GetMonitoringTimeSeriesV2Request as a2, type InboundIntegrationEventConfiguration as a3, type InboundMonitoringEvent as a4, type InboundUseCase as a5, type InboundUseCaseHistoryEntry as a6, type IngestExternalMonitoringEventsRequest as a7, type IngestExternalMonitoringEventsResponse as a8, type Integration as a9, type MeterUniqueIdsConfig as aA, type MonitoringEventV2 as aB, type MonitoringStats as aC, type MonitoringStatsV2 as aD, type MonitoringTraceResponse as aE, type NotificationChannelSet as aF, type NotificationDigestConfig as aG, type NotificationHistoryItem as aH, type NotificationHistoryResponse as aI, type NotificationRecipient as aJ, type NotificationRule as aK, type NotificationRuleStatus as aL, type NotificationStatusResponse as aM, type OutboundConflict as aN, type OutboundDlqListResponse as aO, type OutboundDlqMessage as aP, type OutboundIntegrationEventConfiguration as aQ, type OutboundMapping as aR, type OutboundMessage as aS, type OutboundMonitoringEvent as aT, type OutboundPollStatus as aU, type OutboundStatusResponse as aV, type OutboundUseCase as aW, type OutboundUseCaseHistoryEntry as aX, type OutboundUseCaseStatus as aY, type PollDeliveryConfig as aZ, type PollOutboundMessagesRequest as a_, type IntegrationAppMapping as aa, type IntegrationConfigurationV1 as ab, type IntegrationConfigurationV2 as ac, type IntegrationEditableFields as ad, type IntegrationEntity as ae, type IntegrationEntityField as af, type IntegrationFieldV1 as ag, type IntegrationMeterReading as ah, type IntegrationNotificationConfig as ai, type IntegrationObjectV1 as aj, type IntegrationSettings as ak, type IntegrationWithUseCases as al, type ManagedCallAuth as am, type ManagedCallErrorResponse as an, type ManagedCallExecuteRequest as ao, type ManagedCallExecuteResponse as ap, type ManagedCallOperation as aq, type ManagedCallOperationConfig as ar, type ManagedCallUseCase as as, type ManagedCallUseCaseHistoryEntry as at, type MappingSimulationRequest as au, type MappingSimulationResponse as av, type MappingSimulationV2Request as aw, type MappingSimulationWarning as ax, type MeterReadingPruneScopeConfig as ay, type MeterReadingUpdate as az, type PathsDictionary as b, type PortalOrigin as b0, type PortalRefConfig as b1, type PortalRefFilter as b2, type PruneScopeConfig as b3, type QueryAccessLogsRequest as b4, type QueryEventsRequest as b5, type QueryInboundMonitoringEventsRequest as b6, type QueryMonitoringEventsV2Request as b7, type QueryOutboundMonitoringEventsRequest as b8, type RedriveOutboundDlqRequest as b9, type TimeSeriesBucketV2 as bA, type TriggerErpActionRequest as bB, type TriggerWebhookResp as bC, type TypeAnnotations as bD, type TypeDescriptor as bE, type UnblockOutboundStreamRequest as bF, type UnblockOutboundStreamResponse as bG, type UpdateFileProxyUseCaseRequest as bH, type UpdateInboundUseCaseRequest as bI, type UpdateIntegrationRequest as bJ, type UpdateManagedCallUseCaseRequest as bK, type UpdateOutboundUseCaseRequest as bL, type UpdateSecureProxyUseCaseRequest as bM, type UpdateUseCaseRequest as bN, type UpdateUseCaseRequestBase as bO, type UpsertIntegrationWithUseCasesRequest as bP, type UseCase as bQ, type UseCaseBase as bR, type UseCaseHistoryEntry as bS, type UseCaseHistoryEntryBase as bT, type UseCaseTypePreview as bU, type WebhookDeliveryConfig as bV, type WebhookStatus as bW, type RedriveOutboundDlqResponse as ba, type RedriveOutboundDlqResult as bb, type RelationConfig as bc, type RelationItemConfig as bd, type RelationRefItemConfig as be, type RelationRefValueConfig as bf, type RelationRefsConfig as bg, type RelationUniqueIdField as bh, type RepeatableFieldType as bi, type ReplayEventsRequest as bj, type RuleBaselineBucket as bk, type RuleBaselineStatus as bl, type SecureProxyRequest as bm, type SecureProxyResponse as bn, type SecureProxySummary as bo, type SecureProxyUpstreamError as bp, type SecureProxyUseCase as bq, type SecureProxyUseCaseConfiguration as br, type SecureProxyUseCaseHistoryEntry as bs, type SecureProxyWhitelist as bt, type SecureProxyWhitelistUpdate as bu, type SetIntegrationAppMappingRequest as bv, type TestNotificationRequest as bw, type TestNotificationResponse as bx, type TimeSeriesBreakdownItemV2 as by, type TimeSeriesBucket as bz, type AckOutboundMessagesRequest as c, type AckOutboundMessagesResponse as d, type AckResult as e, type AutoRefreshSettings as f, type CommitTypesRequest as g, type CommitTypesResponse as h, type ConnectorConfig as i, type CreateFileProxyUseCaseRequest as j, type CreateInboundUseCaseRequest as k, type CreateIntegrationRequest as l, type CreateManagedCallUseCaseRequest as m, type CreateOutboundUseCaseRequest as n, type CreateSecureProxyUseCaseRequest as o, type CreateUseCaseRequest as p, type CreateUseCaseRequestBase as q, type DeliveryConfig as r, type EmbeddedInboundUseCaseRequest as s, type EmbeddedManagedCallUseCaseRequest as t, type EmbeddedOutboundUseCaseRequest as u, type EmbeddedSecureProxyUseCaseRequest as v, type EmbeddedUseCaseRequest as w, type EmbeddedUseCaseRequestBase as x, type EntityUpdate as y, type EnvVarRefConfig as z };