@dynamic-labs-sdk/client 1.33.2 → 1.33.4

package/dist/modules/waas/businessAccounts/removeBusinessAccountSigner/removeBusinessAccountSigner.d.ts

@@ -1,7 +1,9 @@
 import type { DynamicClient } from '../../../../client/types';
-import type { BusinessAccountActionRequired, BusinessAccountSigner } from '../businessAccounts.types';
+import type { BusinessAccountActionRequired, BusinessAccountSigner, SignedBusinessAccountIntent } from '../businessAccounts.types';
 type RemoveSignerParams = {
+    autoExecute?: boolean;
     businessAccountId: string;
+    signed?: SignedBusinessAccountIntent;
     signerId: string;
     walletId: string;
 };
@@ -11,9 +13,16 @@ type RemoveSignerParams = {
  * identity can no longer sign for that wallet. The backend refuses to remove
  * the last remaining signer on a wallet.
  *
+ * When the account governs `removeSignerFromWallet`, nothing is written and
+ * the 202 body is returned instead. Resend with `signed` (from
+ * `signBusinessAccountIntent`) to move past `INTENT_REQUIRED`.
+ *
  * @param params.businessAccountId - The business account the wallet belongs to.
  * @param params.walletId - The wallet the signer is attached to.
  * @param params.signerId - The id of the signer to remove (`BusinessAccountSigner.id`).
+ * @param [params.autoExecute] - Whether to apply on the completing approval.
+ *   Only meaningful on the first call.
+ * @param [params.signed] - A previously-signed intent, to resend past `INTENT_REQUIRED`.
  * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
  * @returns The removed signer, or the outstanding action required.
  *
@@ -33,6 +42,6 @@ type RemoveSignerParams = {
  * @throws {UnexpectedConsentResponseError} When a governed account answers 202 with an unrecognized body.
  * @notInstrumented
  */
-export declare const removeBusinessAccountSigner: ({ businessAccountId, walletId, signerId }: RemoveSignerParams, client?: DynamicClient) => Promise<BusinessAccountActionRequired | BusinessAccountSigner>;
+export declare const removeBusinessAccountSigner: ({ businessAccountId, walletId, signerId, autoExecute, signed }: RemoveSignerParams, client?: DynamicClient) => Promise<BusinessAccountActionRequired | BusinessAccountSigner>;
 export {};
 //# sourceMappingURL=removeBusinessAccountSigner.d.ts.map

package/dist/modules/waas/businessAccounts/removeBusinessAccountSigner/removeBusinessAccountSigner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"removeBusinessAccountSigner.d.ts","sourceRoot":"","sources":["../../../../../src/modules/waas/businessAccounts/removeBusinessAccountSigner/removeBusinessAccountSigner.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAE9D,OAAO,KAAK,EACV,6BAA6B,EAC7B,qBAAqB,EACtB,MAAM,2BAA2B,CAAC;AAGnC,KAAK,kBAAkB,GAAG;IACxB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,2BAA2B,8CACK,kBAAkB,WACrD,aAAa,KACpB,OAAO,CAAC,6BAA6B,GAAG,qBAAqB,CA0B/D,CAAC"}
+{"version":3,"file":"removeBusinessAccountSigner.d.ts","sourceRoot":"","sources":["../../../../../src/modules/waas/businessAccounts/removeBusinessAccountSigner/removeBusinessAccountSigner.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAE9D,OAAO,KAAK,EACV,6BAA6B,EAC7B,qBAAqB,EACrB,2BAA2B,EAC5B,MAAM,2BAA2B,CAAC;AAInC,KAAK,kBAAkB,GAAG;IACxB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,MAAM,CAAC,EAAE,2BAA2B,CAAC;IACrC,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,eAAO,MAAM,2BAA2B,mEAC0B,kBAAkB,WAC1E,aAAa,KACpB,OAAO,CAAC,6BAA6B,GAAG,qBAAqB,CA8B/D,CAAC"}

package/dist/modules/waas/businessAccounts/removeBusinessAccountWallet/removeBusinessAccountWallet.d.ts

@@ -1,16 +1,24 @@
 import type { DynamicClient } from '../../../../client/types';
-import type { BusinessAccountActionRequired, BusinessAccountDetail } from '../businessAccounts.types';
+import type { BusinessAccountActionRequired, BusinessAccountDetail, SignedBusinessAccountIntent } from '../businessAccounts.types';
 type RemoveBusinessAccountWalletParams = {
+    autoExecute?: boolean;
     businessAccountId: string;
+    signed?: SignedBusinessAccountIntent;
     walletId: string;
 };
 /**
  * Removes a wallet from a business account (owner-/admin-only). The wallet and
- * all its associated signer rows are detached from the account. The backend
- * refuses to remove the last wallet on a business account.
+ * all its associated signer rows are detached from the account.
+ *
+ * When the account governs `removeWallet`, nothing is written and the 202
+ * body is returned instead. Resend with `signed` (from
+ * `signBusinessAccountIntent`) to move past `INTENT_REQUIRED`.
  *
  * @param params.businessAccountId - The business account the wallet belongs to.
  * @param params.walletId - The wallet to remove (`BusinessAccountWallet.id`).
+ * @param [params.autoExecute] - Whether to apply on the completing approval.
+ *   Only meaningful on the first call.
+ * @param [params.signed] - A previously-signed intent, to resend past `INTENT_REQUIRED`.
  * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
  * @returns The updated business account detail, or the outstanding action required.
  *
@@ -28,6 +36,6 @@ type RemoveBusinessAccountWalletParams = {
  * @throws {UnexpectedConsentResponseError} When a governed account answers 202 with an unrecognized body.
  * @notInstrumented
  */
-export declare const removeBusinessAccountWallet: ({ businessAccountId, walletId }: RemoveBusinessAccountWalletParams, client?: DynamicClient) => Promise<BusinessAccountActionRequired | BusinessAccountDetail>;
+export declare const removeBusinessAccountWallet: ({ businessAccountId, walletId, autoExecute, signed }: RemoveBusinessAccountWalletParams, client?: DynamicClient) => Promise<BusinessAccountActionRequired | BusinessAccountDetail>;
 export {};
 //# sourceMappingURL=removeBusinessAccountWallet.d.ts.map

package/dist/modules/waas/businessAccounts/removeBusinessAccountWallet/removeBusinessAccountWallet.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"removeBusinessAccountWallet.d.ts","sourceRoot":"","sources":["../../../../../src/modules/waas/businessAccounts/removeBusinessAccountWallet/removeBusinessAccountWallet.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAG9D,OAAO,KAAK,EACV,6BAA6B,EAC7B,qBAAqB,EACtB,MAAM,2BAA2B,CAAC;AAGnC,KAAK,iCAAiC,GAAG;IACvC,iBAAiB,EAAE,MAAM,CAAC;IAC1B,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,2BAA2B,oCACL,iCAAiC,WAC1D,aAAa,KACpB,OAAO,CAAC,6BAA6B,GAAG,qBAAqB,CA+B/D,CAAC"}
+{"version":3,"file":"removeBusinessAccountWallet.d.ts","sourceRoot":"","sources":["../../../../../src/modules/waas/businessAccounts/removeBusinessAccountWallet/removeBusinessAccountWallet.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAG9D,OAAO,KAAK,EACV,6BAA6B,EAC7B,qBAAqB,EACrB,2BAA2B,EAC5B,MAAM,2BAA2B,CAAC;AAInC,KAAK,iCAAiC,GAAG;IACvC,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,MAAM,CAAC,EAAE,2BAA2B,CAAC;IACrC,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,eAAO,MAAM,2BAA2B,yDACgB,iCAAiC,WAC/E,aAAa,KACpB,OAAO,CAAC,6BAA6B,GAAG,qBAAqB,CAmC/D,CAAC"}

package/dist/modules/waas/businessAccounts/resendFields.d.ts

@@ -0,0 +1,39 @@
+import type { SignedBusinessAccountIntent } from './businessAccounts.types';
+type ResendFieldsParams = {
+    autoExecute?: boolean;
+    signed?: SignedBusinessAccountIntent;
+};
+/** The fields `resendFields` produces, shaped to match every generated
+ *  governed-mutation request body's `autoExecute`/`intent`/`intentSignature`
+ *  fields. */
+type ResendFieldsResult = {
+    autoExecute?: boolean;
+    intent?: Record<string, object>;
+    intentSignature?: string;
+};
+/**
+ * The `autoExecute`/`intent`/`intentSignature` fields shared by every governed
+ * mutation's request body.
+ *
+ * `autoExecute` is read only on the first call — once an intent is signed, it
+ * carries its own copy and the server ignores whatever this call sends, so an
+ * approver's consent can't be overridden after the fact.
+ *
+ * @param [params.autoExecute] - Whether to apply immediately on the completing
+ *   approval. Only meaningful on the first (unsigned) call.
+ * @param [params.signed] - A previously-signed intent, to resend past
+ *   `INTENT_REQUIRED`.
+ * @returns The fields to spread into a governed mutation's SDK request body.
+ *
+ * @example
+ * ```ts
+ * const body = { businessAccountId, ...resendFields({ signed }) };
+ * ```
+ *
+ * @see {@link SignedBusinessAccountIntent} for what `signed` carries.
+ * @see {@link parseGovernedResponse} for reading the `intent` back off a 202.
+ * @notInstrumented
+ */
+export declare const resendFields: ({ autoExecute, signed, }: ResendFieldsParams) => ResendFieldsResult;
+export {};
+//# sourceMappingURL=resendFields.d.ts.map

package/dist/modules/waas/businessAccounts/resendFields.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resendFields.d.ts","sourceRoot":"","sources":["../../../../src/modules/waas/businessAccounts/resendFields.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,0BAA0B,CAAC;AAE5E,KAAK,kBAAkB,GAAG;IACxB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,MAAM,CAAC,EAAE,2BAA2B,CAAC;CACtC,CAAC;AAEF;;cAEc;AACd,KAAK,kBAAkB,GAAG;IACxB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,YAAY,6BAGtB,kBAAkB,KAAG,kBAWtB,CAAC"}

package/dist/modules/waas/businessAccounts/setBusinessAccountGovernance/index.d.ts

@@ -0,0 +1,2 @@
+export { setBusinessAccountGovernance } from './setBusinessAccountGovernance';
+//# sourceMappingURL=index.d.ts.map

package/dist/modules/waas/businessAccounts/setBusinessAccountGovernance/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/modules/waas/businessAccounts/setBusinessAccountGovernance/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,4BAA4B,EAAE,MAAM,gCAAgC,CAAC"}

package/dist/modules/waas/businessAccounts/setBusinessAccountGovernance/setBusinessAccountGovernance.d.ts

@@ -0,0 +1,49 @@
+import type { DynamicClient } from '../../../../client/types';
+import type { BusinessAccountActionRequired, BusinessAccountGovernance, BusinessAccountMutationVersion, SignedBusinessAccountIntent } from '../businessAccounts.types';
+type SetGovernanceParams = {
+    autoExecute?: boolean;
+    businessAccountId: string;
+    governance: BusinessAccountGovernance;
+    signed?: SignedBusinessAccountIntent;
+};
+/**
+ * Replaces the account's entire governance section. Wholesale, not a merge —
+ * an action left out of `governance` is refused rather than read as "delete
+ * its requirements"; send it back with its existing requirements (or an
+ * empty array) to keep or clear it.
+ *
+ * `setGovernance` is itself always governed at the capability-table floor
+ * (owner-only today), so the 202 path applies here too: nothing is written
+ * and the 202 body is returned instead. Resend with `signed` (from
+ * `signBusinessAccountIntent`) to move past `INTENT_REQUIRED`.
+ *
+ * @param params.businessAccountId - The business account whose governance changes.
+ * @param params.governance - The full governance section to write, keyed by
+ *   governed action. Read the current value with `getBusinessAccountGovernance`
+ *   first if you're changing only one action.
+ * @param [params.autoExecute] - Whether to apply on the completing approval.
+ *   Only meaningful on the first call.
+ * @param [params.signed] - A previously-signed intent, to resend past `INTENT_REQUIRED`.
+ * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
+ * @returns The new document version, or the outstanding action required.
+ *
+ * @example
+ * ```ts
+ * const current = await getBusinessAccountGovernance({ businessAccountId });
+ * await setBusinessAccountGovernance({
+ *   businessAccountId,
+ *   governance: {
+ *     ...current,
+ *     addMember: [{ id: 'one-admin', schemaVersion: 1, requiredApprovals: 1, eligibleApproverRoles: ['admin'] }],
+ *   },
+ * });
+ * ```
+ *
+ * @see {@link getBusinessAccountGovernance} for reading the current section first.
+ * @see {@link defineBusinessAccountRole} for defining a role governance can name.
+ * @throws {UnexpectedConsentResponseError} When a governed account answers 202 with an unrecognized body.
+ * @notInstrumented
+ */
+export declare const setBusinessAccountGovernance: ({ businessAccountId, governance, autoExecute, signed }: SetGovernanceParams, client?: DynamicClient) => Promise<BusinessAccountActionRequired | BusinessAccountMutationVersion>;
+export {};
+//# sourceMappingURL=setBusinessAccountGovernance.d.ts.map

package/dist/modules/waas/businessAccounts/setBusinessAccountGovernance/setBusinessAccountGovernance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setBusinessAccountGovernance.d.ts","sourceRoot":"","sources":["../../../../../src/modules/waas/businessAccounts/setBusinessAccountGovernance/setBusinessAccountGovernance.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAE9D,OAAO,KAAK,EACV,6BAA6B,EAC7B,yBAAyB,EACzB,8BAA8B,EAC9B,2BAA2B,EAC5B,MAAM,2BAA2B,CAAC;AAInC,KAAK,mBAAmB,GAAG;IACzB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,UAAU,EAAE,yBAAyB,CAAC;IACtC,MAAM,CAAC,EAAE,2BAA2B,CAAC;CACtC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,eAAO,MAAM,4BAA4B,2DACiB,mBAAmB,WACnE,aAAa,KACpB,OAAO,CAAC,6BAA6B,GAAG,8BAA8B,CA8BxE,CAAC"}

package/dist/modules/waas/businessAccounts/transferBusinessAccountOwnership/transferBusinessAccountOwnership.d.ts

@@ -1,16 +1,25 @@
 import type { DynamicClient } from '../../../../client/types';
-import type { BusinessAccountActionRequired, BusinessAccountDetail } from '../businessAccounts.types';
+import type { BusinessAccountActionRequired, BusinessAccountDetail, SignedBusinessAccountIntent } from '../businessAccounts.types';
 type TransferBusinessAccountOwnershipParams = {
+    autoExecute?: boolean;
     businessAccountId: string;
     newOwnerUserId: string;
+    signed?: SignedBusinessAccountIntent;
 };
 /**
  * Transfers ownership of a business account to another member. Owner-only: the
  * `newOwnerUserId` must already be a member, is promoted to owner, and the
  * current owner is atomically demoted to admin.
  *
+ * When the account governs `transferOwnership`, nothing is written and the
+ * 202 body is returned instead. Resend with `signed` (from
+ * `signBusinessAccountIntent`) to move past `INTENT_REQUIRED`.
+ *
  * @param params.businessAccountId - The business account whose ownership moves.
  * @param params.newOwnerUserId - The member to promote to owner.
+ * @param [params.autoExecute] - Whether to apply on the completing approval.
+ *   Only meaningful on the first call.
+ * @param [params.signed] - A previously-signed intent, to resend past `INTENT_REQUIRED`.
  * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
  * @returns The updated business account detail, or the outstanding action required.
  *
@@ -28,6 +37,6 @@ type TransferBusinessAccountOwnershipParams = {
  * @throws {UnexpectedConsentResponseError} When a governed account answers 202 with an unrecognized body.
  * @notInstrumented
  */
-export declare const transferBusinessAccountOwnership: ({ businessAccountId, newOwnerUserId }: TransferBusinessAccountOwnershipParams, client?: DynamicClient) => Promise<BusinessAccountActionRequired | BusinessAccountDetail>;
+export declare const transferBusinessAccountOwnership: ({ businessAccountId, newOwnerUserId, autoExecute, signed }: TransferBusinessAccountOwnershipParams, client?: DynamicClient) => Promise<BusinessAccountActionRequired | BusinessAccountDetail>;
 export {};
 //# sourceMappingURL=transferBusinessAccountOwnership.d.ts.map

package/dist/modules/waas/businessAccounts/transferBusinessAccountOwnership/transferBusinessAccountOwnership.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transferBusinessAccountOwnership.d.ts","sourceRoot":"","sources":["../../../../../src/modules/waas/businessAccounts/transferBusinessAccountOwnership/transferBusinessAccountOwnership.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAG9D,OAAO,KAAK,EACV,6BAA6B,EAC7B,qBAAqB,EACtB,MAAM,2BAA2B,CAAC;AAGnC,KAAK,sCAAsC,GAAG;IAC5C,iBAAiB,EAAE,MAAM,CAAC;IAC1B,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,gCAAgC,0CACJ,sCAAsC,WACrE,aAAa,KACpB,OAAO,CAAC,6BAA6B,GAAG,qBAAqB,CAmC/D,CAAC"}
+{"version":3,"file":"transferBusinessAccountOwnership.d.ts","sourceRoot":"","sources":["../../../../../src/modules/waas/businessAccounts/transferBusinessAccountOwnership/transferBusinessAccountOwnership.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAG9D,OAAO,KAAK,EACV,6BAA6B,EAC7B,qBAAqB,EACrB,2BAA2B,EAC5B,MAAM,2BAA2B,CAAC;AAInC,KAAK,sCAAsC,GAAG;IAC5C,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,CAAC,EAAE,2BAA2B,CAAC;CACtC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,eAAO,MAAM,gCAAgC,+DACiB,sCAAsC,WAC1F,aAAa,KACpB,OAAO,CAAC,6BAA6B,GAAG,qBAAqB,CAsC/D,CAAC"}

package/dist/modules/waas/businessAccounts/updateBusinessAccountMemberRole/updateBusinessAccountMemberRole.d.ts

@@ -1,5 +1,5 @@
 import type { DynamicClient } from '../../../../client/types';
-import type { BuiltInBusinessAccountMemberRole, BusinessAccountActionRequired, BusinessAccountMember } from '../businessAccounts.types';
+import type { BuiltInBusinessAccountMemberRole, BusinessAccountActionRequired, BusinessAccountMember, SignedBusinessAccountIntent } from '../businessAccounts.types';
 /**
  * Roles a member can be reassigned to: a built-in other than owner, or one this
  * account defined. Ownership moves only via transferOwnership, which the API
@@ -7,8 +7,10 @@ import type { BuiltInBusinessAccountMemberRole, BusinessAccountActionRequired, B
  */
 type AssignableRole = Exclude<BuiltInBusinessAccountMemberRole, 'owner'> | (string & {});
 type UpdateBusinessAccountMemberRoleParams = {
+    autoExecute?: boolean;
     businessAccountId: string;
     role: AssignableRole;
+    signed?: SignedBusinessAccountIntent;
     userId: string;
 };
 /**
@@ -17,10 +19,17 @@ type UpdateBusinessAccountMemberRoleParams = {
  * another. Owner is not assignable here — use
  * `transferBusinessAccountOwnership` for that.
  *
+ * When the account governs `updateMemberRole`, nothing is written and the
+ * 202 body is returned instead. Resend with `signed` (from
+ * `signBusinessAccountIntent`) to move past `INTENT_REQUIRED`.
+ *
  * @param params.businessAccountId - The business account the member belongs to.
  * @param params.userId - The member whose role changes.
  * @param params.role - The new role: a built-in (`admin`, `viewer`) or a role
  *   this account defined.
+ * @param [params.autoExecute] - Whether to apply on the completing approval.
+ *   Only meaningful on the first call.
+ * @param [params.signed] - A previously-signed intent, to resend past `INTENT_REQUIRED`.
  * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
  * @returns The updated business account member, or the outstanding action required.
  *
@@ -38,6 +47,6 @@ type UpdateBusinessAccountMemberRoleParams = {
  * @throws {UnexpectedConsentResponseError} When a governed account answers 202 with an unrecognized body.
  * @notInstrumented
  */
-export declare const updateBusinessAccountMemberRole: ({ businessAccountId, userId, role }: UpdateBusinessAccountMemberRoleParams, client?: DynamicClient) => Promise<BusinessAccountActionRequired | BusinessAccountMember>;
+export declare const updateBusinessAccountMemberRole: ({ businessAccountId, userId, role, autoExecute, signed }: UpdateBusinessAccountMemberRoleParams, client?: DynamicClient) => Promise<BusinessAccountActionRequired | BusinessAccountMember>;
 export {};
 //# sourceMappingURL=updateBusinessAccountMemberRole.d.ts.map

package/dist/modules/waas/businessAccounts/updateBusinessAccountMemberRole/updateBusinessAccountMemberRole.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"updateBusinessAccountMemberRole.d.ts","sourceRoot":"","sources":["../../../../../src/modules/waas/businessAccounts/updateBusinessAccountMemberRole/updateBusinessAccountMemberRole.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAE9D,OAAO,KAAK,EACV,gCAAgC,EAChC,6BAA6B,EAC7B,qBAAqB,EACtB,MAAM,2BAA2B,CAAC;AAGnC;;;;GAIG;AACH,KAAK,cAAc,GACf,OAAO,CAAC,gCAAgC,EAAE,OAAO,CAAC,GAClD,CAAC,MAAM,GAAG,EAAE,CAAC,CAAC;AAElB,KAAK,qCAAqC,GAAG;IAC3C,iBAAiB,EAAE,MAAM,CAAC;IAC1B,IAAI,EAAE,cAAc,CAAC;IACrB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,+BAA+B,wCACL,qCAAqC,WAClE,aAAa,KACpB,OAAO,CAAC,6BAA6B,GAAG,qBAAqB,CA6B/D,CAAC"}
+{"version":3,"file":"updateBusinessAccountMemberRole.d.ts","sourceRoot":"","sources":["../../../../../src/modules/waas/businessAccounts/updateBusinessAccountMemberRole/updateBusinessAccountMemberRole.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAE9D,OAAO,KAAK,EACV,gCAAgC,EAChC,6BAA6B,EAC7B,qBAAqB,EACrB,2BAA2B,EAC5B,MAAM,2BAA2B,CAAC;AAInC;;;;GAIG;AACH,KAAK,cAAc,GACf,OAAO,CAAC,gCAAgC,EAAE,OAAO,CAAC,GAClD,CAAC,MAAM,GAAG,EAAE,CAAC,CAAC;AAElB,KAAK,qCAAqC,GAAG;IAC3C,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,IAAI,EAAE,cAAc,CAAC;IACrB,MAAM,CAAC,EAAE,2BAA2B,CAAC;IACrC,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,eAAO,MAAM,+BAA+B,6DACgB,qCAAqC,WACvF,aAAa,KACpB,OAAO,CAAC,6BAA6B,GAAG,qBAAqB,CA8B/D,CAAC"}

package/dist/modules/waas/businessAccounts/vetoBusinessAccountProposal/index.d.ts

@@ -0,0 +1,2 @@
+export { vetoBusinessAccountProposal } from './vetoBusinessAccountProposal';
+//# sourceMappingURL=index.d.ts.map

package/dist/modules/waas/businessAccounts/vetoBusinessAccountProposal/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/modules/waas/businessAccounts/vetoBusinessAccountProposal/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,2BAA2B,EAAE,MAAM,+BAA+B,CAAC"}

package/dist/modules/waas/businessAccounts/vetoBusinessAccountProposal/vetoBusinessAccountProposal.d.ts

@@ -0,0 +1,29 @@
+import type { DynamicClient } from '../../../../client/types';
+import type { BusinessAccountProposal } from '../businessAccounts.types';
+type VetoProposalParams = {
+    businessAccountId: string;
+    proposalId: string;
+};
+/**
+ * Vetoes a pending proposal — terminal: a vetoed proposal can never be
+ * approved or executed afterward. Gated on its own scope
+ * (`business_account:proposal:veto`), distinct from approving one, so a
+ * caller with only approve-scoped access cannot veto instead.
+ *
+ * @param params.businessAccountId - The business account the proposal belongs to.
+ * @param params.proposalId - The proposal to veto.
+ * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
+ * @returns The proposal, now `status: 'vetoed'`.
+ *
+ * @example
+ * ```ts
+ * await vetoBusinessAccountProposal({ businessAccountId, proposalId });
+ * ```
+ *
+ * @see {@link approveBusinessAccountProposal} for consenting to a proposal instead.
+ * @see {@link BusinessAccountProposal} for the returned shape.
+ * @notInstrumented
+ */
+export declare const vetoBusinessAccountProposal: ({ businessAccountId, proposalId }: VetoProposalParams, client?: DynamicClient) => Promise<BusinessAccountProposal>;
+export {};
+//# sourceMappingURL=vetoBusinessAccountProposal.d.ts.map

package/dist/modules/waas/businessAccounts/vetoBusinessAccountProposal/vetoBusinessAccountProposal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vetoBusinessAccountProposal.d.ts","sourceRoot":"","sources":["../../../../../src/modules/waas/businessAccounts/vetoBusinessAccountProposal/vetoBusinessAccountProposal.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAE9D,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,2BAA2B,CAAC;AAEzE,KAAK,kBAAkB,GAAG;IACxB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,2BAA2B,sCACH,kBAAkB,WAC7C,aAAa,KACpB,OAAO,CAAC,uBAAuB,CAejC,CAAC"}

package/dist/modules/waas/businessAccounts/withdrawBusinessAccountProposalApproval/index.d.ts

@@ -0,0 +1,2 @@
+export { withdrawBusinessAccountProposalApproval } from './withdrawBusinessAccountProposalApproval';
+//# sourceMappingURL=index.d.ts.map

package/dist/modules/waas/businessAccounts/withdrawBusinessAccountProposalApproval/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/modules/waas/businessAccounts/withdrawBusinessAccountProposalApproval/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uCAAuC,EAAE,MAAM,2CAA2C,CAAC"}

package/dist/modules/waas/businessAccounts/withdrawBusinessAccountProposalApproval/withdrawBusinessAccountProposalApproval.d.ts

@@ -0,0 +1,29 @@
+import type { DynamicClient } from '../../../../client/types';
+import type { BusinessAccountProposal } from '../businessAccounts.types';
+type WithdrawApprovalParams = {
+    businessAccountId: string;
+    proposalId: string;
+};
+/**
+ * Withdraws this session's own approval from a proposal still collecting
+ * them. The approval row is kept with `revokedAt` set rather than deleted —
+ * consent is recorded as given and taken back, not erased — so approving
+ * again afterward reuses the same row.
+ *
+ * @param params.businessAccountId - The business account the proposal belongs to.
+ * @param params.proposalId - The proposal to withdraw this session's approval from.
+ * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
+ * @returns The proposal, with this approval's count no longer contributing.
+ *
+ * @example
+ * ```ts
+ * await withdrawBusinessAccountProposalApproval({ businessAccountId, proposalId });
+ * ```
+ *
+ * @see {@link approveBusinessAccountProposal} for approving (or re-approving) instead.
+ * @see {@link BusinessAccountProposalApprovalRecord} for what `revokedAt` looks like once set.
+ * @notInstrumented
+ */
+export declare const withdrawBusinessAccountProposalApproval: ({ businessAccountId, proposalId }: WithdrawApprovalParams, client?: DynamicClient) => Promise<BusinessAccountProposal>;
+export {};
+//# sourceMappingURL=withdrawBusinessAccountProposalApproval.d.ts.map

package/dist/modules/waas/businessAccounts/withdrawBusinessAccountProposalApproval/withdrawBusinessAccountProposalApproval.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"withdrawBusinessAccountProposalApproval.d.ts","sourceRoot":"","sources":["../../../../../src/modules/waas/businessAccounts/withdrawBusinessAccountProposalApproval/withdrawBusinessAccountProposalApproval.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAE9D,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,2BAA2B,CAAC;AAEzE,KAAK,sBAAsB,GAAG;IAC5B,iBAAiB,EAAE,MAAM,CAAC;IAC1B,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,uCAAuC,sCACf,sBAAsB,WACjD,aAAa,KACpB,OAAO,CAAC,uBAAuB,CAYjC,CAAC"}

package/dist/services/resilientIndexedDbStore/createResilientIndexedDbStore/createResilientIndexedDbStore.d.ts

@@ -0,0 +1,44 @@
+import type { CreateResilientIndexedDbStoreParams, ResilientIndexedDbStore } from '../resilientIndexedDbStore.types';
+/**
+ * Key/value store backed by IndexedDB that keeps working while the browser
+ * closes its IndexedDB connections, as mobile WebKit does under memory
+ * pressure. A read is answered from the queued mutations this instance holds
+ * and otherwise from IndexedDB, and reports `unavailable` rather than `absent`
+ * when the database does not answer within the budget. Writes are stable
+ * because they are queued and retried with backoff, and a deletion is also
+ * kept in the storage service until IndexedDB acknowledges it, so it survives
+ * a reload. Values are structured cloned and never serialized, which is what
+ * lets them hold browser owned handles such as a non-extractable `CryptoKey`.
+ *
+ * @example
+ * ```ts
+ * const store = createResilientIndexedDbStore<StoredKey>({
+ *   dbName: 'dynamic_keychain',
+ *   keyPath: 'keyName',
+ *   storage,
+ *   storeName: 'keys',
+ * });
+ *
+ * store.set({ value: storedKey });
+ *
+ * const result = await store.get({ key: 'session' });
+ *
+ * if (result.status === 'found') {
+ *   await crypto.subtle.sign(algorithm, result.value.privateKey, data);
+ * }
+ * ```
+ *
+ * @param params.dbName - Name of the IndexedDB database backing the store.
+ * @param params.keyPath - Property of a value that holds its key.
+ * @param params.logger - Reports degraded storage.
+ * @param params.readTimeoutMs - How long a read waits before reporting unavailability.
+ * @param params.storage - Persists deletions that IndexedDB has not acknowledged.
+ * @param params.storeName - Name of the object store inside the database.
+ * @returns A store exposing get, set, remove, and waitUntilIdle.
+ * @see readStoredValue
+ * @see createWorkQueue
+ * @see replayTombstones
+ * @notInstrumented
+ */
+export declare const createResilientIndexedDbStore: <TValue>({ dbName, keyPath, logger, readTimeoutMs, storage, storeName, }: CreateResilientIndexedDbStoreParams) => ResilientIndexedDbStore<TValue>;
+//# sourceMappingURL=createResilientIndexedDbStore.d.ts.map

package/dist/services/resilientIndexedDbStore/createResilientIndexedDbStore/createResilientIndexedDbStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createResilientIndexedDbStore.d.ts","sourceRoot":"","sources":["../../../../src/services/resilientIndexedDbStore/createResilientIndexedDbStore/createResilientIndexedDbStore.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,mCAAmC,EACnC,uBAAuB,EAGxB,MAAM,kCAAkC,CAAC;AAQ1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,eAAO,MAAM,6BAA6B,GAAI,MAAM,mEAOjD,mCAAmC,KAAG,uBAAuB,CAAC,MAAM,CA2DtE,CAAC"}

package/dist/services/resilientIndexedDbStore/createResilientIndexedDbStore/index.d.ts

@@ -0,0 +1,2 @@
+export { createResilientIndexedDbStore } from './createResilientIndexedDbStore';
+//# sourceMappingURL=index.d.ts.map

package/dist/services/resilientIndexedDbStore/createResilientIndexedDbStore/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/services/resilientIndexedDbStore/createResilientIndexedDbStore/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,6BAA6B,EAAE,MAAM,iCAAiC,CAAC"}

package/dist/services/resilientIndexedDbStore/errors/TransactionNotCompletedError.d.ts

@@ -0,0 +1,5 @@
+import { BaseError } from '../../../errors/base';
+export declare class TransactionNotCompletedError extends BaseError {
+    constructor();
+}
+//# sourceMappingURL=TransactionNotCompletedError.d.ts.map

package/dist/services/resilientIndexedDbStore/errors/TransactionNotCompletedError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TransactionNotCompletedError.d.ts","sourceRoot":"","sources":["../../../../src/services/resilientIndexedDbStore/errors/TransactionNotCompletedError.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAEjD,qBAAa,4BAA6B,SAAQ,SAAS;;CAU1D"}

package/dist/services/resilientIndexedDbStore/resilientIndexedDbStore.types.d.ts

@@ -0,0 +1,79 @@
+import type { Logger } from '../logger';
+import type { Storage } from '../storage/storage.types';
+/**
+ * Where a store keeps its records. The key path is the property of a value
+ * that holds its key, since records are written to IndexedDB as they are and
+ * are never wrapped, which keeps values readable by anything that opens the
+ * same database.
+ */
+export type StoreDatabaseConfig = {
+    dbName: string;
+    keyPath: string;
+    storeName: string;
+};
+/**
+ * Outcome of a store read. `unavailable` distinguishes "IndexedDB never became
+ * readable within the budget" from "the value is genuinely not stored", so
+ * callers can fail loudly instead of treating an outage as missing data.
+ */
+export type StoreReadResult<TValue> = {
+    status: 'absent';
+} | {
+    status: 'found';
+    value: TValue;
+} | {
+    status: 'unavailable';
+};
+/**
+ * A change that still has to reach IndexedDB. Reads are never modelled as
+ * mutations: a read is awaited by its caller and has no durability
+ * requirement, so queueing it would only add latency.
+ */
+export type StoreMutation<TValue> = {
+    key: string;
+    type: 'delete';
+} | {
+    key: string;
+    type: 'set';
+    value: TValue;
+};
+export type ResilientIndexedDbStore<TValue> = {
+    /** Reads a value, waiting for IndexedDB within the read budget. */
+    get: (params: {
+        key: string;
+    }) => Promise<StoreReadResult<TValue>>;
+    /**
+     * Forgets a value. Resolves once the deletion is durably recorded so it
+     * survives a reload; the IndexedDB delete continues in the background.
+     *
+     * @throws When the deletion cannot be recorded durably, since it would not
+     * survive a reload.
+     */
+    remove: (params: {
+        key: string;
+    }) => Promise<void>;
+    /**
+     * Stores a value under the key it carries in the store's key path.
+     * Persisted asynchronously, never throws.
+     */
+    set: (params: {
+        value: TValue;
+    }) => void;
+    /** Resolves once every mutation the store can persist has been written. */
+    waitUntilIdle: () => Promise<void>;
+};
+export type CreateResilientIndexedDbStoreParams = {
+    /** Name of the IndexedDB database backing the store. */
+    dbName: string;
+    /** Property of a value that holds its key. */
+    keyPath: string;
+    /** Reports degraded storage. The store works without it. */
+    logger?: Logger;
+    /** Upper bound for how long a read waits before reporting unavailability. */
+    readTimeoutMs?: number;
+    /** Persists deletions that IndexedDB has not acknowledged. */
+    storage: Storage;
+    /** Name of the object store inside the database. */
+    storeName: string;
+};
+//# sourceMappingURL=resilientIndexedDbStore.types.d.ts.map

package/dist/services/resilientIndexedDbStore/resilientIndexedDbStore.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resilientIndexedDbStore.types.d.ts","sourceRoot":"","sources":["../../../src/services/resilientIndexedDbStore/resilientIndexedDbStore.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AACxC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAC;AAExD;;;;;GAKG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAChC,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,eAAe,CAAC,MAAM,IAC9B;IAAE,MAAM,EAAE,QAAQ,CAAA;CAAE,GACpB;IAAE,MAAM,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAClC;IAAE,MAAM,EAAE,aAAa,CAAA;CAAE,CAAC;AAE9B;;;;GAIG;AACH,MAAM,MAAM,aAAa,CAAC,MAAM,IAC5B;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,QAAQ,CAAA;CAAE,GAC/B;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAEhD,MAAM,MAAM,uBAAuB,CAAC,MAAM,IAAI;IAC5C,mEAAmE;IACnE,GAAG,EAAE,CAAC,MAAM,EAAE;QAAE,GAAG,EAAE,MAAM,CAAA;KAAE,KAAK,OAAO,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC,CAAC;IAEnE;;;;;;OAMG;IACH,MAAM,EAAE,CAAC,MAAM,EAAE;QAAE,GAAG,EAAE,MAAM,CAAA;KAAE,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAEnD;;;OAGG;IACH,GAAG,EAAE,CAAC,MAAM,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,CAAC;IAEzC,2EAA2E;IAC3E,aAAa,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CACpC,CAAC;AAEF,MAAM,MAAM,mCAAmC,GAAG;IAChD,wDAAwD;IACxD,MAAM,EAAE,MAAM,CAAC;IAEf,8CAA8C;IAC9C,OAAO,EAAE,MAAM,CAAC;IAEhB,4DAA4D;IAC5D,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB,6EAA6E;IAC7E,aAAa,CAAC,EAAE,MAAM,CAAC;IAEvB,8DAA8D;IAC9D,OAAO,EAAE,OAAO,CAAC;IAEjB,oDAAoD;IACpD,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC"}

package/dist/services/resilientIndexedDbStore/utils/applyMutation/applyMutation.d.ts

@@ -0,0 +1,29 @@
+import type { StoreDatabaseConfig, StoreMutation } from '../../resilientIndexedDbStore.types';
+type ApplyMutationParams<TValue> = {
+    /** Where the store keeps its records. */
+    database: StoreDatabaseConfig;
+    /** The mutation to persist. */
+    mutation: StoreMutation<TValue>;
+};
+/**
+ * Writes a single queued mutation to IndexedDB.
+ *
+ * @example
+ * ```ts
+ * await applyMutation({
+ *   database,
+ *   mutation: { key: 'session', type: 'delete' },
+ * });
+ * ```
+ *
+ * @param params.database - Where the store keeps its records.
+ * @param params.mutation - The mutation to persist.
+ * @returns A promise that resolves once the mutation has landed.
+ * @throws When IndexedDB rejects the write, so the caller can retry it.
+ * @see createWorkQueue
+ * @see withDatabase
+ * @notInstrumented
+ */
+export declare const applyMutation: <TValue>({ database, mutation, }: ApplyMutationParams<TValue>) => Promise<void>;
+export {};
+//# sourceMappingURL=applyMutation.d.ts.map

package/dist/services/resilientIndexedDbStore/utils/applyMutation/applyMutation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"applyMutation.d.ts","sourceRoot":"","sources":["../../../../../src/services/resilientIndexedDbStore/utils/applyMutation/applyMutation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,mBAAmB,EACnB,aAAa,EACd,MAAM,qCAAqC,CAAC;AAK7C,KAAK,mBAAmB,CAAC,MAAM,IAAI;IACjC,yCAAyC;IACzC,QAAQ,EAAE,mBAAmB,CAAC;IAE9B,+BAA+B;IAC/B,QAAQ,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;CACjC,CAAC;AAEF;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,aAAa,GAAI,MAAM,2BAGjC,mBAAmB,CAAC,MAAM,CAAC,KAAG,OAAO,CAAC,IAAI,CAsB5C,CAAC"}

package/dist/services/resilientIndexedDbStore/utils/applyMutation/index.d.ts

@@ -0,0 +1,2 @@
+export { applyMutation } from './applyMutation';
+//# sourceMappingURL=index.d.ts.map

package/dist/services/resilientIndexedDbStore/utils/applyMutation/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/services/resilientIndexedDbStore/utils/applyMutation/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/services/resilientIndexedDbStore/utils/constants.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Upper bound for how long a read may wait for IndexedDB to become available
+ * before it resolves as unavailable. A user is usually blocked on this, so the
+ * budget is short enough to keep an interaction responsive.
+ */
+export declare const DEFAULT_READ_TIMEOUT_MS = 3000;
+/**
+ * How long a single open-and-operate attempt against IndexedDB may take. An
+ * open blocked by another connection, and a request on a connection the
+ * browser closed, settle neither way, so every attempt needs a boundary of its
+ * own for the read budget and the queue worker to mean anything.
+ */
+export declare const DATABASE_OPERATION_TIMEOUT_MS = 3000;
+/**
+ * How long one queued task may occupy the single worker. Bounds work that is
+ * not an IndexedDB operation, such as reading pending deletions from the
+ * storage service, so no task can hold back the mutations behind it.
+ */
+export declare const QUEUED_TASK_TIMEOUT_MS = 10000;
+/** Delay before the first retry of an IndexedDB operation. */
+export declare const INITIAL_BACKOFF_MS = 50;
+/** Ceiling for the exponential backoff between IndexedDB retries. */
+export declare const MAX_BACKOFF_MS = 1000;
+//# sourceMappingURL=constants.d.ts.map

package/dist/services/resilientIndexedDbStore/utils/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../src/services/resilientIndexedDbStore/utils/constants.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,eAAO,MAAM,uBAAuB,OAAQ,CAAC;AAE7C;;;;;GAKG;AACH,eAAO,MAAM,6BAA6B,OAAQ,CAAC;AAEnD;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,QAAS,CAAC;AAE7C,8DAA8D;AAC9D,eAAO,MAAM,kBAAkB,KAAK,CAAC;AAErC,qEAAqE;AACrE,eAAO,MAAM,cAAc,OAAQ,CAAC"}