@distyra/sdk 0.3.0 → 0.4.0

package/dist/generated.d.ts

@@ -548,6 +548,56 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v1/billing/invoices/{id}/pdf": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Download an invoice or credit-note PDF
+         * @description Streams the stored PDF for one of the organization's invoices or credit notes.
+         *
+         *     **404** for an unknown id (RLS-scoped to your org). **410** if the PDF has not been generated/stored yet.
+         *
+         *     Required scope: `enrichment:read`.
+         */
+        get: operations["getBillingInvoicePdf"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/billing/payments/{paymentId}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Live Mollie state for one of the org’s payments
+         * @description Returns a reconciliation projection of the Mollie payment behind a ledger
+         *     entry or invoice: status, method, settlement, refund/chargeback totals, and
+         *     the payment's own dashboard deep-link. First-party only (service principal).
+         *
+         *     **404** if the payment id is not one of this org’s payments.
+         *
+         *     Required scope: `enrichment:read`.
+         */
+        get: operations["getBillingPayment"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v1/enrich/batch/async": {
         parameters: {
             query?: never;
@@ -730,6 +780,110 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v1/connect/aspsps": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** List banks (ASPSPs) available for a country */
+        get: operations["listAspsps"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/connect/connections": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** List your bank connections */
+        get: operations["listConnections"];
+        put?: never;
+        /** Open a bank connection (returns the authorization URL) */
+        post: operations["createConnection"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/connect/connections/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Read a bank connection */
+        get: operations["getConnection"];
+        put?: never;
+        post?: never;
+        /** Revoke a bank connection */
+        delete: operations["revokeConnection"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/connect/connections/{id}/accounts": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** List the accounts on a connection */
+        get: operations["getConnectionAccounts"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/connect/connections/{id}/transactions": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Fetch normalized transactions for a connection */
+        get: operations["getConnectionTransactions"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/connect/hosted-link": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Mint a hosted bank-connect link for an applicant */
+        post: operations["createHostedConnectLink"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v1/internal/crawl/re-enqueue": {
         parameters: {
             query?: never;
@@ -3126,6 +3280,11 @@ export interface operations {
                             /** Format: uuid */
                             id: string;
                             applicant_id: string;
+                            /**
+                             * @description The lender's own reference for Distyra Connect analyses, joined from the originating connection. For connect-originated analyses `applicant_id` is the connection id (the data-source identity used for idempotency), and this is the human reference the lender set on the connection. null for direct JSON /analyze submissions, where the lender's reference is already `applicant_id`.
+                             * @example loan_app_42
+                             */
+                            applicant_ref: string | null;
                             /** Format: date-time */
                             created_at: string;
                             /** @description false for 7-day idempotent re-pulls and for calls within the included-quota tier. */
@@ -4643,65 +4802,24 @@ export interface operations {
             };
         };
     };
-    enrichBatchAsync: {
+    getBillingInvoicePdf: {
         parameters: {
             query?: never;
             header?: never;
-            path?: never;
-            cookie?: never;
-        };
-        requestBody: {
-            content: {
-                "application/json": {
-                    items: {
-                        descriptor: string;
-                        amount?: number;
-                        currency?: string;
-                        mcc?: string;
-                        country_hint?: string;
-                        merchant_name?: string;
-                        bank_code_description?: string;
-                    }[];
-                };
+            path: {
+                id: string;
             };
+            cookie?: never;
         };
+        requestBody?: never;
         responses: {
             /** @description Default Response */
-            202: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "application/json": {
-                        /** Format: uuid */
-                        id: string;
-                        /** @enum {string} */
-                        status: "pending";
-                        item_count: number;
-                        /** Format: date-time */
-                        submitted_at: string;
-                        /** Format: date-time */
-                        expires_at: string;
-                        /** Format: uri */
-                        status_url: string;
-                    };
-                };
-            };
-            /** @description Standard error envelope used for all non-2xx responses. */
-            400: {
+            200: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": {
-                        /**
-                         * @description Stable machine-readable code. SDK consumers should switch on this.
-                         * @example invalid_key
-                         */
-                        error: string;
-                        /** @description Free-form human-readable explanation. Safe to surface. */
-                        detail?: string;
-                    };
+                    "application/pdf": unknown;
                 };
             };
             /** @description Standard error envelope used for all non-2xx responses. */
@@ -4710,7 +4828,7 @@ export interface operations {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": {
+                    "application/pdf": {
                         /**
                          * @description Stable machine-readable code. SDK consumers should switch on this.
                          * @example invalid_key
@@ -4722,12 +4840,12 @@ export interface operations {
                 };
             };
             /** @description Standard error envelope used for all non-2xx responses. */
-            402: {
+            403: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": {
+                    "application/pdf": {
                         /**
                          * @description Stable machine-readable code. SDK consumers should switch on this.
                          * @example invalid_key
@@ -4739,12 +4857,12 @@ export interface operations {
                 };
             };
             /** @description Standard error envelope used for all non-2xx responses. */
-            403: {
+            404: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": {
+                    "application/pdf": {
                         /**
                          * @description Stable machine-readable code. SDK consumers should switch on this.
                          * @example invalid_key
@@ -4756,12 +4874,12 @@ export interface operations {
                 };
             };
             /** @description Standard error envelope used for all non-2xx responses. */
-            429: {
+            410: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": {
+                    "application/pdf": {
                         /**
                          * @description Stable machine-readable code. SDK consumers should switch on this.
                          * @example invalid_key
@@ -4774,12 +4892,12 @@ export interface operations {
             };
         };
     };
-    enrichBatchAsyncStatus: {
+    getBillingPayment: {
         parameters: {
             query?: never;
             header?: never;
             path: {
-                id: string;
+                paymentId: string;
             };
             cookie?: never;
         };
@@ -4792,22 +4910,31 @@ export interface operations {
                 };
                 content: {
                     "application/json": {
-                        /** Format: uuid */
                         id: string;
-                        status: "pending" | "running" | "completed" | "failed" | "expired";
-                        item_count: number;
-                        completed_count: number;
-                        failed_count: number;
-                        /** Format: date-time */
-                        submitted_at: string;
-                        started_at: string | null;
-                        completed_at: string | null;
-                        /** Format: date-time */
-                        expires_at: string;
-                        result: {
-                            [key: string]: unknown;
-                        }[] | null;
-                        error: string | null;
+                        status: string;
+                        method: string | null;
+                        sequenceType: string | null;
+                        amount: {
+                            value: string;
+                            currency: string;
+                        };
+                        settlementAmount: {
+                            value: string;
+                            currency: string;
+                        } | null;
+                        amountRefunded: {
+                            value: string;
+                            currency: string;
+                        } | null;
+                        amountChargedBack: {
+                            value: string;
+                            currency: string;
+                        } | null;
+                        isRefunded: boolean;
+                        isChargedBack: boolean;
+                        createdAt: string | null;
+                        paidAt: string | null;
+                        dashboardUrl: string | null;
                     };
                 };
             };
@@ -4862,46 +4989,8 @@ export interface operations {
                     };
                 };
             };
-        };
-    };
-    getMerchant: {
-        parameters: {
-            query?: never;
-            header?: never;
-            path: {
-                /** @description Catalog id (positive integer, accepted as a path string). */
-                id: string;
-            };
-            cookie?: never;
-        };
-        requestBody?: never;
-        responses: {
-            /** @description Default Response */
-            200: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "application/json": {
-                        /** @description Catalog id; pass to /v1/merchants/{id} to refetch. */
-                        id: number;
-                        name: string;
-                        parent: string | null;
-                        domain: string | null;
-                        logo_url: string | null;
-                        brand_colors: {
-                            [key: string]: unknown;
-                        };
-                        industry: string | null;
-                        subindustries: string[];
-                        primary_mcc: string | null;
-                        /** @description ISO-3166 alpha-2. */
-                        country_codes: string[];
-                    };
-                };
-            };
             /** @description Standard error envelope used for all non-2xx responses. */
-            400: {
+            502: {
                 headers: {
                     [name: string]: unknown;
                 };
@@ -4918,7 +5007,7 @@ export interface operations {
                 };
             };
             /** @description Standard error envelope used for all non-2xx responses. */
-            401: {
+            503: {
                 headers: {
                     [name: string]: unknown;
                 };
@@ -4934,8 +5023,1006 @@ export interface operations {
                     };
                 };
             };
-            /** @description Standard error envelope used for all non-2xx responses. */
-            403: {
+        };
+    };
+    enrichBatchAsync: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    items: {
+                        descriptor: string;
+                        amount?: number;
+                        currency?: string;
+                        mcc?: string;
+                        country_hint?: string;
+                        merchant_name?: string;
+                        bank_code_description?: string;
+                    }[];
+                };
+            };
+        };
+        responses: {
+            /** @description Default Response */
+            202: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** Format: uuid */
+                        id: string;
+                        /** @enum {string} */
+                        status: "pending";
+                        item_count: number;
+                        /** Format: date-time */
+                        submitted_at: string;
+                        /** Format: date-time */
+                        expires_at: string;
+                        /** Format: uri */
+                        status_url: string;
+                    };
+                };
+            };
+            /** @description Standard error envelope used for all non-2xx responses. */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /**
+                         * @description Stable machine-readable code. SDK consumers should switch on this.
+                         * @example invalid_key
+                         */
+                        error: string;
+                        /** @description Free-form human-readable explanation. Safe to surface. */
+                        detail?: string;
+                    };
+                };
+            };
+            /** @description Standard error envelope used for all non-2xx responses. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /**
+                         * @description Stable machine-readable code. SDK consumers should switch on this.
+                         * @example invalid_key
+                         */
+                        error: string;
+                        /** @description Free-form human-readable explanation. Safe to surface. */
+                        detail?: string;
+                    };
+                };
+            };
+            /** @description Standard error envelope used for all non-2xx responses. */
+            402: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /**
+                         * @description Stable machine-readable code. SDK consumers should switch on this.
+                         * @example invalid_key
+                         */
+                        error: string;
+                        /** @description Free-form human-readable explanation. Safe to surface. */
+                        detail?: string;
+                    };
+                };
+            };
+            /** @description Standard error envelope used for all non-2xx responses. */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /**
+                         * @description Stable machine-readable code. SDK consumers should switch on this.
+                         * @example invalid_key
+                         */
+                        error: string;
+                        /** @description Free-form human-readable explanation. Safe to surface. */
+                        detail?: string;
+                    };
+                };
+            };
+            /** @description Standard error envelope used for all non-2xx responses. */
+            429: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /**
+                         * @description Stable machine-readable code. SDK consumers should switch on this.
+                         * @example invalid_key
+                         */
+                        error: string;
+                        /** @description Free-form human-readable explanation. Safe to surface. */
+                        detail?: string;
+                    };
+                };
+            };
+        };
+    };
+    enrichBatchAsyncStatus: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Default Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** Format: uuid */
+                        id: string;
+                        status: "pending" | "running" | "completed" | "failed" | "expired";
+                        item_count: number;
+                        completed_count: number;
+                        failed_count: number;
+                        /** Format: date-time */
+                        submitted_at: string;
+                        started_at: string | null;
+                        completed_at: string | null;
+                        /** Format: date-time */
+                        expires_at: string;
+                        result: {
+                            [key: string]: unknown;
+                        }[] | null;
+                        error: string | null;
+                    };
+                };
+            };
+            /** @description Standard error envelope used for all non-2xx responses. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /**
+                         * @description Stable machine-readable code. SDK consumers should switch on this.
+                         * @example invalid_key
+                         */
+                        error: string;
+                        /** @description Free-form human-readable explanation. Safe to surface. */
+                        detail?: string;
+                    };
+                };
+            };
+            /** @description Standard error envelope used for all non-2xx responses. */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /**
+                         * @description Stable machine-readable code. SDK consumers should switch on this.
+                         * @example invalid_key
+                         */
+                        error: string;
+                        /** @description Free-form human-readable explanation. Safe to surface. */
+                        detail?: string;
+                    };
+                };
+            };
+            /** @description Standard error envelope used for all non-2xx responses. */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /**
+                         * @description Stable machine-readable code. SDK consumers should switch on this.
+                         * @example invalid_key
+                         */
+                        error: string;
+                        /** @description Free-form human-readable explanation. Safe to surface. */
+                        detail?: string;
+                    };
+                };
+            };
+        };
+    };
+    getMerchant: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Catalog id (positive integer, accepted as a path string). */
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Default Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @description Catalog id; pass to /v1/merchants/{id} to refetch. */
+                        id: number;
+                        name: string;
+                        parent: string | null;
+                        domain: string | null;
+                        logo_url: string | null;
+                        brand_colors: {
+                            [key: string]: unknown;
+                        };
+                        industry: string | null;
+                        subindustries: string[];
+                        primary_mcc: string | null;
+                        /** @description ISO-3166 alpha-2. */
+                        country_codes: string[];
+                    };
+                };
+            };
+            /** @description Standard error envelope used for all non-2xx responses. */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /**
+                         * @description Stable machine-readable code. SDK consumers should switch on this.
+                         * @example invalid_key
+                         */
+                        error: string;
+                        /** @description Free-form human-readable explanation. Safe to surface. */
+                        detail?: string;
+                    };
+                };
+            };
+            /** @description Standard error envelope used for all non-2xx responses. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /**
+                         * @description Stable machine-readable code. SDK consumers should switch on this.
+                         * @example invalid_key
+                         */
+                        error: string;
+                        /** @description Free-form human-readable explanation. Safe to surface. */
+                        detail?: string;
+                    };
+                };
+            };
+            /** @description Standard error envelope used for all non-2xx responses. */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /**
+                         * @description Stable machine-readable code. SDK consumers should switch on this.
+                         * @example invalid_key
+                         */
+                        error: string;
+                        /** @description Free-form human-readable explanation. Safe to surface. */
+                        detail?: string;
+                    };
+                };
+            };
+            /** @description Standard error envelope used for all non-2xx responses. */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /**
+                         * @description Stable machine-readable code. SDK consumers should switch on this.
+                         * @example invalid_key
+                         */
+                        error: string;
+                        /** @description Free-form human-readable explanation. Safe to surface. */
+                        detail?: string;
+                    };
+                };
+            };
+            /** @description Standard error envelope used for all non-2xx responses. */
+            429: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /**
+                         * @description Stable machine-readable code. SDK consumers should switch on this.
+                         * @example invalid_key
+                         */
+                        error: string;
+                        /** @description Free-form human-readable explanation. Safe to surface. */
+                        detail?: string;
+                    };
+                };
+            };
+        };
+    };
+    getCategories: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Default Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        industries: {
+                            name: string;
+                            subindustries: string[];
+                        }[];
+                    };
+                };
+            };
+            /** @description Standard error envelope used for all non-2xx responses. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /**
+                         * @description Stable machine-readable code. SDK consumers should switch on this.
+                         * @example invalid_key
+                         */
+                        error: string;
+                        /** @description Free-form human-readable explanation. Safe to surface. */
+                        detail?: string;
+                    };
+                };
+            };
+            /** @description Standard error envelope used for all non-2xx responses. */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /**
+                         * @description Stable machine-readable code. SDK consumers should switch on this.
+                         * @example invalid_key
+                         */
+                        error: string;
+                        /** @description Free-form human-readable explanation. Safe to surface. */
+                        detail?: string;
+                    };
+                };
+            };
+            /** @description Standard error envelope used for all non-2xx responses. */
+            429: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /**
+                         * @description Stable machine-readable code. SDK consumers should switch on this.
+                         * @example invalid_key
+                         */
+                        error: string;
+                        /** @description Free-form human-readable explanation. Safe to surface. */
+                        detail?: string;
+                    };
+                };
+            };
+        };
+    };
+    submitCorrection: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** @description At least one of `corrected_merchant_id` or `corrected_merchant_name` must be provided. */
+        requestBody: {
+            content: {
+                "application/json": {
+                    /** @description The original transaction descriptor as passed to /v1/enrich. */
+                    descriptor: string;
+                    /** @description Catalog id of the merchant that should have been returned. Use this when the right merchant exists in the catalog (lookup via /v1/merchants/{id} or by trial enrichment). */
+                    corrected_merchant_id?: number;
+                    /** @description Free-text name of the right merchant when no catalog id is known. Triages into the manual-review queue; a catalog-mint may follow. */
+                    corrected_merchant_name?: string;
+                    /** @description Optional free-text context (e.g. "this is a French chain not the German one"). */
+                    note?: string;
+                };
+            };
+        };
+        responses: {
+            /** @description Default Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /**
+                         * Format: uuid
+                         * @description Server-generated id of the persisted feedback row.
+                         */
+                        id: string;
+                        /** @description The normalized descriptor hash this feedback is keyed on. Matches the hash /v1/enrich uses for cache + tenant_corrections lookup. */
+                        descriptor_hash: string;
+                    };
+                };
+            };
+            /** @description Standard error envelope used for all non-2xx responses. */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /**
+                         * @description Stable machine-readable code. SDK consumers should switch on this.
+                         * @example invalid_key
+                         */
+                        error: string;
+                        /** @description Free-form human-readable explanation. Safe to surface. */
+                        detail?: string;
+                    };
+                };
+            };
+            /** @description Standard error envelope used for all non-2xx responses. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /**
+                         * @description Stable machine-readable code. SDK consumers should switch on this.
+                         * @example invalid_key
+                         */
+                        error: string;
+                        /** @description Free-form human-readable explanation. Safe to surface. */
+                        detail?: string;
+                    };
+                };
+            };
+            /** @description Standard error envelope used for all non-2xx responses. */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /**
+                         * @description Stable machine-readable code. SDK consumers should switch on this.
+                         * @example invalid_key
+                         */
+                        error: string;
+                        /** @description Free-form human-readable explanation. Safe to surface. */
+                        detail?: string;
+                    };
+                };
+            };
+            /** @description Standard error envelope used for all non-2xx responses. */
+            429: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /**
+                         * @description Stable machine-readable code. SDK consumers should switch on this.
+                         * @example invalid_key
+                         */
+                        error: string;
+                        /** @description Free-form human-readable explanation. Safe to surface. */
+                        detail?: string;
+                    };
+                };
+            };
+        };
+    };
+    submitConfirmation: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    /** @description The original transaction descriptor as passed to /v1/enrich. */
+                    descriptor: string;
+                    /** @description Catalog id of the merchant whose enrichment is being confirmed. Omit to confirm a "no merchant resolved" decision (e.g. /v1/enrich correctly classified this as a bank fee). */
+                    confirmed_merchant_id?: number;
+                };
+            };
+        };
+        responses: {
+            /** @description Default Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /**
+                         * Format: uuid
+                         * @description Server-generated id of the persisted feedback row.
+                         */
+                        id: string;
+                        /** @description The normalized descriptor hash this feedback is keyed on. Matches the hash /v1/enrich uses for cache + tenant_corrections lookup. */
+                        descriptor_hash: string;
+                    };
+                };
+            };
+            /** @description Standard error envelope used for all non-2xx responses. */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /**
+                         * @description Stable machine-readable code. SDK consumers should switch on this.
+                         * @example invalid_key
+                         */
+                        error: string;
+                        /** @description Free-form human-readable explanation. Safe to surface. */
+                        detail?: string;
+                    };
+                };
+            };
+            /** @description Standard error envelope used for all non-2xx responses. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /**
+                         * @description Stable machine-readable code. SDK consumers should switch on this.
+                         * @example invalid_key
+                         */
+                        error: string;
+                        /** @description Free-form human-readable explanation. Safe to surface. */
+                        detail?: string;
+                    };
+                };
+            };
+            /** @description Standard error envelope used for all non-2xx responses. */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /**
+                         * @description Stable machine-readable code. SDK consumers should switch on this.
+                         * @example invalid_key
+                         */
+                        error: string;
+                        /** @description Free-form human-readable explanation. Safe to surface. */
+                        detail?: string;
+                    };
+                };
+            };
+            /** @description Standard error envelope used for all non-2xx responses. */
+            429: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /**
+                         * @description Stable machine-readable code. SDK consumers should switch on this.
+                         * @example invalid_key
+                         */
+                        error: string;
+                        /** @description Free-form human-readable explanation. Safe to surface. */
+                        detail?: string;
+                    };
+                };
+            };
+        };
+    };
+    listWebhookEndpoints: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Default Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        endpoints: {
+                            /** Format: uuid */
+                            id: string;
+                            /** Format: uri */
+                            url: string;
+                            secret_prefix: string;
+                            events: string[];
+                            status: "active" | "disabled" | "auto_disabled";
+                            consecutive_failures: number;
+                            /** Format: date-time */
+                            created_at: string;
+                            rotated_at: string | null;
+                            last_delivered_at: string | null;
+                        }[];
+                    };
+                };
+            };
+            /** @description Standard error envelope used for all non-2xx responses. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /**
+                         * @description Stable machine-readable code. SDK consumers should switch on this.
+                         * @example invalid_key
+                         */
+                        error: string;
+                        /** @description Free-form human-readable explanation. Safe to surface. */
+                        detail?: string;
+                    };
+                };
+            };
+            /** @description Standard error envelope used for all non-2xx responses. */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /**
+                         * @description Stable machine-readable code. SDK consumers should switch on this.
+                         * @example invalid_key
+                         */
+                        error: string;
+                        /** @description Free-form human-readable explanation. Safe to surface. */
+                        detail?: string;
+                    };
+                };
+            };
+        };
+    };
+    createWebhookEndpoint: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    /**
+                     * Format: uri
+                     * @description HTTPS URL to receive events. Plain HTTP rejected.
+                     */
+                    url: string;
+                    /** @description Subset of supported events to subscribe to. Defaults to all currently-supported. */
+                    events?: ("batch.completed" | "batch.failed" | "analysis.completed" | "ingestion.completed" | "connect.connection.activated")[];
+                };
+            };
+        };
+        responses: {
+            /** @description Default Response */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** Format: uuid */
+                        id: string;
+                        /** Format: uri */
+                        url: string;
+                        secret_prefix: string;
+                        events: string[];
+                        status: "active" | "disabled" | "auto_disabled";
+                        consecutive_failures: number;
+                        /** Format: date-time */
+                        created_at: string;
+                        rotated_at: string | null;
+                        last_delivered_at: string | null;
+                    } & {
+                        /** @description Raw signing secret — shown ONCE. Save it; it cannot be recovered. Use it to verify the X-Distyra-Signature header on incoming deliveries. */
+                        secret: string;
+                    };
+                };
+            };
+            /** @description Standard error envelope used for all non-2xx responses. */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /**
+                         * @description Stable machine-readable code. SDK consumers should switch on this.
+                         * @example invalid_key
+                         */
+                        error: string;
+                        /** @description Free-form human-readable explanation. Safe to surface. */
+                        detail?: string;
+                    };
+                };
+            };
+            /** @description Standard error envelope used for all non-2xx responses. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /**
+                         * @description Stable machine-readable code. SDK consumers should switch on this.
+                         * @example invalid_key
+                         */
+                        error: string;
+                        /** @description Free-form human-readable explanation. Safe to surface. */
+                        detail?: string;
+                    };
+                };
+            };
+            /** @description Standard error envelope used for all non-2xx responses. */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /**
+                         * @description Stable machine-readable code. SDK consumers should switch on this.
+                         * @example invalid_key
+                         */
+                        error: string;
+                        /** @description Free-form human-readable explanation. Safe to surface. */
+                        detail?: string;
+                    };
+                };
+            };
+        };
+    };
+    getWebhookEndpoint: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Default Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** Format: uuid */
+                        id: string;
+                        /** Format: uri */
+                        url: string;
+                        secret_prefix: string;
+                        events: string[];
+                        status: "active" | "disabled" | "auto_disabled";
+                        consecutive_failures: number;
+                        /** Format: date-time */
+                        created_at: string;
+                        rotated_at: string | null;
+                        last_delivered_at: string | null;
+                    };
+                };
+            };
+            /** @description Standard error envelope used for all non-2xx responses. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /**
+                         * @description Stable machine-readable code. SDK consumers should switch on this.
+                         * @example invalid_key
+                         */
+                        error: string;
+                        /** @description Free-form human-readable explanation. Safe to surface. */
+                        detail?: string;
+                    };
+                };
+            };
+            /** @description Standard error envelope used for all non-2xx responses. */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /**
+                         * @description Stable machine-readable code. SDK consumers should switch on this.
+                         * @example invalid_key
+                         */
+                        error: string;
+                        /** @description Free-form human-readable explanation. Safe to surface. */
+                        detail?: string;
+                    };
+                };
+            };
+            /** @description Standard error envelope used for all non-2xx responses. */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /**
+                         * @description Stable machine-readable code. SDK consumers should switch on this.
+                         * @example invalid_key
+                         */
+                        error: string;
+                        /** @description Free-form human-readable explanation. Safe to surface. */
+                        detail?: string;
+                    };
+                };
+            };
+        };
+    };
+    deleteWebhookEndpoint: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Default Response */
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Standard error envelope used for all non-2xx responses. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /**
+                         * @description Stable machine-readable code. SDK consumers should switch on this.
+                         * @example invalid_key
+                         */
+                        error: string;
+                        /** @description Free-form human-readable explanation. Safe to surface. */
+                        detail?: string;
+                    };
+                };
+            };
+            /** @description Standard error envelope used for all non-2xx responses. */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /**
+                         * @description Stable machine-readable code. SDK consumers should switch on this.
+                         * @example invalid_key
+                         */
+                        error: string;
+                        /** @description Free-form human-readable explanation. Safe to surface. */
+                        detail?: string;
+                    };
+                };
+            };
+            /** @description Standard error envelope used for all non-2xx responses. */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /**
+                         * @description Stable machine-readable code. SDK consumers should switch on this.
+                         * @example invalid_key
+                         */
+                        error: string;
+                        /** @description Free-form human-readable explanation. Safe to surface. */
+                        detail?: string;
+                    };
+                };
+            };
+        };
+    };
+    rotateWebhookEndpointSecret: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Default Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** Format: uuid */
+                        id: string;
+                        /** Format: uri */
+                        url: string;
+                        secret_prefix: string;
+                        events: string[];
+                        status: "active" | "disabled" | "auto_disabled";
+                        consecutive_failures: number;
+                        /** Format: date-time */
+                        created_at: string;
+                        rotated_at: string | null;
+                        last_delivered_at: string | null;
+                    } & {
+                        /** @description Raw signing secret — shown ONCE. Save it; it cannot be recovered. Use it to verify the X-Distyra-Signature header on incoming deliveries. */
+                        secret: string;
+                    };
+                };
+            };
+            /** @description Standard error envelope used for all non-2xx responses. */
+            401: {
                 headers: {
                     [name: string]: unknown;
                 };
@@ -4952,7 +6039,7 @@ export interface operations {
                 };
             };
             /** @description Standard error envelope used for all non-2xx responses. */
-            404: {
+            403: {
                 headers: {
                     [name: string]: unknown;
                 };
@@ -4969,7 +6056,7 @@ export interface operations {
                 };
             };
             /** @description Standard error envelope used for all non-2xx responses. */
-            429: {
+            404: {
                 headers: {
                     [name: string]: unknown;
                 };
@@ -4987,9 +6074,12 @@ export interface operations {
             };
         };
     };
-    getCategories: {
+    listAspsps: {
         parameters: {
-            query?: never;
+            query: {
+                country: string;
+                psu_type?: "business" | "personal";
+            };
             header?: never;
             path?: never;
             cookie?: never;
@@ -5003,14 +6093,33 @@ export interface operations {
                 };
                 content: {
                     "application/json": {
-                        industries: {
+                        country: string;
+                        psu_type: "business" | "personal";
+                        aspsps: {
                             name: string;
-                            subindustries: string[];
+                            country: string;
                         }[];
                     };
                 };
             };
             /** @description Standard error envelope used for all non-2xx responses. */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /**
+                         * @description Stable machine-readable code. SDK consumers should switch on this.
+                         * @example invalid_key
+                         */
+                        error: string;
+                        /** @description Free-form human-readable explanation. Safe to surface. */
+                        detail?: string;
+                    };
+                };
+            };
+            /** @description Standard error envelope used for all non-2xx responses. */
             401: {
                 headers: {
                     [name: string]: unknown;
@@ -5045,7 +6154,24 @@ export interface operations {
                 };
             };
             /** @description Standard error envelope used for all non-2xx responses. */
-            429: {
+            502: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /**
+                         * @description Stable machine-readable code. SDK consumers should switch on this.
+                         * @example invalid_key
+                         */
+                        error: string;
+                        /** @description Free-form human-readable explanation. Safe to surface. */
+                        detail?: string;
+                    };
+                };
+            };
+            /** @description Standard error envelope used for all non-2xx responses. */
+            503: {
                 headers: {
                     [name: string]: unknown;
                 };
@@ -5063,43 +6189,112 @@ export interface operations {
             };
         };
     };
-    submitCorrection: {
+    listConnections: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Default Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        connections: {
+                            /** Format: uuid */
+                            id: string;
+                            applicant_ref: string | null;
+                            aspsp_name: string | null;
+                            country: string | null;
+                            psu_type: "business" | "personal";
+                            status: "pending" | "active" | "expired" | "revoked";
+                            consent_expires_at: string | null;
+                            /** Format: date-time */
+                            created_at: string;
+                        }[];
+                    };
+                };
+            };
+            /** @description Standard error envelope used for all non-2xx responses. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /**
+                         * @description Stable machine-readable code. SDK consumers should switch on this.
+                         * @example invalid_key
+                         */
+                        error: string;
+                        /** @description Free-form human-readable explanation. Safe to surface. */
+                        detail?: string;
+                    };
+                };
+            };
+            /** @description Standard error envelope used for all non-2xx responses. */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /**
+                         * @description Stable machine-readable code. SDK consumers should switch on this.
+                         * @example invalid_key
+                         */
+                        error: string;
+                        /** @description Free-form human-readable explanation. Safe to surface. */
+                        detail?: string;
+                    };
+                };
+            };
+        };
+    };
+    createConnection: {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** @description At least one of `corrected_merchant_id` or `corrected_merchant_name` must be provided. */
         requestBody: {
             content: {
                 "application/json": {
-                    /** @description The original transaction descriptor as passed to /v1/enrich. */
-                    descriptor: string;
-                    /** @description Catalog id of the merchant that should have been returned. Use this when the right merchant exists in the catalog (lookup via /v1/merchants/{id} or by trial enrichment). */
-                    corrected_merchant_id?: number;
-                    /** @description Free-text name of the right merchant when no catalog id is known. Triages into the manual-review queue; a catalog-mint may follow. */
-                    corrected_merchant_name?: string;
-                    /** @description Optional free-text context (e.g. "this is a French chain not the German one"). */
-                    note?: string;
+                    /** @description ISO-2 country code, e.g. DE. */
+                    country: string;
+                    /** @description Bank name; resolved to the canonical Enable Banking ASPSP name. */
+                    aspsp_name: string;
+                    /** @description Your reference for the applicant/deal (model 2). Omit for a self-link of your own accounts (model 1). */
+                    applicant_ref?: string;
+                    /**
+                     * Format: uri
+                     * @description Where to send the applicant after consent. Defaults to a Distyra-hosted page.
+                     */
+                    return_url?: string;
                 };
             };
         };
         responses: {
             /** @description Default Response */
-            200: {
+            201: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
                     "application/json": {
+                        /** Format: uuid */
+                        connection_id: string;
                         /**
-                         * Format: uuid
-                         * @description Server-generated id of the persisted feedback row.
+                         * Format: uri
+                         * @description Redirect the applicant here to complete SCA at their bank.
                          */
-                        id: string;
-                        /** @description The normalized descriptor hash this feedback is keyed on. Matches the hash /v1/enrich uses for cache + tenant_corrections lookup. */
-                        descriptor_hash: string;
+                        authorization_url: string;
                     };
                 };
             };
@@ -5110,13 +6305,148 @@ export interface operations {
                 };
                 content: {
                     "application/json": {
-                        /**
-                         * @description Stable machine-readable code. SDK consumers should switch on this.
-                         * @example invalid_key
-                         */
-                        error: string;
-                        /** @description Free-form human-readable explanation. Safe to surface. */
-                        detail?: string;
+                        /**
+                         * @description Stable machine-readable code. SDK consumers should switch on this.
+                         * @example invalid_key
+                         */
+                        error: string;
+                        /** @description Free-form human-readable explanation. Safe to surface. */
+                        detail?: string;
+                    };
+                };
+            };
+            /** @description Standard error envelope used for all non-2xx responses. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /**
+                         * @description Stable machine-readable code. SDK consumers should switch on this.
+                         * @example invalid_key
+                         */
+                        error: string;
+                        /** @description Free-form human-readable explanation. Safe to surface. */
+                        detail?: string;
+                    };
+                };
+            };
+            /** @description Standard error envelope used for all non-2xx responses. */
+            402: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /**
+                         * @description Stable machine-readable code. SDK consumers should switch on this.
+                         * @example invalid_key
+                         */
+                        error: string;
+                        /** @description Free-form human-readable explanation. Safe to surface. */
+                        detail?: string;
+                    };
+                };
+            };
+            /** @description Standard error envelope used for all non-2xx responses. */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /**
+                         * @description Stable machine-readable code. SDK consumers should switch on this.
+                         * @example invalid_key
+                         */
+                        error: string;
+                        /** @description Free-form human-readable explanation. Safe to surface. */
+                        detail?: string;
+                    };
+                };
+            };
+            /** @description Standard error envelope used for all non-2xx responses. */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /**
+                         * @description Stable machine-readable code. SDK consumers should switch on this.
+                         * @example invalid_key
+                         */
+                        error: string;
+                        /** @description Free-form human-readable explanation. Safe to surface. */
+                        detail?: string;
+                    };
+                };
+            };
+            /** @description Standard error envelope used for all non-2xx responses. */
+            502: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /**
+                         * @description Stable machine-readable code. SDK consumers should switch on this.
+                         * @example invalid_key
+                         */
+                        error: string;
+                        /** @description Free-form human-readable explanation. Safe to surface. */
+                        detail?: string;
+                    };
+                };
+            };
+            /** @description Standard error envelope used for all non-2xx responses. */
+            503: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /**
+                         * @description Stable machine-readable code. SDK consumers should switch on this.
+                         * @example invalid_key
+                         */
+                        error: string;
+                        /** @description Free-form human-readable explanation. Safe to surface. */
+                        detail?: string;
+                    };
+                };
+            };
+        };
+    };
+    getConnection: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Default Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** Format: uuid */
+                        id: string;
+                        applicant_ref: string | null;
+                        aspsp_name: string | null;
+                        country: string | null;
+                        psu_type: "business" | "personal";
+                        status: "pending" | "active" | "expired" | "revoked";
+                        consent_expires_at: string | null;
+                        /** Format: date-time */
+                        created_at: string;
                     };
                 };
             };
@@ -5155,7 +6485,7 @@ export interface operations {
                 };
             };
             /** @description Standard error envelope used for all non-2xx responses. */
-            429: {
+            404: {
                 headers: {
                     [name: string]: unknown;
                 };
@@ -5173,57 +6503,23 @@ export interface operations {
             };
         };
     };
-    submitConfirmation: {
+    revokeConnection: {
         parameters: {
             query?: never;
             header?: never;
-            path?: never;
-            cookie?: never;
-        };
-        requestBody: {
-            content: {
-                "application/json": {
-                    /** @description The original transaction descriptor as passed to /v1/enrich. */
-                    descriptor: string;
-                    /** @description Catalog id of the merchant whose enrichment is being confirmed. Omit to confirm a "no merchant resolved" decision (e.g. /v1/enrich correctly classified this as a bank fee). */
-                    confirmed_merchant_id?: number;
-                };
+            path: {
+                id: string;
             };
+            cookie?: never;
         };
+        requestBody?: never;
         responses: {
             /** @description Default Response */
-            200: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "application/json": {
-                        /**
-                         * Format: uuid
-                         * @description Server-generated id of the persisted feedback row.
-                         */
-                        id: string;
-                        /** @description The normalized descriptor hash this feedback is keyed on. Matches the hash /v1/enrich uses for cache + tenant_corrections lookup. */
-                        descriptor_hash: string;
-                    };
-                };
-            };
-            /** @description Standard error envelope used for all non-2xx responses. */
-            400: {
+            204: {
                 headers: {
                     [name: string]: unknown;
                 };
-                content: {
-                    "application/json": {
-                        /**
-                         * @description Stable machine-readable code. SDK consumers should switch on this.
-                         * @example invalid_key
-                         */
-                        error: string;
-                        /** @description Free-form human-readable explanation. Safe to surface. */
-                        detail?: string;
-                    };
-                };
+                content?: never;
             };
             /** @description Standard error envelope used for all non-2xx responses. */
             401: {
@@ -5260,7 +6556,7 @@ export interface operations {
                 };
             };
             /** @description Standard error envelope used for all non-2xx responses. */
-            429: {
+            404: {
                 headers: {
                     [name: string]: unknown;
                 };
@@ -5278,11 +6574,13 @@ export interface operations {
             };
         };
     };
-    listWebhookEndpoints: {
+    getConnectionAccounts: {
         parameters: {
             query?: never;
             header?: never;
-            path?: never;
+            path: {
+                id: string;
+            };
             cookie?: never;
         };
         requestBody?: never;
@@ -5294,19 +6592,17 @@ export interface operations {
                 };
                 content: {
                     "application/json": {
-                        endpoints: {
-                            /** Format: uuid */
-                            id: string;
-                            /** Format: uri */
-                            url: string;
-                            secret_prefix: string;
-                            events: string[];
-                            status: "active" | "disabled" | "auto_disabled";
-                            consecutive_failures: number;
-                            /** Format: date-time */
-                            created_at: string;
-                            rotated_at: string | null;
-                            last_delivered_at: string | null;
+                        accounts: {
+                            account_id: string;
+                            uid?: string;
+                            name: string;
+                            currency: string;
+                            iban?: string;
+                            account_type?: string;
+                            balance: {
+                                amount: number;
+                                currency: string;
+                            };
                         }[];
                     };
                 };
@@ -5345,56 +6641,25 @@ export interface operations {
                     };
                 };
             };
-        };
-    };
-    createWebhookEndpoint: {
-        parameters: {
-            query?: never;
-            header?: never;
-            path?: never;
-            cookie?: never;
-        };
-        requestBody: {
-            content: {
-                "application/json": {
-                    /**
-                     * Format: uri
-                     * @description HTTPS URL to receive events. Plain HTTP rejected.
-                     */
-                    url: string;
-                    /** @description Subset of supported events to subscribe to. Defaults to all currently-supported. */
-                    events?: ("batch.completed" | "batch.failed" | "analysis.completed" | "ingestion.completed")[];
-                };
-            };
-        };
-        responses: {
-            /** @description Default Response */
-            201: {
+            /** @description Standard error envelope used for all non-2xx responses. */
+            404: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
                     "application/json": {
-                        /** Format: uuid */
-                        id: string;
-                        /** Format: uri */
-                        url: string;
-                        secret_prefix: string;
-                        events: string[];
-                        status: "active" | "disabled" | "auto_disabled";
-                        consecutive_failures: number;
-                        /** Format: date-time */
-                        created_at: string;
-                        rotated_at: string | null;
-                        last_delivered_at: string | null;
-                    } & {
-                        /** @description Raw signing secret — shown ONCE. Save it; it cannot be recovered. Use it to verify the X-Distyra-Signature header on incoming deliveries. */
-                        secret: string;
+                        /**
+                         * @description Stable machine-readable code. SDK consumers should switch on this.
+                         * @example invalid_key
+                         */
+                        error: string;
+                        /** @description Free-form human-readable explanation. Safe to surface. */
+                        detail?: string;
                     };
                 };
             };
             /** @description Standard error envelope used for all non-2xx responses. */
-            400: {
+            409: {
                 headers: {
                     [name: string]: unknown;
                 };
@@ -5411,7 +6676,7 @@ export interface operations {
                 };
             };
             /** @description Standard error envelope used for all non-2xx responses. */
-            401: {
+            502: {
                 headers: {
                     [name: string]: unknown;
                 };
@@ -5428,7 +6693,7 @@ export interface operations {
                 };
             };
             /** @description Standard error envelope used for all non-2xx responses. */
-            403: {
+            503: {
                 headers: {
                     [name: string]: unknown;
                 };
@@ -5446,9 +6711,18 @@ export interface operations {
             };
         };
     };
-    getWebhookEndpoint: {
+    getConnectionTransactions: {
         parameters: {
-            query?: never;
+            query?: {
+                /** @description EB account uid; omit to fetch all accounts on the connection. */
+                account_id?: string;
+                date_from?: string;
+                date_to?: string;
+                /** @description Run enrichment on each transaction (bills the enrichment meter; needs enrichment:read). */
+                enrich?: "true" | "false";
+                /** @description Run the full underwriting analysis (enrichment always included; bills the per-applicant underwriting meter; needs underwriting:write). Returns the analysis bundle instead of transactions. */
+                underwrite?: "true" | "false";
+            };
             header?: never;
             path: {
                 id: string;
@@ -5464,18 +6738,7 @@ export interface operations {
                 };
                 content: {
                     "application/json": {
-                        /** Format: uuid */
-                        id: string;
-                        /** Format: uri */
-                        url: string;
-                        secret_prefix: string;
-                        events: string[];
-                        status: "active" | "disabled" | "auto_disabled";
-                        consecutive_failures: number;
-                        /** Format: date-time */
-                        created_at: string;
-                        rotated_at: string | null;
-                        last_delivered_at: string | null;
+                        [key: string]: unknown;
                     };
                 };
             };
@@ -5497,6 +6760,23 @@ export interface operations {
                 };
             };
             /** @description Standard error envelope used for all non-2xx responses. */
+            402: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /**
+                         * @description Stable machine-readable code. SDK consumers should switch on this.
+                         * @example invalid_key
+                         */
+                        error: string;
+                        /** @description Free-form human-readable explanation. Safe to surface. */
+                        detail?: string;
+                    };
+                };
+            };
+            /** @description Standard error envelope used for all non-2xx responses. */
             403: {
                 headers: {
                     [name: string]: unknown;
@@ -5530,28 +6810,25 @@ export interface operations {
                     };
                 };
             };
-        };
-    };
-    deleteWebhookEndpoint: {
-        parameters: {
-            query?: never;
-            header?: never;
-            path: {
-                id: string;
-            };
-            cookie?: never;
-        };
-        requestBody?: never;
-        responses: {
-            /** @description Default Response */
-            204: {
+            /** @description Standard error envelope used for all non-2xx responses. */
+            409: {
                 headers: {
                     [name: string]: unknown;
                 };
-                content?: never;
+                content: {
+                    "application/json": {
+                        /**
+                         * @description Stable machine-readable code. SDK consumers should switch on this.
+                         * @example invalid_key
+                         */
+                        error: string;
+                        /** @description Free-form human-readable explanation. Safe to surface. */
+                        detail?: string;
+                    };
+                };
             };
             /** @description Standard error envelope used for all non-2xx responses. */
-            401: {
+            422: {
                 headers: {
                     [name: string]: unknown;
                 };
@@ -5568,7 +6845,7 @@ export interface operations {
                 };
             };
             /** @description Standard error envelope used for all non-2xx responses. */
-            403: {
+            502: {
                 headers: {
                     [name: string]: unknown;
                 };
@@ -5585,7 +6862,7 @@ export interface operations {
                 };
             };
             /** @description Standard error envelope used for all non-2xx responses. */
-            404: {
+            503: {
                 headers: {
                     [name: string]: unknown;
                 };
@@ -5603,39 +6880,55 @@ export interface operations {
             };
         };
     };
-    rotateWebhookEndpointSecret: {
+    createHostedConnectLink: {
         parameters: {
             query?: never;
             header?: never;
-            path: {
-                id: string;
-            };
+            path?: never;
             cookie?: never;
         };
-        requestBody?: never;
+        requestBody: {
+            content: {
+                "application/json": {
+                    country: string;
+                    applicant_ref?: string;
+                    /** Format: uri */
+                    return_url?: string;
+                    /** @default 72 */
+                    expires_in_hours?: number;
+                };
+            };
+        };
         responses: {
             /** @description Default Response */
-            200: {
+            201: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
                     "application/json": {
-                        /** Format: uuid */
-                        id: string;
                         /** Format: uri */
                         url: string;
-                        secret_prefix: string;
-                        events: string[];
-                        status: "active" | "disabled" | "auto_disabled";
-                        consecutive_failures: number;
+                        token: string;
                         /** Format: date-time */
-                        created_at: string;
-                        rotated_at: string | null;
-                        last_delivered_at: string | null;
-                    } & {
-                        /** @description Raw signing secret — shown ONCE. Save it; it cannot be recovered. Use it to verify the X-Distyra-Signature header on incoming deliveries. */
-                        secret: string;
+                        expires_at: string;
+                    };
+                };
+            };
+            /** @description Standard error envelope used for all non-2xx responses. */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /**
+                         * @description Stable machine-readable code. SDK consumers should switch on this.
+                         * @example invalid_key
+                         */
+                        error: string;
+                        /** @description Free-form human-readable explanation. Safe to surface. */
+                        detail?: string;
                     };
                 };
             };
@@ -5674,7 +6967,7 @@ export interface operations {
                 };
             };
             /** @description Standard error envelope used for all non-2xx responses. */
-            404: {
+            503: {
                 headers: {
                     [name: string]: unknown;
                 };