@coinbase/cdp-api-client 0.0.0 → 0.0.5

package/dist/types/index.d.ts

@@ -0,0 +1,1458 @@
+import { AxiosRequestConfig } from 'axios';
+
+export declare type Abi = AbiItem[];
+
+export declare interface AbiFunction {
+    type: AbiFunctionType;
+    name: string;
+    inputs: AbiParameter[];
+    outputs: AbiParameter[];
+    constant?: boolean;
+    payable?: boolean;
+    stateMutability: AbiStateMutability;
+    gas?: number;
+}
+
+export declare type AbiFunctionType = (typeof AbiFunctionType)[keyof typeof AbiFunctionType];
+
+export declare const AbiFunctionType: {
+    readonly function: "function";
+};
+
+export declare interface AbiInput {
+    type: AbiInputType;
+    additionalProperties?: unknown;
+}
+
+export declare type AbiInputType = (typeof AbiInputType)[keyof typeof AbiInputType];
+
+export declare const AbiInputType: {
+    readonly constructor: "constructor";
+    readonly error: "error";
+    readonly event: "event";
+    readonly fallback: "fallback";
+    readonly receive: "receive";
+};
+
+export declare type AbiItem = AbiFunction | AbiInput;
+
+export declare interface AbiParameter {
+    name?: string;
+    type: string;
+    internalType?: string;
+    components?: AbiParameter[];
+}
+
+export declare type AbiStateMutability = (typeof AbiStateMutability)[keyof typeof AbiStateMutability];
+
+export declare const AbiStateMutability: {
+    readonly pure: "pure";
+    readonly view: "view";
+    readonly nonpayable: "nonpayable";
+    readonly payable: "payable";
+};
+
+export declare interface AccountTokenAddressesResponse {
+    accountAddress?: string;
+    tokenAddresses?: string[];
+    totalCount?: number;
+}
+
+export declare type AlreadyExistsErrorResponse = Error_2;
+
+export declare type AuthenticationMethod = EmailAuthentication | DeveloperJWTAuthentication;
+
+export declare type AuthenticationMethods = AuthenticationMethod[];
+
+export declare interface AuthManager {
+    getToken: () => Promise<string | null>;
+    getXWalletAuth: (options: {
+        requestMethod: string;
+        requestHost: string;
+        requestPath: string;
+        requestData?: Record<string, unknown>;
+    }) => Promise<string>;
+}
+
+export declare type BadGatewayErrorResponse = Error_2;
+
+declare const cdpApiClient: <T>(config: AxiosRequestConfig, idempotencyKey?: string) => Promise<T>;
+
+export declare type CdpOptions = {
+    debugging?: boolean;
+    basePath?: string;
+};
+
+export declare interface CommonSwapResponse {
+    blockNumber: string;
+    toAmount: string;
+    toToken: string;
+    fees: CommonSwapResponseFees;
+    issues: CommonSwapResponseIssues;
+    liquidityAvailable: boolean;
+    minToAmount: string;
+    fromAmount: string;
+    fromToken: string;
+}
+
+export declare type CommonSwapResponseFees = {
+    gasFee: CommonSwapResponseFeesGasFee;
+    protocolFee: CommonSwapResponseFeesProtocolFee;
+};
+
+export declare type CommonSwapResponseFeesGasFee = TokenFee | null;
+
+export declare type CommonSwapResponseFeesProtocolFee = TokenFee | null;
+
+export declare type CommonSwapResponseIssues = {
+    allowance: CommonSwapResponseIssuesAllowance;
+    balance: CommonSwapResponseIssuesBalance;
+    simulationIncomplete: boolean;
+};
+
+export declare type CommonSwapResponseIssuesAllowance = {
+    currentAllowance: string;
+    spender: string;
+} | null;
+
+export declare type CommonSwapResponseIssuesBalance = {
+    token: string;
+    currentBalance: string;
+    requiredBalance: string;
+} | null;
+
+export declare const configureCdpApiClient: (options: CdpOptions) => void;
+
+export declare const createEndUserEvmAccount: (projectId: string, userId: string, createEndUserEvmAccountBody: CreateEndUserEvmAccountBody, options?: SecondParameter<typeof cdpApiClient>) => Promise<EndUser>;
+
+export declare type CreateEndUserEvmAccountBody = {
+    walletSecretId?: string;
+};
+
+export declare type CreateEndUserEvmAccountResult = NonNullable<Awaited<ReturnType<typeof createEndUserEvmAccount>>>;
+
+export declare type CreateSwapQuoteResponse = CreateSwapQuoteResponseAllOf & CommonSwapResponse;
+
+export declare type CreateSwapQuoteResponseAllOf = {
+    permit2: CreateSwapQuoteResponseAllOfPermit2;
+    transaction: CreateSwapQuoteResponseAllOfTransaction;
+};
+
+export declare type CreateSwapQuoteResponseAllOfPermit2 = {
+    hash: string;
+    eip712: EIP712Message;
+} | null;
+
+export declare type CreateSwapQuoteResponseAllOfTransaction = {
+    to: string;
+    data: string;
+    gas: string;
+    gasPrice: string;
+    value: string;
+};
+
+export declare type CreateSwapQuoteResponseWrapper = CreateSwapQuoteResponse | SwapUnavailableResponse;
+
+export declare interface CryptoRail {
+    currency: string;
+    name: string;
+    networks: CryptoRailNetworksItem[];
+    actions: PaymentRailAction[];
+}
+
+export declare interface CryptoRailAddress {
+    currency: string;
+    network: string;
+    address: string;
+}
+
+export declare type CryptoRailNetworksItem = {
+    name?: string;
+    chainId?: number;
+    contractAddress?: string;
+};
+
+export declare interface DeveloperJWTAuthentication {
+    type: DeveloperJWTAuthenticationType;
+    kid: string;
+    sub: string;
+}
+
+export declare type DeveloperJWTAuthenticationType = (typeof DeveloperJWTAuthenticationType)[keyof typeof DeveloperJWTAuthenticationType];
+
+export declare const DeveloperJWTAuthenticationType: {
+    readonly jwt: "jwt";
+};
+
+export declare interface EIP712Domain {
+    name?: string;
+    version?: string;
+    chainId?: number;
+    verifyingContract?: string;
+    salt?: string;
+}
+
+export declare interface EIP712Message {
+    domain: EIP712Domain;
+    types: EIP712Types;
+    primaryType: string;
+    message: EIP712MessageMessage;
+}
+
+export declare type EIP712MessageMessage = {
+    [key: string]: unknown;
+};
+
+export declare interface EIP712Types {
+    [key: string]: unknown;
+}
+
+export declare interface EmailAuthentication {
+    type: EmailAuthenticationType;
+    email: string;
+}
+
+export declare type EmailAuthenticationType = (typeof EmailAuthenticationType)[keyof typeof EmailAuthenticationType];
+
+export declare const EmailAuthenticationType: {
+    readonly email: "email";
+};
+
+export declare interface EndUser {
+    userId: string;
+    authenticationMethods: AuthenticationMethods;
+    evmAccounts?: string[];
+}
+
+declare interface Error_2 {
+    errorType: ErrorType;
+    errorMessage: string;
+    correlationId?: string;
+    errorLink?: string;
+}
+export { Error_2 as Error }
+
+export declare type ErrorType = (typeof ErrorType)[keyof typeof ErrorType];
+
+export declare const ErrorType: {
+    readonly already_exists: "already_exists";
+    readonly bad_gateway: "bad_gateway";
+    readonly faucet_limit_exceeded: "faucet_limit_exceeded";
+    readonly forbidden: "forbidden";
+    readonly idempotency_error: "idempotency_error";
+    readonly internal_server_error: "internal_server_error";
+    readonly invalid_request: "invalid_request";
+    readonly invalid_signature: "invalid_signature";
+    readonly malformed_transaction: "malformed_transaction";
+    readonly not_found: "not_found";
+    readonly payment_method_required: "payment_method_required";
+    readonly rate_limit_exceeded: "rate_limit_exceeded";
+    readonly request_canceled: "request_canceled";
+    readonly service_unavailable: "service_unavailable";
+    readonly timed_out: "timed_out";
+    readonly unauthorized: "unauthorized";
+    readonly policy_violation: "policy_violation";
+    readonly policy_in_use: "policy_in_use";
+    readonly account_limit_exceeded: "account_limit_exceeded";
+    readonly network_not_tradable: "network_not_tradable";
+    readonly guest_permission_denied: "guest_permission_denied";
+    readonly guest_region_forbidden: "guest_region_forbidden";
+    readonly guest_transaction_limit: "guest_transaction_limit";
+    readonly guest_transaction_count: "guest_transaction_count";
+    readonly guest_phone_number_verification_expired: "guest_phone_number_verification_expired";
+};
+
+export declare interface EthValueCriterion {
+    type: EthValueCriterionType;
+    ethValue: string;
+    operator: EthValueCriterionOperator;
+}
+
+export declare type EthValueCriterionOperator = (typeof EthValueCriterionOperator)[keyof typeof EthValueCriterionOperator];
+
+export declare const EthValueCriterionOperator: {
+    readonly ">": ">";
+    readonly ">=": ">=";
+    readonly "<": "<";
+    readonly "<=": "<=";
+    readonly "==": "==";
+};
+
+export declare type EthValueCriterionType = (typeof EthValueCriterionType)[keyof typeof EthValueCriterionType];
+
+export declare const EthValueCriterionType: {
+    readonly ethValue: "ethValue";
+};
+
+export declare interface EvmAccount {
+    address: string;
+    name?: string;
+    policies?: string[];
+    createdAt?: string;
+    updatedAt?: string;
+}
+
+export declare interface EvmAddressCriterion {
+    type: EvmAddressCriterionType;
+    addresses: string[];
+    operator: EvmAddressCriterionOperator;
+}
+
+export declare type EvmAddressCriterionOperator = (typeof EvmAddressCriterionOperator)[keyof typeof EvmAddressCriterionOperator];
+
+export declare const EvmAddressCriterionOperator: {
+    readonly in: "in";
+    readonly not_in: "not in";
+};
+
+export declare type EvmAddressCriterionType = (typeof EvmAddressCriterionType)[keyof typeof EvmAddressCriterionType];
+
+export declare const EvmAddressCriterionType: {
+    readonly evmAddress: "evmAddress";
+};
+
+export declare interface EvmCall {
+    to: string;
+    value: string;
+    data: string;
+}
+
+export declare interface EvmDataCondition {
+    function: string;
+    params?: EvmDataConditionParamsItem[];
+}
+
+export declare type EvmDataConditionParamsItem = EvmDataParameterCondition | EvmDataParameterConditionList;
+
+export declare interface EvmDataCriterion {
+    type: EvmDataCriterionType;
+    abi: EvmDataCriterionAbi;
+    conditions: EvmDataCondition[];
+}
+
+export declare type EvmDataCriterionAbi = KnownAbiType | Abi;
+
+export declare type EvmDataCriterionType = (typeof EvmDataCriterionType)[keyof typeof EvmDataCriterionType];
+
+export declare const EvmDataCriterionType: {
+    readonly evmData: "evmData";
+};
+
+export declare interface EvmDataParameterCondition {
+    name: string;
+    operator: EvmDataParameterConditionOperator;
+    value: string;
+}
+
+export declare interface EvmDataParameterConditionList {
+    name: string;
+    operator: EvmDataParameterConditionListOperator;
+    values: string[];
+}
+
+export declare type EvmDataParameterConditionListOperator = (typeof EvmDataParameterConditionListOperator)[keyof typeof EvmDataParameterConditionListOperator];
+
+export declare const EvmDataParameterConditionListOperator: {
+    readonly in: "in";
+    readonly not_in: "not in";
+};
+
+export declare type EvmDataParameterConditionOperator = (typeof EvmDataParameterConditionOperator)[keyof typeof EvmDataParameterConditionOperator];
+
+export declare const EvmDataParameterConditionOperator: {
+    readonly ">": ">";
+    readonly ">=": ">=";
+    readonly "<": "<";
+    readonly "<=": "<=";
+    readonly "==": "==";
+};
+
+export declare interface EvmMessageCriterion {
+    type: EvmMessageCriterionType;
+    match: string;
+}
+
+export declare type EvmMessageCriterionType = (typeof EvmMessageCriterionType)[keyof typeof EvmMessageCriterionType];
+
+export declare const EvmMessageCriterionType: {
+    readonly evmMessage: "evmMessage";
+};
+
+export declare interface EvmNetworkCriterion {
+    type: EvmNetworkCriterionType;
+    networks: EvmNetworkCriterionNetworksItem[];
+    operator: EvmNetworkCriterionOperator;
+}
+
+export declare type EvmNetworkCriterionNetworksItem = (typeof EvmNetworkCriterionNetworksItem)[keyof typeof EvmNetworkCriterionNetworksItem];
+
+export declare const EvmNetworkCriterionNetworksItem: {
+    readonly "base-sepolia": "base-sepolia";
+    readonly base: "base";
+};
+
+export declare type EvmNetworkCriterionOperator = (typeof EvmNetworkCriterionOperator)[keyof typeof EvmNetworkCriterionOperator];
+
+export declare const EvmNetworkCriterionOperator: {
+    readonly in: "in";
+    readonly not_in: "not in";
+};
+
+export declare type EvmNetworkCriterionType = (typeof EvmNetworkCriterionType)[keyof typeof EvmNetworkCriterionType];
+
+export declare const EvmNetworkCriterionType: {
+    readonly evmNetwork: "evmNetwork";
+};
+
+export declare interface EvmSmartAccount {
+    address: string;
+    owners: string[];
+    name?: string;
+    policies?: string[];
+    createdAt?: string;
+    updatedAt?: string;
+}
+
+export declare type EvmSwapsNetwork = (typeof EvmSwapsNetwork)[keyof typeof EvmSwapsNetwork];
+
+export declare const EvmSwapsNetwork: {
+    readonly base: "base";
+    readonly ethereum: "ethereum";
+};
+
+export declare interface EvmTypedAddressCondition {
+    addresses: string[];
+    operator: EvmTypedAddressConditionOperator;
+    path: string;
+}
+
+export declare type EvmTypedAddressConditionOperator = (typeof EvmTypedAddressConditionOperator)[keyof typeof EvmTypedAddressConditionOperator];
+
+export declare const EvmTypedAddressConditionOperator: {
+    readonly in: "in";
+    readonly not_in: "not in";
+};
+
+export declare interface EvmTypedNumericalCondition {
+    value: string;
+    operator: EvmTypedNumericalConditionOperator;
+    path: string;
+}
+
+export declare type EvmTypedNumericalConditionOperator = (typeof EvmTypedNumericalConditionOperator)[keyof typeof EvmTypedNumericalConditionOperator];
+
+export declare const EvmTypedNumericalConditionOperator: {
+    readonly ">": ">";
+    readonly ">=": ">=";
+    readonly "<": "<";
+    readonly "<=": "<=";
+    readonly "==": "==";
+};
+
+export declare interface EvmTypedStringCondition {
+    match: string;
+    path: string;
+}
+
+export declare interface EvmUserOperation {
+    network: EvmUserOperationNetwork;
+    userOpHash: string;
+    calls: EvmCall[];
+    status: EvmUserOperationStatus;
+    transactionHash?: string;
+    receipts?: UserOperationReceipt[];
+}
+
+export declare type EvmUserOperationNetwork = (typeof EvmUserOperationNetwork)[keyof typeof EvmUserOperationNetwork];
+
+export declare const EvmUserOperationNetwork: {
+    readonly "base-sepolia": "base-sepolia";
+    readonly base: "base";
+};
+
+export declare type EvmUserOperationStatus = (typeof EvmUserOperationStatus)[keyof typeof EvmUserOperationStatus];
+
+export declare const EvmUserOperationStatus: {
+    readonly pending: "pending";
+    readonly signed: "signed";
+    readonly broadcast: "broadcast";
+    readonly complete: "complete";
+    readonly dropped: "dropped";
+    readonly failed: "failed";
+};
+
+export declare const exportEndUserEvmAccount: (projectId: string, userId: string, exportEndUserEvmAccountBody: ExportEndUserEvmAccountBody, options?: SecondParameter<typeof cdpApiClient>) => Promise<ExportEndUserEvmAccount200>;
+
+export declare type ExportEndUserEvmAccount200 = {
+    encryptedPrivateKey: string;
+};
+
+export declare type ExportEndUserEvmAccountBody = {
+    address: string;
+    exportEncryptionKey: string;
+    walletSecretId: string;
+};
+
+export declare type ExportEndUserEvmAccountResult = NonNullable<Awaited<ReturnType<typeof exportEndUserEvmAccount>>>;
+
+export declare interface Fee {
+    type: FeeType;
+    amount: string;
+    currency: string;
+    description?: string;
+}
+
+export declare type FeeType = (typeof FeeType)[keyof typeof FeeType];
+
+export declare const FeeType: {
+    readonly exchange_fee: "exchange_fee";
+    readonly network_fee: "network_fee";
+};
+
+export declare type FromAmount = string;
+
+export declare type FromToken = string;
+
+export declare type GasPrice = string;
+
+export declare const getAuthenticatedEndUser: (projectId: string, userId: string, options?: SecondParameter<typeof cdpApiClient>) => Promise<EndUser>;
+
+export declare type GetAuthenticatedEndUserResult = NonNullable<Awaited<ReturnType<typeof getAuthenticatedEndUser>>>;
+
+export declare type GetSwapPriceResponse = CommonSwapResponse & GetSwapPriceResponseAllOf;
+
+export declare type GetSwapPriceResponseAllOf = {
+    gas: string | null;
+    gasPrice: string;
+};
+
+export declare type GetSwapPriceResponseWrapper = GetSwapPriceResponse | SwapUnavailableResponse;
+
+export declare type IdempotencyErrorResponse = Error_2;
+
+export declare type IdempotencyKeyParameter = string;
+
+export declare const initiateAuthentication: (projectId: string, initiateAuthenticationRequest: InitiateAuthenticationRequest, options?: SecondParameter<typeof cdpApiClient>) => Promise<InitiateEmailAuthenticationResponse>;
+
+export declare type InitiateAuthenticationRequest = InitiateEmailAuthenticationRequest;
+
+export declare type InitiateAuthenticationResult = NonNullable<Awaited<ReturnType<typeof initiateAuthentication>>>;
+
+export declare interface InitiateEmailAuthenticationNextStep {
+    type: InitiateEmailAuthenticationNextStepType;
+    url: string;
+}
+
+export declare type InitiateEmailAuthenticationNextStepType = (typeof InitiateEmailAuthenticationNextStepType)[keyof typeof InitiateEmailAuthenticationNextStepType];
+
+export declare const InitiateEmailAuthenticationNextStepType: {
+    readonly "verify-otp": "verify-otp";
+};
+
+export declare interface InitiateEmailAuthenticationRequest {
+    type: InitiateEmailAuthenticationRequestType;
+    email: string;
+}
+
+export declare type InitiateEmailAuthenticationRequestType = (typeof InitiateEmailAuthenticationRequestType)[keyof typeof InitiateEmailAuthenticationRequestType];
+
+export declare const InitiateEmailAuthenticationRequestType: {
+    readonly email: "email";
+};
+
+export declare interface InitiateEmailAuthenticationResponse {
+    message: string;
+    flowId: string;
+    nextStep: InitiateEmailAuthenticationNextStep;
+}
+
+export declare type InternalServerErrorResponse = Error_2;
+
+export declare type KnownAbiType = (typeof KnownAbiType)[keyof typeof KnownAbiType];
+
+export declare const KnownAbiType: {
+    readonly erc20: "erc20";
+    readonly erc721: "erc721";
+    readonly erc1155: "erc1155";
+};
+
+export declare type ListEvmTokenBalancesNetwork = (typeof ListEvmTokenBalancesNetwork)[keyof typeof ListEvmTokenBalancesNetwork];
+
+export declare const ListEvmTokenBalancesNetwork: {
+    readonly base: "base";
+    readonly "base-sepolia": "base-sepolia";
+    readonly ethereum: "ethereum";
+};
+
+export declare interface ListResponse {
+    nextPageToken?: string;
+}
+
+export declare type ListSolanaTokenBalancesNetwork = (typeof ListSolanaTokenBalancesNetwork)[keyof typeof ListSolanaTokenBalancesNetwork];
+
+export declare const ListSolanaTokenBalancesNetwork: {
+    readonly solana: "solana";
+    readonly "solana-devnet": "solana-devnet";
+};
+
+export declare const logOutEndUser: (projectId: string, options?: SecondParameter<typeof cdpApiClient>) => Promise<void>;
+
+export declare type LogOutEndUserResult = NonNullable<Awaited<ReturnType<typeof logOutEndUser>>>;
+
+export declare interface OnrampOrder {
+    orderId?: string;
+    paymentTotal?: string;
+    paymentSubtotal?: unknown;
+    paymentCurrency?: string;
+    paymentMethod?: OnrampPaymentMethodTypeId;
+    purchaseAmount?: string;
+    purchaseCurrency?: string;
+    fees?: OnrampOrderFee[];
+    exchangeRate?: string;
+    destinationAddress?: string;
+    destinationNetwork?: string;
+    status?: OnrampOrderStatus;
+    txHash?: string;
+    createdAt?: string;
+    updatedAt?: string;
+}
+
+export declare interface OnrampOrderFee {
+    type?: OnrampOrderFeeType;
+    amount?: string;
+    currency?: string;
+}
+
+export declare type OnrampOrderFeeType = (typeof OnrampOrderFeeType)[keyof typeof OnrampOrderFeeType];
+
+export declare const OnrampOrderFeeType: {
+    readonly FEE_TYPE_NETWORK: "FEE_TYPE_NETWORK";
+    readonly FEE_TYPE_EXCHANGE: "FEE_TYPE_EXCHANGE";
+};
+
+export declare type OnrampOrderStatus = (typeof OnrampOrderStatus)[keyof typeof OnrampOrderStatus];
+
+export declare const OnrampOrderStatus: {
+    readonly ONRAMP_ORDER_STATUS_PENDING_AUTH: "ONRAMP_ORDER_STATUS_PENDING_AUTH";
+    readonly ONRAMP_ORDER_STATUS_PENDING_PAYMENT: "ONRAMP_ORDER_STATUS_PENDING_PAYMENT";
+    readonly ONRAMP_ORDER_STATUS_PROCESSING: "ONRAMP_ORDER_STATUS_PROCESSING";
+    readonly ONRAMP_ORDER_STATUS_COMPLETED: "ONRAMP_ORDER_STATUS_COMPLETED";
+    readonly ONRAMP_ORDER_STATUS_FAILED: "ONRAMP_ORDER_STATUS_FAILED";
+};
+
+export declare interface OnrampPaymentLink {
+    url?: string;
+    paymentLinkType?: OnrampPaymentLinkType;
+}
+
+export declare type OnrampPaymentLinkType = (typeof OnrampPaymentLinkType)[keyof typeof OnrampPaymentLinkType];
+
+export declare const OnrampPaymentLinkType: {
+    readonly PAYMENT_LINK_TYPE_APPLE_PAY_BUTTON: "PAYMENT_LINK_TYPE_APPLE_PAY_BUTTON";
+};
+
+export declare type OnrampPaymentMethodTypeId = (typeof OnrampPaymentMethodTypeId)[keyof typeof OnrampPaymentMethodTypeId];
+
+export declare const OnrampPaymentMethodTypeId: {
+    readonly GUEST_CHECKOUT_APPLE_PAY: "GUEST_CHECKOUT_APPLE_PAY";
+};
+
+export declare interface PaymentMethod {
+    id: string;
+    type: PaymentMethodType;
+    currency: string;
+    actions: PaymentRailAction[];
+    limits?: PaymentMethodLimits;
+}
+
+export declare type PaymentMethodLimits = {
+    sourceLimit?: PaymentMethodLimitsSourceLimit;
+    targetLimit?: PaymentMethodLimitsTargetLimit;
+};
+
+export declare type PaymentMethodLimitsSourceLimit = {
+    amount?: string;
+    currency?: string;
+};
+
+export declare type PaymentMethodLimitsTargetLimit = {
+    amount?: string;
+    currency?: string;
+};
+
+export declare interface PaymentMethodRequest {
+    id: string;
+}
+
+export declare type PaymentMethodRequiredErrorResponse = Error_2;
+
+export declare type PaymentMethodType = (typeof PaymentMethodType)[keyof typeof PaymentMethodType];
+
+export declare const PaymentMethodType: {
+    readonly card: "card";
+    readonly fiat_account: "fiat_account";
+};
+
+export declare type PaymentRailAction = (typeof PaymentRailAction)[keyof typeof PaymentRailAction];
+
+export declare const PaymentRailAction: {
+    readonly source: "source";
+    readonly target: "target";
+};
+
+export declare interface Policy {
+    id: string;
+    description?: string;
+    scope: PolicyScope;
+    rules: Rule[];
+    createdAt: string;
+    updatedAt: string;
+}
+
+export declare type PolicyScope = (typeof PolicyScope)[keyof typeof PolicyScope];
+
+export declare const PolicyScope: {
+    readonly project: "project";
+    readonly account: "account";
+};
+
+export declare interface PrepareRevokeSpendPermissionRequest {
+    network: string;
+    permissionHash: string;
+    paymasterUrl?: string;
+}
+
+export declare interface PrepareSpendPermissionRequest {
+    network: string;
+    account: string;
+    spender: string;
+    token: string;
+    allowance: string;
+    period: string;
+    start: string;
+    end: string;
+    salt?: string;
+    extraData?: string;
+    paymasterUrl?: string;
+}
+
+export declare type PrepareUserOperationCriteria = PrepareUserOperationCriteriaItem[];
+
+export declare type PrepareUserOperationCriteriaItem = EthValueCriterion | EvmAddressCriterion | EvmNetworkCriterion | EvmDataCriterion;
+
+export declare interface PrepareUserOperationRule {
+    action: PrepareUserOperationRuleAction;
+    operation: PrepareUserOperationRuleOperation;
+    criteria: PrepareUserOperationCriteria;
+}
+
+export declare type PrepareUserOperationRuleAction = (typeof PrepareUserOperationRuleAction)[keyof typeof PrepareUserOperationRuleAction];
+
+export declare const PrepareUserOperationRuleAction: {
+    readonly reject: "reject";
+    readonly accept: "accept";
+};
+
+export declare type PrepareUserOperationRuleOperation = (typeof PrepareUserOperationRuleOperation)[keyof typeof PrepareUserOperationRuleOperation];
+
+export declare const PrepareUserOperationRuleOperation: {
+    readonly prepareUserOperation: "prepareUserOperation";
+};
+
+export declare interface QueryRequest {
+    sql: string;
+}
+
+export declare interface QueryResult {
+    result?: QueryResultResultItem[];
+    schema?: QueryResultSchema;
+}
+
+export declare type QueryResultResultItem = {
+    [key: string]: unknown;
+};
+
+export declare type QueryResultSchema = {
+    columns?: QueryResultSchemaColumnsItem[];
+};
+
+export declare type QueryResultSchemaColumnsItem = {
+    name?: string;
+    type?: QueryResultSchemaColumnsItemType;
+};
+
+export declare type QueryResultSchemaColumnsItemType = (typeof QueryResultSchemaColumnsItemType)[keyof typeof QueryResultSchemaColumnsItemType];
+
+export declare const QueryResultSchemaColumnsItemType: {
+    readonly String: "String";
+    readonly UInt8: "UInt8";
+    readonly UInt16: "UInt16";
+    readonly UInt32: "UInt32";
+    readonly UInt64: "UInt64";
+    readonly UInt128: "UInt128";
+    readonly UInt256: "UInt256";
+    readonly Int8: "Int8";
+    readonly Int16: "Int16";
+    readonly Int32: "Int32";
+    readonly Int64: "Int64";
+    readonly Int128: "Int128";
+    readonly Int256: "Int256";
+    readonly Float32: "Float32";
+    readonly Float64: "Float64";
+    readonly Bool: "Bool";
+    readonly Date: "Date";
+    readonly DateTime: "DateTime";
+    readonly DateTime64: "DateTime64";
+    readonly UUID: "UUID";
+    readonly IPv4: "IPv4";
+    readonly IPv6: "IPv6";
+};
+
+export declare type RateLimitExceededResponse = Error_2;
+
+export declare const refreshAccessToken: (projectId: string, refreshAccessTokenBody: RefreshAccessTokenBody, options?: SecondParameter<typeof cdpApiClient>) => Promise<RefreshAccessToken200>;
+
+export declare type RefreshAccessToken200 = {
+    endUser: EndUser;
+    accessToken: string;
+    validUntil: string;
+};
+
+export declare type RefreshAccessTokenBody = {
+    grantType: RefreshAccessTokenBodyGrantType;
+};
+
+export declare type RefreshAccessTokenBodyGrantType = (typeof RefreshAccessTokenBodyGrantType)[keyof typeof RefreshAccessTokenBodyGrantType];
+
+export declare const RefreshAccessTokenBodyGrantType: {
+    readonly refresh_token: "refresh_token";
+};
+
+export declare type RefreshAccessTokenResult = NonNullable<Awaited<ReturnType<typeof refreshAccessToken>>>;
+
+export declare const registerTemporaryWalletSecret: (projectId: string, userId: string, registerTemporaryWalletSecretBody: RegisterTemporaryWalletSecretBody, options?: SecondParameter<typeof cdpApiClient>) => Promise<RegisterTemporaryWalletSecret200>;
+
+export declare type RegisterTemporaryWalletSecret200 = {
+    walletSecretId: string;
+    validUntil: string;
+};
+
+export declare type RegisterTemporaryWalletSecretBody = {
+    publicKey: string;
+    validUntil: string;
+    walletSecretId?: string;
+};
+
+export declare type RegisterTemporaryWalletSecretResult = NonNullable<Awaited<ReturnType<typeof registerTemporaryWalletSecret>>>;
+
+export declare type Rule = SignEvmTransactionRule | SendEvmTransactionRule | SignEvmMessageRule | SignEvmTypedDataRule | SignSolTransactionRule | SignEvmHashRule | PrepareUserOperationRule | SendUserOperationRule;
+
+export declare type SecondFactorProofTokenParameter = string;
+
+declare type SecondParameter<T extends (...args: never) => unknown> = Parameters<T>[1];
+
+export declare type SendEvmTransactionCriteria = SendEvmTransactionCriteriaItem[];
+
+export declare type SendEvmTransactionCriteriaItem = EthValueCriterion | EvmAddressCriterion | EvmNetworkCriterion | EvmDataCriterion;
+
+export declare interface SendEvmTransactionRule {
+    action: SendEvmTransactionRuleAction;
+    operation: SendEvmTransactionRuleOperation;
+    criteria: SendEvmTransactionCriteria;
+}
+
+export declare type SendEvmTransactionRuleAction = (typeof SendEvmTransactionRuleAction)[keyof typeof SendEvmTransactionRuleAction];
+
+export declare const SendEvmTransactionRuleAction: {
+    readonly reject: "reject";
+    readonly accept: "accept";
+};
+
+export declare type SendEvmTransactionRuleOperation = (typeof SendEvmTransactionRuleOperation)[keyof typeof SendEvmTransactionRuleOperation];
+
+export declare const SendEvmTransactionRuleOperation: {
+    readonly sendEvmTransaction: "sendEvmTransaction";
+};
+
+export declare const sendEvmTransactionWithEndUserAccount: (projectId: string, userId: string, sendEvmTransactionWithEndUserAccountBody: SendEvmTransactionWithEndUserAccountBody, options?: SecondParameter<typeof cdpApiClient>) => Promise<SendEvmTransactionWithEndUserAccount200>;
+
+export declare type SendEvmTransactionWithEndUserAccount200 = {
+    transactionHash: string;
+};
+
+export declare type SendEvmTransactionWithEndUserAccountBody = {
+    address: string;
+    network: SendEvmTransactionWithEndUserAccountBodyNetwork;
+    walletSecretId: string;
+    transaction: string;
+};
+
+export declare type SendEvmTransactionWithEndUserAccountBodyNetwork = (typeof SendEvmTransactionWithEndUserAccountBodyNetwork)[keyof typeof SendEvmTransactionWithEndUserAccountBodyNetwork];
+
+export declare const SendEvmTransactionWithEndUserAccountBodyNetwork: {
+    readonly base: "base";
+    readonly "base-sepolia": "base-sepolia";
+};
+
+export declare type SendEvmTransactionWithEndUserAccountResult = NonNullable<Awaited<ReturnType<typeof sendEvmTransactionWithEndUserAccount>>>;
+
+export declare interface SendRevokeSpendPermissionRequest {
+    signature: string;
+}
+
+export declare interface SendSpendPermissionRequest {
+    signature: string;
+}
+
+export declare type SendUserOperationCriteria = SendUserOperationCriteriaItem[];
+
+export declare type SendUserOperationCriteriaItem = EthValueCriterion | EvmAddressCriterion | EvmDataCriterion;
+
+export declare interface SendUserOperationRule {
+    action: SendUserOperationRuleAction;
+    operation: SendUserOperationRuleOperation;
+    criteria: SendUserOperationCriteria;
+}
+
+export declare type SendUserOperationRuleAction = (typeof SendUserOperationRuleAction)[keyof typeof SendUserOperationRuleAction];
+
+export declare const SendUserOperationRuleAction: {
+    readonly reject: "reject";
+    readonly accept: "accept";
+};
+
+export declare type SendUserOperationRuleOperation = (typeof SendUserOperationRuleOperation)[keyof typeof SendUserOperationRuleOperation];
+
+export declare const SendUserOperationRuleOperation: {
+    readonly sendUserOperation: "sendUserOperation";
+};
+
+export declare type ServiceUnavailableErrorResponse = Error_2;
+
+export declare const setAuthManager: (manager: AuthManager) => void;
+
+export declare type SignerAddress = string;
+
+export declare interface SignEvmHashRule {
+    action: SignEvmHashRuleAction;
+    operation: SignEvmHashRuleOperation;
+}
+
+export declare type SignEvmHashRuleAction = (typeof SignEvmHashRuleAction)[keyof typeof SignEvmHashRuleAction];
+
+export declare const SignEvmHashRuleAction: {
+    readonly reject: "reject";
+    readonly accept: "accept";
+};
+
+export declare type SignEvmHashRuleOperation = (typeof SignEvmHashRuleOperation)[keyof typeof SignEvmHashRuleOperation];
+
+export declare const SignEvmHashRuleOperation: {
+    readonly signEvmHash: "signEvmHash";
+};
+
+export declare const signEvmHashWithEndUserAccount: (projectId: string, userId: string, signEvmHashWithEndUserAccountBody: SignEvmHashWithEndUserAccountBody, options?: SecondParameter<typeof cdpApiClient>) => Promise<SignEvmHashWithEndUserAccount200>;
+
+export declare type SignEvmHashWithEndUserAccount200 = {
+    signature: string;
+};
+
+export declare type SignEvmHashWithEndUserAccountBody = {
+    hash: string;
+    address: string;
+    walletSecretId: string;
+};
+
+export declare type SignEvmHashWithEndUserAccountResult = NonNullable<Awaited<ReturnType<typeof signEvmHashWithEndUserAccount>>>;
+
+export declare type SignEvmMessageCriteria = EvmMessageCriterion[];
+
+export declare interface SignEvmMessageRule {
+    action: SignEvmMessageRuleAction;
+    operation: SignEvmMessageRuleOperation;
+    criteria: SignEvmMessageCriteria;
+}
+
+export declare type SignEvmMessageRuleAction = (typeof SignEvmMessageRuleAction)[keyof typeof SignEvmMessageRuleAction];
+
+export declare const SignEvmMessageRuleAction: {
+    readonly reject: "reject";
+    readonly accept: "accept";
+};
+
+export declare type SignEvmMessageRuleOperation = (typeof SignEvmMessageRuleOperation)[keyof typeof SignEvmMessageRuleOperation];
+
+export declare const SignEvmMessageRuleOperation: {
+    readonly signEvmMessage: "signEvmMessage";
+};
+
+export declare const signEvmMessageWithEndUserAccount: (projectId: string, userId: string, signEvmMessageWithEndUserAccountBody: SignEvmMessageWithEndUserAccountBody, options?: SecondParameter<typeof cdpApiClient>) => Promise<SignEvmMessageWithEndUserAccount200>;
+
+export declare type SignEvmMessageWithEndUserAccount200 = {
+    signature: string;
+};
+
+export declare type SignEvmMessageWithEndUserAccountBody = {
+    address: string;
+    message: string;
+    walletSecretId: string;
+};
+
+export declare type SignEvmMessageWithEndUserAccountResult = NonNullable<Awaited<ReturnType<typeof signEvmMessageWithEndUserAccount>>>;
+
+export declare type SignEvmTransactionCriteria = SignEvmTransactionCriteriaItem[];
+
+export declare type SignEvmTransactionCriteriaItem = EthValueCriterion | EvmAddressCriterion | EvmDataCriterion;
+
+export declare interface SignEvmTransactionRule {
+    action: SignEvmTransactionRuleAction;
+    operation: SignEvmTransactionRuleOperation;
+    criteria: SignEvmTransactionCriteria;
+}
+
+export declare type SignEvmTransactionRuleAction = (typeof SignEvmTransactionRuleAction)[keyof typeof SignEvmTransactionRuleAction];
+
+export declare const SignEvmTransactionRuleAction: {
+    readonly reject: "reject";
+    readonly accept: "accept";
+};
+
+export declare type SignEvmTransactionRuleOperation = (typeof SignEvmTransactionRuleOperation)[keyof typeof SignEvmTransactionRuleOperation];
+
+export declare const SignEvmTransactionRuleOperation: {
+    readonly signEvmTransaction: "signEvmTransaction";
+};
+
+export declare const signEvmTransactionWithEndUserAccount: (projectId: string, userId: string, signEvmTransactionWithEndUserAccountBody: SignEvmTransactionWithEndUserAccountBody, options?: SecondParameter<typeof cdpApiClient>) => Promise<SignEvmTransactionWithEndUserAccount200>;
+
+export declare type SignEvmTransactionWithEndUserAccount200 = {
+    signedTransaction: string;
+};
+
+export declare type SignEvmTransactionWithEndUserAccountBody = {
+    address: string;
+    transaction: string;
+    walletSecretId: string;
+};
+
+export declare type SignEvmTransactionWithEndUserAccountResult = NonNullable<Awaited<ReturnType<typeof signEvmTransactionWithEndUserAccount>>>;
+
+export declare type SignEvmTypedDataCriteria = SignEvmTypedDataCriteriaItem[];
+
+export declare type SignEvmTypedDataCriteriaItem = SignEvmTypedDataFieldCriterion | SignEvmTypedDataVerifyingContractCriterion;
+
+export declare interface SignEvmTypedDataFieldCriterion {
+    type: SignEvmTypedDataFieldCriterionType;
+    types: SignEvmTypedDataFieldCriterionTypes;
+    conditions: SignEvmTypedDataFieldCriterionConditionsItem[];
+}
+
+export declare type SignEvmTypedDataFieldCriterionConditionsItem = EvmTypedAddressCondition | EvmTypedNumericalCondition | EvmTypedStringCondition;
+
+export declare type SignEvmTypedDataFieldCriterionType = (typeof SignEvmTypedDataFieldCriterionType)[keyof typeof SignEvmTypedDataFieldCriterionType];
+
+export declare const SignEvmTypedDataFieldCriterionType: {
+    readonly evmTypedDataField: "evmTypedDataField";
+};
+
+export declare type SignEvmTypedDataFieldCriterionTypes = {
+    types: SignEvmTypedDataFieldCriterionTypesTypes;
+    primaryType: string;
+};
+
+export declare type SignEvmTypedDataFieldCriterionTypesTypes = {
+    [key: string]: SignEvmTypedDataFieldCriterionTypesTypesItem[];
+};
+
+export declare type SignEvmTypedDataFieldCriterionTypesTypesItem = {
+    name?: string;
+    type?: string;
+};
+
+export declare interface SignEvmTypedDataRule {
+    action: SignEvmTypedDataRuleAction;
+    operation: SignEvmTypedDataRuleOperation;
+    criteria: SignEvmTypedDataCriteria;
+}
+
+export declare type SignEvmTypedDataRuleAction = (typeof SignEvmTypedDataRuleAction)[keyof typeof SignEvmTypedDataRuleAction];
+
+export declare const SignEvmTypedDataRuleAction: {
+    readonly reject: "reject";
+    readonly accept: "accept";
+};
+
+export declare type SignEvmTypedDataRuleOperation = (typeof SignEvmTypedDataRuleOperation)[keyof typeof SignEvmTypedDataRuleOperation];
+
+export declare const SignEvmTypedDataRuleOperation: {
+    readonly signEvmTypedData: "signEvmTypedData";
+};
+
+export declare interface SignEvmTypedDataVerifyingContractCriterion {
+    type: SignEvmTypedDataVerifyingContractCriterionType;
+    addresses: string[];
+    operator: SignEvmTypedDataVerifyingContractCriterionOperator;
+}
+
+export declare type SignEvmTypedDataVerifyingContractCriterionOperator = (typeof SignEvmTypedDataVerifyingContractCriterionOperator)[keyof typeof SignEvmTypedDataVerifyingContractCriterionOperator];
+
+export declare const SignEvmTypedDataVerifyingContractCriterionOperator: {
+    readonly in: "in";
+    readonly not_in: "not in";
+};
+
+export declare type SignEvmTypedDataVerifyingContractCriterionType = (typeof SignEvmTypedDataVerifyingContractCriterionType)[keyof typeof SignEvmTypedDataVerifyingContractCriterionType];
+
+export declare const SignEvmTypedDataVerifyingContractCriterionType: {
+    readonly evmTypedDataVerifyingContract: "evmTypedDataVerifyingContract";
+};
+
+export declare const signEvmTypedDataWithEndUserAccount: (projectId: string, userId: string, signEvmTypedDataWithEndUserAccountBody: SignEvmTypedDataWithEndUserAccountBody, options?: SecondParameter<typeof cdpApiClient>) => Promise<SignEvmTypedDataWithEndUserAccount200>;
+
+export declare type SignEvmTypedDataWithEndUserAccount200 = {
+    signature: string;
+};
+
+export declare type SignEvmTypedDataWithEndUserAccountBody = {
+    address: string;
+    typedData: EIP712Message;
+    walletSecretId: string;
+};
+
+export declare type SignEvmTypedDataWithEndUserAccountResult = NonNullable<Awaited<ReturnType<typeof signEvmTypedDataWithEndUserAccount>>>;
+
+export declare type SignSolTransactionCriteria = SolAddressCriterion[];
+
+export declare interface SignSolTransactionRule {
+    action: SignSolTransactionRuleAction;
+    operation: SignSolTransactionRuleOperation;
+    criteria: SignSolTransactionCriteria;
+}
+
+export declare type SignSolTransactionRuleAction = (typeof SignSolTransactionRuleAction)[keyof typeof SignSolTransactionRuleAction];
+
+export declare const SignSolTransactionRuleAction: {
+    readonly reject: "reject";
+    readonly accept: "accept";
+};
+
+export declare type SignSolTransactionRuleOperation = (typeof SignSolTransactionRuleOperation)[keyof typeof SignSolTransactionRuleOperation];
+
+export declare const SignSolTransactionRuleOperation: {
+    readonly signSolTransaction: "signSolTransaction";
+};
+
+export declare type SlippageBps = number;
+
+export declare interface SolAddressCriterion {
+    type: SolAddressCriterionType;
+    addresses: string[];
+    operator: SolAddressCriterionOperator;
+}
+
+export declare type SolAddressCriterionOperator = (typeof SolAddressCriterionOperator)[keyof typeof SolAddressCriterionOperator];
+
+export declare const SolAddressCriterionOperator: {
+    readonly in: "in";
+    readonly not_in: "not in";
+};
+
+export declare type SolAddressCriterionType = (typeof SolAddressCriterionType)[keyof typeof SolAddressCriterionType];
+
+export declare const SolAddressCriterionType: {
+    readonly solAddress: "solAddress";
+};
+
+export declare interface SolanaAccount {
+    address: string;
+    name?: string;
+    policies?: string[];
+    createdAt?: string;
+    updatedAt?: string;
+}
+
+export declare interface SolanaToken {
+    symbol?: string;
+    name?: string;
+    mintAddress: string;
+}
+
+export declare interface SolanaTokenAmount {
+    amount: string;
+    decimals: number;
+}
+
+export declare interface SolanaTokenBalance {
+    amount: SolanaTokenAmount;
+    token: SolanaToken;
+}
+
+export declare interface SwapUnavailableResponse {
+    liquidityAvailable: boolean;
+}
+
+export declare type Taker = string;
+
+export declare interface Token {
+    network: ListEvmTokenBalancesNetwork;
+    symbol?: string;
+    name?: string;
+    contractAddress: string;
+}
+
+export declare interface TokenAmount {
+    amount: string;
+    decimals: number;
+}
+
+export declare interface TokenBalance {
+    amount: TokenAmount;
+    token: Token;
+}
+
+export declare interface TokenFee {
+    amount: string;
+    token: string;
+}
+
+export declare type ToToken = string;
+
+export declare interface Transfer {
+    id: string;
+    sourceType: TransferSourceType;
+    source: PaymentMethodRequest;
+    targetType: TransferTargetType;
+    target: CryptoRailAddress;
+    sourceAmount: string;
+    sourceCurrency: string;
+    targetAmount: string;
+    targetCurrency: string;
+    userAmount: string;
+    userCurrency: string;
+    fees: Fee[];
+    status: TransferStatus;
+    createdAt: string;
+    updatedAt: string;
+    transactionHash?: string;
+}
+
+export declare type TransferSource = PaymentMethodRequest;
+
+export declare type TransferSourceType = (typeof TransferSourceType)[keyof typeof TransferSourceType];
+
+export declare const TransferSourceType: {
+    readonly payment_method: "payment_method";
+};
+
+export declare type TransferStatus = (typeof TransferStatus)[keyof typeof TransferStatus];
+
+export declare const TransferStatus: {
+    readonly created: "created";
+    readonly pending: "pending";
+    readonly started: "started";
+    readonly completed: "completed";
+    readonly failed: "failed";
+};
+
+export declare type TransferTarget = CryptoRailAddress;
+
+export declare type TransferTargetType = (typeof TransferTargetType)[keyof typeof TransferTargetType];
+
+export declare const TransferTargetType: {
+    readonly crypto_rail: "crypto_rail";
+};
+
+export declare type UnauthorizedErrorResponse = Error_2;
+
+export declare interface UserOperationReceipt {
+    revert?: UserOperationReceiptRevert;
+}
+
+export declare type UserOperationReceiptRevert = {
+    data?: string;
+    message?: string;
+};
+
+export declare const verifyEmailAuthentication: (projectId: string, verifyEmailAuthenticationRequest: VerifyEmailAuthenticationRequest, options?: SecondParameter<typeof cdpApiClient>) => Promise<VerifyEmailAuthentication200>;
+
+export declare type VerifyEmailAuthentication200 = {
+    endUser: EndUser;
+    isNewEndUser: boolean;
+    message: string;
+    accessToken: string;
+    validUntil: string;
+};
+
+export declare interface VerifyEmailAuthenticationRequest {
+    flowId: string;
+    otp: string;
+}
+
+export declare type VerifyEmailAuthenticationResult = NonNullable<Awaited<ReturnType<typeof verifyEmailAuthentication>>>;
+
+export declare interface WalletSecretMetadata {
+    updatedAt: string;
+}
+
+export declare interface X402ExactEvmPayload {
+    signature: string;
+    authorization: X402ExactEvmPayloadAuthorization;
+}
+
+export declare type X402ExactEvmPayloadAuthorization = {
+    from: string;
+    to: string;
+    value: string;
+    validAfter: string;
+    validBefore: string;
+    nonce: string;
+};
+
+export declare interface X402PaymentPayload {
+    x402Version: X402PaymentPayloadX402Version;
+    scheme: X402PaymentPayloadScheme;
+    network: X402PaymentPayloadNetwork;
+    payload: X402ExactEvmPayload;
+}
+
+export declare type X402PaymentPayloadNetwork = (typeof X402PaymentPayloadNetwork)[keyof typeof X402PaymentPayloadNetwork];
+
+export declare const X402PaymentPayloadNetwork: {
+    readonly "base-sepolia": "base-sepolia";
+    readonly base: "base";
+};
+
+export declare type X402PaymentPayloadScheme = (typeof X402PaymentPayloadScheme)[keyof typeof X402PaymentPayloadScheme];
+
+export declare const X402PaymentPayloadScheme: {
+    readonly exact: "exact";
+};
+
+export declare type X402PaymentPayloadX402Version = (typeof X402PaymentPayloadX402Version)[keyof typeof X402PaymentPayloadX402Version];
+
+export declare const X402PaymentPayloadX402Version: {
+    readonly NUMBER_1: 1;
+};
+
+export declare interface X402PaymentRequirements {
+    scheme: X402PaymentRequirementsScheme;
+    network: X402PaymentRequirementsNetwork;
+    maxAmountRequired: string;
+    resource: string;
+    description: string;
+    mimeType: string;
+    outputSchema?: X402PaymentRequirementsOutputSchema;
+    payTo: string;
+    maxTimeoutSeconds: number;
+    asset: string;
+    extra?: X402PaymentRequirementsExtra;
+}
+
+export declare type X402PaymentRequirementsExtra = {
+    [key: string]: unknown;
+};
+
+export declare type X402PaymentRequirementsNetwork = (typeof X402PaymentRequirementsNetwork)[keyof typeof X402PaymentRequirementsNetwork];
+
+export declare const X402PaymentRequirementsNetwork: {
+    readonly "base-sepolia": "base-sepolia";
+    readonly base: "base";
+};
+
+export declare type X402PaymentRequirementsOutputSchema = {
+    [key: string]: unknown;
+};
+
+export declare type X402PaymentRequirementsScheme = (typeof X402PaymentRequirementsScheme)[keyof typeof X402PaymentRequirementsScheme];
+
+export declare const X402PaymentRequirementsScheme: {
+    readonly exact: "exact";
+};
+
+export declare type X402SettleErrorReason = (typeof X402SettleErrorReason)[keyof typeof X402SettleErrorReason];
+
+export declare const X402SettleErrorReason: {
+    readonly insufficient_funds: "insufficient_funds";
+    readonly invalid_scheme: "invalid_scheme";
+    readonly invalid_network: "invalid_network";
+    readonly invalid_x402_version: "invalid_x402_version";
+    readonly invalid_payment_requirements: "invalid_payment_requirements";
+    readonly invalid_payload: "invalid_payload";
+    readonly invalid_exact_evm_payload_authorization_value: "invalid_exact_evm_payload_authorization_value";
+    readonly invalid_exact_evm_payload_authorization_valid_after: "invalid_exact_evm_payload_authorization_valid_after";
+    readonly invalid_exact_evm_payload_authorization_valid_before: "invalid_exact_evm_payload_authorization_valid_before";
+    readonly invalid_exact_evm_payload_authorization_typed_data_message: "invalid_exact_evm_payload_authorization_typed_data_message";
+    readonly invalid_exact_evm_payload_authorization_from_address_kyt: "invalid_exact_evm_payload_authorization_from_address_kyt";
+    readonly invalid_exact_evm_payload_authorization_to_address_kyt: "invalid_exact_evm_payload_authorization_to_address_kyt";
+    readonly invalid_exact_evm_payload_signature_address: "invalid_exact_evm_payload_signature_address";
+};
+
+export declare type X402SettleResponseResponse = {
+    success: boolean;
+    errorReason?: X402SettleErrorReason;
+    payer: string;
+    transaction: string;
+    network: string;
+};
+
+export declare interface X402SupportedPaymentKind {
+    x402Version: X402SupportedPaymentKindX402Version;
+    scheme: X402SupportedPaymentKindScheme;
+    network: X402SupportedPaymentKindNetwork;
+}
+
+export declare type X402SupportedPaymentKindNetwork = (typeof X402SupportedPaymentKindNetwork)[keyof typeof X402SupportedPaymentKindNetwork];
+
+export declare const X402SupportedPaymentKindNetwork: {
+    readonly "base-sepolia": "base-sepolia";
+    readonly base: "base";
+};
+
+export declare type X402SupportedPaymentKindScheme = (typeof X402SupportedPaymentKindScheme)[keyof typeof X402SupportedPaymentKindScheme];
+
+export declare const X402SupportedPaymentKindScheme: {
+    readonly exact: "exact";
+};
+
+export declare type X402SupportedPaymentKindsResponseResponse = {
+    kinds: X402SupportedPaymentKind[];
+};
+
+export declare type X402SupportedPaymentKindX402Version = (typeof X402SupportedPaymentKindX402Version)[keyof typeof X402SupportedPaymentKindX402Version];
+
+export declare const X402SupportedPaymentKindX402Version: {
+    readonly NUMBER_1: 1;
+};
+
+export declare type X402VerifyInvalidReason = (typeof X402VerifyInvalidReason)[keyof typeof X402VerifyInvalidReason];
+
+export declare const X402VerifyInvalidReason: {
+    readonly insufficient_funds: "insufficient_funds";
+    readonly invalid_scheme: "invalid_scheme";
+    readonly invalid_network: "invalid_network";
+    readonly invalid_x402_version: "invalid_x402_version";
+    readonly invalid_payment_requirements: "invalid_payment_requirements";
+    readonly invalid_payload: "invalid_payload";
+    readonly invalid_exact_evm_payload_authorization_value: "invalid_exact_evm_payload_authorization_value";
+    readonly invalid_exact_evm_payload_authorization_valid_after: "invalid_exact_evm_payload_authorization_valid_after";
+    readonly invalid_exact_evm_payload_authorization_valid_before: "invalid_exact_evm_payload_authorization_valid_before";
+    readonly invalid_exact_evm_payload_authorization_typed_data_message: "invalid_exact_evm_payload_authorization_typed_data_message";
+    readonly invalid_exact_evm_payload_authorization_from_address_kyt: "invalid_exact_evm_payload_authorization_from_address_kyt";
+    readonly invalid_exact_evm_payload_authorization_to_address_kyt: "invalid_exact_evm_payload_authorization_to_address_kyt";
+    readonly invalid_exact_evm_payload_signature: "invalid_exact_evm_payload_signature";
+    readonly invalid_exact_evm_payload_signature_address: "invalid_exact_evm_payload_signature_address";
+};
+
+export declare type X402VerifyResponseResponse = {
+    isValid: boolean;
+    invalidReason?: X402VerifyInvalidReason;
+    payer: string;
+};
+
+export declare type XDeveloperAuthParameter = string;
+
+export declare type XWalletAuthOptionalParameter = string;
+
+export declare type XWalletAuthParameter = string;
+
+export { }