@dakota-xyz/ts-sdk 2.1.0 → 2.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/index.d.mts CHANGED
@@ -67,7 +67,20 @@ interface DakotaClientConfig {
67
67
  baseURL?: string;
68
68
  /** Authentication mode (default: Auto) */
69
69
  authMode?: AuthMode;
70
- /** Request timeout in milliseconds (default: 15000) */
70
+ /**
71
+ * Request timeout in milliseconds (default: 15000).
72
+ *
73
+ * Setting this explicitly applies it to EVERY request, including the
74
+ * model-backed agentic endpoints that otherwise get a longer default
75
+ * ({@link AGENTIC_MODEL_TIMEOUT_MS}) — so you keep full control, but a
76
+ * global value tuned for fast reads will also cap agent turns. To keep
77
+ * the long agentic default while tightening everything else, leave this
78
+ * unset and pass `{ timeout }` per request instead.
79
+ *
80
+ * Note this is a per-ATTEMPT deadline: with the default retry policy a
81
+ * timing-out request can be attempted up to `retryPolicy.maxAttempts`
82
+ * times, so worst-case wall clock is roughly `timeout × maxAttempts`.
83
+ */
71
84
  timeout?: number;
72
85
  /** Retry policy configuration */
73
86
  retryPolicy?: Partial<RetryPolicy>;
@@ -89,6 +102,15 @@ interface ResolvedConfig {
89
102
  baseURL: string;
90
103
  authMode: AuthMode;
91
104
  timeout: number;
105
+ /**
106
+ * Whether `timeout` came from the caller rather than the default.
107
+ *
108
+ * An explicit timeout is a deliberate choice and wins everywhere. An
109
+ * inherited default does not, so endpoints that know they are slow (the
110
+ * model-backed agentic ones) can raise it without overriding a value the
111
+ * caller actually asked for.
112
+ */
113
+ timeoutWasExplicit: boolean;
92
114
  retryPolicy: RetryPolicy;
93
115
  logger: Logger;
94
116
  automaticIdempotency: boolean;
@@ -123,6 +145,18 @@ interface TransportRequestOptions {
123
145
  headers?: Record<string, string>;
124
146
  idempotencyKey?: string;
125
147
  signal?: AbortSignal;
148
+ /**
149
+ * Caller-supplied deadline (ms) for this one request. Beats everything —
150
+ * it is the most specific statement of intent available.
151
+ */
152
+ timeout?: number;
153
+ /**
154
+ * The deadline (ms) this ENDPOINT wants when nobody has said otherwise —
155
+ * how long its work actually takes. Used only when the caller passed no
156
+ * per-request timeout AND set no explicit client-wide one, so it can
157
+ * never override a deadline someone deliberately chose.
158
+ */
159
+ endpointTimeout?: number;
126
160
  }
127
161
  /**
128
162
  * HTTP transport with retry, auth, and idempotency support.
@@ -146,8 +180,26 @@ declare class Transport {
146
180
  * Add authentication header based on auth mode and path.
147
181
  */
148
182
  private addAuthHeader;
183
+ /**
184
+ * Resolve the deadline for one request, most specific intent first:
185
+ *
186
+ * 1. the caller's per-request `timeout`
187
+ * 2. an explicit client-wide `timeout`
188
+ * 3. the endpoint's own default (slow endpoints raise their own)
189
+ * 4. the client-wide default
190
+ *
191
+ * (2) sits above (3) on purpose: a caller who configured a timeout chose
192
+ * it, and an endpoint must not quietly overrule that. (3) exists so the
193
+ * far more common caller — the one who configured nothing — gets a
194
+ * deadline that matches what the endpoint actually does.
195
+ */
196
+ private resolveTimeout;
149
197
  /**
150
198
  * Execute request with exponential backoff retry.
199
+ *
200
+ * `timeout` is per ATTEMPT, not per call: each attempt gets its own
201
+ * deadline, so a request that keeps timing out can take up to
202
+ * `timeout × maxAttempts` before it throws.
151
203
  */
152
204
  private executeWithRetry;
153
205
  /**
@@ -506,6 +558,11 @@ type components = {
506
558
  readonly wallet_id?: string;
507
559
  readonly amount: string;
508
560
  readonly asset: string;
561
+ /**
562
+ * @description The chain THIS payment settles on. The network belongs to the payment, not to the payee: an address belongs to a whole family, so which chain a given payment uses is chosen when the payment is made. Optional — the destination's own network is used when omitted. When the destination pins a DIFFERENT one in the same family, this payment's network wins (the pin records what an earlier payment did, not a restriction on the address). Across chain FAMILIES the address does not carry at all, and that is refused.
563
+ * @example base-sepolia
564
+ */
565
+ readonly network_id?: string;
509
566
  readonly dates?: readonly number[];
510
567
  readonly count?: number;
511
568
  /** Format: int64 */
@@ -562,6 +619,11 @@ type components = {
562
619
  readonly source_network_id: components["schemas"]["NetworkId"];
563
620
  /** @description The asset the recipient receives (a currency such as USD for a bank offramp). */
564
621
  readonly output_asset: string;
622
+ /**
623
+ * @description The chain the PAYEE is paid on — the payout leg, and a different chain from `source_network_id` (the deposit the funding wallet pays). Crypto payouts only; a bank offramp has no chain. Optional: the destination's own network is used when omitted. When set it decides, because the network belongs to the payment and not to the payee — an address receives on every chain in its family, so a destination's saved network records what a previous payment did rather than restricting this one. Across chain FAMILIES the address does not carry at all, and that is refused.
624
+ * @example base-sepolia
625
+ */
626
+ readonly output_network_id?: string;
565
627
  /** @description Outbound rail — REQUIRED for a bank offramp (e.g. ach, fedwire, swift); omit for a crypto swap. */
566
628
  readonly rail?: string;
567
629
  /** @enum {string} */
@@ -572,9 +634,28 @@ type components = {
572
634
  */
573
635
  readonly fee_bps?: number;
574
636
  };
637
+ /**
638
+ * @description Your developer fee, declared per payout type. A conversion is charged the rate for the kind of payout it funds: `swap_bps` for a crypto payout, `offramp_bps` for a bank payout. Omit a rate, or send zero, and that payout type carries no fee at all — nothing is charged, nothing is added to the amount, and the agent is told nothing about a fee it could mention. The two are independent, so one conversation can charge a swap and stay silent about a bank payout in the same turn.
639
+ *
640
+ * Both rates are DEFAULTS for the auto-accounts a request creates. An action-level `fee_bps` is an explicit override and still wins outright, for either type.
641
+ */
642
+ readonly DeveloperFee: {
643
+ /**
644
+ * Format: int32
645
+ * @description Rate for a crypto payout — a `create_auto_account` naming no `rail`.
646
+ */
647
+ readonly swap_bps?: number;
648
+ /**
649
+ * Format: int32
650
+ * @description Rate for a bank payout — a `create_auto_account` naming a `rail`. An offramp converts too (it just settles on a rail instead of a chain), so charging it is a pricing decision that belongs to you. Zero or omitted means the payout is free of a conversion fee.
651
+ */
652
+ readonly offramp_bps?: number;
653
+ };
575
654
  readonly CreateInstructionsRequest: {
655
+ readonly client_policy?: components["schemas"]["AgenticClientPolicy"];
576
656
  readonly payment_agent_id: string;
577
657
  readonly proposals: readonly components["schemas"]["AgenticProposal"][];
658
+ readonly developer_fee?: components["schemas"]["DeveloperFee"];
578
659
  };
579
660
  readonly AgenticInstructionsResult: {
580
661
  /** @description Every mandate this batch DRAFTED, in full wire shape (identical to GET /mandates/{mandate_id}) — sign the §8 approval immediately, no follow-up fetch or polling. Pending until a signer other than the bound one approves. */
@@ -592,6 +673,87 @@ type components = {
592
673
  * @example America/Los_Angeles
593
674
  */
594
675
  readonly timezone?: string;
676
+ readonly client_policy?: components["schemas"]["AgenticClientPolicy"];
677
+ };
678
+ /**
679
+ * @description ALPHA — how THIS client's product speaks, and what the agent may propose for it. It reshapes what the drafting model SEES (tool results, tool descriptions, prompt sections) and constrains what it may PROPOSE, so the agent narrates in the client's own nouns instead of platform ones.
680
+ *
681
+ * SCOPE: this is a per-CLIENT policy — it belongs to the `client_id` behind the API key, never to a key (api keys are N:1 to clients, so a per-key policy would fragment for a client running one service key per deployment). REGISTER IT ONCE at `PUT /clients/{client_id}/agentic-policy`.
682
+ *
683
+ * DELIVERY: sent in a `POST .../proposals` body this object is a DEVELOPMENT OVERRIDE — it wins for that one turn and the server logs that it did. Prefer the registration: forgetting to send the body copy fails SILENTLY, and the agent simply starts narrating in platform's nouns again with no error anywhere. Resolution per request is: a non-empty body policy, else this client's registration, else nothing at all.
684
+ *
685
+ * STRICT: an unknown key, an unknown value, or a label for a concept the server does not implement is a 400 — "accepted" always means "enforced". Absent (or every field empty) ⇒ platform defaults, byte-for-byte the behaviour of a request that never mentioned it.
686
+ */
687
+ readonly AgenticClientPolicy: {
688
+ /**
689
+ * @description How payees are shaped in tool results. `nested` (the default, and what an absent policy means) returns ONE payee carrying N payout methods. `flat` returns one entry PER payout method — a payee is a name plus one way of being paid — each with `payee_ref` (the id to pass straight through wherever a payout method is referenced), `entity_ref` (the person behind the entry; several entries can share one, and it is what binds a new payout method to an existing person instead of duplicating them), `name`, and `paid_by` (a rendered human phrase such as `bank account at Chase ****4321` or `base-sepolia 0x1234…cdef`). A payout method never pins an asset, so `paid_by` never names one.
690
+ * @example flat
691
+ * @enum {string}
692
+ */
693
+ readonly payee_model?: "" | "nested" | "flat";
694
+ /**
695
+ * @description The assets a PAYEE may receive — what a conversion may output, and what a direct payment may send. Absent or empty means unrestricted, which is the platform default.
696
+ *
697
+ * State it when your product's FUNDING asset is not something a payee is ever paid in. Platform's asset registry only knows which assets settle on which chain, so it cannot tell that your funding stablecoin is a category error as a payout — it will happily draft one if a customer names it, and because that route needs no conversion account it also creates a duplicate payee for someone already saved. Declaring the allowlist turns both into a refusal the model sees before the customer does.
698
+ *
699
+ * Case-insensitive and de-duplicated; the order you send is the order quoted back to the customer.
700
+ * @example [
701
+ * "USDC",
702
+ * "USDT"
703
+ * ]
704
+ */
705
+ readonly payout_assets?: readonly string[];
706
+ /**
707
+ * @description Platform concept → the noun THIS client's customers use for it. The noun replaces the platform word in the tool results the agent reads AND in what it writes to the customer. Implemented concepts: `limit` (the spending limit; platform calls it a mandate), `payee` (the person being paid), and `limit_unit` (the UNIT the limit's amounts are quoted in, e.g. `USD`). Any other key is a 400 — a label for a concept the server does not implement would be accepted and then ignored.
708
+ *
709
+ * `limit` and `payee` are nouns and must match `^[a-z][a-z0-9 _-]{0,30}$`. `limit_unit` is a unit code and must match `^[A-Za-z][A-Za-z0-9]{0,9}$`, so it may be uppercase. Never a phrase, never a sentence.
710
+ *
711
+ * `limit_unit` matters most under a `payout_route` that forces a conversion account: the limit governs the DEPOSIT leg, so its own asset is the funding asset the customer has never heard of. With the unit set the agent quotes the caps and remaining budget in it ("your spending limit is 10 USD per month, 0.98 left") instead of reaching for the funding asset.
712
+ *
713
+ * Labelling `payee` also renames the flat view's keys: the container becomes the label plus `s` and each entry's ref becomes the label plus `_ref` — so `{"payee": "recipient"}` yields `recipients[]` with `recipient_ref`. `entity_ref` is NOT renamed; it is an opaque handle to the person behind the entry, not the labelled concept. The plural is a literal `+s` (the charset restricts labels to simple lowercase nouns), so an irregular noun gets an odd but harmless plural.
714
+ * @example {
715
+ * "limit": "spending limit",
716
+ * "limit_unit": "USD",
717
+ * "payee": "recipient"
718
+ * }
719
+ */
720
+ readonly labels?: {
721
+ readonly [key: string]: string;
722
+ };
723
+ /**
724
+ * @description `external_only`: spending limits live entirely OUTSIDE this conversation — the client creates and amends them in its own limit editor through the customer-signed amend API. The agent never drafts one; a drafted payment must fit an existing active limit's remaining budget, and when nothing covers it the agent says so and points the customer at the app instead of proposing a limit. Absent ⇒ the agent drafts limits as usual.
725
+ * @example external_only
726
+ * @enum {string}
727
+ */
728
+ readonly mandate_strategy?: "" | "external_only";
729
+ /**
730
+ * @description Restricts how the money may leave. `conversion_account_only`: every scheduled payment must fund a conversion account — no direct wallet-to-address send. `bank_only`: on top of that the payout must land in a bank account — an outbound bank rail is required and no crypto payout method may be created. Absent ⇒ any supported route.
731
+ *
732
+ * Either value also makes the FUNDING leg system-chosen, which changes two things. The payment has two legs and the customer only names one: what they ask for is what ARRIVES (the conversion's output), while what LEAVES the wallet is the conversion deposit. The spending limit governs the DEPOSIT leg, so (a) the asset or chain the customer names can never put a payment outside the limit — coverage is judged on the per-payment cap and the remaining budget alone — and (b) the deposit's asset and network move out of the limit's `rule` into a `funding_leg_internal` block in the `active_mandates` result, which the agent copies into the conversion account and never says out loud. Pair this with `labels.limit_unit` so the agent has a unit to quote the limit in.
733
+ * @example conversion_account_only
734
+ * @enum {string}
735
+ */
736
+ readonly payout_route?: "" | "conversion_account_only" | "bank_only";
737
+ } & {
738
+ readonly [key: string]: unknown;
739
+ };
740
+ /**
741
+ * @description A client's registered `client_policy` (ALPHA) with its registration timestamps.
742
+ *
743
+ * `policy` is the NORMALIZED form — what the server will actually apply, not an echo of what was sent. Values that mean "the default" are normalized away (`payee_model: nested` becomes absent, because an explicit nested and an absent policy have to be the same value rather than two values that merely behave alike today).
744
+ */
745
+ readonly RegisteredAgenticClientPolicy: {
746
+ readonly policy: components["schemas"]["AgenticClientPolicy"];
747
+ /**
748
+ * Format: int64
749
+ * @description Unix time this client first registered a policy.
750
+ */
751
+ readonly created_at?: number;
752
+ /**
753
+ * Format: int64
754
+ * @description Unix time the registration was last replaced.
755
+ */
756
+ readonly updated_at?: number;
595
757
  };
596
758
  readonly AgenticChatMessage: {
597
759
  /** @enum {string} */
@@ -645,12 +807,31 @@ type components = {
645
807
  */
646
808
  readonly updated_at?: number;
647
809
  };
810
+ /** @description One machine-actionable reason a drafting turn produced no proposals. Verified server-side before it is returned. */
811
+ readonly AgenticBlocker: {
812
+ /**
813
+ * @description `mandate_does_not_cover_payee` — a spending limit is in force but its rule does not reach the named payee. This is the ACTIONABLE one: the limit can be amended to ADD the payee as a target, which changes nothing else and so can never raise the limit; collect the customer's signature for that amendment and run the turn again. `no_mandate` — no active limit exists at all, so there is nothing to amend and the customer must establish one first. The two are kept distinct so a client never opens an amend flow against a limit that does not exist.
814
+ * @enum {string}
815
+ */
816
+ readonly code: "mandate_does_not_cover_payee" | "no_mandate";
817
+ readonly mandate_id?: components["schemas"]["KSUID"];
818
+ /** @description The payee the customer named, verbatim. A NAME and not an id, because in the case this exists for the payee does not exist yet — which is why nothing covers them. */
819
+ readonly payee_name?: string;
820
+ /** @description Short human-readable note. Advisory only — branch on `code`. */
821
+ readonly detail?: string;
822
+ };
648
823
  /** @description The agent's next step. At least one of `proposals` or `reply` is always present in a successful response — `proposals` at high confidence (optionally with a short `reply` note), or `reply` alone when the agent needs more from the user. */
649
824
  readonly AgenticProposalsResult: {
650
825
  /** @description Validated action-series proposals, ready to accept via POST /instructions. Present only at high confidence. */
651
826
  readonly proposals?: readonly components["schemas"]["AgenticProposal"][];
652
827
  /** @description The agent's conversational reply — a clarifying question or confirmation. Present without proposals when the agent needs more from the user; may accompany proposals as a short note. */
653
828
  readonly reply?: string;
829
+ /**
830
+ * @description ALPHA — machine-actionable reasons the agent could not complete the request, for the CLIENT APPLICATION rather than the customer. `reply` explains it in prose, which software cannot branch on: "extend the limit to cover Priya", "I need her bank details" and "that rail is not supported" all arrive as some text. A blocker names the reason as a stable code so the client can act on it — opening its own limit editor with the payee filled in, say — and only then decide what the customer sees.
831
+ * MAY ACCOMPANY PROPOSALS, and routinely does. The common case is a payee who does not exist yet: the turn proposes creating them AND reports that the limit will not reach them, because the client has to do both, in that order — accept the proposal so the payee has an id, then amend the limit to include it. Treat proposals and blockers as independent, never as alternatives.
832
+ * Absent when nothing blocked the turn. ALWAYS switch on `code` and ignore codes you do not know, as new ones are added over time. Every blocker returned has been re-checked against the server's own data, so a code never reflects only the model's opinion.
833
+ */
834
+ readonly blockers?: readonly components["schemas"]["AgenticBlocker"][];
654
835
  /**
655
836
  * @description How the boundary screen treated this turn. `ok` is a normal payments turn; `warned` means the request was off-topic and the customer was warned but may continue; `blocked` means the conversation has been terminated (repeated off-topic turns or a manipulation attempt) — the client should stop serving it and offer a fresh chat. `rejected_input` means this message was refused wholesale (e.g. more payees than one conversation supports) and should NOT be added to the conversation history — the reply explains what to resend; the conversation itself continues unaffected.
656
837
  * @enum {string}
@@ -1942,15 +2123,41 @@ type components = {
1942
2123
  readonly developer_fee_bps?: number;
1943
2124
  /**
1944
2125
  * Format: int32
1945
- * @description Caps how many sweeps this account performs before it stops
1946
- * converting. A sweep is one convert-and-forward of funds received at
1947
- * the account through to its destination, so `1` makes the account a
1948
- * one-off — the deposit details self-disable after a single sweep —
1949
- * and `N` lets one account serve exactly N sweeps.
2126
+ * @description Hard cap on how many transactions this account may ever create. A
2127
+ * transaction is one convert-and-forward of funds received at the
2128
+ * account through to its destination, so `1` makes the account a
2129
+ * one-off and `N` lets one account serve N payments.
1950
2130
  *
1951
2131
  * Omit for the default, which is unchanged: the account is uncapped
1952
2132
  * and keeps sweeping every deposit indefinitely (a durable, standing
1953
2133
  * account).
2134
+ *
2135
+ * **Reaching the cap refuses further deposits; it does not turn the
2136
+ * deposit details off.** Once the cap is used up:
2137
+ *
2138
+ * - Deposits sent to the account are **refused**. They are *not*
2139
+ * returned to the sender — the funds still arrive and are then held
2140
+ * pending manual intervention. Nothing is converted, nothing is
2141
+ * forwarded, and no transaction appears on the account for them. Stop
2142
+ * sending to the deposit details once the cap is reached.
2143
+ * - The account is closed and stops serving new payments.
2144
+ * - This is **not recoverable through this API**. `max_transactions` is
2145
+ * immutable — it cannot be raised, and a closed account cannot be
2146
+ * reopened — so a capped-out account is finished. Create a new
2147
+ * account (with new deposit details) to keep receiving.
2148
+ *
2149
+ * **A slot is consumed by any transaction in flight or delivered, not
2150
+ * only a successful one.** A slot is released only when a transaction
2151
+ * ends with the value *not* staying with the recipient: canceled,
2152
+ * rejected, reversed, or refunded. A failed or returned transaction
2153
+ * keeps its slot, because its funds are still held and it can still be
2154
+ * retried, until it is refunded. Size the cap against the number of
2155
+ * deposits you expect, not the number of successes you need. Releasing
2156
+ * a slot does not reopen a closed account.
2157
+ *
2158
+ * The cap is checked as each deposit arrives, so deposits that race
2159
+ * each other can briefly overshoot `N`; the account closes on the next
2160
+ * one.
1954
2161
  * @example 1
1955
2162
  */
1956
2163
  readonly max_transactions?: number;
@@ -21627,6 +21834,173 @@ interface operations {
21627
21834
  };
21628
21835
  };
21629
21836
  };
21837
+ readonly getClientAgenticPolicy: {
21838
+ readonly parameters: {
21839
+ readonly query?: never;
21840
+ readonly header?: never;
21841
+ readonly path: {
21842
+ readonly client_id: components["schemas"]["KSUID"];
21843
+ };
21844
+ readonly cookie?: never;
21845
+ };
21846
+ readonly requestBody?: never;
21847
+ readonly responses: {
21848
+ /** @description The client's registered agentic policy, normalized. */
21849
+ readonly 200: {
21850
+ headers: {
21851
+ readonly [name: string]: unknown;
21852
+ };
21853
+ content: {
21854
+ /**
21855
+ * @example {
21856
+ * "policy": {
21857
+ * "payee_model": "flat",
21858
+ * "mandate_strategy": "external_only",
21859
+ * "payout_route": "bank_only",
21860
+ * "labels": {
21861
+ * "limit": "spending limit",
21862
+ * "limit_unit": "USD",
21863
+ * "payee": "recipient"
21864
+ * }
21865
+ * },
21866
+ * "created_at": 1761600000,
21867
+ * "updated_at": 1761686400
21868
+ * }
21869
+ */
21870
+ readonly "application/json": components["schemas"]["RegisteredAgenticClientPolicy"];
21871
+ };
21872
+ };
21873
+ /** @description Bad Request */
21874
+ readonly 400: {
21875
+ headers: {
21876
+ readonly [name: string]: unknown;
21877
+ };
21878
+ content: {
21879
+ readonly "application/problem+json": components["schemas"]["ProblemDetails"];
21880
+ };
21881
+ };
21882
+ /** @description Unauthorized */
21883
+ readonly 401: {
21884
+ headers: {
21885
+ readonly [name: string]: unknown;
21886
+ };
21887
+ content: {
21888
+ readonly "application/problem+json": components["schemas"]["ProblemDetails"];
21889
+ };
21890
+ };
21891
+ /** @description Forbidden */
21892
+ readonly 403: {
21893
+ headers: {
21894
+ readonly [name: string]: unknown;
21895
+ };
21896
+ content: {
21897
+ readonly "application/problem+json": components["schemas"]["ProblemDetails"];
21898
+ };
21899
+ };
21900
+ /** @description This client has no registered policy. */
21901
+ readonly 404: {
21902
+ headers: {
21903
+ readonly [name: string]: unknown;
21904
+ };
21905
+ content: {
21906
+ readonly "application/problem+json": components["schemas"]["ProblemDetails"];
21907
+ };
21908
+ };
21909
+ };
21910
+ };
21911
+ readonly updateClientAgenticPolicy: {
21912
+ readonly parameters: {
21913
+ readonly query?: never;
21914
+ readonly header: {
21915
+ /** @description Unique key to ensure request idempotency. If the same key is used within a certain time window, the original response will be returned instead of executing the request again. */
21916
+ readonly "x-idempotency-key": components["parameters"]["IdempotencyKeyHeader"];
21917
+ };
21918
+ readonly path: {
21919
+ readonly client_id: components["schemas"]["KSUID"];
21920
+ };
21921
+ readonly cookie?: never;
21922
+ };
21923
+ readonly requestBody: {
21924
+ readonly content: {
21925
+ /**
21926
+ * @example {
21927
+ * "payee_model": "flat",
21928
+ * "mandate_strategy": "external_only",
21929
+ * "payout_route": "bank_only",
21930
+ * "labels": {
21931
+ * "limit": "spending limit",
21932
+ * "limit_unit": "USD",
21933
+ * "payee": "recipient"
21934
+ * }
21935
+ * }
21936
+ */
21937
+ readonly "application/json": components["schemas"]["AgenticClientPolicy"];
21938
+ };
21939
+ };
21940
+ readonly responses: {
21941
+ /** @description The registered policy, normalized as it will be applied. */
21942
+ readonly 200: {
21943
+ headers: {
21944
+ readonly [name: string]: unknown;
21945
+ };
21946
+ content: {
21947
+ /**
21948
+ * @example {
21949
+ * "policy": {
21950
+ * "payee_model": "flat",
21951
+ * "mandate_strategy": "external_only",
21952
+ * "payout_route": "bank_only",
21953
+ * "labels": {
21954
+ * "limit": "spending limit",
21955
+ * "limit_unit": "USD",
21956
+ * "payee": "recipient"
21957
+ * }
21958
+ * },
21959
+ * "created_at": 1761600000,
21960
+ * "updated_at": 1761686400
21961
+ * }
21962
+ */
21963
+ readonly "application/json": components["schemas"]["RegisteredAgenticClientPolicy"];
21964
+ };
21965
+ };
21966
+ /** @description The policy is not one this server can enforce — an unknown key, an unsupported value, or a label for an unimplemented concept. */
21967
+ readonly 400: {
21968
+ headers: {
21969
+ readonly [name: string]: unknown;
21970
+ };
21971
+ content: {
21972
+ readonly "application/problem+json": components["schemas"]["ProblemDetails"];
21973
+ };
21974
+ };
21975
+ /** @description Unauthorized */
21976
+ readonly 401: {
21977
+ headers: {
21978
+ readonly [name: string]: unknown;
21979
+ };
21980
+ content: {
21981
+ readonly "application/problem+json": components["schemas"]["ProblemDetails"];
21982
+ };
21983
+ };
21984
+ /** @description Forbidden */
21985
+ readonly 403: {
21986
+ headers: {
21987
+ readonly [name: string]: unknown;
21988
+ };
21989
+ content: {
21990
+ readonly "application/problem+json": components["schemas"]["ProblemDetails"];
21991
+ };
21992
+ };
21993
+ /** @description Not Found */
21994
+ readonly 404: {
21995
+ headers: {
21996
+ readonly [name: string]: unknown;
21997
+ };
21998
+ content: {
21999
+ readonly "application/problem+json": components["schemas"]["ProblemDetails"];
22000
+ };
22001
+ };
22002
+ };
22003
+ };
21630
22004
  readonly getPaymentAgent: {
21631
22005
  readonly parameters: {
21632
22006
  readonly query?: never;
@@ -24098,6 +24472,18 @@ interface RequestOptions {
24098
24472
  * - Not reused across different business intents
24099
24473
  */
24100
24474
  idempotencyKey?: string;
24475
+ /**
24476
+ * Deadline for THIS request, in milliseconds.
24477
+ *
24478
+ * Overrides the client-wide `timeout` (and any endpoint default) for this
24479
+ * call only — so one slow operation does not force you to loosen the
24480
+ * deadline on every fast one, or to build a second client that differs by
24481
+ * a single number.
24482
+ *
24483
+ * Per ATTEMPT, not per call: a request that keeps timing out is retried
24484
+ * per `retryPolicy`, so budget roughly `timeout × maxAttempts`.
24485
+ */
24486
+ timeout?: number;
24101
24487
  /**
24102
24488
  * Endorsed-request envelope (`{ signatures, intent }`) for mutating
24103
24489
  * policy, signer-group, and wallet-transaction endpoints. Required by the
@@ -24204,6 +24590,46 @@ type MandateBudget = components['schemas']['MandateBudget'];
24204
24590
  type MandateBudgetLine = components['schemas']['MandateBudgetLine'];
24205
24591
  /** Live snapshot of an in-flight proposal-drafting turn (advisory display only). */
24206
24592
  type AgenticProposalsProgress = components['schemas']['AgenticProposalsProgress'];
24593
+ /**
24594
+ * One machine-actionable reason a drafting turn could not complete — for the
24595
+ * CLIENT APPLICATION, not the customer.
24596
+ *
24597
+ * `reply` explains the same thing in prose, which software cannot branch on.
24598
+ * Always switch on `code` and IGNORE codes you do not recognize: new ones are
24599
+ * added over time.
24600
+ */
24601
+ type AgenticBlocker = components['schemas']['AgenticBlocker'];
24602
+ /** The stable `code` of an {@link AgenticBlocker}. Treat as an OPEN set. */
24603
+ type AgenticBlockerCode = NonNullable<AgenticBlocker['code']>;
24604
+ /**
24605
+ * How THIS client's product speaks, and what the agent may propose for it.
24606
+ *
24607
+ * Reshapes what the drafting model sees and constrains what it may propose,
24608
+ * so the agent narrates in your nouns instead of the platform's. Register it
24609
+ * ONCE via `client.agenticPolicy.set(clientId, policy)`; sending it per
24610
+ * request is a development override that wins for that turn only.
24611
+ *
24612
+ * STRICT — an unknown key, an unknown value, or a label for a concept the
24613
+ * server does not implement is a 400, so "accepted" always means "enforced".
24614
+ */
24615
+ type AgenticClientPolicy = components['schemas']['AgenticClientPolicy'];
24616
+ /**
24617
+ * A client's registered policy plus its registration timestamps.
24618
+ *
24619
+ * `policy` is the NORMALIZED form — what the server will actually apply, not
24620
+ * an echo of what was sent (values meaning "the default" are normalized away).
24621
+ */
24622
+ type RegisteredAgenticClientPolicy = components['schemas']['RegisteredAgenticClientPolicy'];
24623
+ /**
24624
+ * Your developer fee, declared per payout type: `swap_bps` for a crypto
24625
+ * payout, `offramp_bps` for a bank payout.
24626
+ *
24627
+ * The two are independent — omit one (or send zero) and that payout type
24628
+ * carries no fee at all, and the agent is told nothing about a fee it could
24629
+ * mention. Both are DEFAULTS for the auto-accounts a request creates; an
24630
+ * action-level `fee_bps` still wins outright.
24631
+ */
24632
+ type DeveloperFee = components['schemas']['DeveloperFee'];
24207
24633
  /** A scheduled payment — bookkeeping row created by accepting an instruction. */
24208
24634
  type ScheduledPayment = components['schemas']['ScheduledPaymentResponse'];
24209
24635
  /** Request body for POST /scheduled-payments — direct (signer-first) schedule create. */
@@ -24728,6 +25154,14 @@ declare class AccountsResource extends BaseResource {
24728
25154
  * });
24729
25155
  * // Returns: { bank_account: { bank_name, aba_routing_number, account_number } } - customer sends USD here
24730
25156
  * ```
25157
+ *
25158
+ * @remarks
25159
+ * `max_transactions` caps how many transactions the account may ever
25160
+ * create — `1` makes it a one-off. Know what reaching the cap does before
25161
+ * you set one: further deposits are **refused, not returned**. The funds
25162
+ * still arrive and are then held pending manual intervention, with nothing
25163
+ * converted, nothing forwarded, and no transaction on the account for
25164
+ * them. Stop sending to the deposit details once the cap is reached.
24731
25165
  */
24732
25166
  create(data: AccountCreateRequest, options?: RequestOptions): Promise<Account>;
24733
25167
  /**
@@ -26120,6 +26554,21 @@ declare class PaymentAgentsResource extends BaseResource {
26120
26554
  * `AgentConversation` for multi-turn chat; use this directly only for
26121
26555
  * one-shot proposals.
26122
26556
  *
26557
+ * SLOW BY NATURE. A turn is a sequence of model calls — read the payees,
26558
+ * check balances, draft, revise — so a multi-payee request legitimately
26559
+ * runs minutes. It therefore defaults to {@link AGENTIC_MODEL_TIMEOUT_MS}
26560
+ * rather than the client's ordinary deadline. Pass `{ timeout }` to
26561
+ * change it for one call; an explicit client-wide `timeout` still wins.
26562
+ *
26563
+ * The result may carry `blockers` ALONGSIDE proposals — they are not
26564
+ * alternatives. Branch on `blocker.code`, not on `reply`, and ignore codes
26565
+ * you do not recognize.
26566
+ *
26567
+ * `data.client_policy` is a DEVELOPMENT override of the vocabulary the
26568
+ * agent drafts under; prefer registering it once with
26569
+ * `client.agenticPolicy.set()`, since forgetting to send it here fails
26570
+ * silently.
26571
+ *
26123
26572
  * @param paymentAgentId - Payment agent ID
26124
26573
  * @param data - Prompt and/or messages
26125
26574
  * @returns Proposals (at high confidence) and/or a conversational reply
@@ -26174,6 +26623,19 @@ declare class InstructionsResource extends BaseResource {
26174
26623
  /**
26175
26624
  * Accept proposals — actuate them into persisted instructions.
26176
26625
  *
26626
+ * Two optional fields shape the actuation:
26627
+ *
26628
+ * - `developer_fee` declares your fee PER PAYOUT TYPE — `swap_bps` for a
26629
+ * crypto payout, `offramp_bps` for a bank payout. They are independent,
26630
+ * so one conversation can charge a swap and stay silent about a bank
26631
+ * payout in the same turn. Omit a rate (or send zero) and that payout
26632
+ * type carries no fee: nothing is charged, nothing is added to the
26633
+ * amount, and the agent is told nothing about a fee it could mention.
26634
+ * Both are DEFAULTS for the auto-accounts this request creates — an
26635
+ * action-level `fee_bps` still wins outright.
26636
+ * - `client_policy` is the same development override the proposals call
26637
+ * takes. Prefer registering it once with `client.agenticPolicy.set()`.
26638
+ *
26177
26639
  * @param data - The payment agent id and the proposals to accept
26178
26640
  * @returns instruction_ids + the mandates the batch drafted (in full
26179
26641
  * wire shape; sign the §8 approval immediately)
@@ -26417,6 +26879,10 @@ declare class InsightsResource extends BaseResource {
26417
26879
  * never moves money. Rate-limited per customer (hourly burst + daily
26418
26880
  * window) — a 429 means back off and retry later.
26419
26881
  *
26882
+ * Model-backed, so it defaults to {@link AGENTIC_MODEL_TIMEOUT_MS} rather
26883
+ * than the client's ordinary deadline. Pass `{ timeout }` to change it for
26884
+ * one call; an explicit client-wide `timeout` still wins.
26885
+ *
26420
26886
  * @param customerId - Customer ID
26421
26887
  * @param data - The conversation so far (1–40 messages)
26422
26888
  * @returns The assistant's reply (+ how the boundary screen treated the turn)
@@ -26424,6 +26890,82 @@ declare class InsightsResource extends BaseResource {
26424
26890
  chat(customerId: string, data: InsightChatRequest, options?: RequestOptions): Promise<InsightChatResponse>;
26425
26891
  }
26426
26892
 
26893
+ /**
26894
+ * Agentic Client Policy resource (ALPHA).
26895
+ *
26896
+ * Agentic payments is an alpha surface (x-alpha, flag-gated on the platform)
26897
+ * and may change without a major-version bump.
26898
+ */
26899
+
26900
+ /**
26901
+ * Agentic Client Policy API resource (ALPHA).
26902
+ *
26903
+ * The policy is per CLIENT — it belongs to the `client_id` behind your API
26904
+ * key, never to a key, since API keys are N:1 to clients and a per-key policy
26905
+ * would fragment for anyone running one service key per deployment.
26906
+ *
26907
+ * You may read and write your OWN policy; another client's is a 403.
26908
+ */
26909
+ declare class AgenticPolicyResource extends BaseResource {
26910
+ /**
26911
+ * Get the policy registered for this client.
26912
+ *
26913
+ * A 404 here is the DEFAULT, not an error condition: with no registration
26914
+ * and no per-request policy the agent drafts on platform defaults, exactly
26915
+ * as it did before registration existed.
26916
+ *
26917
+ * @param clientId - Your client ID
26918
+ * @returns The normalized registered policy + its timestamps
26919
+ *
26920
+ * @example
26921
+ * ```typescript
26922
+ * try {
26923
+ * const { policy } = await client.agenticPolicy.get(clientId);
26924
+ * console.log(policy.labels);
26925
+ * } catch (e) {
26926
+ * if (e instanceof APIError && e.statusCode === 404) {
26927
+ * // No registration — platform defaults apply.
26928
+ * }
26929
+ * }
26930
+ * ```
26931
+ */
26932
+ get(clientId: string): Promise<RegisteredAgenticClientPolicy>;
26933
+ /**
26934
+ * Register — or fully replace — this client's agentic policy.
26935
+ *
26936
+ * Declaring the vocabulary once removes a silent failure mode. Sending
26937
+ * `client_policy` in each proposals request still works and still wins, but
26938
+ * FORGETTING to send it fails silently: the agent just narrates in the
26939
+ * platform's nouns again ("destination", "mandate") and nothing errors
26940
+ * anywhere. A registration makes that impossible.
26941
+ *
26942
+ * FULL REPLACE, not a merge — the registration IS your declared vocabulary,
26943
+ * so an omitted field means you no longer want it, and an empty body (`{}`)
26944
+ * clears the registration back to platform defaults.
26945
+ *
26946
+ * Validated exactly like the per-request copy, so an unknown key, an
26947
+ * unsupported value, or a label for an unimplemented concept is a 400 HERE,
26948
+ * at registration — not a surprise on a customer's first conversation.
26949
+ *
26950
+ * @param clientId - Your client ID
26951
+ * @param policy - The complete policy (`{}` clears it)
26952
+ * @param options - Request options (e.g., custom idempotency key)
26953
+ * @returns The normalized stored policy + its timestamps
26954
+ *
26955
+ * @example
26956
+ * ```typescript
26957
+ * await client.agenticPolicy.set(clientId, {
26958
+ * payee_model: 'flat',
26959
+ * payout_assets: ['USDC', 'USDT'],
26960
+ * labels: { limit: 'spending limit', payee: 'recipient', limit_unit: 'USD' },
26961
+ * payout_route: 'conversion_account_only',
26962
+ * mandate_strategy: 'external_only',
26963
+ * });
26964
+ * ```
26965
+ */
26966
+ set(clientId: string, policy: AgenticClientPolicy, options?: RequestOptions): Promise<RegisteredAgenticClientPolicy>;
26967
+ }
26968
+
26427
26969
  /**
26428
26970
  * Multi-turn agent chat. The platform's proposals endpoint is STATELESS —
26429
26971
  * it holds no session and must be sent the whole transcript on every turn.
@@ -26479,6 +27021,26 @@ interface ConversationTurn {
26479
27021
  proposals: AgenticProposal[];
26480
27022
  /** Whether the agent drafted proposals this turn. */
26481
27023
  hasProposals: boolean;
27024
+ /**
27025
+ * Machine-actionable reasons the turn could not complete — for YOUR
27026
+ * application, not the customer. `reply` says the same thing in prose,
27027
+ * which software cannot branch on: "extend the limit to cover Priya",
27028
+ * "I need her bank details" and "that rail is not supported" all arrive
27029
+ * as some text.
27030
+ *
27031
+ * These ACCOMPANY proposals rather than replacing them, and routinely do.
27032
+ * The common case is a payee who does not exist yet: the turn proposes
27033
+ * creating them AND reports that the limit will not reach them, because
27034
+ * you have to do both, in that order — accept the proposal so the payee
27035
+ * has an id, then amend the limit to include it. Never treat proposals
27036
+ * and blockers as alternatives.
27037
+ *
27038
+ * Empty when nothing blocked the turn. Always switch on `code` and ignore
27039
+ * codes you do not know; new ones are added over time.
27040
+ */
27041
+ blockers: AgenticBlocker[];
27042
+ /** Whether the turn reported any blocker. */
27043
+ hasBlockers: boolean;
26482
27044
  /**
26483
27045
  * The boundary screen's verdict for this turn: `"ok"` (normal), `"warned"`
26484
27046
  * (off-topic — the customer was warned), or `"blocked"` (the chat is
@@ -26503,6 +27065,33 @@ interface AgentConversationOptions {
26503
27065
  * DST transition before a far-future fire date shifts it by the DST delta.
26504
27066
  */
26505
27067
  timezone?: string;
27068
+ /**
27069
+ * Deadline (ms) for each turn of this conversation.
27070
+ *
27071
+ * Turns default to {@link AGENTIC_MODEL_TIMEOUT_MS}, which is sized for a
27072
+ * multi-payee drafting turn. Set this when your own turns are longer (a
27073
+ * very large payee list) or shorter (you would rather show the customer a
27074
+ * failure than keep them waiting).
27075
+ *
27076
+ * Required if the client was built with an explicit `timeout`: that
27077
+ * choice wins over the endpoint default, so a client configured with a
27078
+ * short global deadline will cut turns off unless you raise it here.
27079
+ */
27080
+ timeout?: number;
27081
+ /**
27082
+ * Per-turn `client_policy` override — the vocabulary and payout
27083
+ * constraints the agent drafts under.
27084
+ *
27085
+ * This is a DEVELOPMENT override. It wins for the turns of this
27086
+ * conversation and the server logs that it did. For production, register
27087
+ * the policy once with `client.agenticPolicy.set(clientId, policy)`
27088
+ * instead: forgetting to pass it here fails SILENTLY — the agent simply
27089
+ * narrates in the platform's nouns again, with no error anywhere.
27090
+ *
27091
+ * Resolution per request is: a non-empty policy here, else the client's
27092
+ * registration, else platform defaults.
27093
+ */
27094
+ clientPolicy?: AgenticClientPolicy;
26506
27095
  }
26507
27096
  /**
26508
27097
  * A stateful, multi-turn proposals chat with one agent.
@@ -26520,6 +27109,8 @@ declare class AgentConversation {
26520
27109
  private readonly client;
26521
27110
  private readonly paymentAgentId;
26522
27111
  private readonly timezone?;
27112
+ private readonly timeout?;
27113
+ private readonly clientPolicy?;
26523
27114
  private history;
26524
27115
  constructor(client: DakotaClient, paymentAgentId: string, history?: ChatMessage[], options?: AgentConversationOptions);
26525
27116
  /**
@@ -26630,6 +27221,8 @@ declare class DakotaClient {
26630
27221
  readonly scheduledPayments: ScheduledPaymentsResource;
26631
27222
  /** Insights API (ALPHA) - read-only advisory reporting over agentic activity */
26632
27223
  readonly insights: InsightsResource;
27224
+ /** Agentic Policy API (ALPHA) - register the vocabulary the agent speaks for your product */
27225
+ readonly agenticPolicy: AgenticPolicyResource;
26633
27226
  /**
26634
27227
  * Create a new Dakota client.
26635
27228
  *
@@ -27050,4 +27643,4 @@ declare function verifyMandateSignature(publicKeyBase64: string, payload: Uint8A
27050
27643
  */
27051
27644
  declare function canonicalJSON(value: unknown): string;
27052
27645
 
27053
- export { APIError, type Account, type AccountCreateRequest, type AccountListParams, type AccountUpdateRequest, AccountsResource, type Address, type AdvanceSimulationRequest, type AdvanceSimulationResult, AgentConversation, type AgentConversationOptions, type AgenticAction, type AgenticActionDownstream, type AgenticInstruction, type AgenticInstructionsResult, type AgenticProposal, type AgenticProposalsProgress, type AgenticProposalsResult, type AmendMandateRequest, type ApiKey, type ApiKeyCreateRequest, type ApiKeyResponse, ApiKeysResource, type Application, type ApplicationDocumentType, type ApplicationDocumentUploadRequest, type ApplicationDocumentUploadUrlRequest, type ApplicationListItem, type ApplicationStatus, type ApplicationSubmissionRequest, ApplicationsResource, type ApproveMandateRequest, type AssociatedIndividual, type AssociatedIndividualRequest, type AttachedPolicy, type AttachedWallet, type Attachment, type AttachmentMediaType, type AttestationSubmitRequest, type AttestationType, AuthMode, type AutoTransaction, AutoTransactionsResource, type AverageMonthlyRevenue, type BulkImportSumsubTokensRequest, type BulkImportSumsubTokensResponse, type BulkImportSumsubTokensResult, type BusinessApplicationCreateRequest, type BusinessDetailsResponse, type BusinessPurposeOfAccount, type BusinessSourceOfFunds, type CancelMandateRequest, type Capability, type CapabilityRequirement, type ChatMessage, type ClientPricingConfig, ConfigurationError, type ConversationTurn, type Country, type CreateApiKeyForClientRequest, type CreateInstructionsRequest, type CreateMandateRequest, type CreateProposalsRequest, type CreateScheduledPaymentRequest, type CryptoDestination, type CryptoDestinationRequest, type CursorExtractor, type Customer, type CustomerCapabilities, type CustomerCreateRequest, type CustomerCreateResponse, type CustomerListParams, type CustomerReEngagementResponse, CustomersResource, DEFAULT_RETRY_POLICY, DakotaClient, type DakotaClientConfig, type Destination, type DestinationCreateResponse, type DestinationRequest, DestinationsResource, type DocumentUploadResponse, type DocumentUploadUrlResponse, type EDDRequest, type EDDWithApplicationID, type EmploymentStatus, type EndorsedRequest, Environment, type Event, type EventListParams, type EventType, EventsResource, type ExpectedMonthlyDeposit, type Family, type FeePayoutDestination, FeePayoutDestinationResource, type FiatUSDestination, type FiatUSDestinationRequest, type ImportPersonaTokensRequest, type ImportPersonaTokensResponse, type IndividualDetailsResponse, type IndividualDocumentType, type IndividualDocumentUploadRequest, type IndividualDocumentUploadUrlRequest, type IndividualRequest, type IndividualRole, type IndividualTitle, InfoResource, type InsightChatMessage, type InsightChatRequest, type InsightChatResponse, type InsightEvidence, type InsightItem, type InsightReport, type InsightSnapshot, InsightsResource, InstructionsResource, type KSUID, type KybStatus, type LegalStructure, type ListParams, type Logger, type Mandate, type MandateAction, type MandateBudget, type MandateBudgetLine, type MandateListParams, type MandateResponse, type MandateRule, type MandateSigner, type MandateVersion, MandatesResource, type Meta, type Network, type NetworkId, type OfframpAccount, type OfframpAccountCreateRequest, type OneOffTransaction, type OneOffTransactionRequest, type OnrampAccount, type OnrampAccountCreateRequest, P256MandateSigner, type PageFetcher, PaginatedIterator, type PaginatedResponse, type PaginationMeta, type PaginationParams, type PaymentAgent, type PaymentAgentCreateRequest, type PaymentAgentSignerGroupRef, PaymentAgentsResource, type PaymentCapability, type PersonName, type PersonaImportJob, type PersonaImportJobListParams, type PersonaImportJobParams, type PersonaImportJobSummary, type PersonaImportJobsPage, type PersonaImportRowResult, PoliciesResource, type Policy, type PolicyCreateRequest, type PolicyRule, type PolicyRuleCreateRequest, type PutFeePayoutDestinationRequest, type Recipient, type RecipientRequest, type RecipientUpdateRequest, RecipientsResource, type RequestOptions, type ResolvedConfig, type RetryPolicy, SandboxResource, type SandboxScenario, type ScheduledPayment, type ScheduledPaymentListParams, ScheduledPaymentsResource, type SelfServeCreditTier, type SelfServeCreditTiersResponse, type SelfServeCreditsBalanceResponse, type SelfServeCreditsLedgerEntry, type SelfServeCreditsLedgerEntryType, type SelfServeCreditsLedgerParams, type SelfServeCreditsLedgerResponse, type SelfServeCreditsPricingResponse, type SelfServeCreditsPurchaseRequest, type SelfServeCreditsPurchaseResponse, SelfServeResource, type SendTransactionIntent, type Signer, type SignerCreateRequest, type SignerGroup, type SignerGroupCreateRequest, type SignerGroupGetParams, type SignerGroupSignerAddRequest, SignerGroupsResource, SignersResource, type SimulateInboundRequest, type SimulateInboundType, type SimulateOnboardingRequest, type SimulateOnboardingResponse, type SimulateOnboardingType, type SimulationCallbackRecord, type SimulationInspection, type SimulationResponse, type SubClientSummary, type SwapAccount, type SwapAccountCreateRequest, type TransactionListParams, type TransactionStatus, TransactionsResource, TransportError, type UpdateCustomerSubClientRequest, type UploadedDocumentMetadata, type UsdcWalletPayoutDestination, type User, type UserCreateRequest, type UserUpdateRequest, UsersResource, type Wallet, type WalletBalance, type WalletBalances, type WalletCreateRequest, type WalletTransaction, type WalletTransactionRequest, WalletsResource, type WebhookEvent, type WebhookHistoryList, type WebhookHistoryListParams, type WebhookHistoryResponse, type WebhookReplayResponse, type WebhookTarget, type WebhookTargetCreateRequest, type WebhookTargetUpdateRequest, WebhooksResource, addPolicyRulePayload, attachGroupPayload, attachPolicyPayload, attachUserToWallet, canonicalJSON, consoleLogger, deletePolicyPayload, detachGroupPayload, detachPolicyPayload, detachUserFromWallet, getEnvironmentURL, mandateAmendSignPayload, mandateSignPayload, noopLogger, paginate, removePolicyRulePayload, updatePolicyRulePayload, verifyMandateSignature };
27646
+ export { APIError, type Account, type AccountCreateRequest, type AccountListParams, type AccountUpdateRequest, AccountsResource, type Address, type AdvanceSimulationRequest, type AdvanceSimulationResult, AgentConversation, type AgentConversationOptions, type AgenticAction, type AgenticActionDownstream, type AgenticBlocker, type AgenticBlockerCode, type AgenticClientPolicy, type AgenticInstruction, type AgenticInstructionsResult, AgenticPolicyResource, type AgenticProposal, type AgenticProposalsProgress, type AgenticProposalsResult, type AmendMandateRequest, type ApiKey, type ApiKeyCreateRequest, type ApiKeyResponse, ApiKeysResource, type Application, type ApplicationDocumentType, type ApplicationDocumentUploadRequest, type ApplicationDocumentUploadUrlRequest, type ApplicationListItem, type ApplicationStatus, type ApplicationSubmissionRequest, ApplicationsResource, type ApproveMandateRequest, type AssociatedIndividual, type AssociatedIndividualRequest, type AttachedPolicy, type AttachedWallet, type Attachment, type AttachmentMediaType, type AttestationSubmitRequest, type AttestationType, AuthMode, type AutoTransaction, AutoTransactionsResource, type AverageMonthlyRevenue, type BulkImportSumsubTokensRequest, type BulkImportSumsubTokensResponse, type BulkImportSumsubTokensResult, type BusinessApplicationCreateRequest, type BusinessDetailsResponse, type BusinessPurposeOfAccount, type BusinessSourceOfFunds, type CancelMandateRequest, type Capability, type CapabilityRequirement, type ChatMessage, type ClientPricingConfig, ConfigurationError, type ConversationTurn, type Country, type CreateApiKeyForClientRequest, type CreateInstructionsRequest, type CreateMandateRequest, type CreateProposalsRequest, type CreateScheduledPaymentRequest, type CryptoDestination, type CryptoDestinationRequest, type CursorExtractor, type Customer, type CustomerCapabilities, type CustomerCreateRequest, type CustomerCreateResponse, type CustomerListParams, type CustomerReEngagementResponse, CustomersResource, DEFAULT_RETRY_POLICY, DakotaClient, type DakotaClientConfig, type Destination, type DestinationCreateResponse, type DestinationRequest, DestinationsResource, type DeveloperFee, type DocumentUploadResponse, type DocumentUploadUrlResponse, type EDDRequest, type EDDWithApplicationID, type EmploymentStatus, type EndorsedRequest, Environment, type Event, type EventListParams, type EventType, EventsResource, type ExpectedMonthlyDeposit, type Family, type FeePayoutDestination, FeePayoutDestinationResource, type FiatUSDestination, type FiatUSDestinationRequest, type ImportPersonaTokensRequest, type ImportPersonaTokensResponse, type IndividualDetailsResponse, type IndividualDocumentType, type IndividualDocumentUploadRequest, type IndividualDocumentUploadUrlRequest, type IndividualRequest, type IndividualRole, type IndividualTitle, InfoResource, type InsightChatMessage, type InsightChatRequest, type InsightChatResponse, type InsightEvidence, type InsightItem, type InsightReport, type InsightSnapshot, InsightsResource, InstructionsResource, type KSUID, type KybStatus, type LegalStructure, type ListParams, type Logger, type Mandate, type MandateAction, type MandateBudget, type MandateBudgetLine, type MandateListParams, type MandateResponse, type MandateRule, type MandateSigner, type MandateVersion, MandatesResource, type Meta, type Network, type NetworkId, type OfframpAccount, type OfframpAccountCreateRequest, type OneOffTransaction, type OneOffTransactionRequest, type OnrampAccount, type OnrampAccountCreateRequest, P256MandateSigner, type PageFetcher, PaginatedIterator, type PaginatedResponse, type PaginationMeta, type PaginationParams, type PaymentAgent, type PaymentAgentCreateRequest, type PaymentAgentSignerGroupRef, PaymentAgentsResource, type PaymentCapability, type PersonName, type PersonaImportJob, type PersonaImportJobListParams, type PersonaImportJobParams, type PersonaImportJobSummary, type PersonaImportJobsPage, type PersonaImportRowResult, PoliciesResource, type Policy, type PolicyCreateRequest, type PolicyRule, type PolicyRuleCreateRequest, type PutFeePayoutDestinationRequest, type Recipient, type RecipientRequest, type RecipientUpdateRequest, RecipientsResource, type RegisteredAgenticClientPolicy, type RequestOptions, type ResolvedConfig, type RetryPolicy, SandboxResource, type SandboxScenario, type ScheduledPayment, type ScheduledPaymentListParams, ScheduledPaymentsResource, type SelfServeCreditTier, type SelfServeCreditTiersResponse, type SelfServeCreditsBalanceResponse, type SelfServeCreditsLedgerEntry, type SelfServeCreditsLedgerEntryType, type SelfServeCreditsLedgerParams, type SelfServeCreditsLedgerResponse, type SelfServeCreditsPricingResponse, type SelfServeCreditsPurchaseRequest, type SelfServeCreditsPurchaseResponse, SelfServeResource, type SendTransactionIntent, type Signer, type SignerCreateRequest, type SignerGroup, type SignerGroupCreateRequest, type SignerGroupGetParams, type SignerGroupSignerAddRequest, SignerGroupsResource, SignersResource, type SimulateInboundRequest, type SimulateInboundType, type SimulateOnboardingRequest, type SimulateOnboardingResponse, type SimulateOnboardingType, type SimulationCallbackRecord, type SimulationInspection, type SimulationResponse, type SubClientSummary, type SwapAccount, type SwapAccountCreateRequest, type TransactionListParams, type TransactionStatus, TransactionsResource, TransportError, type UpdateCustomerSubClientRequest, type UploadedDocumentMetadata, type UsdcWalletPayoutDestination, type User, type UserCreateRequest, type UserUpdateRequest, UsersResource, type Wallet, type WalletBalance, type WalletBalances, type WalletCreateRequest, type WalletTransaction, type WalletTransactionRequest, WalletsResource, type WebhookEvent, type WebhookHistoryList, type WebhookHistoryListParams, type WebhookHistoryResponse, type WebhookReplayResponse, type WebhookTarget, type WebhookTargetCreateRequest, type WebhookTargetUpdateRequest, WebhooksResource, addPolicyRulePayload, attachGroupPayload, attachPolicyPayload, attachUserToWallet, canonicalJSON, consoleLogger, deletePolicyPayload, detachGroupPayload, detachPolicyPayload, detachUserFromWallet, getEnvironmentURL, mandateAmendSignPayload, mandateSignPayload, noopLogger, paginate, removePolicyRulePayload, updatePolicyRulePayload, verifyMandateSignature };