@distyra/sdk 0.5.0 → 0.6.0

package/README.md

@@ -36,8 +36,9 @@ if (error) {
   throw new Error(error.detail ?? error.error);
 }
 
-// `data` is fully typed against the EnrichResponse schema
-console.log(data.merchant.name, data.category.primary);
+// `data` is fully typed against the EnrichResponse schema. `merchant` is null
+// for non-merchant transactions (bank fees, transfers), so guard it.
+console.log(data.merchant?.name ?? '(no merchant)', data.category.primary);
 ```
 
 ## Options
@@ -52,6 +53,30 @@ console.log(data.merchant.name, data.category.primary);
 
 The returned client is a typed [`openapi-fetch`](https://openapi-ts.dev/openapi-fetch/) client — use `.GET`, `.POST`, etc. against any path in the spec, with full request/response typing.
 
+## Handling unknown merchants (eventual consistency)
+
+The first time anyone enriches a brand-new merchant, the response may be unresolved
+(`resolution.status` other than `resolved`). The system then discovers and confirms that
+merchant in the background, so the same descriptor resolves shortly after, for every
+caller, with no model call.
+
+Read `resolution.retry_after`:
+
+- A number (seconds) means a confirmed answer is likely coming. Retry the same descriptor
+  once after that delay, or just let your next natural re-sync pick it up.
+- `null` means the result is definitive; no retry will help.
+
+```ts
+const { data } = await distyra.POST('/v1/enrich', { body: { descriptor, country_hint } });
+if (data.resolution.status !== 'resolved' && data.resolution.retry_after != null) {
+  // retry once after data.resolution.retry_after seconds, or wait for your next sync
+}
+```
+
+Note: `resolution.retryable` is a different signal. It is `true` only for a transient
+backend error (`timed_out` / `transient_error`), which you retry within seconds. See the
+full resolution-and-retries guide at <https://api.distyra.com/docs>.
+
 ## Lower-level access
 
 The generated `paths` and `operations` types are re-exported if you want to build your own `openapi-fetch` client or reference response shapes directly:

package/dist/generated.d.ts

@@ -23,6 +23,23 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v1/connect/coverage": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** List the banks (ASPSPs) Connect covers across Europe */
+        get: operations["connectCoverage"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v1/enrich": {
         parameters: {
             query?: never;
@@ -757,7 +774,11 @@ export interface paths {
         delete: operations["deleteWebhookEndpoint"];
         options?: never;
         head?: never;
-        patch?: never;
+        /**
+         * Update a webhook endpoint (url, events, status)
+         * @description Partial update. Provide any subset of url, events, status. `events` fully replaces the subscription list. Setting status=active clears the failure counter and re-enables an auto-disabled endpoint. The signing secret is unchanged — use rotate_secret for that.
+         */
+        patch: operations["updateWebhookEndpoint"];
         trace?: never;
     };
     "/v1/webhook_endpoints/{id}/rotate_secret": {
@@ -780,6 +801,26 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v1/webhook_deliveries": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List webhook delivery attempts for the caller org
+         * @description Per-attempt delivery log, most-recent-first, scoped to the caller org. Filter by endpoint_id and/or status; page backwards with the `before` cursor. Payload bytes are not included — response_excerpt, error_excerpt and http_status are provided for debugging.
+         */
+        get: operations["listWebhookDeliveries"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v1/connect/aspsps": {
         parameters: {
             query?: never;
@@ -850,6 +891,26 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v1/connect/connections/{id}/identity": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Account-holder identity for a connection (ownership verification)
+         * @description Returns the account holder name the bank reports for each account. Pass applicant_name to get a token-match verdict (match / partial / no_match) per account, to confirm an account belongs to your applicant. Holder names are provided by the bank and vary in format; use the verdict as a confirmation signal.
+         */
+        get: operations["getConnectionIdentity"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v1/connect/connections/{id}/transactions": {
         parameters: {
             query?: never;
@@ -857,7 +918,10 @@ export interface paths {
             path?: never;
             cookie?: never;
         };
-        /** Fetch normalized transactions for a connection */
+        /**
+         * Fetch normalized transactions for a connection
+         * @description Transactions are fetched live from the bank on each call and never stored, so this is a pull API. Sync contract for keeping your own system up to date: on the first pull omit the date filters (you get the default 90-day backfill, the PSD2 no-SCA window); on each later pull pass since=<the next_cursor from your previous response> to fetch only from where you left off. The response always returns next_cursor (the end of the window just fetched) — poll on your own cadence and use it as the next since. Because the boundary day can overlap, DEDUPLICATE by each transaction's id. A pull reuses the connection's existing bank session, so it does not consume a new Active Session — poll as often as your freshness needs require.
+         */
         get: operations["getConnectionTransactions"];
         put?: never;
         post?: never;
@@ -1023,6 +1087,62 @@ export interface operations {
             };
         };
     };
+    connectCoverage: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Default Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        [key: string]: unknown;
+                    };
+                };
+            };
+            /** @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;
+                    };
+                };
+            };
+        };
+    };
     enrichSingle: {
         parameters: {
             query?: {
@@ -1150,6 +1270,13 @@ export interface operations {
                      *         "transaction_type": 1,
                      *         "overall": 0.96
                      *       },
+                     *       "resolution": {
+                     *         "status": "resolved",
+                     *         "proposed_name": null,
+                     *         "confidence": null,
+                     *         "retryable": false,
+                     *         "retry_after": null
+                     *       },
                      *       "alternatives": [],
                      *       "trace_id": "req-01HXYZ...",
                      *       "cache_hit": true,
@@ -1212,6 +1339,20 @@ export interface operations {
                             transaction_type: number;
                             overall: number;
                         };
+                        /** @description Structured reason for the resolution outcome, so callers can act on null results. */
+                        resolution: {
+                            /**
+                             * @description resolved: a merchant or non-merchant transaction_type was resolved. unresolved_unknown: Tier 4 ran and genuinely couldn't identify the merchant (or was blocked before the call). low_signal_descriptor: the descriptor was too thin to resolve — send the fuller statement form. below_mint_threshold: Tier 4 proposed a name but the quality gate declined it (see proposed_name/confidence). timed_out / transient_error: a transient Tier-4 failure — RETRYABLE, not a verdict.
+                             * @enum {string}
+                             */
+                            status: "resolved" | "unresolved_unknown" | "low_signal_descriptor" | "below_mint_threshold" | "timed_out" | "transient_error";
+                            proposed_name: string | null;
+                            confidence: number | null;
+                            /** @description true for timed_out / transient_error — retry the same request; the null is transient, not a definitive "unknown". */
+                            retryable: boolean;
+                            /** @description Seconds after which retrying the SAME descriptor is worthwhile, or null when it is not. Set when an unknown merchant triggered background discovery: the system is fetching + confirming the brand, so the descriptor typically resolves after this delay (eventual consistency). Retry once after this many seconds, or just let your next natural re-sync pick it up. null = a definitive non-result, no retry will help. */
+                            retry_after: number | null;
+                        };
                         alternatives: {
                             name: string;
                             confidence: number;
@@ -1638,7 +1779,7 @@ export interface operations {
                             /** Format: date */
                             end: string;
                         };
-                        /** @description Computed feature bundle: `aggregation` (turnover, cash_position, customer_concentration, credit_line_utilization — the latter null unless an account declares a committed limit), `recurring` (recurring_revenue, recurring_expense, returned_dd counts), `counterparty` (tax_payments, statutory_contributions, debt_service, supplier_payments — payment-regularity streams over supplier-tagged counterparties; suppliers_tagged=0 means no supplier coverage for this applicant, not "pays nobody"), `debt_capacity` (DSCR + capacity at policy thresholds, with a transparent assumptions block), `anomaly` (null; Engine 4 deferred). Amount fields are stringified micro-EUR bigints so 12-digit values round-trip cleanly through JSON. */
+                        /** @description Computed feature bundle: `aggregation` (turnover, cash_position, customer_concentration, credit_line_utilization — the latter null unless an account declares a committed limit), `recurring` (recurring_revenue, recurring_expense, returned_dd counts), `counterparty` (tax_payments, statutory_contributions, debt_service, supplier_payments — payment-regularity streams over supplier-tagged counterparties; suppliers_tagged=0 means no supplier coverage for this applicant, not "pays nobody"; debt_collection — payments to debt-collection agencies, an adverse signal; collectors_tagged=0 = no collector activity), `debt_capacity` (DSCR + capacity at policy thresholds, with a transparent assumptions block), `anomaly` (null; Engine 4 deferred). Amount fields are stringified micro-EUR bigints so 12-digit values round-trip cleanly through JSON. */
                         features: {
                             [key: string]: unknown;
                         };
@@ -1701,12 +1842,16 @@ export interface operations {
                                     merchant_id: string | null;
                                     merchant_industry: string | null;
                                     merchant_subindustry: string | null;
+                                    /** @description health / pension / accident / sectoral / social_secretariat / social_security / other / null. Set only for statutory bodies (drives the statutory_contributions split); null for everything else, including genuine tax authorities. */
+                                    merchant_statutory_kind: string | null;
                                     transaction_type: string;
                                     is_transfer: boolean;
                                     is_bank_internal: boolean;
                                     counterparty_iban: string | null;
                                     /** @description tax_authority / lender / customer / supplier / employee / payment_processor / internal_transfer / null. The EU-correctness signal. */
                                     counterparty_role: string | null;
+                                    /** @description Provenance of an institutional counterparty_role / merchant_statutory_kind: 'confirmed' (curated catalog row or payer-declared ISO 20022 purpose code) vs 'inferred' (AI category guess). Lets a lender tell a solid obligation from a likely one; inferred rows still count in the totals. Absent on regular merchants. */
+                                    counterparty_source?: "confirmed" | "inferred" | null;
                                 } & {
                                     [key: string]: unknown;
                                 })[];
@@ -1905,7 +2050,7 @@ export interface operations {
                             /** Format: date */
                             end: string;
                         };
-                        /** @description Computed feature bundle: `aggregation` (turnover, cash_position, customer_concentration, credit_line_utilization — the latter null unless an account declares a committed limit), `recurring` (recurring_revenue, recurring_expense, returned_dd counts), `counterparty` (tax_payments, statutory_contributions, debt_service, supplier_payments — payment-regularity streams over supplier-tagged counterparties; suppliers_tagged=0 means no supplier coverage for this applicant, not "pays nobody"), `debt_capacity` (DSCR + capacity at policy thresholds, with a transparent assumptions block), `anomaly` (null; Engine 4 deferred). Amount fields are stringified micro-EUR bigints so 12-digit values round-trip cleanly through JSON. */
+                        /** @description Computed feature bundle: `aggregation` (turnover, cash_position, customer_concentration, credit_line_utilization — the latter null unless an account declares a committed limit), `recurring` (recurring_revenue, recurring_expense, returned_dd counts), `counterparty` (tax_payments, statutory_contributions, debt_service, supplier_payments — payment-regularity streams over supplier-tagged counterparties; suppliers_tagged=0 means no supplier coverage for this applicant, not "pays nobody"; debt_collection — payments to debt-collection agencies, an adverse signal; collectors_tagged=0 = no collector activity), `debt_capacity` (DSCR + capacity at policy thresholds, with a transparent assumptions block), `anomaly` (null; Engine 4 deferred). Amount fields are stringified micro-EUR bigints so 12-digit values round-trip cleanly through JSON. */
                         features: {
                             [key: string]: unknown;
                         };
@@ -1968,12 +2113,16 @@ export interface operations {
                                     merchant_id: string | null;
                                     merchant_industry: string | null;
                                     merchant_subindustry: string | null;
+                                    /** @description health / pension / accident / sectoral / social_secretariat / social_security / other / null. Set only for statutory bodies (drives the statutory_contributions split); null for everything else, including genuine tax authorities. */
+                                    merchant_statutory_kind: string | null;
                                     transaction_type: string;
                                     is_transfer: boolean;
                                     is_bank_internal: boolean;
                                     counterparty_iban: string | null;
                                     /** @description tax_authority / lender / customer / supplier / employee / payment_processor / internal_transfer / null. The EU-correctness signal. */
                                     counterparty_role: string | null;
+                                    /** @description Provenance of an institutional counterparty_role / merchant_statutory_kind: 'confirmed' (curated catalog row or payer-declared ISO 20022 purpose code) vs 'inferred' (AI category guess). Lets a lender tell a solid obligation from a likely one; inferred rows still count in the totals. Absent on regular merchants. */
+                                    counterparty_source?: "confirmed" | "inferred" | null;
                                 } & {
                                     [key: string]: unknown;
                                 })[];
@@ -2422,7 +2571,7 @@ export interface operations {
                             /** Format: date */
                             end: string;
                         };
-                        /** @description Computed feature bundle: `aggregation` (turnover, cash_position, customer_concentration, credit_line_utilization — the latter null unless an account declares a committed limit), `recurring` (recurring_revenue, recurring_expense, returned_dd counts), `counterparty` (tax_payments, statutory_contributions, debt_service, supplier_payments — payment-regularity streams over supplier-tagged counterparties; suppliers_tagged=0 means no supplier coverage for this applicant, not "pays nobody"), `debt_capacity` (DSCR + capacity at policy thresholds, with a transparent assumptions block), `anomaly` (null; Engine 4 deferred). Amount fields are stringified micro-EUR bigints so 12-digit values round-trip cleanly through JSON. */
+                        /** @description Computed feature bundle: `aggregation` (turnover, cash_position, customer_concentration, credit_line_utilization — the latter null unless an account declares a committed limit), `recurring` (recurring_revenue, recurring_expense, returned_dd counts), `counterparty` (tax_payments, statutory_contributions, debt_service, supplier_payments — payment-regularity streams over supplier-tagged counterparties; suppliers_tagged=0 means no supplier coverage for this applicant, not "pays nobody"; debt_collection — payments to debt-collection agencies, an adverse signal; collectors_tagged=0 = no collector activity), `debt_capacity` (DSCR + capacity at policy thresholds, with a transparent assumptions block), `anomaly` (null; Engine 4 deferred). Amount fields are stringified micro-EUR bigints so 12-digit values round-trip cleanly through JSON. */
                         features: {
                             [key: string]: unknown;
                         };
@@ -2485,12 +2634,16 @@ export interface operations {
                                     merchant_id: string | null;
                                     merchant_industry: string | null;
                                     merchant_subindustry: string | null;
+                                    /** @description health / pension / accident / sectoral / social_secretariat / social_security / other / null. Set only for statutory bodies (drives the statutory_contributions split); null for everything else, including genuine tax authorities. */
+                                    merchant_statutory_kind: string | null;
                                     transaction_type: string;
                                     is_transfer: boolean;
                                     is_bank_internal: boolean;
                                     counterparty_iban: string | null;
                                     /** @description tax_authority / lender / customer / supplier / employee / payment_processor / internal_transfer / null. The EU-correctness signal. */
                                     counterparty_role: string | null;
+                                    /** @description Provenance of an institutional counterparty_role / merchant_statutory_kind: 'confirmed' (curated catalog row or payer-declared ISO 20022 purpose code) vs 'inferred' (AI category guess). Lets a lender tell a solid obligation from a likely one; inferred rows still count in the totals. Absent on regular merchants. */
+                                    counterparty_source?: "confirmed" | "inferred" | null;
                                 } & {
                                     [key: string]: unknown;
                                 })[];
@@ -2945,7 +3098,7 @@ export interface operations {
                             /** Format: date */
                             end: string;
                         };
-                        /** @description Computed feature bundle: `aggregation` (turnover, cash_position, customer_concentration, credit_line_utilization — the latter null unless an account declares a committed limit), `recurring` (recurring_revenue, recurring_expense, returned_dd counts), `counterparty` (tax_payments, statutory_contributions, debt_service, supplier_payments — payment-regularity streams over supplier-tagged counterparties; suppliers_tagged=0 means no supplier coverage for this applicant, not "pays nobody"), `debt_capacity` (DSCR + capacity at policy thresholds, with a transparent assumptions block), `anomaly` (null; Engine 4 deferred). Amount fields are stringified micro-EUR bigints so 12-digit values round-trip cleanly through JSON. */
+                        /** @description Computed feature bundle: `aggregation` (turnover, cash_position, customer_concentration, credit_line_utilization — the latter null unless an account declares a committed limit), `recurring` (recurring_revenue, recurring_expense, returned_dd counts), `counterparty` (tax_payments, statutory_contributions, debt_service, supplier_payments — payment-regularity streams over supplier-tagged counterparties; suppliers_tagged=0 means no supplier coverage for this applicant, not "pays nobody"; debt_collection — payments to debt-collection agencies, an adverse signal; collectors_tagged=0 = no collector activity), `debt_capacity` (DSCR + capacity at policy thresholds, with a transparent assumptions block), `anomaly` (null; Engine 4 deferred). Amount fields are stringified micro-EUR bigints so 12-digit values round-trip cleanly through JSON. */
                         features: {
                             [key: string]: unknown;
                         };
@@ -3008,12 +3161,16 @@ export interface operations {
                                     merchant_id: string | null;
                                     merchant_industry: string | null;
                                     merchant_subindustry: string | null;
+                                    /** @description health / pension / accident / sectoral / social_secretariat / social_security / other / null. Set only for statutory bodies (drives the statutory_contributions split); null for everything else, including genuine tax authorities. */
+                                    merchant_statutory_kind: string | null;
                                     transaction_type: string;
                                     is_transfer: boolean;
                                     is_bank_internal: boolean;
                                     counterparty_iban: string | null;
                                     /** @description tax_authority / lender / customer / supplier / employee / payment_processor / internal_transfer / null. The EU-correctness signal. */
                                     counterparty_role: string | null;
+                                    /** @description Provenance of an institutional counterparty_role / merchant_statutory_kind: 'confirmed' (curated catalog row or payer-declared ISO 20022 purpose code) vs 'inferred' (AI category guess). Lets a lender tell a solid obligation from a likely one; inferred rows still count in the totals. Absent on regular merchants. */
+                                    counterparty_source?: "confirmed" | "inferred" | null;
                                 } & {
                                     [key: string]: unknown;
                                 })[];
@@ -5766,7 +5923,7 @@ export interface operations {
                      */
                     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")[];
+                    events?: ("batch.completed" | "batch.failed" | "analysis.completed" | "ingestion.completed" | "connect.connection.activated" | "connect.connection.reconsent_required" | "connect.connection.expired" | "connect.connection.error")[];
                 };
             };
         };
@@ -6006,6 +6163,123 @@ export interface operations {
             };
         };
     };
+    updateWebhookEndpoint: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    /**
+                     * Format: uri
+                     * @description New HTTPS URL. Plain HTTP rejected.
+                     */
+                    url?: string;
+                    /** @description Replacement event subscription list (full replace, not merge). */
+                    events?: ("batch.completed" | "batch.failed" | "analysis.completed" | "ingestion.completed" | "connect.connection.activated" | "connect.connection.reconsent_required" | "connect.connection.expired" | "connect.connection.error")[];
+                    /** @description Set 'disabled' to pause deliveries, 'active' to resume (also clears the failure counter). */
+                    status?: "active" | "disabled";
+                };
+            };
+        };
+        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. */
+            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;
+                    };
+                };
+            };
+        };
+    };
     rotateWebhookEndpointSecret: {
         parameters: {
             query?: never;
@@ -6095,6 +6369,101 @@ export interface operations {
             };
         };
     };
+    listWebhookDeliveries: {
+        parameters: {
+            query?: {
+                /** @description Only deliveries for this endpoint. */
+                endpoint_id?: string;
+                status?: "pending" | "delivered" | "failed" | "exhausted";
+                limit?: number;
+                /** @description Cursor: return deliveries created strictly before this timestamp (page backwards in time). */
+                before?: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Default Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        deliveries: {
+                            /** Format: uuid */
+                            id: string;
+                            /** Format: uuid */
+                            endpoint_id: string;
+                            event: string;
+                            status: "pending" | "delivered" | "failed" | "exhausted";
+                            attempt: number;
+                            http_status: number | null;
+                            response_excerpt: string | null;
+                            error_excerpt: string | null;
+                            next_attempt_at: string | null;
+                            delivered_at: string | null;
+                            /** Format: date-time */
+                            created_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;
+                    };
+                };
+            };
+            /** @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;
+                    };
+                };
+            };
+        };
+    };
     listAspsps: {
         parameters: {
             query: {
@@ -6229,11 +6598,12 @@ export interface operations {
                         connections: {
                             /** Format: uuid */
                             id: string;
+                            external_ref: string | null;
                             applicant_ref: string | null;
                             aspsp_name: string | null;
                             country: string | null;
                             psu_type: "business" | "personal";
-                            status: "pending" | "active" | "expired" | "revoked";
+                            status: "pending" | "active" | "expired" | "revoked" | "error";
                             consent_expires_at: string | null;
                             /** Format: date-time */
                             created_at: string;
@@ -6293,6 +6663,8 @@ export interface operations {
                     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;
+                    /** @description Your own stable id for this connection (e.g. your user or account id). Unlike the connection id, it survives reconsent: pass the same value when a customer re-authorizes and key your integration off it. Echoed in list responses and every connect.connection.* webhook. */
+                    external_ref?: string;
                     /**
                      * Format: uri
                      * @description Where to send the applicant after consent. Defaults to a Distyra-hosted page.
@@ -6460,11 +6832,12 @@ export interface operations {
                     "application/json": {
                         /** Format: uuid */
                         id: string;
+                        external_ref: string | null;
                         applicant_ref: string | null;
                         aspsp_name: string | null;
                         country: string | null;
                         psu_type: "business" | "personal";
-                        status: "pending" | "active" | "expired" | "revoked";
+                        status: "pending" | "active" | "expired" | "revoked" | "error";
                         consent_expires_at: string | null;
                         /** Format: date-time */
                         created_at: string;
@@ -6617,6 +6990,7 @@ export interface operations {
                             account_id: string;
                             uid?: string;
                             name: string;
+                            holder_name?: string;
                             currency: string;
                             iban?: string;
                             account_type?: string;
@@ -6624,6 +6998,146 @@ export interface operations {
                                 amount: number;
                                 currency: string;
                             };
+                            balance_known: boolean;
+                        }[];
+                    };
+                };
+            };
+            /** @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. */
+            409: {
+                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;
+                    };
+                };
+            };
+        };
+    };
+    getConnectionIdentity: {
+        parameters: {
+            query?: {
+                /** @description Name to match holders against. */
+                applicant_name?: string;
+            };
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Default Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        accounts: {
+                            account_id: string;
+                            holder_name: string | null;
+                            iban?: string;
+                            account_type?: string;
+                            currency: string;
+                            name_match?: {
+                                verdict: "match" | "partial" | "no_match";
+                                score: number;
+                            };
                         }[];
                     };
                 };
@@ -6737,6 +7251,9 @@ export interface operations {
             query?: {
                 /** @description EB account uid; omit to fetch all accounts on the connection. */
                 account_id?: string;
+                /** @description Incremental cursor: the next_cursor from your previous response. Sets the window start when date_from is not given. Dedupe by transaction id across the boundary. */
+                since?: string;
+                /** @description Explicit window start (overrides since). */
                 date_from?: string;
                 date_to?: string;
                 /** @description Run enrichment on each transaction (bills the enrichment meter; needs enrichment:read). */
@@ -6913,6 +7430,17 @@ export interface operations {
                 "application/json": {
                     country: string;
                     applicant_ref?: string;
+                    /** @description Your own stable id for the connection this link creates. Survives reconsent; echoed in list responses and every connect.connection.* webhook. */
+                    external_ref?: string;
+                    /** @description Override the hosted page brand name for this link (defaults to your org branding). */
+                    brand_name?: string;
+                    /**
+                     * Format: uri
+                     * @description Override brand logo (https URL) for this link.
+                     */
+                    brand_logo_url?: string;
+                    /** @description Override brand accent colour (#RRGGBB) for this link. */
+                    brand_color?: string;
                     /** Format: uri */
                     return_url?: string;
                     /** @default 72 */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@distyra/sdk",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "TypeScript SDK for the Distyra Transaction Enrichment & SME Underwriting API. Generated from the committed OpenAPI spec; thin, typed wrapper around openapi-fetch.",
   "license": "MIT",
   "author": "Brightfield Software",