@epilot/sdk 2.18.6 → 2.18.8

package/dist/{integration-toolkit.d-E2nrIdIM.d.cts → integration-toolkit.d-D5LjhCQB.d.cts}

@@ -1338,16 +1338,22 @@ declare namespace Components {
              */
             latest_types_package_name?: string;
         }
+        /**
+         * Register an already-uploaded file as an import. The use case is chosen later, via `:validate` — upload and interpretation are separate decisions.
+         */
         export interface CreateErpImportRequest {
             s3_reference: S3Reference;
-            integration_id: string;
-            use_case_slug?: string;
+            /**
+             * Return a sample of the file's first rows. Informational only — `:validate` is still the authority. `preview` is present iff this is true.
+             */
+            include_preview?: boolean;
         }
         export interface CreateErpImportResponse {
             /**
              * `imp_{ULID}` — time-ordered, also used as the job's correlation_id.
              */
             import_id: string;
+            preview?: /* Sample of the file's first rows, using the same parser as `:validate`. `status` is the outcome of this read, not a verdict on the file. */ ErpImportFilePreview;
         }
         export interface CreateFileProxyUseCaseRequest {
             /**
@@ -1368,11 +1374,25 @@ declare namespace Components {
              */
             type: "file_proxy";
             configuration?: /**
-             * Configuration for file_proxy use cases. Defines how to authenticate and fetch files from external document systems.
+             * Configuration for file_proxy use cases. Defines how to authenticate and move files
+             * between epilot and an external document system, in either direction (see `direction`).
+             *
+             * **Download** (`direction: download`, the default) fetches a file from the external system
+             * and serves it to a browser. The download URL always requires `orgId`, `integrationId`, and
+             * either `useCaseSlug` (recommended) or `useCaseId` (legacy UUID) as query parameters.
+             * The `orgId` is included in the signed URL to establish organization context without
+             * requiring authentication. Additional use-case-specific parameters are declared in the
+             * `params` array. `response` is REQUIRED for download use cases.
              *
-             * The file proxy download URL always requires `orgId`, `integrationId`, and either `useCaseSlug` (recommended) or `useCaseId` (legacy UUID) as query parameters.
-             * The `orgId` is included in the signed URL to establish organization context without requiring authentication.
-             * Additional use-case-specific parameters are declared in the `params` array.
+             * **Upload** (`direction: upload`) pushes epilot files to the external system. It is not
+             * reachable over the download endpoint; an outbound use case points at it via a `file_proxy`
+             * delivery, and this configuration owns everything about what gets sent: `fan_out` decides
+             * how many deliveries one event produces, `params_mapping` builds the values, and the
+             * `steps` place those values into requests via `{{ params.* }}`.
+             * `upload` and `params_mapping` are REQUIRED and `response` MUST be omitted.
+             *
+             * OpenAPI 3.0 cannot express this conditional requiredness, so it is enforced by the
+             * server-side validator, which returns an explicit message naming the offending field.
              *
              */
             FileProxyUseCaseConfiguration;
@@ -1525,9 +1545,26 @@ declare namespace Components {
             component_id: string; // uuid
         }
         /**
-         * Configuration for how the event should be delivered. webhook = push delivery via svc-webhooks (JSONata-transformed payload); poll = pull-based queue delivery where the consumer fetches items via the poll API (raw event payload)
+         * Configuration for how the event should be delivered. webhook = push delivery via svc-webhooks (JSONata-transformed payload); poll = pull-based queue delivery where the consumer fetches items via the poll API (raw event payload); file_proxy = one push per event attachment to an external document system, through a file_proxy use case (JSONata-transformed payload carrying the file bytes)
          */
-        export type DeliveryConfig = /* Configuration for how the event should be delivered. webhook = push delivery via svc-webhooks (JSONata-transformed payload); poll = pull-based queue delivery where the consumer fetches items via the poll API (raw event payload) */ /* Push delivery of the transformed event to a webhook via svc-webhooks */ WebhookDeliveryConfig | /* Pull-based queue delivery. Items carry the raw standardized event-catalog payload; no JSONata mapping is applied in poll mode. Consumers fetch and acknowledge items via the poll API. */ PollDeliveryConfig;
+        export type DeliveryConfig = /* Configuration for how the event should be delivered. webhook = push delivery via svc-webhooks (JSONata-transformed payload); poll = pull-based queue delivery where the consumer fetches items via the poll API (raw event payload); file_proxy = one push per event attachment to an external document system, through a file_proxy use case (JSONata-transformed payload carrying the file bytes) */ /* Push delivery of the transformed event to a webhook via svc-webhooks */ WebhookDeliveryConfig | /* Pull-based queue delivery. Items carry the raw standardized event-catalog payload; no JSONata mapping is applied in poll mode. Consumers fetch and acknowledge items via the poll API. */ PollDeliveryConfig | /**
+         * Push delivery to an external document system through a `file_proxy` use case.
+         *
+         * A pure pointer, deliberately. The outbound use case decides WHEN to deliver — its event
+         * name plus `event_filter` — and the referenced `file_proxy` use case decides WHAT and HOW:
+         * which items to fan out over (`fan_out`), what values to build (`params_mapping`,
+         * `lookups`, `constants`), and the steps that send them. Keeping every file concern on the
+         * file_proxy side is what lets one upload recipe be shared by several event subscriptions
+         * without duplicating any of it.
+         *
+         * `jsonata_expression` on the mapping is NOT used for this delivery type and is rejected.
+         *
+         * The slug is resolved at delivery time, not at save time, so use cases can be saved in any
+         * order; a dangling reference surfaces as a `USE_CASE_NOT_FOUND` monitoring event naming
+         * the referencing mapping.
+         *
+         */
+        FileProxyDeliveryConfig;
         export interface EmbeddedFileProxyUseCaseRequest {
             /**
              * Optional use case ID for update matching.
@@ -1559,11 +1596,25 @@ declare namespace Components {
              */
             type: "file_proxy";
             configuration?: /**
-             * Configuration for file_proxy use cases. Defines how to authenticate and fetch files from external document systems.
+             * Configuration for file_proxy use cases. Defines how to authenticate and move files
+             * between epilot and an external document system, in either direction (see `direction`).
              *
-             * The file proxy download URL always requires `orgId`, `integrationId`, and either `useCaseSlug` (recommended) or `useCaseId` (legacy UUID) as query parameters.
-             * The `orgId` is included in the signed URL to establish organization context without requiring authentication.
-             * Additional use-case-specific parameters are declared in the `params` array.
+             * **Download** (`direction: download`, the default) fetches a file from the external system
+             * and serves it to a browser. The download URL always requires `orgId`, `integrationId`, and
+             * either `useCaseSlug` (recommended) or `useCaseId` (legacy UUID) as query parameters.
+             * The `orgId` is included in the signed URL to establish organization context without
+             * requiring authentication. Additional use-case-specific parameters are declared in the
+             * `params` array. `response` is REQUIRED for download use cases.
+             *
+             * **Upload** (`direction: upload`) pushes epilot files to the external system. It is not
+             * reachable over the download endpoint; an outbound use case points at it via a `file_proxy`
+             * delivery, and this configuration owns everything about what gets sent: `fan_out` decides
+             * how many deliveries one event produces, `params_mapping` builds the values, and the
+             * `steps` place those values into requests via `{{ params.* }}`.
+             * `upload` and `params_mapping` are REQUIRED and `response` MUST be omitted.
+             *
+             * OpenAPI 3.0 cannot express this conditional requiredness, so it is enforced by the
+             * server-side validator, which returns an explicit message naming the offending field.
              *
              */
             FileProxyUseCaseConfiguration;
@@ -2040,6 +2091,23 @@ declare namespace Components {
              */
             message: string;
         }
+        /**
+         * Sample of the file's first rows, using the same parser as `:validate`. `status` is the outcome of this read, not a verdict on the file.
+         */
+        export interface ErpImportFilePreview {
+            /**
+             * Treat an unrecognized value as "no preview available". Values may be added. UNREADABLE covers empty, header-only, malformed, or gone — there is no breakdown; `:validate` reports the reason.
+             */
+            status: "AVAILABLE" | "FORMAT_UNSUPPORTED" | "UNREADABLE";
+            /**
+             * Effective column names (trimmed, duplicates collapsed). Set iff `status` is AVAILABLE.
+             */
+            columns?: string[];
+            /**
+             * Up to the first 5 data rows, aligned to `columns`.
+             */
+            rows?: string[][];
+        }
         /**
          * A problem found during validation, scoped to the file as a whole rather than to individual rows. See `code` for the kinds reported.
          */
@@ -2066,14 +2134,17 @@ declare namespace Components {
             import_id: string;
             org_id: string;
             created_by?: string;
-            integration_id: string;
             /**
-             * The inbound use case whose mapping drives both phases.
+             * The integration owning the chosen use case. Absent until the first `:validate`.
+             */
+            integration_id?: string;
+            /**
+             * The inbound use case whose mapping drives both phases. Absent until the first `:validate`, and MUTABLE — re-validating with a different use case replaces it.
              */
             use_case_slug?: string;
             format: "csv" | "xlsx";
             /**
-             * PENDING → VALIDATING → READY → PROCESSING → IMPORTED, with FAILED reachable from any working status, and CANCELLING → CANCELLED reachable from VALIDATING or PROCESSING via :abort. IMPORTED, FAILED and CANCELLED are terminal and final.
+             * PENDING → VALIDATING → READY → PROCESSING → IMPORTED, with FAILED reachable from any working status, and CANCELLING → CANCELLED reachable from VALIDATING or PROCESSING via :abort. Only IMPORTED and CANCELLED are terminal. READY and FAILED both accept a further `:validate`, which is how a wrong use case is corrected without re-uploading the file.
              * IMPORTED means every row was handed to the platform, not that the platform finished — per-row outcomes live in monitoring, filtered by correlation_id. A file that fails validation is FAILED with error.code = VALIDATION_BLOCKED.
              * READY is legitimately idle for as long as the user takes to confirm, so it carries no running work and never goes stale.
              * CANCELLING is transient and cooperative: the abort has been recorded but the worker only notices at its next batch boundary. Rows already published stay published — a stop is not a rollback.
@@ -2116,6 +2187,24 @@ declare namespace Components {
              */
             total_rows?: number;
         }
+        export interface ErpImportUseCaseSuggestion {
+            integration_id: string;
+            integration_name: string;
+            use_case_slug: string;
+            use_case_name: string;
+            /**
+             * How many distinct entity schemas this mapping uses.
+             */
+            entity_types: number;
+            /**
+             * How many of the FILE's columns this use case reads, by exact trimmed name.
+             */
+            matched_columns: number;
+            /**
+             * Columns in the file. Identical across entries; repeated per entry so each row renders standalone as "matches N of your M columns".
+             */
+            file_columns: number;
+        }
         /**
          * Validate-phase summary: what the file will create, and whether it may be confirmed. Absent until the validate phase completes. No per-row detail is kept — a rejected file is corrected and imported again.
          */
@@ -2302,6 +2391,110 @@ declare namespace Components {
                 [name: string]: string;
             };
         }
+        /**
+         * Push delivery to an external document system through a `file_proxy` use case.
+         *
+         * A pure pointer, deliberately. The outbound use case decides WHEN to deliver — its event
+         * name plus `event_filter` — and the referenced `file_proxy` use case decides WHAT and HOW:
+         * which items to fan out over (`fan_out`), what values to build (`params_mapping`,
+         * `lookups`, `constants`), and the steps that send them. Keeping every file concern on the
+         * file_proxy side is what lets one upload recipe be shared by several event subscriptions
+         * without duplicating any of it.
+         *
+         * `jsonata_expression` on the mapping is NOT used for this delivery type and is rejected.
+         *
+         * The slug is resolved at delivery time, not at save time, so use cases can be saved in any
+         * order; a dangling reference surfaces as a `USE_CASE_NOT_FOUND` monitoring event naming
+         * the referencing mapping.
+         *
+         */
+        export interface FileProxyDeliveryConfig {
+            /**
+             * Delivery mechanism type
+             */
+            type: "file_proxy";
+            /**
+             * Slug of a `file_proxy` use case with `direction: upload` in the SAME integration.
+             *
+             * example:
+             * wemag_d3_document_upload
+             */
+            use_case_slug: string;
+        }
+        /**
+         * Splits one event into several independent deliveries.
+         *
+         * Mirrors the inbound mapping idiom, where an entity's JSONata expression returning an array
+         * produces one entity update per element. Made explicit with a toggle here because an upload
+         * is also legitimately used without splitting, and because auto-detecting "array means
+         * split" would make a single-element result ambiguous.
+         *
+         * Each resulting delivery is fully independent: its own idempotency record, its own retry
+         * schedule, its own monitoring events. A four-item event can therefore end up three-of-four
+         * delivered, which is the honest state to report.
+         *
+         * The split is evaluated ONCE, when the event is enqueued, so item indices — and therefore
+         * idempotency keys — stay stable across retries.
+         *
+         */
+        export interface FileProxyFanOutConfig {
+            /**
+             * When false (or absent), the event produces exactly one delivery and `$item` is not
+             * bound in `params_mapping`.
+             *
+             */
+            enabled: boolean;
+            /**
+             * JSONata over the event that MUST return an array; one delivery is created per element,
+             * bound as `$item` in `params_mapping`. Required when `enabled` is true.
+             *
+             * Keep this a plain projection — scoping which events are handled at all belongs in the
+             * outbound use case's `event_filter`, not here. A non-array result fails the event with
+             * `FAN_OUT_INVALID_RESULT`; an empty array produces no deliveries and one info-level
+             * `FAN_OUT_EMPTY`, which is the normal outcome for a catch-all subscription seeing an
+             * event with nothing to send.
+             *
+             * example:
+             * event_attachments
+             */
+            split_expression?: string;
+        }
+        /**
+         * A named translation from a value in the event to a value the external system expects.
+         *
+         */
+        export interface FileProxyLookup {
+            /**
+             * JSONata expression over the event producing the lookup key
+             * example:
+             * ticket._purpose_name[0]
+             */
+            source: string;
+            /**
+             * Key-to-value translation table
+             * example:
+             * {
+             *   "Zählerstandsmeldung": "Zählerstand",
+             *   "Kündigung": "Kündigung"
+             * }
+             */
+            entries: {
+                [name: string]: string;
+            };
+            /**
+             * Value used when the key is absent from `entries`
+             */
+            default?: string;
+            /**
+             * What happens when the key is not in `entries`.
+             * `default` substitutes `default` silently; `warn` substitutes it and emits a
+             * `LOOKUP_UNMAPPED` warning so the gap is visible without stopping delivery;
+             * `fail` aborts the delivery terminally.
+             * Defaults to `default` when a `default` is set, and to `warn` when it is not.
+             *
+             */
+            on_miss?: "default" | "warn" | "fail";
+        }
         export interface FileProxyParam {
             /**
              * Parameter name as it appears in the query string
@@ -2316,6 +2509,11 @@ declare namespace Components {
              */
             description?: string;
         }
+        /**
+         * How to extract the file from the step results. REQUIRED when `direction` is `download`;
+         * rejected when `direction` is `upload` (an upload has no file to extract).
+         *
+         */
         export interface FileProxyResponseConfig {
             /**
              * JSONata expression to extract file content from step results
@@ -2348,7 +2546,7 @@ declare namespace Components {
             /**
              * HTTP method
              */
-            method: "GET" | "POST";
+            method: "GET" | "POST" | "PUT" | "PATCH";
             /**
              * Handlebars templates for request headers
              */
@@ -2356,7 +2554,21 @@ declare namespace Components {
                 [name: string]: string;
             };
             /**
-             * Handlebars template for the request body (POST only)
+             * Handlebars template for the request body (write methods only). On an `upload` use
+             * case this is where the payload is assembled, reading `{{ params.* }}` built by
+             * `params_mapping`, plus `{{ env.* }}` and `{{ steps.N.body }}`.
+             *
+             * **Route every user-controlled value through the `json` helper**: the template engine
+             * does not escape, so `"name":"{{ params.fileName }}"` produces invalid JSON the moment
+             * a filename contains a quote. Write `"name": {{json params.fileName}}` instead — the
+             * helper emits the surrounding quotes itself and renders absent values as `null`. Use
+             * `{{jsonEscape v}}` if you prefer to keep your own quotes. Upload configurations whose
+             * body would break on such input are rejected at save time.
+             *
+             * Handlebars block helpers work, so optional fields can be omitted rather than sent
+             * empty: `{{#if params.pin}},"pin": {{json params.pin}}{{/if}}`. Note that `{{/if}}}`
+             * fails to parse — leave a space before a closing brace: `{{/if}} }`.
+             *
              */
             body?: string;
             /**
@@ -2364,6 +2576,54 @@ declare namespace Components {
              */
             response_type: "json" | "binary";
         }
+        /**
+         * Upload-side settings for a file_proxy use case with `direction: upload`.
+         * Everything about WHAT is sent lives on the outbound mapping
+         * (see `FileProxyDeliveryConfig`); this object only governs HOW the transfer is bounded
+         * and judged.
+         *
+         */
+        export interface FileProxyUploadConfig {
+            /**
+             * Per-file ceiling for this use case, in bytes. Files above it fail terminally with
+             * `FILE_TOO_LARGE` before any bytes are fetched. Defaults to — and is clamped by — the
+             * platform ceiling of 100 MiB (104857600).
+             *
+             */
+            max_file_bytes?: number;
+            /**
+             * Maximum delivery attempts per item before the delivery is marked failed and the
+             * message is dead-lettered. Attempts are spaced by an exponential, jittered backoff
+             * spanning roughly 16 hours over the default 8 attempts, so an ERP maintenance window
+             * does not exhaust them.
+             *
+             * Lives here rather than on the outbound delivery because how hard to retry is a
+             * property of the transport — the same judgement as `max_file_bytes` — and the outbound
+             * delivery is a pure pointer.
+             *
+             */
+            max_delivery_attempts?: number;
+            /**
+             * Optional JSONata predicate evaluated against the final step result
+             * (`{ statusCode, headers, body }`) to decide whether the external system really
+             * accepted the file. When omitted, any 2xx counts as delivered. Use this for systems
+             * that return 200 with an error envelope.
+             *
+             * example:
+             * body.status = 'OK'
+             */
+            success_when?: string;
+            /**
+             * Optional JSONata expression over the step results yielding the external system's
+             * identifier for the stored document. Recorded on the delivery record and on the
+             * `FILE_PROXY_UPLOADED` monitoring event so an operator can find the document in the
+             * target system.
+             *
+             * example:
+             * steps[-1].body.documentId
+             */
+            external_id?: string;
+        }
         /**
          * Auto-constructs a file proxy download URL. orgId and integrationId are injected from context. Exactly one of use_case_id or use_case_slug must be provided. Using use_case_slug is recommended as it is portable across environments.
          *
@@ -2454,24 +2714,169 @@ declare namespace Components {
              */
             updated_at: string; // date-time
             configuration?: /**
-             * Configuration for file_proxy use cases. Defines how to authenticate and fetch files from external document systems.
+             * Configuration for file_proxy use cases. Defines how to authenticate and move files
+             * between epilot and an external document system, in either direction (see `direction`).
+             *
+             * **Download** (`direction: download`, the default) fetches a file from the external system
+             * and serves it to a browser. The download URL always requires `orgId`, `integrationId`, and
+             * either `useCaseSlug` (recommended) or `useCaseId` (legacy UUID) as query parameters.
+             * The `orgId` is included in the signed URL to establish organization context without
+             * requiring authentication. Additional use-case-specific parameters are declared in the
+             * `params` array. `response` is REQUIRED for download use cases.
+             *
+             * **Upload** (`direction: upload`) pushes epilot files to the external system. It is not
+             * reachable over the download endpoint; an outbound use case points at it via a `file_proxy`
+             * delivery, and this configuration owns everything about what gets sent: `fan_out` decides
+             * how many deliveries one event produces, `params_mapping` builds the values, and the
+             * `steps` place those values into requests via `{{ params.* }}`.
+             * `upload` and `params_mapping` are REQUIRED and `response` MUST be omitted.
              *
-             * The file proxy download URL always requires `orgId`, `integrationId`, and either `useCaseSlug` (recommended) or `useCaseId` (legacy UUID) as query parameters.
-             * The `orgId` is included in the signed URL to establish organization context without requiring authentication.
-             * Additional use-case-specific parameters are declared in the `params` array.
+             * OpenAPI 3.0 cannot express this conditional requiredness, so it is enforced by the
+             * server-side validator, which returns an explicit message naming the offending field.
              *
              */
             FileProxyUseCaseConfiguration;
         }
         /**
-         * Configuration for file_proxy use cases. Defines how to authenticate and fetch files from external document systems.
+         * Configuration for file_proxy use cases. Defines how to authenticate and move files
+         * between epilot and an external document system, in either direction (see `direction`).
          *
-         * The file proxy download URL always requires `orgId`, `integrationId`, and either `useCaseSlug` (recommended) or `useCaseId` (legacy UUID) as query parameters.
-         * The `orgId` is included in the signed URL to establish organization context without requiring authentication.
-         * Additional use-case-specific parameters are declared in the `params` array.
+         * **Download** (`direction: download`, the default) fetches a file from the external system
+         * and serves it to a browser. The download URL always requires `orgId`, `integrationId`, and
+         * either `useCaseSlug` (recommended) or `useCaseId` (legacy UUID) as query parameters.
+         * The `orgId` is included in the signed URL to establish organization context without
+         * requiring authentication. Additional use-case-specific parameters are declared in the
+         * `params` array. `response` is REQUIRED for download use cases.
+         *
+         * **Upload** (`direction: upload`) pushes epilot files to the external system. It is not
+         * reachable over the download endpoint; an outbound use case points at it via a `file_proxy`
+         * delivery, and this configuration owns everything about what gets sent: `fan_out` decides
+         * how many deliveries one event produces, `params_mapping` builds the values, and the
+         * `steps` place those values into requests via `{{ params.* }}`.
+         * `upload` and `params_mapping` are REQUIRED and `response` MUST be omitted.
+         *
+         * OpenAPI 3.0 cannot express this conditional requiredness, so it is enforced by the
+         * server-side validator, which returns an explicit message naming the offending field.
          *
          */
         export interface FileProxyUseCaseConfiguration {
+            /**
+             * Direction of file travel. `download` (default) pulls a file from the external system
+             * into epilot; `upload` pushes an epilot file out to the external system. Omitted means
+             * `download`, so every pre-existing configuration keeps its exact meaning.
+             *
+             * Note this is the direction of the FILE, not the epilot use-case type — an `upload`
+             * file_proxy use case is still a `file_proxy` use case, never an `outbound` one.
+             *
+             */
+            direction?: "download" | "upload";
+            upload?: /**
+             * Upload-side settings for a file_proxy use case with `direction: upload`.
+             * Everything about WHAT is sent lives on the outbound mapping
+             * (see `FileProxyDeliveryConfig`); this object only governs HOW the transfer is bounded
+             * and judged.
+             *
+             */
+            FileProxyUploadConfig;
+            fan_out?: /**
+             * Splits one event into several independent deliveries.
+             *
+             * Mirrors the inbound mapping idiom, where an entity's JSONata expression returning an array
+             * produces one entity update per element. Made explicit with a toggle here because an upload
+             * is also legitimately used without splitting, and because auto-detecting "array means
+             * split" would make a single-element result ambiguous.
+             *
+             * Each resulting delivery is fully independent: its own idempotency record, its own retry
+             * schedule, its own monitoring events. A four-item event can therefore end up three-of-four
+             * delivered, which is the honest state to report.
+             *
+             * The split is evaluated ONCE, when the event is enqueued, so item indices — and therefore
+             * idempotency keys — stay stable across retries.
+             *
+             */
+            FileProxyFanOutConfig;
+            /**
+             * Upload-only, REQUIRED when `direction` is `upload`. JSONata expression evaluated once
+             * per fan-out item, producing the `params` object that step templates read as
+             * `{{ params.* }}`.
+             *
+             * The evaluation root is the hydrated event, so `contact.customer_pin` and
+             * `ticket._purpose` are reachable directly, unprefixed.
+             *
+             * **Everything per-item is a `$`-prefixed JSONata binding**: `$item` (the fan-out
+             * element, absent when `fan_out` is disabled), `$file_base64` and `$file`
+             * (`{filename, mime_type, size_bytes}`) for the resolved file, plus `$constants`,
+             * `$lookups`, `$ack_id`, `$germanDate(iso)` and `$now()`. Writing `item.filename`
+             * instead of `$item.filename` yields nothing — it reads a field named `item` on the
+             * event, which does not exist.
+             *
+             * Must evaluate to an object. `constants` are shallow-merged underneath the result, so
+             * the expression wins on any key collision.
+             *
+             * example:
+             * { "documentType": $lookups.documentType, "fileName": $item.filename, "fileData": $file_base64, "pin": contact.customer_pin }
+             */
+            params_mapping?: string;
+            /**
+             * Upload-only. Named translation tables resolved BEFORE `params_mapping` runs and bound
+             * as `$lookups`, so an expression reads `$lookups.documentType` rather than carrying a
+             * conditional chain. Deliberately generic: the next ERP calls the same concept
+             * `Belegart`.
+             *
+             */
+            lookups?: {
+                [name: string]: /**
+                 * A named translation from a value in the event to a value the external system expects.
+                 *
+                 */
+                FileProxyLookup;
+            };
+            /**
+             * Upload-only. Fixed values shallow-merged UNDERNEATH the `params_mapping` result — the
+             * expression wins on key collisions, constants only add. Use for the unchanging strings
+             * (tenant, sender, channel) that would otherwise be repeated in every expression.
+             *
+             * example:
+             * {
+             *   "mandant": "EPILOT_WNG",
+             *   "sender": "KSSP"
+             * }
+             */
+            constants?: {
+                [name: string]: any;
+            };
+            /**
+             * Upload-only. JSONata returning the attachment-shaped object (`entity_id`, optionally
+             * `s3ref`) whose bytes should be fetched for this delivery. The evaluation root is the
+             * event; the fan-out element is the `$item` binding, same as in `params_mapping`.
+             *
+             * Usually unnecessary: when the fan-out item is itself attachment-shaped it is used
+             * directly. Supply this only when splitting over something that is not the attachment
+             * — for example one delivery per meter reading, each carrying a file referenced from
+             * elsewhere in the event. When nothing resolves, no file is fetched and `file_base64`
+             * is undefined, which is valid for a fan-out that sends metadata only.
+             *
+             * example:
+             * event_attachments[entity_id = $item.file_id][0]
+             */
+            file_source?: string;
+            /**
+             * Upload-only. Params that MUST be present after `params_mapping` runs. Any listed name
+             * resolving to null or undefined fails the delivery terminally with
+             * `REQUIRED_PARAM_MISSING` before a single step executes.
+             *
+             * This is the generic net behind a lookup's `on_miss: fail`: it catches a required field
+             * going missing for any reason, so the external system never receives a body that is
+             * silently short a field its API requires.
+             *
+             * example:
+             * [
+             *   "documentType",
+             *   "fileName",
+             *   "fileData"
+             * ]
+             */
+            required_params?: string[];
             /**
              * Optional secure proxy attachment for routing all outbound file proxy requests.
              * Only `use_case_slug` is supported and the referenced secure_proxy use case
@@ -2486,22 +2891,37 @@ declare namespace Components {
             };
             auth?: FileProxyAuth;
             /**
-             * Additional use-case-specific parameters expected in the download URL query string (beyond the required orgId, integrationId, and useCaseSlug or useCaseId)
+             * Download-only. Additional use-case-specific parameters expected in the download URL
+             * query string (beyond the required orgId, integrationId, and useCaseSlug or useCaseId).
+             * Rejected when `direction` is `upload`.
+             *
              */
             params?: FileProxyParam[];
             /**
-             * Additional origins permitted to call /download for this use case (CORS, exact match). Portal origins are always allowed.
+             * Download-only. Additional origins permitted to call /download for this use case
+             * (CORS, exact match). Portal origins are always allowed. Rejected when `direction`
+             * is `upload`.
+             *
              */
             allowed_origins?: string /* uri ^https?:// */[];
             /**
-             * Ordered list of HTTP steps to execute to retrieve the file
+             * Ordered list of HTTP steps to execute. For `download` these retrieve the file; for
+             * `upload` they deliver it, each assembling its own request body from `{{ params.* }}`
+             * built by `params_mapping`.
+             *
              */
             steps: [
                 FileProxyStep,
                 ...FileProxyStep[]
             ];
-            response: FileProxyResponseConfig;
+            response?: /**
+             * How to extract the file from the step results. REQUIRED when `direction` is `download`;
+             * rejected when `direction` is `upload` (an upload has no file to extract).
+             *
+             */
+            FileProxyResponseConfig;
             /**
+             * Download-only; rejected when `direction` is `upload`.
              * 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
@@ -2562,11 +2982,25 @@ declare namespace Components {
              */
             type: "file_proxy";
             configuration?: /**
-             * Configuration for file_proxy use cases. Defines how to authenticate and fetch files from external document systems.
+             * Configuration for file_proxy use cases. Defines how to authenticate and move files
+             * between epilot and an external document system, in either direction (see `direction`).
              *
-             * The file proxy download URL always requires `orgId`, `integrationId`, and either `useCaseSlug` (recommended) or `useCaseId` (legacy UUID) as query parameters.
-             * The `orgId` is included in the signed URL to establish organization context without requiring authentication.
-             * Additional use-case-specific parameters are declared in the `params` array.
+             * **Download** (`direction: download`, the default) fetches a file from the external system
+             * and serves it to a browser. The download URL always requires `orgId`, `integrationId`, and
+             * either `useCaseSlug` (recommended) or `useCaseId` (legacy UUID) as query parameters.
+             * The `orgId` is included in the signed URL to establish organization context without
+             * requiring authentication. Additional use-case-specific parameters are declared in the
+             * `params` array. `response` is REQUIRED for download use cases.
+             *
+             * **Upload** (`direction: upload`) pushes epilot files to the external system. It is not
+             * reachable over the download endpoint; an outbound use case points at it via a `file_proxy`
+             * delivery, and this configuration owns everything about what gets sent: `fan_out` decides
+             * how many deliveries one event produces, `params_mapping` builds the values, and the
+             * `steps` place those values into requests via `{{ params.* }}`.
+             * `upload` and `params_mapping` are REQUIRED and `response` MUST be omitted.
+             *
+             * OpenAPI 3.0 cannot express this conditional requiredness, so it is enforced by the
+             * server-side validator, which returns an explicit message naming the offending field.
              *
              */
             FileProxyUseCaseConfiguration;
@@ -4731,6 +5165,49 @@ declare namespace Components {
              */
             expires_at?: string; // date-time
         }
+        /**
+         * Resolution state of one file_proxy mapping's referenced upload use case.
+         *
+         * Because the transport lives on a separate use case, edits to the endpoint or credentials
+         * do not appear in THIS use case's history. `target_updated_at` is the hook that lets an
+         * operator notice a target changed underneath a delivery that started failing.
+         *
+         */
+        export interface OutboundFileProxyTargetStatus {
+            /**
+             * The mapping holding this file_proxy delivery
+             */
+            mapping_id: string;
+            /**
+             * Slug of the referenced file_proxy use case
+             */
+            use_case_slug: string;
+            /**
+             * Whether the slug currently resolves to an enabled `file_proxy` use case with
+             * `direction: upload` in this integration. References are resolved at delivery time,
+             * so `false` is a live warning rather than a save-time error.
+             *
+             */
+            resolved: boolean;
+            /**
+             * Id of the referenced use case — absent when unresolved
+             */
+            target_use_case_id?: string; // uuid
+            /**
+             * Whether the referenced use case is enabled — absent when unresolved
+             */
+            target_enabled?: boolean;
+            /**
+             * When the referenced use case was last modified — absent when unresolved. Surfaced
+             * because a change here is invisible in this use case's own history diff.
+             *
+             */
+            target_updated_at?: string; // date-time
+            /**
+             * Why the reference did not resolve — absent when `resolved` is true
+             */
+            unresolved_reason?: "not_found" | "wrong_type" | "wrong_direction" | "disabled";
+        }
         /**
          * Configuration for outbound use cases. Defines the event that triggers the flow and the webhook mappings.
          */
@@ -4741,16 +5218,49 @@ declare namespace Components {
              * contract.created
              */
             event_catalog_event: string;
+            /**
+             * JSONata boolean predicate over the hydrated event payload. The use case handles the
+             * event only when this evaluates truthy; when absent it handles every event of its name,
+             * which is the behaviour of every pre-existing configuration.
+             *
+             * This is where event scoping belongs — narrowing to certain ticket purposes, contract
+             * types or channels. Evaluation input is the full hydrated event, so relation nodes such
+             * as `ticket` and `contact` are populated. An expression that throws is treated as no
+             * match and logged, so one malformed filter cannot block the other use cases subscribed
+             * to the same event.
+             *
+             * example:
+             * $count(ticket._purpose[$ in ['bae4b4d1-d728-49ef-92ff-54486dd301b4']]) > 0
+             */
+            event_filter?: string;
             /**
              * List of mappings that transform and deliver the event
              */
             mappings: [
-                /* A mapping that delivers an event to an external system — either pushed to a webhook (with a JSONata payload transformation) or made available on the pull-based poll queue (raw event payload, no transformation) */ OutboundMapping,
-                .../* A mapping that delivers an event to an external system — either pushed to a webhook (with a JSONata payload transformation) or made available on the pull-based poll queue (raw event payload, no transformation) */ OutboundMapping[]
+                /* A mapping that delivers an event to an external system by one of three mechanisms — pushed to a webhook (with a JSONata payload transformation), made available on the pull-based poll queue (raw event payload, no transformation), or handed to a file_proxy use case that uploads files to an external document system (a pointer only; the referenced use case owns the payload and the fan-out) */ OutboundMapping,
+                .../* A mapping that delivers an event to an external system by one of three mechanisms — pushed to a webhook (with a JSONata payload transformation), made available on the pull-based poll queue (raw event payload, no transformation), or handed to a file_proxy use case that uploads files to an external document system (a pointer only; the referenced use case owns the payload and the fan-out) */ OutboundMapping[]
             ];
+            /**
+             * Whether this use case participates in the acknowledgement protocol.
+             *
+             * `on` (the default, and the behaviour of every pre-existing use case) records an
+             * ACK_PENDING on each event and expects the consumer to confirm receipt via
+             * `POST /v1/erp/tracking/acknowledgement`; unconfirmed events raise ACK_TIMEOUT after
+             * the timeout window.
+             *
+             * `off` opts the use case out entirely: no tracking row, no ACK_PENDING, no
+             * ACK_TIMEOUT. Set it for consumers that never acknowledge — otherwise every event
+             * produces a guaranteed timeout warning — and for deliveries that already keep their
+             * own durable per-item record, such as `file_proxy`.
+             *
+             * The tracking row is per-event, not per-use-case, so it is suppressed only when EVERY
+             * enabled use case matching the event has opted out.
+             *
+             */
+            ack_tracking?: "on" | "off";
         }
         /**
-         * A mapping that delivers an event to an external system — either pushed to a webhook (with a JSONata payload transformation) or made available on the pull-based poll queue (raw event payload, no transformation)
+         * A mapping that delivers an event to an external system by one of three mechanisms — pushed to a webhook (with a JSONata payload transformation), made available on the pull-based poll queue (raw event payload, no transformation), or handed to a file_proxy use case that uploads files to an external document system (a pointer only; the referenced use case owns the payload and the fan-out)
          */
         export interface OutboundMapping {
             /**
@@ -4764,7 +5274,7 @@ declare namespace Components {
              */
             name: string;
             /**
-             * JSONata expression to transform the event payload. Required for webhook delivery; ignored for poll delivery.
+             * JSONata expression to transform the event payload. Required for webhook delivery, ignored for poll delivery, and rejected for file_proxy delivery — a file_proxy payload is built by the referenced use case's `params_mapping`, so accepting an expression here would silently do nothing.
              * example:
              * { "id": entity._id, "customer": entity.customer_name }
              */
@@ -4773,7 +5283,7 @@ declare namespace Components {
              * Whether this mapping is active
              */
             enabled: boolean;
-            delivery: /* Configuration for how the event should be delivered. webhook = push delivery via svc-webhooks (JSONata-transformed payload); poll = pull-based queue delivery where the consumer fetches items via the poll API (raw event payload) */ DeliveryConfig;
+            delivery: /* Configuration for how the event should be delivered. webhook = push delivery via svc-webhooks (JSONata-transformed payload); poll = pull-based queue delivery where the consumer fetches items via the poll API (raw event payload); file_proxy = one push per event attachment to an external document system, through a file_proxy use case (JSONata-transformed payload carrying the file bytes) */ DeliveryConfig;
             /**
              * Timestamp when the mapping was created
              */
@@ -5059,6 +5569,20 @@ declare namespace Components {
              *
              */
             OutboundPollStatus;
+            /**
+             * One entry per file_proxy mapping on this use case. Present only on use cases with a
+             * file_proxy delivery mapping.
+             *
+             */
+            file_proxy?: /**
+             * Resolution state of one file_proxy mapping's referenced upload use case.
+             *
+             * Because the transport lives on a separate use case, edits to the endpoint or credentials
+             * do not appear in THIS use case's history. `target_updated_at` is the hook that lets an
+             * operator notice a target changed underneath a delivery that started failing.
+             *
+             */
+            OutboundFileProxyTargetStatus[];
         }
         /**
          * Pull-based queue delivery. Items carry the raw standardized event-catalog payload; no JSONata mapping is applied in poll mode. Consumers fetch and acknowledge items via the poll API.
@@ -6172,6 +6696,9 @@ declare namespace Components {
              */
             overwrite?: boolean;
         }
+        export interface SuggestErpImportUseCasesResponse {
+            suggestions: ErpImportUseCaseSuggestion[];
+        }
         export interface TestNotificationRequest {
             /**
              * The kind of notification to render and send.
@@ -6443,11 +6970,25 @@ declare namespace Components {
              */
             type?: "file_proxy";
             configuration?: /**
-             * Configuration for file_proxy use cases. Defines how to authenticate and fetch files from external document systems.
+             * Configuration for file_proxy use cases. Defines how to authenticate and move files
+             * between epilot and an external document system, in either direction (see `direction`).
              *
-             * The file proxy download URL always requires `orgId`, `integrationId`, and either `useCaseSlug` (recommended) or `useCaseId` (legacy UUID) as query parameters.
-             * The `orgId` is included in the signed URL to establish organization context without requiring authentication.
-             * Additional use-case-specific parameters are declared in the `params` array.
+             * **Download** (`direction: download`, the default) fetches a file from the external system
+             * and serves it to a browser. The download URL always requires `orgId`, `integrationId`, and
+             * either `useCaseSlug` (recommended) or `useCaseId` (legacy UUID) as query parameters.
+             * The `orgId` is included in the signed URL to establish organization context without
+             * requiring authentication. Additional use-case-specific parameters are declared in the
+             * `params` array. `response` is REQUIRED for download use cases.
+             *
+             * **Upload** (`direction: upload`) pushes epilot files to the external system. It is not
+             * reachable over the download endpoint; an outbound use case points at it via a `file_proxy`
+             * delivery, and this configuration owns everything about what gets sent: `fan_out` decides
+             * how many deliveries one event produces, `params_mapping` builds the values, and the
+             * `steps` place those values into requests via `{{ params.* }}`.
+             * `upload` and `params_mapping` are REQUIRED and `response` MUST be omitted.
+             *
+             * OpenAPI 3.0 cannot express this conditional requiredness, so it is enforced by the
+             * server-side validator, which returns an explicit message naming the offending field.
              *
              */
             FileProxyUseCaseConfiguration;
@@ -6724,6 +7265,13 @@ declare namespace Components {
             response_shape: /* Describes the inferred type shape of a JSONata expression */ TypeDescriptor;
             existing_annotations?: /* Developer-provided type annotations for a use case's request and response fields */ TypeAnnotations;
         }
+        export interface ValidateErpImportRequest {
+            integration_id: string;
+            /**
+             * An inbound use case's slug, unique within its integration.
+             */
+            use_case_slug: string;
+        }
         /**
          * Push delivery of the transformed event to a webhook via svc-webhooks
          */
@@ -6832,7 +7380,7 @@ declare namespace Paths {
         }
     }
     namespace CreateErpImport {
-        export type RequestBody = Components.Schemas.CreateErpImportRequest;
+        export type RequestBody = /* Register an already-uploaded file as an import. The use case is chosen later, via `:validate` — upload and interpretation are separate decisions. */ Components.Schemas.CreateErpImportRequest;
         namespace Responses {
             export type $202 = Components.Schemas.CreateErpImportResponse;
             export type $400 = Components.Responses.BadRequest;
@@ -7660,6 +8208,21 @@ declare namespace Paths {
             export type $500 = Components.Responses.InternalServerError;
         }
     }
+    namespace SuggestErpImportUseCases {
+        namespace Parameters {
+            export type ImportId = string;
+        }
+        export interface PathParameters {
+            importId: Parameters.ImportId;
+        }
+        namespace Responses {
+            export type $200 = Components.Schemas.SuggestErpImportUseCasesResponse;
+            export type $400 = Components.Responses.BadRequest;
+            export type $403 = Components.Responses.Forbidden;
+            export type $404 = Components.Responses.NotFound;
+            export type $500 = Components.Responses.InternalServerError;
+        }
+    }
     namespace TestSendNotification {
         namespace Parameters {
             export type IntegrationId = string; // uuid
@@ -7800,6 +8363,23 @@ declare namespace Paths {
             export type $500 = Components.Responses.InternalServerError;
         }
     }
+    namespace ValidateErpImport {
+        namespace Parameters {
+            export type ImportId = string;
+        }
+        export interface PathParameters {
+            importId: Parameters.ImportId;
+        }
+        export type RequestBody = Components.Schemas.ValidateErpImportRequest;
+        namespace Responses {
+            export type $202 = Components.Schemas.ErpImportJob;
+            export type $403 = Components.Responses.Forbidden;
+            export type $404 = Components.Responses.NotFound;
+            export type $409 = Components.Responses.Conflict;
+            export type $422 = Components.Schemas.ErrorResponseBase;
+            export type $500 = Components.Responses.InternalServerError;
+        }
+    }
 }
 
 
@@ -8549,7 +9129,7 @@ interface OperationMethods {
   /**
    * createErpImport - createErpImport
    * 
-   * Create a pricing-file import job from an already-uploaded file (S3 ref). Returns a job id and starts the validate phase asynchronously — poll GET /v2/erp/imports/{importId}.
+   * Register an already-uploaded file (S3 ref) as a pricing-file import job and return its id. Nothing runs yet: no use case is chosen and no validation starts here. Rank the candidates with POST /v2/erp/imports/{importId}:suggest-use-cases, then start the validate phase with POST /v2/erp/imports/{importId}:validate.
    */
   'createErpImport'(
     parameters?: Parameters<UnknownParamsObject> | null,
@@ -8566,6 +9146,29 @@ interface OperationMethods {
     data?: any,
     config?: AxiosRequestConfig  
   ): OperationResponse<Paths.GetErpImport.Responses.$200>
+  /**
+   * validateErpImport - validateErpImport
+   * 
+   * Choose the use case to read this file with, and start the validate phase.
+   * Callable from PENDING, READY and FAILED — so a wrong choice is corrected by calling this again with a different use case, rather than re-uploading. Each call replaces any previous verdict. Any other status returns 409.
+   */
+  'validateErpImport'(
+    parameters?: Parameters<Paths.ValidateErpImport.PathParameters> | null,
+    data?: Paths.ValidateErpImport.RequestBody,
+    config?: AxiosRequestConfig  
+  ): OperationResponse<Paths.ValidateErpImport.Responses.$202>
+  /**
+   * suggestErpImportUseCases - suggestErpImportUseCases
+   * 
+   * Rank the org's inbound use cases against this file's columns — the input to the ranked picker ("matches 6 of your 7 columns"). Reads only the file's first row, not its data.
+   * Every eligible use case is returned, including ones matching nothing: the "nothing fits, pick anyway" view needs the full list. Highest match first.
+   * CSV only — an xlsx import fails with 400 rather than silently returning zero matches, which would look identical to "we checked and nothing matches".
+   */
+  'suggestErpImportUseCases'(
+    parameters?: Parameters<Paths.SuggestErpImportUseCases.PathParameters> | null,
+    data?: any,
+    config?: AxiosRequestConfig  
+  ): OperationResponse<Paths.SuggestErpImportUseCases.Responses.$200>
   /**
    * executeErpImport - executeErpImport
    * 
@@ -9412,7 +10015,7 @@ interface PathsDictionary {
     /**
      * createErpImport - createErpImport
      * 
-     * Create a pricing-file import job from an already-uploaded file (S3 ref). Returns a job id and starts the validate phase asynchronously — poll GET /v2/erp/imports/{importId}.
+     * Register an already-uploaded file (S3 ref) as a pricing-file import job and return its id. Nothing runs yet: no use case is chosen and no validation starts here. Rank the candidates with POST /v2/erp/imports/{importId}:suggest-use-cases, then start the validate phase with POST /v2/erp/imports/{importId}:validate.
      */
     'post'(
       parameters?: Parameters<UnknownParamsObject> | null,
@@ -9447,6 +10050,33 @@ interface PathsDictionary {
       config?: AxiosRequestConfig  
     ): OperationResponse<Paths.GetErpImport.Responses.$200>
   }
+  ['/v2/erp/imports/{importId}:validate']: {
+    /**
+     * validateErpImport - validateErpImport
+     * 
+     * Choose the use case to read this file with, and start the validate phase.
+     * Callable from PENDING, READY and FAILED — so a wrong choice is corrected by calling this again with a different use case, rather than re-uploading. Each call replaces any previous verdict. Any other status returns 409.
+     */
+    'post'(
+      parameters?: Parameters<Paths.ValidateErpImport.PathParameters> | null,
+      data?: Paths.ValidateErpImport.RequestBody,
+      config?: AxiosRequestConfig  
+    ): OperationResponse<Paths.ValidateErpImport.Responses.$202>
+  }
+  ['/v2/erp/imports/{importId}:suggest-use-cases']: {
+    /**
+     * suggestErpImportUseCases - suggestErpImportUseCases
+     * 
+     * Rank the org's inbound use cases against this file's columns — the input to the ranked picker ("matches 6 of your 7 columns"). Reads only the file's first row, not its data.
+     * Every eligible use case is returned, including ones matching nothing: the "nothing fits, pick anyway" view needs the full list. Highest match first.
+     * CSV only — an xlsx import fails with 400 rather than silently returning zero matches, which would look identical to "we checked and nothing matches".
+     */
+    'post'(
+      parameters?: Parameters<Paths.SuggestErpImportUseCases.PathParameters> | null,
+      data?: any,
+      config?: AxiosRequestConfig  
+    ): OperationResponse<Paths.SuggestErpImportUseCases.Responses.$200>
+  }
   ['/v2/erp/imports/{importId}:execute']: {
     /**
      * executeErpImport - executeErpImport
@@ -9512,10 +10142,12 @@ type EnvironmentFieldConfig = Components.Schemas.EnvironmentFieldConfig;
 type ErpEvent = Components.Schemas.ErpEvent;
 type ErpEventV3 = Components.Schemas.ErpEventV3;
 type ErpImportError = Components.Schemas.ErpImportError;
+type ErpImportFilePreview = Components.Schemas.ErpImportFilePreview;
 type ErpImportIssue = Components.Schemas.ErpImportIssue;
 type ErpImportJob = Components.Schemas.ErpImportJob;
 type ErpImportList = Components.Schemas.ErpImportList;
 type ErpImportProgress = Components.Schemas.ErpImportProgress;
+type ErpImportUseCaseSuggestion = Components.Schemas.ErpImportUseCaseSuggestion;
 type ErpImportValidation = Components.Schemas.ErpImportValidation;
 type ErpUpdatesEventsV2Request = Components.Schemas.ErpUpdatesEventsV2Request;
 type ErpUpdatesEventsV3Request = Components.Schemas.ErpUpdatesEventsV3Request;
@@ -9523,10 +10155,14 @@ type ErrorResponseBase = Components.Schemas.ErrorResponseBase;
 type ExecuteErpImportRequest = Components.Schemas.ExecuteErpImportRequest;
 type ExternalMonitoringSpan = Components.Schemas.ExternalMonitoringSpan;
 type FileProxyAuth = Components.Schemas.FileProxyAuth;
+type FileProxyDeliveryConfig = Components.Schemas.FileProxyDeliveryConfig;
+type FileProxyFanOutConfig = Components.Schemas.FileProxyFanOutConfig;
+type FileProxyLookup = Components.Schemas.FileProxyLookup;
 type FileProxyParam = Components.Schemas.FileProxyParam;
 type FileProxyResponseConfig = Components.Schemas.FileProxyResponseConfig;
 type FileProxySecureProxyAttachment = Components.Schemas.FileProxySecureProxyAttachment;
 type FileProxyStep = Components.Schemas.FileProxyStep;
+type FileProxyUploadConfig = Components.Schemas.FileProxyUploadConfig;
 type FileProxyUrlConfig = Components.Schemas.FileProxyUrlConfig;
 type FileProxyUrlParam = Components.Schemas.FileProxyUrlParam;
 type FileProxyUrlParams = Components.Schemas.FileProxyUrlParams;
@@ -9590,6 +10226,7 @@ type NotificationStatusResponse = Components.Schemas.NotificationStatusResponse;
 type OutboundConflict = Components.Schemas.OutboundConflict;
 type OutboundDlqListResponse = Components.Schemas.OutboundDlqListResponse;
 type OutboundDlqMessage = Components.Schemas.OutboundDlqMessage;
+type OutboundFileProxyTargetStatus = Components.Schemas.OutboundFileProxyTargetStatus;
 type OutboundIntegrationEventConfiguration = Components.Schemas.OutboundIntegrationEventConfiguration;
 type OutboundMapping = Components.Schemas.OutboundMapping;
 type OutboundMessage = Components.Schemas.OutboundMessage;
@@ -9635,6 +10272,7 @@ type SecureProxyUseCaseHistoryEntry = Components.Schemas.SecureProxyUseCaseHisto
 type SecureProxyWhitelist = Components.Schemas.SecureProxyWhitelist;
 type SecureProxyWhitelistUpdate = Components.Schemas.SecureProxyWhitelistUpdate;
 type SetIntegrationAppMappingRequest = Components.Schemas.SetIntegrationAppMappingRequest;
+type SuggestErpImportUseCasesResponse = Components.Schemas.SuggestErpImportUseCasesResponse;
 type TestNotificationRequest = Components.Schemas.TestNotificationRequest;
 type TestNotificationResponse = Components.Schemas.TestNotificationResponse;
 type TimeSeriesBreakdownItemV2 = Components.Schemas.TimeSeriesBreakdownItemV2;
@@ -9660,7 +10298,8 @@ type UseCaseBase = Components.Schemas.UseCaseBase;
 type UseCaseHistoryEntry = Components.Schemas.UseCaseHistoryEntry;
 type UseCaseHistoryEntryBase = Components.Schemas.UseCaseHistoryEntryBase;
 type UseCaseTypePreview = Components.Schemas.UseCaseTypePreview;
+type ValidateErpImportRequest = Components.Schemas.ValidateErpImportRequest;
 type WebhookDeliveryConfig = Components.Schemas.WebhookDeliveryConfig;
 type WebhookStatus = Components.Schemas.WebhookStatus;
 
-export { type FileProxyStep as $, type AccessLogEntry as A, type EntityPruneScopeUpdate as B, type Client as C, type DeleteIntegrationAppMappingRequest as D, type EmbeddedFileProxyUseCaseRequest as E, type EntityUpdate as F, type EnvVarRefConfig as G, type EnvironmentFieldConfig as H, type ErpEvent as I, type ErpEventV3 as J, type ErpImportError as K, type ErpImportIssue as L, type ErpImportJob as M, type ErpImportList as N, type OperationMethods as O, Paths as P, type ErpImportProgress as Q, type ErpImportValidation as R, type ErpUpdatesEventsV2Request as S, type ErpUpdatesEventsV3Request as T, type ErrorResponseBase as U, type ExecuteErpImportRequest as V, type ExternalMonitoringSpan as W, type FileProxyAuth as X, type FileProxyParam as Y, type FileProxyResponseConfig as Z, type FileProxySecureProxyAttachment as _, Components as a, type OutboundIntegrationEventConfiguration as a$, type FileProxyUrlConfig as a0, type FileProxyUrlParam as a1, type FileProxyUrlParams as a2, type FileProxyUseCase as a3, type FileProxyUseCaseConfiguration as a4, type FileProxyUseCaseHistoryEntry as a5, type GenerateTypesPreviewResponse as a6, type GenerateTypesRequest as a7, type GenerateTypesResponse as a8, type GetMonitoringStatsRequest as a9, type ManagedCallOperation as aA, type ManagedCallOperationConfig as aB, type ManagedCallUseCase as aC, type ManagedCallUseCaseHistoryEntry as aD, type MappingSimulationRequest as aE, type MappingSimulationResponse as aF, type MappingSimulationV2Request as aG, type MappingSimulationWarning as aH, type MeterReadingPruneScopeConfig as aI, type MeterReadingPruneScopeUpdate as aJ, type MeterReadingUpdate as aK, type MeterUniqueIdsConfig as aL, type MonitoringEventV2 as aM, type MonitoringStats as aN, type MonitoringStatsV2 as aO, type MonitoringTraceResponse as aP, type NotificationChannelSet as aQ, type NotificationDigestConfig as aR, type NotificationHistoryItem as aS, type NotificationHistoryResponse as aT, type NotificationRecipient as aU, type NotificationRule as aV, type NotificationRuleStatus as aW, type NotificationStatusResponse as aX, type OutboundConflict as aY, type OutboundDlqListResponse as aZ, type OutboundDlqMessage as a_, type GetMonitoringStatsV2Request as aa, type GetMonitoringTimeSeriesRequest as ab, type GetMonitoringTimeSeriesV2Request as ac, type InboundIntegrationEventConfiguration as ad, type InboundMonitoringEvent as ae, type InboundUseCase as af, type InboundUseCaseHistoryEntry as ag, type IngestExternalMonitoringEventsRequest as ah, type IngestExternalMonitoringEventsResponse as ai, type Integration as aj, type IntegrationAppMapping as ak, type IntegrationConfigurationV1 as al, type IntegrationConfigurationV2 as am, type IntegrationEditableFields as an, type IntegrationEntity as ao, type IntegrationEntityField as ap, type IntegrationFieldV1 as aq, type IntegrationMeterReading as ar, type IntegrationNotificationConfig as as, type IntegrationObjectV1 as at, type IntegrationSettings as au, type IntegrationWithUseCases as av, type ManagedCallAuth as aw, type ManagedCallErrorResponse as ax, type ManagedCallExecuteRequest as ay, type ManagedCallExecuteResponse as az, type PathsDictionary as b, type UpsertIntegrationWithUseCasesRequest as b$, type OutboundMapping as b0, type OutboundMessage as b1, type OutboundMonitoringEvent as b2, type OutboundPollStatus as b3, type OutboundStatusResponse as b4, type OutboundUseCase as b5, type OutboundUseCaseHistoryEntry as b6, type OutboundUseCaseStatus as b7, type PollDeliveryConfig as b8, type PollOutboundMessagesRequest as b9, type SecureProxySummary as bA, type SecureProxyUpstreamError as bB, type SecureProxyUseCase as bC, type SecureProxyUseCaseConfiguration as bD, type SecureProxyUseCaseHistoryEntry as bE, type SecureProxyWhitelist as bF, type SecureProxyWhitelistUpdate as bG, type SetIntegrationAppMappingRequest as bH, type TestNotificationRequest as bI, type TestNotificationResponse as bJ, type TimeSeriesBreakdownItemV2 as bK, type TimeSeriesBucket as bL, type TimeSeriesBucketV2 as bM, type TriggerErpActionRequest as bN, type TriggerWebhookResp as bO, type TypeAnnotations as bP, type TypeDescriptor as bQ, type UnblockOutboundStreamRequest as bR, type UnblockOutboundStreamResponse as bS, type UpdateFileProxyUseCaseRequest as bT, type UpdateInboundUseCaseRequest as bU, type UpdateIntegrationRequest as bV, type UpdateManagedCallUseCaseRequest as bW, type UpdateOutboundUseCaseRequest as bX, type UpdateSecureProxyUseCaseRequest as bY, type UpdateUseCaseRequest as bZ, type UpdateUseCaseRequestBase as b_, type PollOutboundMessagesResponse as ba, type PortalOrigin as bb, type PortalRefConfig as bc, type PortalRefFilter as bd, type PruneScopeConfig as be, type QueryAccessLogsRequest as bf, type QueryEventsRequest as bg, type QueryInboundMonitoringEventsRequest as bh, type QueryMonitoringEventsV2Request as bi, type QueryOutboundMonitoringEventsRequest as bj, type RedriveOutboundDlqRequest as bk, type RedriveOutboundDlqResponse as bl, type RedriveOutboundDlqResult as bm, type RelationConfig as bn, type RelationItemConfig as bo, type RelationRefItemConfig as bp, type RelationRefValueConfig as bq, type RelationRefsConfig as br, type RelationUniqueIdField as bs, type RepeatableFieldType as bt, type ReplayEventsRequest as bu, type RuleBaselineBucket as bv, type RuleBaselineStatus as bw, type S3Reference as bx, type SecureProxyRequest as by, type SecureProxyResponse as bz, type AckOutboundMessagesRequest as c, type UseCase as c0, type UseCaseBase as c1, type UseCaseHistoryEntry as c2, type UseCaseHistoryEntryBase as c3, type UseCaseTypePreview as c4, type WebhookDeliveryConfig as c5, type WebhookStatus as c6, 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 CreateErpImportRequest as j, type CreateErpImportResponse as k, type CreateFileProxyUseCaseRequest as l, type CreateInboundUseCaseRequest as m, type CreateIntegrationRequest as n, type CreateManagedCallUseCaseRequest as o, type CreateOutboundUseCaseRequest as p, type CreateSecureProxyUseCaseRequest as q, type CreateUseCaseRequest as r, type CreateUseCaseRequestBase as s, type DeliveryConfig as t, type EmbeddedInboundUseCaseRequest as u, type EmbeddedManagedCallUseCaseRequest as v, type EmbeddedOutboundUseCaseRequest as w, type EmbeddedSecureProxyUseCaseRequest as x, type EmbeddedUseCaseRequest as y, type EmbeddedUseCaseRequestBase as z };
+export { type FileProxyFanOutConfig as $, type AccessLogEntry as A, type EntityPruneScopeUpdate as B, type Client as C, type DeleteIntegrationAppMappingRequest as D, type EmbeddedFileProxyUseCaseRequest as E, type EntityUpdate as F, type EnvVarRefConfig as G, type EnvironmentFieldConfig as H, type ErpEvent as I, type ErpEventV3 as J, type ErpImportError as K, type ErpImportFilePreview as L, type ErpImportIssue as M, type ErpImportJob as N, type OperationMethods as O, Paths as P, type ErpImportList as Q, type ErpImportProgress as R, type ErpImportUseCaseSuggestion as S, type ErpImportValidation as T, type ErpUpdatesEventsV2Request as U, type ErpUpdatesEventsV3Request as V, type ErrorResponseBase as W, type ExecuteErpImportRequest as X, type ExternalMonitoringSpan as Y, type FileProxyAuth as Z, type FileProxyDeliveryConfig as _, Components as a, type NotificationRule as a$, type FileProxyLookup as a0, type FileProxyParam as a1, type FileProxyResponseConfig as a2, type FileProxySecureProxyAttachment as a3, type FileProxyStep as a4, type FileProxyUploadConfig as a5, type FileProxyUrlConfig as a6, type FileProxyUrlParam as a7, type FileProxyUrlParams as a8, type FileProxyUseCase as a9, type IntegrationSettings as aA, type IntegrationWithUseCases as aB, type ManagedCallAuth as aC, type ManagedCallErrorResponse as aD, type ManagedCallExecuteRequest as aE, type ManagedCallExecuteResponse as aF, type ManagedCallOperation as aG, type ManagedCallOperationConfig as aH, type ManagedCallUseCase as aI, type ManagedCallUseCaseHistoryEntry as aJ, type MappingSimulationRequest as aK, type MappingSimulationResponse as aL, type MappingSimulationV2Request as aM, type MappingSimulationWarning as aN, type MeterReadingPruneScopeConfig as aO, type MeterReadingPruneScopeUpdate as aP, type MeterReadingUpdate as aQ, type MeterUniqueIdsConfig as aR, type MonitoringEventV2 as aS, type MonitoringStats as aT, type MonitoringStatsV2 as aU, type MonitoringTraceResponse as aV, type NotificationChannelSet as aW, type NotificationDigestConfig as aX, type NotificationHistoryItem as aY, type NotificationHistoryResponse as aZ, type NotificationRecipient as a_, type FileProxyUseCaseConfiguration as aa, type FileProxyUseCaseHistoryEntry as ab, type GenerateTypesPreviewResponse as ac, type GenerateTypesRequest as ad, type GenerateTypesResponse as ae, type GetMonitoringStatsRequest as af, type GetMonitoringStatsV2Request as ag, type GetMonitoringTimeSeriesRequest as ah, type GetMonitoringTimeSeriesV2Request as ai, type InboundIntegrationEventConfiguration as aj, type InboundMonitoringEvent as ak, type InboundUseCase as al, type InboundUseCaseHistoryEntry as am, type IngestExternalMonitoringEventsRequest as an, type IngestExternalMonitoringEventsResponse as ao, type Integration as ap, type IntegrationAppMapping as aq, type IntegrationConfigurationV1 as ar, type IntegrationConfigurationV2 as as, type IntegrationEditableFields as at, type IntegrationEntity as au, type IntegrationEntityField as av, type IntegrationFieldV1 as aw, type IntegrationMeterReading as ax, type IntegrationNotificationConfig as ay, type IntegrationObjectV1 as az, type PathsDictionary as b, type UpdateFileProxyUseCaseRequest as b$, type NotificationRuleStatus as b0, type NotificationStatusResponse as b1, type OutboundConflict as b2, type OutboundDlqListResponse as b3, type OutboundDlqMessage as b4, type OutboundFileProxyTargetStatus as b5, type OutboundIntegrationEventConfiguration as b6, type OutboundMapping as b7, type OutboundMessage as b8, type OutboundMonitoringEvent as b9, type RepeatableFieldType as bA, type ReplayEventsRequest as bB, type RuleBaselineBucket as bC, type RuleBaselineStatus as bD, type S3Reference as bE, type SecureProxyRequest as bF, type SecureProxyResponse as bG, type SecureProxySummary as bH, type SecureProxyUpstreamError as bI, type SecureProxyUseCase as bJ, type SecureProxyUseCaseConfiguration as bK, type SecureProxyUseCaseHistoryEntry as bL, type SecureProxyWhitelist as bM, type SecureProxyWhitelistUpdate as bN, type SetIntegrationAppMappingRequest as bO, type SuggestErpImportUseCasesResponse as bP, type TestNotificationRequest as bQ, type TestNotificationResponse as bR, type TimeSeriesBreakdownItemV2 as bS, type TimeSeriesBucket as bT, type TimeSeriesBucketV2 as bU, type TriggerErpActionRequest as bV, type TriggerWebhookResp as bW, type TypeAnnotations as bX, type TypeDescriptor as bY, type UnblockOutboundStreamRequest as bZ, type UnblockOutboundStreamResponse as b_, type OutboundPollStatus as ba, type OutboundStatusResponse as bb, type OutboundUseCase as bc, type OutboundUseCaseHistoryEntry as bd, type OutboundUseCaseStatus as be, type PollDeliveryConfig as bf, type PollOutboundMessagesRequest as bg, type PollOutboundMessagesResponse as bh, type PortalOrigin as bi, type PortalRefConfig as bj, type PortalRefFilter as bk, type PruneScopeConfig as bl, type QueryAccessLogsRequest as bm, type QueryEventsRequest as bn, type QueryInboundMonitoringEventsRequest as bo, type QueryMonitoringEventsV2Request as bp, type QueryOutboundMonitoringEventsRequest as bq, type RedriveOutboundDlqRequest as br, type RedriveOutboundDlqResponse as bs, type RedriveOutboundDlqResult as bt, type RelationConfig as bu, type RelationItemConfig as bv, type RelationRefItemConfig as bw, type RelationRefValueConfig as bx, type RelationRefsConfig as by, type RelationUniqueIdField as bz, type AckOutboundMessagesRequest as c, type UpdateInboundUseCaseRequest as c0, type UpdateIntegrationRequest as c1, type UpdateManagedCallUseCaseRequest as c2, type UpdateOutboundUseCaseRequest as c3, type UpdateSecureProxyUseCaseRequest as c4, type UpdateUseCaseRequest as c5, type UpdateUseCaseRequestBase as c6, type UpsertIntegrationWithUseCasesRequest as c7, type UseCase as c8, type UseCaseBase as c9, type UseCaseHistoryEntry as ca, type UseCaseHistoryEntryBase as cb, type UseCaseTypePreview as cc, type ValidateErpImportRequest as cd, type WebhookDeliveryConfig as ce, type WebhookStatus as cf, 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 CreateErpImportRequest as j, type CreateErpImportResponse as k, type CreateFileProxyUseCaseRequest as l, type CreateInboundUseCaseRequest as m, type CreateIntegrationRequest as n, type CreateManagedCallUseCaseRequest as o, type CreateOutboundUseCaseRequest as p, type CreateSecureProxyUseCaseRequest as q, type CreateUseCaseRequest as r, type CreateUseCaseRequestBase as s, type DeliveryConfig as t, type EmbeddedInboundUseCaseRequest as u, type EmbeddedManagedCallUseCaseRequest as v, type EmbeddedOutboundUseCaseRequest as w, type EmbeddedSecureProxyUseCaseRequest as x, type EmbeddedUseCaseRequest as y, type EmbeddedUseCaseRequestBase as z };