@multiagency/sdk 0.3.1

package/dist/contract/owner-contract.d.ts

@@ -0,0 +1,1156 @@
+import { z } from "zod";
+export declare const ownerErrors: {
+    /** Refused before anything was sent: an earlier operation has no proven outcome, or another action holds the lock. */
+    CONFLICT: {
+        data: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"unresolved">;
+        }, z.core.$loose>, z.ZodObject<{
+            kind: z.ZodLiteral<"busy">;
+        }, z.core.$loose>, z.ZodObject<{
+            kind: z.ZodLiteral<"refused">;
+            code: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>], "kind">;
+    };
+    /** Refused by the platform, or by the provider (with its code and supplementary details). */
+    BAD_REQUEST: {
+        data: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"refused">;
+            code: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>, z.ZodObject<{
+            kind: z.ZodLiteral<"provider">;
+            code: z.ZodOptional<z.ZodString>;
+            availableAt: z.ZodNullable<z.ZodString>;
+            budgetRemainingUsd: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>], "kind">;
+    };
+};
+/**
+ * The owner contract, contract-first: inputs, outputs and typed errors in one place. The server implements it
+ * (src/rpc/*, `implement` with output validation off: reads validate only, mutations and streams are not validated
+ * server-side) and `ownerClient` is typed from it.
+ */
+export declare const ownerContract: {
+    overview: import("@orpc/contract").ProcedureContractBuilderWithOutput<z.ZodObject<{
+        agentId: z.ZodString;
+        area: z.ZodOptional<z.ZodEnum<{
+            payables: "payables";
+            treasury: "treasury";
+        }>>;
+        book: z.ZodArray<z.ZodObject<{
+            asset: z.ZodString;
+            symbol: z.ZodString;
+            decimals: z.ZodNumber;
+            public: z.ZodBigInt;
+            confidential: z.ZodBigInt;
+            price: z.ZodNullable<z.ZodNumber>;
+            priceUpdatedAt: z.ZodNullable<z.ZodString>;
+            priceExpiresAt: z.ZodNullable<z.ZodString>;
+            usd: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$loose>>;
+        unmanaged: z.ZodArray<z.ZodObject<{
+            asset: z.ZodString;
+            symbol: z.ZodString;
+            decimals: z.ZodNullable<z.ZodNumber>;
+            amount: z.ZodBigInt;
+            price: z.ZodNullable<z.ZodNumber>;
+            priceUpdatedAt: z.ZodNullable<z.ZodString>;
+            priceExpiresAt: z.ZodNullable<z.ZodString>;
+            usd: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$loose>>;
+        target: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        rebalance: z.ZodObject<{
+            minLegUsd: z.ZodNumber;
+            maxCostBps: z.ZodNumber;
+        }, z.core.$loose>;
+        policy: z.ZodObject<{
+            wallet_id: z.ZodString;
+            revision: z.ZodNullable<z.ZodNumber>;
+            policy_hash: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            status: z.ZodEnum<{
+                APPLIED: "APPLIED";
+                FAILED: "FAILED";
+                NONE: "NONE";
+                SIGNED: "SIGNED";
+            }>;
+            applied_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            transaction_hash: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            provider_policy_synced: z.ZodBoolean;
+            cooldowns: z.ZodObject<{
+                policy_change_available_at: z.ZodNullable<z.ZodString>;
+                unfreeze_available_at: z.ZodNullable<z.ZodString>;
+            }, z.core.$loose>;
+            policy: z.ZodNullable<z.ZodObject<{
+                frozen: z.ZodBoolean;
+                actions: z.ZodArray<z.ZodEnum<{
+                    swap: "swap";
+                    transfer: "transfer";
+                    withdraw: "withdraw";
+                }>>;
+                confidential: z.ZodBoolean;
+                owner_approval: z.ZodBoolean;
+                assets: z.ZodUnion<readonly [z.ZodLiteral<"any">, z.ZodArray<z.ZodString>]>;
+                limits: z.ZodObject<{
+                    per_transaction: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                    hourly: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                    daily: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                    monthly: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                }, z.core.$loose>;
+                max_actions_per_hour: z.ZodNullable<z.ZodNumber>;
+                destinations: z.ZodObject<{
+                    mode: z.ZodEnum<{
+                        any: "any";
+                        except: "except";
+                        only: "only";
+                    }>;
+                    list: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        action: z.ZodLiteral<"transfer">;
+                        address: z.ZodString;
+                        confidential: z.ZodBoolean;
+                    }, z.core.$loose>, z.ZodObject<{
+                        action: z.ZodLiteral<"withdraw">;
+                        chain: z.ZodString;
+                        address: z.ZodString;
+                        memo: z.ZodNullable<z.ZodString>;
+                    }, z.core.$loose>], "action">>;
+                }, z.core.$loose>;
+                budget: z.ZodObject<{
+                    daily_usd: z.ZodNullable<z.ZodString>;
+                    weekly_usd: z.ZodNullable<z.ZodString>;
+                    monthly_usd: z.ZodNullable<z.ZodString>;
+                }, z.core.$loose>;
+                timelock_ms: z.ZodNumber;
+                schedule: z.ZodOptional<z.ZodObject<{
+                    mode: z.ZodEnum<{
+                        except: "except";
+                        only: "only";
+                    }>;
+                    time_zone: z.ZodString;
+                    windows: z.ZodArray<z.ZodObject<{
+                        days: z.ZodArray<z.ZodEnum<{
+                            fri: "fri";
+                            mon: "mon";
+                            sat: "sat";
+                            sun: "sun";
+                            thu: "thu";
+                            tue: "tue";
+                            wed: "wed";
+                        }>>;
+                        start: z.ZodString;
+                        end: z.ZodString;
+                    }, z.core.$loose>>;
+                }, z.core.$loose>>;
+                sign: z.ZodOptional<z.ZodObject<{
+                    recipients: z.ZodArray<z.ZodString>;
+                }, z.core.$loose>>;
+            }, z.core.$loose>>;
+            usage: z.ZodObject<{
+                budget: z.ZodObject<{
+                    daily: z.ZodObject<{
+                        limit_usd: z.ZodNullable<z.ZodString>;
+                        spent_usd: z.ZodString;
+                        remaining_usd: z.ZodNullable<z.ZodString>;
+                        resets_at: z.ZodNullable<z.ZodString>;
+                    }, z.core.$loose>;
+                    weekly: z.ZodObject<{
+                        limit_usd: z.ZodNullable<z.ZodString>;
+                        spent_usd: z.ZodString;
+                        remaining_usd: z.ZodNullable<z.ZodString>;
+                        resets_at: z.ZodNullable<z.ZodString>;
+                    }, z.core.$loose>;
+                    monthly: z.ZodObject<{
+                        limit_usd: z.ZodNullable<z.ZodString>;
+                        spent_usd: z.ZodString;
+                        remaining_usd: z.ZodNullable<z.ZodString>;
+                        resets_at: z.ZodNullable<z.ZodString>;
+                    }, z.core.$loose>;
+                }, z.core.$loose>;
+                timelock: z.ZodObject<{
+                    delay_ms: z.ZodNumber;
+                    scheduled_count: z.ZodNumber;
+                }, z.core.$loose>;
+            }, z.core.$loose>;
+        }, z.core.$loose>;
+        digest: z.ZodNullable<z.ZodString>;
+        notInForce: z.ZodNullable<z.ZodString>;
+        agreed: z.ZodArray<z.ZodString>;
+        grants: z.ZodArray<z.ZodObject<{
+            grant_id: z.ZodString;
+            agent_id: z.ZodString;
+            wallet_id: z.ZodString;
+            label: z.ZodString;
+            issued_at: z.ZodString;
+            expires_at: z.ZodString;
+            revoked_at: z.ZodNullable<z.ZodString>;
+            revoked_reason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            owner_epoch: z.ZodNumber;
+            owner_message: z.ZodUnknown;
+        }, z.core.$loose>>;
+    }, z.core.$loose>, {
+        /** Refused before anything was sent: an earlier operation has no proven outcome, or another action holds the lock. */
+        CONFLICT: {
+            data: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"unresolved">;
+            }, z.core.$loose>, z.ZodObject<{
+                kind: z.ZodLiteral<"busy">;
+            }, z.core.$loose>, z.ZodObject<{
+                kind: z.ZodLiteral<"refused">;
+                code: z.ZodOptional<z.ZodString>;
+            }, z.core.$loose>], "kind">;
+        };
+        /** Refused by the platform, or by the provider (with its code and supplementary details). */
+        BAD_REQUEST: {
+            data: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"refused">;
+                code: z.ZodOptional<z.ZodString>;
+            }, z.core.$loose>, z.ZodObject<{
+                kind: z.ZodLiteral<"provider">;
+                code: z.ZodOptional<z.ZodString>;
+                availableAt: z.ZodNullable<z.ZodString>;
+                budgetRemainingUsd: z.ZodOptional<z.ZodString>;
+            }, z.core.$loose>], "kind">;
+        };
+    }>;
+    activity: import("@orpc/contract").ProcedureContractBuilderWithOutput<z.ZodArray<z.ZodObject<{
+        at: z.ZodString;
+        kind: z.ZodString;
+        request: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        correlationId: z.ZodOptional<z.ZodString>;
+        status: z.ZodOptional<z.ZodString>;
+        refused: z.ZodOptional<z.ZodString>;
+        policyRevision: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        policyDigest: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        planId: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>, {
+        /** Refused before anything was sent: an earlier operation has no proven outcome, or another action holds the lock. */
+        CONFLICT: {
+            data: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"unresolved">;
+            }, z.core.$loose>, z.ZodObject<{
+                kind: z.ZodLiteral<"busy">;
+            }, z.core.$loose>, z.ZodObject<{
+                kind: z.ZodLiteral<"refused">;
+                code: z.ZodOptional<z.ZodString>;
+            }, z.core.$loose>], "kind">;
+        };
+        /** Refused by the platform, or by the provider (with its code and supplementary details). */
+        BAD_REQUEST: {
+            data: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"refused">;
+                code: z.ZodOptional<z.ZodString>;
+            }, z.core.$loose>, z.ZodObject<{
+                kind: z.ZodLiteral<"provider">;
+                code: z.ZodOptional<z.ZodString>;
+                availableAt: z.ZodNullable<z.ZodString>;
+                budgetRemainingUsd: z.ZodOptional<z.ZodString>;
+            }, z.core.$loose>], "kind">;
+        };
+    }>;
+    unresolved: import("@orpc/contract").ProcedureContractBuilderWithOutput<z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        at: z.ZodString;
+        kind: z.ZodString;
+        request: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        status: z.ZodNullable<z.ZodString>;
+        sent: z.ZodBoolean;
+        evidence: z.ZodCatch<z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            at: z.ZodString;
+            httpStatus: z.ZodNumber;
+            code: z.ZodString;
+            requestId: z.ZodNullable<z.ZodString>;
+            providerIds: z.ZodRecord<z.ZodString, z.ZodString>;
+            message: z.ZodString;
+            note: z.ZodString;
+        }, z.core.$loose>>>>;
+    }, z.core.$loose>>, {
+        /** Refused before anything was sent: an earlier operation has no proven outcome, or another action holds the lock. */
+        CONFLICT: {
+            data: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"unresolved">;
+            }, z.core.$loose>, z.ZodObject<{
+                kind: z.ZodLiteral<"busy">;
+            }, z.core.$loose>, z.ZodObject<{
+                kind: z.ZodLiteral<"refused">;
+                code: z.ZodOptional<z.ZodString>;
+            }, z.core.$loose>], "kind">;
+        };
+        /** Refused by the platform, or by the provider (with its code and supplementary details). */
+        BAD_REQUEST: {
+            data: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"refused">;
+                code: z.ZodOptional<z.ZodString>;
+            }, z.core.$loose>, z.ZodObject<{
+                kind: z.ZodLiteral<"provider">;
+                code: z.ZodOptional<z.ZodString>;
+                availableAt: z.ZodNullable<z.ZodString>;
+                budgetRemainingUsd: z.ZodOptional<z.ZodString>;
+            }, z.core.$loose>], "kind">;
+        };
+    }>;
+    strategy: {
+        get: import("@orpc/contract").ProcedureContractBuilderWithOutput<z.ZodObject<{
+            strategy: z.ZodObject<{
+                targetBps: z.ZodRecord<z.ZodString, z.ZodNumber>;
+                minLegUsd: z.ZodNumber;
+                maxCostBps: z.ZodNumber;
+                autopilot: z.ZodObject<{
+                    everyMin: z.ZodNumber;
+                    maxUsd: z.ZodNumber;
+                }, z.core.$loose>;
+            }, z.core.$loose>;
+            digest: z.ZodString;
+            grantSuffix: z.ZodString;
+            executor: z.ZodBoolean;
+            on: z.ZodBoolean;
+            grantMatches: z.ZodNullable<z.ZodBoolean>;
+            unresolved: z.ZodNumber;
+            grant: z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+                label: z.ZodString;
+                expiresAt: z.ZodString;
+            }, z.core.$loose>>;
+            readiness: z.ZodObject<{
+                state: z.ZodEnum<{
+                    "approve-only": "approve-only";
+                    "authorization-required": "authorization-required";
+                    blocked: "blocked";
+                    off: "off";
+                    ready: "ready";
+                }>;
+                reasons: z.ZodArray<z.ZodString>;
+                canEnable: z.ZodBoolean;
+            }, z.core.$loose>;
+            observedAt: z.ZodString;
+        }, z.core.$loose>, {
+            /** Refused before anything was sent: an earlier operation has no proven outcome, or another action holds the lock. */
+            CONFLICT: {
+                data: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    kind: z.ZodLiteral<"unresolved">;
+                }, z.core.$loose>, z.ZodObject<{
+                    kind: z.ZodLiteral<"busy">;
+                }, z.core.$loose>, z.ZodObject<{
+                    kind: z.ZodLiteral<"refused">;
+                    code: z.ZodOptional<z.ZodString>;
+                }, z.core.$loose>], "kind">;
+            };
+            /** Refused by the platform, or by the provider (with its code and supplementary details). */
+            BAD_REQUEST: {
+                data: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    kind: z.ZodLiteral<"refused">;
+                    code: z.ZodOptional<z.ZodString>;
+                }, z.core.$loose>, z.ZodObject<{
+                    kind: z.ZodLiteral<"provider">;
+                    code: z.ZodOptional<z.ZodString>;
+                    availableAt: z.ZodNullable<z.ZodString>;
+                    budgetRemainingUsd: z.ZodOptional<z.ZodString>;
+                }, z.core.$loose>], "kind">;
+            };
+        }>;
+    };
+    owner: {
+        prepare: import("@orpc/contract").ProcedureContractBuilderWithInputOutput<z.ZodObject<{
+            action: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"agent_create">;
+                owner: z.ZodOptional<z.ZodObject<{
+                    type: z.ZodLiteral<"near">;
+                    account_id: z.ZodString;
+                    public_key: z.ZodString;
+                }, z.core.$strip>>;
+                role: z.ZodOptional<z.ZodEnum<{
+                    payout: "payout";
+                    treasury: "treasury";
+                }>>;
+                payees: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"grant_issue">;
+                label: z.ZodOptional<z.ZodEnum<{
+                    invoices: "invoices";
+                    payout: "payout";
+                    treasury: "treasury";
+                }>>;
+                suffix: z.ZodOptional<z.ZodString>;
+                expectedStrategyDigest: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"grant_revoke">;
+                grantId: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"agent_freeze">;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"agent_unfreeze">;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"policy_update">;
+                expectedPolicy: z.ZodObject<{
+                    revision: z.ZodNumber;
+                    digest: z.ZodString;
+                }, z.core.$strip>;
+                changes: z.ZodObject<{
+                    swap: z.ZodOptional<z.ZodBoolean>;
+                    destinations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        address: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+                        confidential: z.ZodBoolean;
+                    }, z.core.$strip>>>;
+                    withdrawals: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        address: z.ZodString;
+                    }, z.core.$strip>>>;
+                    assets: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"any">, z.ZodArray<z.ZodString>]>>;
+                    owner_approval: z.ZodOptional<z.ZodBoolean>;
+                    max_actions_per_hour: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                    budget: z.ZodOptional<z.ZodObject<{
+                        daily_usd: z.ZodNullable<z.ZodString>;
+                        weekly_usd: z.ZodNullable<z.ZodString>;
+                        monthly_usd: z.ZodNullable<z.ZodString>;
+                    }, z.core.$strip>>;
+                    limits: z.ZodOptional<z.ZodObject<{
+                        per_transaction: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                        hourly: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                        daily: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                        monthly: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"approval_vote">;
+                approvalId: z.ZodUUID;
+                verdict: z.ZodEnum<{
+                    approve: "approve";
+                    reject: "reject";
+                }>;
+                correlationId: z.ZodString;
+            }, z.core.$strip>], "type">;
+            signer: z.ZodEnum<{
+                dao: "dao";
+                wallet: "wallet";
+            }>;
+        }, z.core.$strip>, z.ZodObject<{
+            correlationId: z.ZodString;
+            preview: z.ZodObject<{
+                summary: z.ZodString;
+                revision: z.ZodOptional<z.ZodNumber>;
+                previous_revision: z.ZodOptional<z.ZodNumber>;
+                policy_hash: z.ZodOptional<z.ZodString>;
+                policy: z.ZodOptional<z.ZodObject<{
+                    frozen: z.ZodBoolean;
+                    actions: z.ZodArray<z.ZodEnum<{
+                        swap: "swap";
+                        transfer: "transfer";
+                        withdraw: "withdraw";
+                    }>>;
+                    confidential: z.ZodBoolean;
+                    owner_approval: z.ZodBoolean;
+                    assets: z.ZodUnion<readonly [z.ZodLiteral<"any">, z.ZodArray<z.ZodString>]>;
+                    limits: z.ZodObject<{
+                        per_transaction: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                        hourly: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                        daily: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                        monthly: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                    }, z.core.$loose>;
+                    max_actions_per_hour: z.ZodNullable<z.ZodNumber>;
+                    destinations: z.ZodObject<{
+                        mode: z.ZodEnum<{
+                            any: "any";
+                            except: "except";
+                            only: "only";
+                        }>;
+                        list: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                            action: z.ZodLiteral<"transfer">;
+                            address: z.ZodString;
+                            confidential: z.ZodBoolean;
+                        }, z.core.$loose>, z.ZodObject<{
+                            action: z.ZodLiteral<"withdraw">;
+                            chain: z.ZodString;
+                            address: z.ZodString;
+                            memo: z.ZodNullable<z.ZodString>;
+                        }, z.core.$loose>], "action">>;
+                    }, z.core.$loose>;
+                    budget: z.ZodObject<{
+                        daily_usd: z.ZodNullable<z.ZodString>;
+                        weekly_usd: z.ZodNullable<z.ZodString>;
+                        monthly_usd: z.ZodNullable<z.ZodString>;
+                    }, z.core.$loose>;
+                    timelock_ms: z.ZodNumber;
+                    schedule: z.ZodOptional<z.ZodObject<{
+                        mode: z.ZodEnum<{
+                            except: "except";
+                            only: "only";
+                        }>;
+                        time_zone: z.ZodString;
+                        windows: z.ZodArray<z.ZodObject<{
+                            days: z.ZodArray<z.ZodEnum<{
+                                fri: "fri";
+                                mon: "mon";
+                                sat: "sat";
+                                sun: "sun";
+                                thu: "thu";
+                                tue: "tue";
+                                wed: "wed";
+                            }>>;
+                            start: z.ZodString;
+                            end: z.ZodString;
+                        }, z.core.$loose>>;
+                    }, z.core.$loose>>;
+                    sign: z.ZodOptional<z.ZodObject<{
+                        recipients: z.ZodArray<z.ZodString>;
+                    }, z.core.$loose>>;
+                }, z.core.$loose>>;
+                deletion: z.ZodOptional<z.ZodUnknown>;
+                approval: z.ZodOptional<z.ZodObject<{
+                    approval_id: z.ZodString;
+                    request_type: z.ZodString;
+                    request_hash: z.ZodString;
+                    verdict: z.ZodEnum<{
+                        approve: "approve";
+                        reject: "reject";
+                    }>;
+                }, z.core.$loose>>;
+            }, z.core.$loose>;
+            expiresAt: z.ZodString;
+            digest: z.ZodNullable<z.ZodString>;
+            policy: z.ZodOptional<z.ZodObject<{
+                current: z.ZodNullable<z.ZodObject<{
+                    frozen: z.ZodBoolean;
+                    actions: z.ZodArray<z.ZodEnum<{
+                        swap: "swap";
+                        transfer: "transfer";
+                        withdraw: "withdraw";
+                    }>>;
+                    confidential: z.ZodBoolean;
+                    owner_approval: z.ZodBoolean;
+                    assets: z.ZodUnion<readonly [z.ZodLiteral<"any">, z.ZodArray<z.ZodString>]>;
+                    limits: z.ZodObject<{
+                        per_transaction: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                        hourly: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                        daily: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                        monthly: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                    }, z.core.$loose>;
+                    max_actions_per_hour: z.ZodNullable<z.ZodNumber>;
+                    destinations: z.ZodObject<{
+                        mode: z.ZodEnum<{
+                            any: "any";
+                            except: "except";
+                            only: "only";
+                        }>;
+                        list: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                            action: z.ZodLiteral<"transfer">;
+                            address: z.ZodString;
+                            confidential: z.ZodBoolean;
+                        }, z.core.$loose>, z.ZodObject<{
+                            action: z.ZodLiteral<"withdraw">;
+                            chain: z.ZodString;
+                            address: z.ZodString;
+                            memo: z.ZodNullable<z.ZodString>;
+                        }, z.core.$loose>], "action">>;
+                    }, z.core.$loose>;
+                    budget: z.ZodObject<{
+                        daily_usd: z.ZodNullable<z.ZodString>;
+                        weekly_usd: z.ZodNullable<z.ZodString>;
+                        monthly_usd: z.ZodNullable<z.ZodString>;
+                    }, z.core.$loose>;
+                    timelock_ms: z.ZodNumber;
+                    schedule: z.ZodOptional<z.ZodObject<{
+                        mode: z.ZodEnum<{
+                            except: "except";
+                            only: "only";
+                        }>;
+                        time_zone: z.ZodString;
+                        windows: z.ZodArray<z.ZodObject<{
+                            days: z.ZodArray<z.ZodEnum<{
+                                fri: "fri";
+                                mon: "mon";
+                                sat: "sat";
+                                sun: "sun";
+                                thu: "thu";
+                                tue: "tue";
+                                wed: "wed";
+                            }>>;
+                            start: z.ZodString;
+                            end: z.ZodString;
+                        }, z.core.$loose>>;
+                    }, z.core.$loose>>;
+                    sign: z.ZodOptional<z.ZodObject<{
+                        recipients: z.ZodArray<z.ZodString>;
+                    }, z.core.$loose>>;
+                }, z.core.$loose>>;
+                requested: z.ZodObject<{
+                    frozen: z.ZodBoolean;
+                    actions: z.ZodArray<z.ZodEnum<{
+                        swap: "swap";
+                        transfer: "transfer";
+                        withdraw: "withdraw";
+                    }>>;
+                    confidential: z.ZodBoolean;
+                    owner_approval: z.ZodBoolean;
+                    assets: z.ZodUnion<readonly [z.ZodLiteral<"any">, z.ZodArray<z.ZodString>]>;
+                    limits: z.ZodObject<{
+                        per_transaction: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                        hourly: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                        daily: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                        monthly: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                    }, z.core.$loose>;
+                    max_actions_per_hour: z.ZodNullable<z.ZodNumber>;
+                    destinations: z.ZodObject<{
+                        mode: z.ZodEnum<{
+                            any: "any";
+                            except: "except";
+                            only: "only";
+                        }>;
+                        list: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                            action: z.ZodLiteral<"transfer">;
+                            address: z.ZodString;
+                            confidential: z.ZodBoolean;
+                        }, z.core.$loose>, z.ZodObject<{
+                            action: z.ZodLiteral<"withdraw">;
+                            chain: z.ZodString;
+                            address: z.ZodString;
+                            memo: z.ZodNullable<z.ZodString>;
+                        }, z.core.$loose>], "action">>;
+                    }, z.core.$loose>;
+                    budget: z.ZodObject<{
+                        daily_usd: z.ZodNullable<z.ZodString>;
+                        weekly_usd: z.ZodNullable<z.ZodString>;
+                        monthly_usd: z.ZodNullable<z.ZodString>;
+                    }, z.core.$loose>;
+                    timelock_ms: z.ZodNumber;
+                    schedule: z.ZodOptional<z.ZodObject<{
+                        mode: z.ZodEnum<{
+                            except: "except";
+                            only: "only";
+                        }>;
+                        time_zone: z.ZodString;
+                        windows: z.ZodArray<z.ZodObject<{
+                            days: z.ZodArray<z.ZodEnum<{
+                                fri: "fri";
+                                mon: "mon";
+                                sat: "sat";
+                                sun: "sun";
+                                thu: "thu";
+                                tue: "tue";
+                                wed: "wed";
+                            }>>;
+                            start: z.ZodString;
+                            end: z.ZodString;
+                        }, z.core.$loose>>;
+                    }, z.core.$loose>>;
+                    sign: z.ZodOptional<z.ZodObject<{
+                        recipients: z.ZodArray<z.ZodString>;
+                    }, z.core.$loose>>;
+                }, z.core.$loose>;
+            }, z.core.$loose>>;
+            intent: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                standard: z.ZodLiteral<"nep413">;
+                payload: z.ZodObject<{
+                    message: z.ZodString;
+                    recipient: z.ZodString;
+                    nonce: z.ZodString;
+                }, z.core.$loose>;
+            }, z.core.$loose>, z.ZodObject<{
+                standard: z.ZodLiteral<"nep366">;
+                payload: z.ZodObject<{
+                    receiverId: z.ZodString;
+                    actions: z.ZodArray<z.ZodObject<{
+                        type: z.ZodLiteral<"FunctionCall">;
+                        params: z.ZodObject<{
+                            methodName: z.ZodString;
+                            args: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                            gas: z.ZodString;
+                            deposit: z.ZodString;
+                        }, z.core.$loose>;
+                    }, z.core.$loose>>;
+                }, z.core.$loose>;
+            }, z.core.$loose>, z.ZodObject<{
+                standard: z.ZodLiteral<"eip712">;
+                payload: z.ZodObject<{
+                    domain: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                    types: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        type: z.ZodString;
+                    }, z.core.$loose>>>;
+                    primaryType: z.ZodString;
+                    message: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                }, z.core.$loose>;
+            }, z.core.$loose>, z.ZodObject<{
+                standard: z.ZodLiteral<"webauthn">;
+                payload: z.ZodObject<{
+                    challenge: z.ZodString;
+                    rpId: z.ZodString;
+                    allowCredentials: z.ZodArray<z.ZodObject<{
+                        id: z.ZodString;
+                        type: z.ZodLiteral<"public-key">;
+                    }, z.core.$loose>>;
+                    userVerification: z.ZodLiteral<"required">;
+                    timeout: z.ZodNumber;
+                }, z.core.$loose>;
+            }, z.core.$loose>], "standard">>;
+            confirm: z.ZodOptional<z.ZodObject<{
+                url: z.ZodString;
+                expiresAt: z.ZodString;
+            }, z.core.$loose>>;
+            signer: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"near">;
+                account_id: z.ZodString;
+                public_key: z.ZodString;
+            }, z.core.$loose>, z.ZodObject<{
+                type: z.ZodLiteral<"evm">;
+                address: z.ZodString;
+                chain_id: z.ZodNumber;
+                public_key: z.ZodString;
+            }, z.core.$loose>, z.ZodObject<{
+                type: z.ZodLiteral<"passkey">;
+                credential_id: z.ZodString;
+                public_key: z.ZodString;
+                rp_id: z.ZodString;
+                origin: z.ZodString;
+            }, z.core.$loose>], "type">>;
+            payment: z.ZodOptional<z.ZodObject<{
+                correlationId: z.ZodString;
+                verdict: z.ZodEnum<{
+                    approve: "approve";
+                    reject: "reject";
+                }>;
+                terms: z.ZodNullable<z.ZodObject<{
+                    recipient: z.ZodString;
+                    asset: z.ZodString;
+                    amount: z.ZodString;
+                }, z.core.$loose>>;
+            }, z.core.$loose>>;
+            dao: z.ZodOptional<z.ZodObject<{
+                owner: z.ZodString;
+                transaction: z.ZodObject<{
+                    receiverId: z.ZodString;
+                    actions: z.ZodArray<z.ZodObject<{
+                        type: z.ZodLiteral<"FunctionCall">;
+                        params: z.ZodObject<{
+                            methodName: z.ZodString;
+                            args: z.ZodCustom<object, object>;
+                            gas: z.ZodString;
+                            deposit: z.ZodString;
+                        }, z.core.$loose>;
+                    }, z.core.$loose>>;
+                }, z.core.$loose>;
+                proposal: z.ZodNullable<z.ZodObject<{
+                    receiverId: z.ZodString;
+                    actions: z.ZodArray<z.ZodObject<{
+                        type: z.ZodLiteral<"FunctionCall">;
+                        params: z.ZodObject<{
+                            methodName: z.ZodString;
+                            args: z.ZodCustom<object, object>;
+                            gas: z.ZodString;
+                            deposit: z.ZodString;
+                        }, z.core.$loose>;
+                    }, z.core.$loose>>;
+                }, z.core.$loose>>;
+                proposalAndVote: z.ZodNullable<z.ZodObject<{
+                    receiverId: z.ZodString;
+                    actions: z.ZodArray<z.ZodObject<{
+                        type: z.ZodLiteral<"FunctionCall">;
+                        params: z.ZodObject<{
+                            methodName: z.ZodString;
+                            args: z.ZodCustom<object, object>;
+                            gas: z.ZodString;
+                            deposit: z.ZodString;
+                        }, z.core.$loose>;
+                    }, z.core.$loose>>;
+                }, z.core.$loose>>;
+            }, z.core.$loose>>;
+        }, z.core.$loose>, {
+            /** Refused before anything was sent: an earlier operation has no proven outcome, or another action holds the lock. */
+            CONFLICT: {
+                data: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    kind: z.ZodLiteral<"unresolved">;
+                }, z.core.$loose>, z.ZodObject<{
+                    kind: z.ZodLiteral<"busy">;
+                }, z.core.$loose>, z.ZodObject<{
+                    kind: z.ZodLiteral<"refused">;
+                    code: z.ZodOptional<z.ZodString>;
+                }, z.core.$loose>], "kind">;
+            };
+            /** Refused by the platform, or by the provider (with its code and supplementary details). */
+            BAD_REQUEST: {
+                data: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    kind: z.ZodLiteral<"refused">;
+                    code: z.ZodOptional<z.ZodString>;
+                }, z.core.$loose>, z.ZodObject<{
+                    kind: z.ZodLiteral<"provider">;
+                    code: z.ZodOptional<z.ZodString>;
+                    availableAt: z.ZodNullable<z.ZodString>;
+                    budgetRemainingUsd: z.ZodOptional<z.ZodString>;
+                }, z.core.$loose>], "kind">;
+            };
+        }>;
+        submit: import("@orpc/contract").ProcedureContractBuilderWithInputOutput<z.ZodObject<{
+            correlationId: z.ZodString;
+            signedData: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strip>, z.ZodObject<{
+            status: z.ZodString;
+            failureCode: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$loose>, {
+            /** Refused before anything was sent: an earlier operation has no proven outcome, or another action holds the lock. */
+            CONFLICT: {
+                data: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    kind: z.ZodLiteral<"unresolved">;
+                }, z.core.$loose>, z.ZodObject<{
+                    kind: z.ZodLiteral<"busy">;
+                }, z.core.$loose>, z.ZodObject<{
+                    kind: z.ZodLiteral<"refused">;
+                    code: z.ZodOptional<z.ZodString>;
+                }, z.core.$loose>], "kind">;
+            };
+            /** Refused by the platform, or by the provider (with its code and supplementary details). */
+            BAD_REQUEST: {
+                data: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    kind: z.ZodLiteral<"refused">;
+                    code: z.ZodOptional<z.ZodString>;
+                }, z.core.$loose>, z.ZodObject<{
+                    kind: z.ZodLiteral<"provider">;
+                    code: z.ZodOptional<z.ZodString>;
+                    availableAt: z.ZodNullable<z.ZodString>;
+                    budgetRemainingUsd: z.ZodOptional<z.ZodString>;
+                }, z.core.$loose>], "kind">;
+            };
+        }>;
+        status: import("@orpc/contract").ProcedureContractBuilderWithInputOutput<z.ZodObject<{
+            correlationId: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            stage: z.ZodEnum<{
+                expired: "expired";
+                failed: "failed";
+                submitted: "submitted";
+                submitting: "submitting";
+                unknown: "unknown";
+                voting: "voting";
+            }>;
+            status: z.ZodOptional<z.ZodString>;
+            failureCode: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            error: z.ZodOptional<z.ZodString>;
+            expiresAt: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>, {
+            /** Refused before anything was sent: an earlier operation has no proven outcome, or another action holds the lock. */
+            CONFLICT: {
+                data: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    kind: z.ZodLiteral<"unresolved">;
+                }, z.core.$loose>, z.ZodObject<{
+                    kind: z.ZodLiteral<"busy">;
+                }, z.core.$loose>, z.ZodObject<{
+                    kind: z.ZodLiteral<"refused">;
+                    code: z.ZodOptional<z.ZodString>;
+                }, z.core.$loose>], "kind">;
+            };
+            /** Refused by the platform, or by the provider (with its code and supplementary details). */
+            BAD_REQUEST: {
+                data: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    kind: z.ZodLiteral<"refused">;
+                    code: z.ZodOptional<z.ZodString>;
+                }, z.core.$loose>, z.ZodObject<{
+                    kind: z.ZodLiteral<"provider">;
+                    code: z.ZodOptional<z.ZodString>;
+                    availableAt: z.ZodNullable<z.ZodString>;
+                    budgetRemainingUsd: z.ZodOptional<z.ZodString>;
+                }, z.core.$loose>], "kind">;
+            };
+        }>;
+    };
+    rebalance: import("@orpc/contract").ProcedureContractBuilderWithOutput<import("@orpc/contract").Schema<AsyncIteratorObject<{
+        [x: string]: unknown;
+        type: "plan";
+        total: number;
+        book: {
+            [x: string]: unknown;
+            asset: string;
+            symbol: string;
+            decimals: number;
+            price: number;
+            public: bigint;
+            confidential: bigint;
+            usd: number;
+        }[];
+        legs: {
+            [x: string]: unknown;
+            from: {
+                [x: string]: unknown;
+                asset: string;
+                symbol: string;
+                decimals: number;
+                price: number;
+                public: bigint;
+                confidential: bigint;
+                usd: number;
+            };
+            to: {
+                [x: string]: unknown;
+                asset: string;
+                symbol: string;
+                decimals: number;
+                price: number;
+                public: bigint;
+                confidential: bigint;
+                usd: number;
+            };
+            usd: number;
+            amount: bigint;
+        }[];
+        budget?: string | null | undefined;
+        strategy: {
+            [x: string]: unknown;
+            targetBps: Record<string, number>;
+            minLegUsd: number;
+            maxCostBps: number;
+            autopilot: {
+                [x: string]: unknown;
+                everyMin: number;
+                maxUsd: number;
+            };
+        };
+    } | {
+        [x: string]: unknown;
+        type: "quote";
+        leg: number;
+        skipped: boolean;
+        amountOut: string;
+        minAmountOut: string;
+        costBps: number;
+        worstCostBps: number;
+    } | {
+        [x: string]: unknown;
+        type: "saved";
+        plan: {
+            [x: string]: unknown;
+            id: string;
+            source: "external" | "rebalance" | "steward";
+            createdAt: string;
+            expiresAt: string;
+            instruction: string;
+            actions: ({
+                [x: string]: unknown;
+                type: "swap";
+                from: string;
+                to: string;
+                amount: string;
+                amountOut: string;
+                minAmountOut: string;
+                costBps: number;
+            } | {
+                [x: string]: unknown;
+                type: "shield";
+                asset: string;
+                amount: string;
+            })[];
+            agentId: string;
+            policyRevision: number | null;
+            policyDigest: string | null;
+            strategyDigest: string;
+            balances: Record<string, {
+                [x: string]: unknown;
+                public: string;
+                confidential: string;
+            }>;
+        };
+        steps: (number | undefined)[];
+    }, unknown, void>, import("@orpc/contract").AsyncIteratorClass<{
+        [x: string]: unknown;
+        type: "plan";
+        total: number;
+        book: {
+            [x: string]: unknown;
+            asset: string;
+            symbol: string;
+            decimals: number;
+            price: number;
+            public: bigint;
+            confidential: bigint;
+            usd: number;
+        }[];
+        legs: {
+            [x: string]: unknown;
+            from: {
+                [x: string]: unknown;
+                asset: string;
+                symbol: string;
+                decimals: number;
+                price: number;
+                public: bigint;
+                confidential: bigint;
+                usd: number;
+            };
+            to: {
+                [x: string]: unknown;
+                asset: string;
+                symbol: string;
+                decimals: number;
+                price: number;
+                public: bigint;
+                confidential: bigint;
+                usd: number;
+            };
+            usd: number;
+            amount: bigint;
+        }[];
+        budget?: string | null | undefined;
+        strategy: {
+            [x: string]: unknown;
+            targetBps: Record<string, number>;
+            minLegUsd: number;
+            maxCostBps: number;
+            autopilot: {
+                [x: string]: unknown;
+                everyMin: number;
+                maxUsd: number;
+            };
+        };
+    } | {
+        [x: string]: unknown;
+        type: "quote";
+        leg: number;
+        skipped: boolean;
+        amountOut: string;
+        minAmountOut: string;
+        costBps: number;
+        worstCostBps: number;
+    } | {
+        [x: string]: unknown;
+        type: "saved";
+        plan: {
+            [x: string]: unknown;
+            id: string;
+            source: "external" | "rebalance" | "steward";
+            createdAt: string;
+            expiresAt: string;
+            instruction: string;
+            actions: ({
+                [x: string]: unknown;
+                type: "swap";
+                from: string;
+                to: string;
+                amount: string;
+                amountOut: string;
+                minAmountOut: string;
+                costBps: number;
+            } | {
+                [x: string]: unknown;
+                type: "shield";
+                asset: string;
+                amount: string;
+            })[];
+            agentId: string;
+            policyRevision: number | null;
+            policyDigest: string | null;
+            strategyDigest: string;
+            balances: Record<string, {
+                [x: string]: unknown;
+                public: string;
+                confidential: string;
+            }>;
+        };
+        steps: (number | undefined)[];
+    }, unknown, void>>, {
+        /** Refused before anything was sent: an earlier operation has no proven outcome, or another action holds the lock. */
+        CONFLICT: {
+            data: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"unresolved">;
+            }, z.core.$loose>, z.ZodObject<{
+                kind: z.ZodLiteral<"busy">;
+            }, z.core.$loose>, z.ZodObject<{
+                kind: z.ZodLiteral<"refused">;
+                code: z.ZodOptional<z.ZodString>;
+            }, z.core.$loose>], "kind">;
+        };
+        /** Refused by the platform, or by the provider (with its code and supplementary details). */
+        BAD_REQUEST: {
+            data: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"refused">;
+                code: z.ZodOptional<z.ZodString>;
+            }, z.core.$loose>, z.ZodObject<{
+                kind: z.ZodLiteral<"provider">;
+                code: z.ZodOptional<z.ZodString>;
+                availableAt: z.ZodNullable<z.ZodString>;
+                budgetRemainingUsd: z.ZodOptional<z.ZodString>;
+            }, z.core.$loose>], "kind">;
+        };
+    }>;
+    executePlan: import("@orpc/contract").ProcedureContractBuilderWithInputOutput<z.ZodObject<{
+        planId: z.ZodUUID;
+    }, z.core.$strip>, import("@orpc/contract").Schema<AsyncIteratorObject<{
+        [x: string]: unknown;
+        type: "rejected";
+        problems: string[];
+    } | {
+        [x: string]: unknown;
+        type: "action";
+        index: number;
+        action: {
+            [x: string]: unknown;
+            type: "swap";
+            from: string;
+            to: string;
+            amount: string;
+            amountOut: string;
+            minAmountOut: string;
+            costBps: number;
+        } | {
+            [x: string]: unknown;
+            type: "shield";
+            asset: string;
+            amount: string;
+        };
+        shield?: {
+            [x: string]: unknown;
+            amount: string;
+            status: string;
+        } | undefined;
+        status: string;
+        correlationId: string;
+        failureCode?: string | null | undefined;
+    }, unknown, void>, import("@orpc/contract").AsyncIteratorClass<{
+        [x: string]: unknown;
+        type: "rejected";
+        problems: string[];
+    } | {
+        [x: string]: unknown;
+        type: "action";
+        index: number;
+        action: {
+            [x: string]: unknown;
+            type: "swap";
+            from: string;
+            to: string;
+            amount: string;
+            amountOut: string;
+            minAmountOut: string;
+            costBps: number;
+        } | {
+            [x: string]: unknown;
+            type: "shield";
+            asset: string;
+            amount: string;
+        };
+        shield?: {
+            [x: string]: unknown;
+            amount: string;
+            status: string;
+        } | undefined;
+        status: string;
+        correlationId: string;
+        failureCode?: string | null | undefined;
+    }, unknown, void>>, {
+        /** Refused before anything was sent: an earlier operation has no proven outcome, or another action holds the lock. */
+        CONFLICT: {
+            data: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"unresolved">;
+            }, z.core.$loose>, z.ZodObject<{
+                kind: z.ZodLiteral<"busy">;
+            }, z.core.$loose>, z.ZodObject<{
+                kind: z.ZodLiteral<"refused">;
+                code: z.ZodOptional<z.ZodString>;
+            }, z.core.$loose>], "kind">;
+        };
+        /** Refused by the platform, or by the provider (with its code and supplementary details). */
+        BAD_REQUEST: {
+            data: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"refused">;
+                code: z.ZodOptional<z.ZodString>;
+            }, z.core.$loose>, z.ZodObject<{
+                kind: z.ZodLiteral<"provider">;
+                code: z.ZodOptional<z.ZodString>;
+                availableAt: z.ZodNullable<z.ZodString>;
+                budgetRemainingUsd: z.ZodOptional<z.ZodString>;
+            }, z.core.$loose>], "kind">;
+        };
+    }>;
+};
+export type OwnerContract = typeof ownerContract;