@conto_finance/sdk 0.1.0

package/dist/index.d.mts

@@ -0,0 +1,753 @@
+/**
+ * Conto Admin SDK
+ *
+ * Organization-level admin client for managing agents, wallets, and policies.
+ * Requires an organization API key (conto_xxx...) with appropriate scopes.
+ *
+ * Usage:
+ * ```typescript
+ * import { ContoAdmin } from '@conto_finance/sdk';
+ *
+ * const admin = new ContoAdmin({
+ *   orgApiKey: 'conto_xxx...',
+ *   baseUrl: 'https://conto.finance'
+ * });
+ *
+ * // Create a policy with spend limits
+ * const policy = await admin.policies.create({
+ *   name: 'Daily limit',
+ *   policyType: 'SPEND_LIMIT',
+ *   rules: [{ ruleType: 'DAILY_LIMIT', operator: 'LTE', value: '1000' }],
+ * });
+ *
+ * // Assign it to an agent
+ * await admin.agents.assignPolicy(agentId, policy.id);
+ * ```
+ */
+interface ContoAdminConfig {
+    /** Your organization API key (conto_xxx...) */
+    orgApiKey: string;
+    /** Base URL of the Conto API. Defaults to https://conto.finance */
+    baseUrl?: string;
+    /** Request timeout in milliseconds. Defaults to 30000 */
+    timeout?: number;
+}
+interface ContoAdminError extends Error {
+    code: string;
+    status: number;
+}
+interface PaginationParams {
+    limit?: number;
+    offset?: number;
+}
+interface PaginatedResponse<T> {
+    items: T[];
+    total: number;
+    limit: number;
+    offset: number;
+}
+type AgentType = 'OPENAI_ASSISTANT' | 'ANTHROPIC_CLAUDE' | 'LANGCHAIN' | 'AUTOGPT' | 'CUSTOM';
+type AgentStatus = 'ACTIVE' | 'PAUSED' | 'SUSPENDED' | 'REVOKED' | 'FROZEN' | 'DELETED';
+type AgentEnvironment = 'DEV' | 'STAGING' | 'PROD';
+type AgentRiskTier = 'LOW' | 'MEDIUM' | 'HIGH' | 'CRITICAL';
+type AgentAttestationMode = 'KEY_ONLY' | 'SIGNED_REQUEST' | 'SIGNED_REQUEST_WITH_CONTEXT';
+type DelegationType = 'FULL' | 'LIMITED' | 'VIEW_ONLY' | 'PREAPPROVED' | 'ALLOWLIST';
+type ChainType = 'EVM' | 'SOLANA';
+type CustodyType = 'PRIVY' | 'SPONGE' | 'EXTERNAL' | 'SMART_CONTRACT';
+type WalletType = 'EOA' | 'SMART_WALLET' | 'MULTISIG';
+type WalletStatus = 'ACTIVE' | 'FROZEN' | 'CLOSED' | 'ARCHIVED';
+type PolicyType = 'SPEND_LIMIT' | 'MERCHANT' | 'TIME_WINDOW' | 'CATEGORY' | 'VELOCITY' | 'COMPOSITE' | 'GEOGRAPHIC' | 'APPROVAL_THRESHOLD' | 'COUNTERPARTY' | 'BUDGET_ALLOCATION' | 'WHITELIST' | 'EXPIRATION' | 'CONTRACT_ALLOWLIST' | 'BLACKOUT_PERIOD';
+type RuleType = 'MAX_AMOUNT' | 'DAILY_LIMIT' | 'WEEKLY_LIMIT' | 'MONTHLY_LIMIT' | 'ALLOWED_CATEGORIES' | 'BLOCKED_CATEGORIES' | 'ALLOWED_COUNTERPARTIES' | 'BLOCKED_COUNTERPARTIES' | 'TIME_WINDOW' | 'DAY_OF_WEEK' | 'VELOCITY_LIMIT' | 'REQUIRE_APPROVAL_ABOVE' | 'GEOGRAPHIC_RESTRICTION' | 'TRUST_SCORE' | 'COUNTERPARTY_STATUS' | 'BUDGET_CAP' | 'DATE_RANGE' | 'CONTRACT_ALLOWLIST' | 'ALLOWED_CONTRACTS' | 'PROTOCOL_ALLOWLIST' | 'BLACKOUT_PERIOD' | 'MAINTENANCE_WINDOW' | 'BLOCKED_TIME_WINDOW';
+type RuleOperator = 'EQUALS' | 'NOT_EQUALS' | 'GREATER_THAN' | 'LESS_THAN' | 'GTE' | 'LTE' | 'IN' | 'NOT_IN' | 'IN_LIST' | 'NOT_IN_LIST' | 'BETWEEN' | 'NOT_BETWEEN' | 'DENY';
+type RuleAction = 'ALLOW' | 'DENY' | 'REQUIRE_APPROVAL';
+type SdkKeyType = 'standard' | 'admin';
+interface Agent {
+    id: string;
+    name: string;
+    description: string | null;
+    agentIdSlug?: string | null;
+    purpose?: string | null;
+    agentType: AgentType;
+    environment?: AgentEnvironment;
+    riskTier?: AgentRiskTier;
+    publicKey: string;
+    status: AgentStatus;
+    externalId: string | null;
+    attestationMode?: AgentAttestationMode;
+    identityTags?: string[];
+    ownerMembershipId?: string | null;
+    owner?: {
+        membershipId: string;
+        role: string;
+        userId?: string | null;
+        name?: string | null;
+        email?: string | null;
+    } | null;
+    allowedContexts: string | null;
+    organizationId: string;
+    createdAt: string;
+    updatedAt: string;
+    wallets?: AgentWalletLink[];
+    _count?: {
+        sentTransactions: number;
+    };
+}
+interface CreateAgentInput {
+    name: string;
+    agentType: AgentType;
+    description?: string;
+    publicKey?: string;
+    agentIdSlug?: string;
+    purpose?: string;
+    externalId?: string;
+    environment?: AgentEnvironment;
+    riskTier?: AgentRiskTier;
+    ownerMembershipId?: string;
+    attestationMode?: AgentAttestationMode;
+    identityTags?: string[];
+    allowedContexts?: string[];
+}
+interface UpdateAgentInput {
+    name?: string;
+    description?: string;
+    status?: 'ACTIVE' | 'PAUSED' | 'SUSPENDED' | 'REVOKED';
+    agentIdSlug?: string;
+    purpose?: string | null;
+    externalId?: string;
+    environment?: AgentEnvironment;
+    riskTier?: AgentRiskTier;
+    ownerMembershipId?: string | null;
+    attestationMode?: AgentAttestationMode;
+    identityTags?: string[] | null;
+    allowedContexts?: string[];
+}
+interface ListAgentsParams extends PaginationParams {
+    status?: string;
+    search?: string;
+}
+interface ListAgentsResponse {
+    agents: Agent[];
+    total: number;
+    limit: number;
+    offset: number;
+}
+interface FreezeAgentInput {
+    reason: string;
+    freezeWallets?: boolean;
+}
+interface UnfreezeAgentInput {
+    reason: string;
+    unfreezeWallets?: boolean;
+    resetCounters?: boolean;
+}
+interface AgentWalletLink {
+    id: string;
+    agentId: string;
+    walletId: string;
+    delegationType: DelegationType;
+    spendLimitPerTx: number;
+    spendLimitDaily: number;
+    spendLimitWeekly: number | null;
+    spendLimitMonthly: number | null;
+    isActive: boolean;
+    wallet?: {
+        id: string;
+        name: string;
+        address: string;
+        usdcBalance: number;
+        status: string;
+        custodyType?: string;
+    };
+}
+interface OrganizationMember {
+    id: string;
+    organizationId: string;
+    userId: string;
+    role: 'OWNER' | 'ADMIN' | 'MANAGER' | 'VIEWER' | 'MEMBER';
+    createdAt: string;
+    updatedAt: string;
+    user: {
+        id: string;
+        name: string | null;
+        email: string | null;
+        image?: string | null;
+    } | null;
+}
+interface LinkWalletInput {
+    walletId: string;
+    delegationType?: DelegationType;
+    spendLimitPerTx?: number;
+    spendLimitDaily?: number;
+    spendLimitWeekly?: number;
+    spendLimitMonthly?: number;
+    allowedHoursStart?: number;
+    allowedHoursEnd?: number;
+    allowedDays?: string[];
+}
+interface SdkKey {
+    id: string;
+    name: string;
+    keyPrefix: string;
+    keyType: SdkKeyType;
+    isActive: boolean;
+    lastUsedAt: string | null;
+    usageCount: number;
+    expiresAt: string | null;
+    createdAt: string;
+    revokedAt: string | null;
+}
+interface CreateSdkKeyInput {
+    name: string;
+    keyType?: SdkKeyType;
+    expiresInDays?: number;
+}
+interface CreateSdkKeyResult {
+    id: string;
+    key: string;
+    name: string;
+    keyType: SdkKeyType;
+    message: string;
+}
+interface Wallet {
+    id: string;
+    name: string;
+    address: string;
+    chainType: ChainType;
+    chainId: string;
+    walletType: WalletType;
+    custodyType: CustodyType;
+    usdcBalance: number;
+    status: WalletStatus;
+    externalWalletId: string | null;
+    organizationId: string;
+    createdAt: string;
+    updatedAt: string;
+}
+interface CreateWalletInput {
+    name: string;
+    chainType?: ChainType;
+    chainId?: string;
+    custodyType?: CustodyType;
+    walletType?: WalletType;
+    address?: string;
+    externalWalletId?: string;
+    importAddress?: string;
+    isWatchOnly?: boolean;
+}
+interface UpdateWalletInput {
+    name?: string;
+    status?: WalletStatus;
+}
+interface ListWalletsParams extends PaginationParams {
+    status?: string;
+    chainType?: ChainType;
+    chainId?: string;
+}
+interface ListWalletsResponse {
+    wallets: Wallet[];
+    total: number;
+    limit: number;
+    offset: number;
+}
+interface ProvisionWalletResult {
+    wallet: {
+        id: string;
+        name: string;
+        address: string;
+        chainId: string;
+        chainType: string;
+        custodyType: string;
+        balance: number;
+        currency: string;
+    };
+    chain: {
+        name: string;
+        chainId: string;
+        explorer: string;
+    };
+}
+interface WalletChainBalanceSnapshot {
+    chainId: string;
+    chainName: string;
+    balance: number;
+    symbol: string;
+    isTestnet: boolean;
+}
+interface RefreshBalanceResult {
+    totalBalance: number;
+    balances: WalletChainBalanceSnapshot[];
+    lastRefreshed: string;
+}
+interface PolicyRule {
+    id: string;
+    policyId: string;
+    ruleType: string;
+    operator: string;
+    value: string;
+    action: RuleAction;
+    createdAt: string;
+}
+interface Policy {
+    id: string;
+    name: string;
+    description: string | null;
+    policyType: PolicyType;
+    priority: number;
+    isActive: boolean;
+    organizationId: string;
+    rules?: PolicyRule[];
+    createdAt: string;
+    updatedAt: string;
+    _count?: {
+        agentPolicies: number;
+    };
+}
+interface CreatePolicyInput {
+    name: string;
+    policyType: PolicyType;
+    description?: string;
+    priority?: number;
+    isActive?: boolean;
+    rules?: CreatePolicyRuleInput[];
+    agentIds?: string[];
+}
+interface UpdatePolicyInput {
+    name?: string;
+    description?: string;
+    priority?: number;
+    isActive?: boolean;
+}
+interface ListPoliciesParams extends PaginationParams {
+}
+interface ListPoliciesResponse {
+    policies: Policy[];
+    total: number;
+    limit: number;
+    offset: number;
+}
+interface CreatePolicyRuleInput {
+    ruleType: RuleType;
+    operator: RuleOperator;
+    value: string;
+    action?: RuleAction;
+}
+interface UpdatePolicyRuleInput {
+    ruleType?: RuleType;
+    operator?: RuleOperator;
+    value?: string;
+    action?: RuleAction;
+}
+declare class ContoAdmin {
+    private orgApiKey;
+    private baseUrl;
+    private timeout;
+    agents: AgentsClient;
+    wallets: WalletsClient;
+    policies: PoliciesClient;
+    team: TeamClient;
+    constructor(config: ContoAdminConfig);
+    private fetchWithRetry;
+    /** Make an authenticated request to the Conto API */
+    request<T>(method: string, path: string, body?: Record<string, unknown>): Promise<T>;
+}
+declare class AgentsClient {
+    private client;
+    constructor(client: ContoAdmin);
+    /** List agents in the organization */
+    list(params?: ListAgentsParams): Promise<ListAgentsResponse>;
+    /** Create a new agent */
+    create(input: CreateAgentInput): Promise<Agent>;
+    /** Get a single agent by ID */
+    get(agentId: string): Promise<Agent>;
+    /** Update an agent */
+    update(agentId: string, input: UpdateAgentInput): Promise<Agent>;
+    /** Delete an agent (soft delete) */
+    delete(agentId: string): Promise<{
+        message: string;
+    }>;
+    /** Freeze an agent, blocking all transactions */
+    freeze(agentId: string, input: FreezeAgentInput): Promise<Record<string, unknown>>;
+    /** Unfreeze an agent, restoring transaction ability */
+    unfreeze(agentId: string, input: UnfreezeAgentInput): Promise<Record<string, unknown>>;
+    /** List wallets linked to an agent */
+    listWallets(agentId: string): Promise<{
+        wallets: AgentWalletLink[];
+    }>;
+    /** Link a wallet to an agent with spending limits */
+    linkWallet(agentId: string, input: LinkWalletInput): Promise<AgentWalletLink>;
+    /** Unlink a wallet from an agent */
+    unlinkWallet(agentId: string, walletId: string): Promise<{
+        success: boolean;
+    }>;
+    /** List policies assigned to an agent */
+    listPolicies(agentId: string): Promise<{
+        policies: Array<Record<string, unknown>>;
+    }>;
+    /** Assign a policy to an agent */
+    assignPolicy(agentId: string, policyId: string, overrides?: Record<string, unknown>): Promise<Record<string, unknown>>;
+    /** Unassign a policy from an agent */
+    unassignPolicy(agentId: string, policyId: string): Promise<{
+        success: boolean;
+    }>;
+    /** List SDK keys for an agent */
+    listSdkKeys(agentId: string): Promise<SdkKey[]>;
+    /** Create an SDK key for an agent (key value is returned only once) */
+    createSdkKey(agentId: string, input: CreateSdkKeyInput): Promise<CreateSdkKeyResult>;
+    /** Revoke an SDK key */
+    revokeSdkKey(agentId: string, keyId: string): Promise<{
+        success: boolean;
+    }>;
+}
+declare class WalletsClient {
+    private client;
+    constructor(client: ContoAdmin);
+    /** List wallets in the organization */
+    list(params?: ListWalletsParams): Promise<ListWalletsResponse>;
+    /** Create a new wallet or attach an existing provider/self-custodied wallet */
+    create(input: CreateWalletInput): Promise<Wallet>;
+    /** Get a single wallet by ID */
+    get(walletId: string): Promise<Wallet>;
+    /** Update a wallet */
+    update(walletId: string, input: UpdateWalletInput): Promise<Wallet>;
+    /** Delete a wallet (cannot delete if linked to agents) */
+    delete(walletId: string): Promise<{
+        success: boolean;
+    }>;
+    /** Provision a wallet for onchain transactions */
+    provision(walletId: string): Promise<ProvisionWalletResult>;
+    /** Refresh a wallet's balance from the chain */
+    refreshBalance(walletId: string): Promise<RefreshBalanceResult>;
+}
+declare class PoliciesClient {
+    private client;
+    constructor(client: ContoAdmin);
+    /** List policies in the organization */
+    list(params?: ListPoliciesParams): Promise<ListPoliciesResponse>;
+    /** Create a new policy (optionally with rules and agent assignments) */
+    create(input: CreatePolicyInput): Promise<Policy>;
+    /** Get a single policy by ID */
+    get(policyId: string): Promise<Policy>;
+    /** Update a policy */
+    update(policyId: string, input: UpdatePolicyInput): Promise<Policy>;
+    /** Delete a policy */
+    delete(policyId: string): Promise<{
+        success: boolean;
+    }>;
+    /** List rules for a policy */
+    listRules(policyId: string): Promise<{
+        rules: PolicyRule[];
+    }>;
+    /** Add a single rule to a policy */
+    addRule(policyId: string, rule: CreatePolicyRuleInput): Promise<{
+        rules: PolicyRule[];
+    }>;
+    /** Add multiple rules to a policy */
+    addRules(policyId: string, rules: CreatePolicyRuleInput[]): Promise<{
+        rules: PolicyRule[];
+    }>;
+    /** Update a single rule */
+    updateRule(policyId: string, ruleId: string, input: UpdatePolicyRuleInput): Promise<PolicyRule>;
+    /** Delete a single rule */
+    deleteRule(policyId: string, ruleId: string): Promise<{
+        success: boolean;
+    }>;
+    /** Delete all rules for a policy */
+    deleteAllRules(policyId: string): Promise<{
+        success: boolean;
+        deletedCount: number;
+    }>;
+}
+declare class TeamClient {
+    private client;
+    constructor(client: ContoAdmin);
+    /** List organization memberships for the authenticated organization */
+    listMembers(): Promise<{
+        organizationId: string;
+        members: OrganizationMember[];
+    }>;
+}
+
+/**
+ * Conto SDK
+ *
+ * SDK for AI agents to request and execute payments through Conto.
+ *
+ * Usage:
+ * ```typescript
+ * import { Conto } from '@conto_finance/sdk';
+ *
+ * const conto = new Conto({
+ *   apiKey: 'conto_agent_xxx...',
+ *   baseUrl: 'https://conto.finance' // or your self-hosted URL
+ * });
+ *
+ * // Request a payment
+ * const request = await conto.payments.request({
+ *   amount: 10.00,
+ *   recipientAddress: '0x...',
+ *   purpose: 'API usage fee'
+ * });
+ *
+ * // Execute if approved
+ * if (request.status === 'APPROVED') {
+ *   const result = await conto.payments.execute(request.requestId);
+ *   console.log(`Payment sent: ${result.txHash}`);
+ * }
+ * ```
+ */
+interface ContoConfig {
+    /** Your agent's SDK API key (conto_agent_xxx...) */
+    apiKey: string;
+    /** Base URL of the Conto API. Defaults to https://conto.finance */
+    baseUrl?: string;
+    /** Request timeout in milliseconds. Defaults to 30000 */
+    timeout?: number;
+}
+interface PaymentRequestInput {
+    /** Amount in the wallet chain stablecoin */
+    amount: number;
+    /** Recipient wallet address (0x...) */
+    recipientAddress: string;
+    /** Human-readable recipient name */
+    recipientName?: string;
+    /** Why this payment is needed */
+    purpose?: string;
+    /** Spend category for analytics */
+    category?: string;
+    /** Additional context (will be stored) */
+    context?: Record<string, unknown>;
+    /** Specific wallet ID to use (optional) */
+    walletId?: string;
+    /** Payment urgency */
+    urgency?: 'LOW' | 'NORMAL' | 'HIGH' | 'CRITICAL';
+    /** If true, automatically execute the payment if approved (skip separate execute call) */
+    autoExecute?: boolean;
+    /** Contract address for contract-aware policy evaluation */
+    targetContractAddress?: string;
+    /** 4-byte function selector for contract allowlist checks */
+    functionSelector?: string;
+    /** Client-supplied key for idempotent retries */
+    idempotencyKey?: string;
+}
+interface PaymentRequestResult {
+    /** Unique request ID - use this to execute or check status */
+    requestId: string;
+    /** Current status */
+    status: 'APPROVED' | 'DENIED' | 'REQUIRES_APPROVAL' | 'EXECUTED';
+    /** True when the server returned a previously-created request for the same idempotency key */
+    idempotent?: boolean;
+    /** Wallet that will be used for payment (if approved) */
+    wallet?: {
+        id: string;
+        address: string;
+        chainId: string;
+        custodyType: string;
+        availableBalance: number;
+    };
+    /** When the approval expires (ISO timestamp) */
+    expiresAt?: string;
+    /** Explanation of the decision */
+    reasons: string[];
+    /** Policy violations (if denied) */
+    violations?: PolicyViolation[];
+    /** Currency used for the payment (e.g., 'USDC', 'USDC.e', 'pathUSD') */
+    currency?: string;
+    /** Chain information for the selected wallet */
+    chain?: {
+        chainId: string;
+        chainName: string;
+        chainType: string;
+        explorerUrl: string;
+    };
+    /** URL to execute this payment (convenience) */
+    executeUrl?: string;
+    /** Session ID for tracking (used in x402/MPP flows) */
+    sessionId?: string | null;
+    /** Explanation of why this wallet was selected */
+    walletSelectionReason?: string;
+    /** If autoExecute was true and approved, contains the execution result */
+    execution?: {
+        transactionId: string;
+        txHash: string;
+        explorerUrl: string;
+        status: string;
+    };
+    /** If autoExecute failed, the payment is still approved and can be executed manually */
+    autoExecuteError?: {
+        error: string;
+        code?: string;
+    };
+    /** Human-readable recovery hint for denied requests */
+    hint?: string;
+    /** Additional structured context for recovery or debugging */
+    context?: {
+        wallets?: Array<{
+            id: string;
+            address: string;
+            chainId?: string | null;
+            custodyType?: string | null;
+            balance: number;
+        }>;
+        nextSteps?: string[];
+    };
+}
+interface PolicyViolation {
+    type: string;
+    limit: number;
+    current: number;
+    message: string;
+}
+interface PaymentExecuteResult {
+    /** Internal transaction ID */
+    transactionId: string;
+    /** Onchain transaction hash */
+    txHash: string;
+    /** Transaction status */
+    status: 'CONFIRMING' | 'CONFIRMED' | 'FAILED';
+    /** Amount sent */
+    amount: number;
+    /** Currency (USDC) */
+    currency: string;
+    /** Recipient address */
+    recipient: string;
+    /** Recipient name if provided */
+    recipientName?: string;
+    /** Wallet used */
+    wallet: {
+        address: string;
+    };
+    /** Block explorer URL */
+    explorerUrl: string;
+}
+interface PaymentStatusResult {
+    requestId: string;
+    status: string;
+    policyResult: string;
+    amount: number;
+    currency: string;
+    recipient: string;
+    recipientName?: string;
+    purpose?: string;
+    category?: string;
+    wallet?: {
+        address: string;
+    };
+    requiresApproval: boolean;
+    approvedAt?: string;
+    deniedAt?: string;
+    denialReason?: string;
+    expiresAt?: string;
+    createdAt: string;
+    transaction?: {
+        id: string;
+        txHash: string;
+        status: string;
+        confirmedAt?: string;
+        blockNumber?: number;
+    };
+}
+interface ContoError extends Error {
+    code: string;
+    status: number;
+}
+declare class Conto {
+    private apiKey;
+    private baseUrl;
+    private timeout;
+    payments: PaymentsClient;
+    constructor(config: ContoConfig);
+    private fetchWithRetry;
+    /** Make an authenticated request to the Giro API */
+    request<T>(method: string, path: string, body?: Record<string, unknown>): Promise<T>;
+}
+/** Client for payment operations */
+declare class PaymentsClient {
+    private client;
+    constructor(client: Conto);
+    /**
+     * Request authorization for a payment.
+     *
+     * This evaluates spending policies and returns whether the payment
+     * is approved, denied, or requires manual approval.
+     *
+     * @example
+     * ```typescript
+     * const request = await conto.payments.request({
+     *   amount: 25.00,
+     *   recipientAddress: '0x742d35Cc6634C0532925a3b844Bc9e7595f...',
+     *   recipientName: 'OpenAI',
+     *   purpose: 'GPT-4 API credits',
+     *   category: 'API_PROVIDER'
+     * });
+     *
+     * if (request.status === 'APPROVED') {
+     *   // Payment is pre-authorized, execute it
+     *   const result = await conto.payments.execute(request.requestId);
+     * } else if (request.status === 'REQUIRES_APPROVAL') {
+     *   // Wait for human approval
+     *   console.log('Payment requires manual approval');
+     * } else {
+     *   // Payment was denied
+     *   console.log('Denied:', request.reasons.join(', '));
+     * }
+     * ```
+     */
+    request(input: PaymentRequestInput): Promise<PaymentRequestResult>;
+    /**
+     * Execute an approved payment.
+     *
+     * This sends the onchain transaction. Only works for payments
+     * with status 'APPROVED'.
+     *
+     * @param requestId - The requestId from a successful payment request
+     *
+     * @example
+     * ```typescript
+     * const result = await conto.payments.execute(request.requestId);
+     * console.log(`Transaction: ${result.txHash}`);
+     * console.log(`Explorer: ${result.explorerUrl}`);
+     * ```
+     */
+    execute(requestId: string): Promise<PaymentExecuteResult>;
+    /**
+     * Get the status of a payment request.
+     *
+     * @param requestId - The requestId to check
+     *
+     * @example
+     * ```typescript
+     * const status = await conto.payments.status(requestId);
+     * if (status.transaction?.status === 'CONFIRMED') {
+     *   console.log('Payment confirmed at block', status.transaction.blockNumber);
+     * }
+     * ```
+     */
+    status(requestId: string): Promise<PaymentStatusResult>;
+    /**
+     * Request and execute a payment in one call.
+     *
+     * Convenience method that requests authorization and immediately
+     * executes if approved. Throws if denied or requires approval.
+     *
+     * @example
+     * ```typescript
+     * try {
+     *   const result = await conto.payments.pay({
+     *     amount: 10.00,
+     *     recipientAddress: '0x...',
+     *     purpose: 'Service fee'
+     *   });
+     *   console.log(`Paid! TX: ${result.txHash}`);
+     * } catch (error) {
+     *   if (error.code === 'REQUIRES_APPROVAL') {
+     *     console.log('Payment needs human approval');
+     *   } else {
+     *     console.log('Payment denied:', error.message);
+     *   }
+     * }
+     * ```
+     */
+    pay(input: PaymentRequestInput): Promise<PaymentExecuteResult>;
+}
+
+export { type Agent, type AgentStatus, type AgentType, type AgentWalletLink, type ChainType, Conto, ContoAdmin, type ContoAdminConfig, type ContoAdminError, type ContoConfig, type ContoError, type CreateAgentInput, type CreatePolicyInput, type CreatePolicyRuleInput, type CreateSdkKeyInput, type CreateSdkKeyResult, type CreateWalletInput, type CustodyType, type DelegationType, type FreezeAgentInput, Conto as Giro, type ContoConfig as GiroConfig, type ContoError as GiroError, type LinkWalletInput, type ListAgentsParams, type ListAgentsResponse, type ListPoliciesParams, type ListPoliciesResponse, type ListWalletsParams, type ListWalletsResponse, type PaginatedResponse, type PaginationParams, type PaymentExecuteResult, type PaymentRequestInput, type PaymentRequestResult, type PaymentStatusResult, type Policy, type PolicyRule, type PolicyType, type PolicyViolation, type ProvisionWalletResult, type RefreshBalanceResult, type RuleAction, type RuleOperator, type RuleType, type SdkKey, type SdkKeyType, type UnfreezeAgentInput, type UpdateAgentInput, type UpdatePolicyInput, type UpdatePolicyRuleInput, type UpdateWalletInput, type Wallet, type WalletChainBalanceSnapshot, type WalletStatus, type WalletType, Conto as default };