@ampersend_ai/ampersend-sdk 0.0.16 → 0.0.21

package/dist/ampersend/types.d.ts

@@ -7,6 +7,12 @@ export declare const TxHash: Schema.filter<typeof Schema.NonEmptyTrimmedString>;
 export type TxHash = typeof TxHash.Type;
 export declare const Caip2ID: Schema.filter<typeof Schema.NonEmptyTrimmedString>;
 export type Caip2ID = typeof Caip2ID.Type;
+export declare const Hex32Bytes: Schema.filter<typeof Schema.NonEmptyTrimmedString>;
+export type Hex32Bytes = typeof Hex32Bytes.Type;
+export declare const Hex65Bytes: Schema.filter<typeof Schema.NonEmptyTrimmedString>;
+export type Hex65Bytes = typeof Hex65Bytes.Type;
+export declare const NonNegativeIntegerString: Schema.filter<typeof Schema.NonEmptyTrimmedString>;
+export type NonNegativeIntegerString = typeof NonNegativeIntegerString.Type;
 declare const SIWENonceResponse_base: Schema.Class<SIWENonceResponse, {
     nonce: Schema.refine<string, typeof Schema.Trimmed>;
     sessionId: Schema.refine<string, typeof Schema.Trimmed>;
@@ -58,67 +64,20 @@ declare const SIWELoginResponse_base: Schema.Class<SIWELoginResponse, {
 }, {}, {}>;
 export declare class SIWELoginResponse extends SIWELoginResponse_base {
 }
-declare const PaymentRequirements_base: Schema.Class<PaymentRequirements, {
-    scheme: Schema.Literal<["exact"]>;
-    network: Schema.refine<string, typeof Schema.Trimmed>;
-    maxAmountRequired: Schema.refine<string, typeof Schema.Trimmed>;
-    resource: Schema.refine<string, typeof Schema.Trimmed>;
-    description: Schema.refine<string, typeof Schema.Trimmed>;
-    mimeType: Schema.SchemaClass<string, string, never>;
-    payTo: Schema.refine<string, typeof Schema.NonEmptyTrimmedString>;
-    maxTimeoutSeconds: Schema.SchemaClass<number, number, never>;
-    asset: Schema.refine<string, typeof Schema.NonEmptyTrimmedString>;
-    extra: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
-}, Schema.Struct.Encoded<{
-    scheme: Schema.Literal<["exact"]>;
-    network: Schema.refine<string, typeof Schema.Trimmed>;
-    maxAmountRequired: Schema.refine<string, typeof Schema.Trimmed>;
-    resource: Schema.refine<string, typeof Schema.Trimmed>;
-    description: Schema.refine<string, typeof Schema.Trimmed>;
-    mimeType: Schema.SchemaClass<string, string, never>;
-    payTo: Schema.refine<string, typeof Schema.NonEmptyTrimmedString>;
-    maxTimeoutSeconds: Schema.SchemaClass<number, number, never>;
-    asset: Schema.refine<string, typeof Schema.NonEmptyTrimmedString>;
-    extra: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
-}>, never, {
-    readonly description: string;
-} & {
-    readonly scheme: "exact";
-} & {
-    readonly network: string;
-} & {
-    readonly maxAmountRequired: string;
-} & {
-    readonly resource: string;
-} & {
-    readonly mimeType: string;
-} & {
-    readonly payTo: string;
-} & {
-    readonly maxTimeoutSeconds: number;
-} & {
-    readonly asset: string;
-} & {
-    readonly extra?: {
-        readonly [x: string]: unknown;
-    } | undefined;
-}, {}, {}>;
-export declare class PaymentRequirements extends PaymentRequirements_base {
-}
 declare const ERC3009AuthorizationData_base: Schema.Class<ERC3009AuthorizationData, {
     from: Schema.refine<string, typeof Schema.NonEmptyTrimmedString>;
     to: Schema.refine<string, typeof Schema.NonEmptyTrimmedString>;
-    value: Schema.SchemaClass<string, string, never>;
-    validAfter: Schema.SchemaClass<string, string, never>;
-    validBefore: Schema.SchemaClass<string, string, never>;
-    nonce: Schema.SchemaClass<string, string, never>;
+    value: Schema.refine<string, typeof Schema.NonEmptyTrimmedString>;
+    validAfter: Schema.refine<string, typeof Schema.NonEmptyTrimmedString>;
+    validBefore: Schema.refine<string, typeof Schema.NonEmptyTrimmedString>;
+    nonce: Schema.refine<string, typeof Schema.NonEmptyTrimmedString>;
 }, Schema.Struct.Encoded<{
     from: Schema.refine<string, typeof Schema.NonEmptyTrimmedString>;
     to: Schema.refine<string, typeof Schema.NonEmptyTrimmedString>;
-    value: Schema.SchemaClass<string, string, never>;
-    validAfter: Schema.SchemaClass<string, string, never>;
-    validBefore: Schema.SchemaClass<string, string, never>;
-    nonce: Schema.SchemaClass<string, string, never>;
+    value: Schema.refine<string, typeof Schema.NonEmptyTrimmedString>;
+    validAfter: Schema.refine<string, typeof Schema.NonEmptyTrimmedString>;
+    validBefore: Schema.refine<string, typeof Schema.NonEmptyTrimmedString>;
+    nonce: Schema.refine<string, typeof Schema.NonEmptyTrimmedString>;
 }>, never, {
     readonly nonce: string;
 } & {
@@ -143,7 +102,7 @@ declare const ServerAuthorizationData_base: Schema.Class<ServerAuthorizationData
         readonly validAfter: string;
         readonly validBefore: string;
     }, never>;
-    serverSignature: Schema.SchemaClass<string, string, never>;
+    serverSignature: Schema.refine<string, typeof Schema.NonEmptyTrimmedString>;
 }, Schema.Struct.Encoded<{
     authorizationData: Schema.SchemaClass<ERC3009AuthorizationData, {
         readonly nonce: string;
@@ -153,7 +112,7 @@ declare const ServerAuthorizationData_base: Schema.Class<ServerAuthorizationData
         readonly validAfter: string;
         readonly validBefore: string;
     }, never>;
-    serverSignature: Schema.SchemaClass<string, string, never>;
+    serverSignature: Schema.refine<string, typeof Schema.NonEmptyTrimmedString>;
 }>, never, {
     readonly authorizationData: ERC3009AuthorizationData;
 } & {
@@ -161,115 +120,284 @@ declare const ServerAuthorizationData_base: Schema.Class<ServerAuthorizationData
 }, {}, {}>;
 export declare class ServerAuthorizationData extends ServerAuthorizationData_base {
 }
-declare const AgentPaymentAuthRequest_base: Schema.Class<AgentPaymentAuthRequest, {
-    requirements: Schema.NonEmptyArray<typeof PaymentRequirements>;
+/** Dispatch tag on wire envelopes. Distinct from any individual protocol's internal version. */
+export declare const Protocol: Schema.Literal<["x402-v1", "x402-v2"]>;
+export type Protocol = typeof Protocol.Type;
+/** Wire envelope for a {@link PaymentRequest}; `data` validated via `@x402/core/schemas` on decode. */
+export declare const PaymentRequestEnvelope: Schema.Union<[Schema.Struct<{
+    protocol: Schema.Literal<["x402-v1"]>;
+    data: Schema.Schema<{
+        x402Version: 1;
+        accepts: {
+            description: string;
+            scheme: string;
+            network: string;
+            maxAmountRequired: string;
+            resource: string;
+            payTo: string;
+            maxTimeoutSeconds: number;
+            asset: string;
+            mimeType?: string | undefined;
+            outputSchema?: Record<string, unknown> | null | undefined;
+            extra?: Record<string, unknown> | null | undefined;
+        }[];
+        error?: string | undefined;
+    }, {
+        x402Version: 1;
+        accepts: {
+            description: string;
+            scheme: string;
+            network: string;
+            maxAmountRequired: string;
+            resource: string;
+            payTo: string;
+            maxTimeoutSeconds: number;
+            asset: string;
+            mimeType?: string | undefined;
+            outputSchema?: Record<string, unknown> | null | undefined;
+            extra?: Record<string, unknown> | null | undefined;
+        }[];
+        error?: string | undefined;
+    }, never>;
+}>, Schema.Struct<{
+    protocol: Schema.Literal<["x402-v2"]>;
+    data: Schema.Schema<{
+        resource: {
+            url: string;
+            description?: string | undefined;
+            mimeType?: string | undefined;
+        };
+        x402Version: 2;
+        accepts: {
+            scheme: string;
+            network: string;
+            payTo: string;
+            maxTimeoutSeconds: number;
+            asset: string;
+            amount: string;
+            extra?: Record<string, unknown> | null | undefined;
+        }[];
+        error?: string | undefined;
+        extensions?: Record<string, unknown> | null | undefined;
+    }, {
+        resource: {
+            url: string;
+            description?: string | undefined;
+            mimeType?: string | undefined;
+        };
+        x402Version: 2;
+        accepts: {
+            scheme: string;
+            network: string;
+            payTo: string;
+            maxTimeoutSeconds: number;
+            asset: string;
+            amount: string;
+            extra?: Record<string, unknown> | null | undefined;
+        }[];
+        error?: string | undefined;
+        extensions?: Record<string, unknown> | null | undefined;
+    }, never>;
+}>]>;
+export type PaymentRequestEnvelope = typeof PaymentRequestEnvelope.Type;
+/** Wire envelope for a signed {@link PaymentAuthorization}. */
+export declare const PaymentAuthorizationEnvelope: Schema.Union<[Schema.Struct<{
+    protocol: Schema.Literal<["x402-v1"]>;
+    data: Schema.Schema<{
+        scheme: string;
+        network: string;
+        x402Version: 1;
+        payload: Record<string, unknown>;
+    }, {
+        scheme: string;
+        network: string;
+        x402Version: 1;
+        payload: Record<string, unknown>;
+    }, never>;
+}>, Schema.Struct<{
+    protocol: Schema.Literal<["x402-v2"]>;
+    data: Schema.Schema<{
+        x402Version: 2;
+        payload: Record<string, unknown>;
+        accepted: {
+            scheme: string;
+            network: string;
+            payTo: string;
+            maxTimeoutSeconds: number;
+            asset: string;
+            amount: string;
+            extra?: Record<string, unknown> | null | undefined;
+        };
+        resource?: {
+            url: string;
+            description?: string | undefined;
+            mimeType?: string | undefined;
+        } | undefined;
+        extensions?: Record<string, unknown> | null | undefined;
+    }, {
+        x402Version: 2;
+        payload: Record<string, unknown>;
+        accepted: {
+            scheme: string;
+            network: string;
+            payTo: string;
+            maxTimeoutSeconds: number;
+            asset: string;
+            amount: string;
+            extra?: Record<string, unknown> | null | undefined;
+        };
+        resource?: {
+            url: string;
+            description?: string | undefined;
+            mimeType?: string | undefined;
+        } | undefined;
+        extensions?: Record<string, unknown> | null | undefined;
+    }, never>;
+}>]>;
+export type PaymentAuthorizationEnvelope = typeof PaymentAuthorizationEnvelope.Type;
+/** Request body for `POST /api/v1/agents/:agent/payment/authorize`. */
+export declare const AgentAuthorizeRequest: Schema.Struct<{
+    paymentRequest: Schema.Union<[Schema.Struct<{
+        protocol: Schema.Literal<["x402-v1"]>;
+        data: Schema.Schema<{
+            x402Version: 1;
+            accepts: {
+                description: string;
+                scheme: string;
+                network: string;
+                maxAmountRequired: string;
+                resource: string;
+                payTo: string;
+                maxTimeoutSeconds: number;
+                asset: string;
+                mimeType?: string | undefined;
+                outputSchema?: Record<string, unknown> | null | undefined;
+                extra?: Record<string, unknown> | null | undefined;
+            }[];
+            error?: string | undefined;
+        }, {
+            x402Version: 1;
+            accepts: {
+                description: string;
+                scheme: string;
+                network: string;
+                maxAmountRequired: string;
+                resource: string;
+                payTo: string;
+                maxTimeoutSeconds: number;
+                asset: string;
+                mimeType?: string | undefined;
+                outputSchema?: Record<string, unknown> | null | undefined;
+                extra?: Record<string, unknown> | null | undefined;
+            }[];
+            error?: string | undefined;
+        }, never>;
+    }>, Schema.Struct<{
+        protocol: Schema.Literal<["x402-v2"]>;
+        data: Schema.Schema<{
+            resource: {
+                url: string;
+                description?: string | undefined;
+                mimeType?: string | undefined;
+            };
+            x402Version: 2;
+            accepts: {
+                scheme: string;
+                network: string;
+                payTo: string;
+                maxTimeoutSeconds: number;
+                asset: string;
+                amount: string;
+                extra?: Record<string, unknown> | null | undefined;
+            }[];
+            error?: string | undefined;
+            extensions?: Record<string, unknown> | null | undefined;
+        }, {
+            resource: {
+                url: string;
+                description?: string | undefined;
+                mimeType?: string | undefined;
+            };
+            x402Version: 2;
+            accepts: {
+                scheme: string;
+                network: string;
+                payTo: string;
+                maxTimeoutSeconds: number;
+                asset: string;
+                amount: string;
+                extra?: Record<string, unknown> | null | undefined;
+            }[];
+            error?: string | undefined;
+            extensions?: Record<string, unknown> | null | undefined;
+        }, never>;
+    }>]>;
     context: Schema.optional<Schema.Struct<{
         method: Schema.optional<typeof Schema.NonEmptyTrimmedString>;
         serverUrl: Schema.optional<typeof Schema.NonEmptyTrimmedString>;
         params: Schema.optional<typeof Schema.Unknown>;
     }>>;
+}>;
+export type AgentAuthorizeRequest = typeof AgentAuthorizeRequest.Type;
+declare const CoSignature_base: Schema.Class<CoSignature, {
+    authorizationData: Schema.SchemaClass<ERC3009AuthorizationData, {
+        readonly nonce: string;
+        readonly from: string;
+        readonly to: string;
+        readonly value: string;
+        readonly validAfter: string;
+        readonly validBefore: string;
+    }, never>;
+    serverSignature: Schema.refine<string, typeof Schema.NonEmptyTrimmedString>;
 }, Schema.Struct.Encoded<{
-    requirements: Schema.NonEmptyArray<typeof PaymentRequirements>;
-    context: Schema.optional<Schema.Struct<{
-        method: Schema.optional<typeof Schema.NonEmptyTrimmedString>;
-        serverUrl: Schema.optional<typeof Schema.NonEmptyTrimmedString>;
-        params: Schema.optional<typeof Schema.Unknown>;
-    }>>;
+    authorizationData: Schema.SchemaClass<ERC3009AuthorizationData, {
+        readonly nonce: string;
+        readonly from: string;
+        readonly to: string;
+        readonly value: string;
+        readonly validAfter: string;
+        readonly validBefore: string;
+    }, never>;
+    serverSignature: Schema.refine<string, typeof Schema.NonEmptyTrimmedString>;
 }>, never, {
-    readonly requirements: readonly [PaymentRequirements, ...PaymentRequirements[]];
+    readonly authorizationData: ERC3009AuthorizationData;
 } & {
-    readonly context?: {
-        readonly method?: string | undefined;
-        readonly serverUrl?: string | undefined;
-        readonly params?: unknown;
-    } | undefined;
+    readonly serverSignature: string;
 }, {}, {}>;
-export declare class AgentPaymentAuthRequest extends AgentPaymentAuthRequest_base {
+/**
+ * ERC-3009 authorization data + server signature for co-signed agent keys;
+ * the agent signs alongside. Scheme-specific today (exact EVM).
+ */
+export declare class CoSignature extends CoSignature_base {
 }
-declare const AgentPaymentAuthResponse_base: Schema.Class<AgentPaymentAuthResponse, {
+/**
+ * Response body for `POST /api/v1/agents/:agent/payment/authorize`. Returns
+ * *indices* into the request's `accepts[]` — the client has the original
+ * line-items, so byte-exact echo doesn't require re-serialization.
+ *
+ * ```
+ * {
+ *   authorized: {
+ *     selected: { acceptsIndex, limits, coSignature? } | null,
+ *     alternatives: [{ acceptsIndex, limits }],
+ *   },
+ *   rejected: [{ acceptsIndex, reason }],
+ *   suggested?: { nonce, validBefore },
+ * }
+ * ```
+ */
+export declare const AgentAuthorizeResponse: Schema.Struct<{
     authorized: Schema.Struct<{
-        recommended: Schema.NullOr<Schema.refine<number, typeof Schema.NonNegative>>;
-        requirements: Schema.Array$<Schema.Struct<{
-            requirement: Schema.SchemaClass<PaymentRequirements, {
-                readonly description: string;
-                readonly scheme: "exact";
-                readonly network: string;
-                readonly maxAmountRequired: string;
-                readonly resource: string;
-                readonly mimeType: string;
-                readonly payTo: string;
-                readonly maxTimeoutSeconds: number;
-                readonly asset: string;
-                readonly extra?: {
-                    readonly [x: string]: unknown;
-                } | undefined;
-            }, never>;
+        selected: Schema.NullOr<Schema.Struct<{
+            acceptsIndex: Schema.refine<number, typeof Schema.NonNegative>;
             limits: Schema.Struct<{
                 dailyRemaining: Schema.refine<string, typeof Schema.Trimmed>;
                 monthlyRemaining: Schema.refine<string, typeof Schema.Trimmed>;
             }>;
+            coSignature: Schema.optional<typeof CoSignature>;
         }>>;
-    }>;
-    rejected: Schema.Array$<Schema.Struct<{
-        requirement: Schema.SchemaClass<PaymentRequirements, {
-            readonly description: string;
-            readonly scheme: "exact";
-            readonly network: string;
-            readonly maxAmountRequired: string;
-            readonly resource: string;
-            readonly mimeType: string;
-            readonly payTo: string;
-            readonly maxTimeoutSeconds: number;
-            readonly asset: string;
-            readonly extra?: {
-                readonly [x: string]: unknown;
-            } | undefined;
-        }, never>;
-        reason: Schema.refine<string, typeof Schema.Trimmed>;
-    }>>;
-    payment: Schema.optional<Schema.NullOr<Schema.Struct<{
-        authorizationData: Schema.SchemaClass<ERC3009AuthorizationData, {
-            readonly nonce: string;
-            readonly from: string;
-            readonly to: string;
-            readonly value: string;
-            readonly validAfter: string;
-            readonly validBefore: string;
-        }, never>;
-        serverSignature: Schema.SchemaClass<string, string, never>;
-        requirement: Schema.SchemaClass<PaymentRequirements, {
-            readonly description: string;
-            readonly scheme: "exact";
-            readonly network: string;
-            readonly maxAmountRequired: string;
-            readonly resource: string;
-            readonly mimeType: string;
-            readonly payTo: string;
-            readonly maxTimeoutSeconds: number;
-            readonly asset: string;
-            readonly extra?: {
-                readonly [x: string]: unknown;
-            } | undefined;
-        }, never>;
-    }>>>;
-}, Schema.Struct.Encoded<{
-    authorized: Schema.Struct<{
-        recommended: Schema.NullOr<Schema.refine<number, typeof Schema.NonNegative>>;
-        requirements: Schema.Array$<Schema.Struct<{
-            requirement: Schema.SchemaClass<PaymentRequirements, {
-                readonly description: string;
-                readonly scheme: "exact";
-                readonly network: string;
-                readonly maxAmountRequired: string;
-                readonly resource: string;
-                readonly mimeType: string;
-                readonly payTo: string;
-                readonly maxTimeoutSeconds: number;
-                readonly asset: string;
-                readonly extra?: {
-                    readonly [x: string]: unknown;
-                } | undefined;
-            }, never>;
+        alternatives: Schema.Array$<Schema.Struct<{
+            acceptsIndex: Schema.refine<number, typeof Schema.NonNegative>;
             limits: Schema.Struct<{
                 dailyRemaining: Schema.refine<string, typeof Schema.Trimmed>;
                 monthlyRemaining: Schema.refine<string, typeof Schema.Trimmed>;
@@ -277,72 +405,15 @@ declare const AgentPaymentAuthResponse_base: Schema.Class<AgentPaymentAuthRespon
         }>>;
     }>;
     rejected: Schema.Array$<Schema.Struct<{
-        requirement: Schema.SchemaClass<PaymentRequirements, {
-            readonly description: string;
-            readonly scheme: "exact";
-            readonly network: string;
-            readonly maxAmountRequired: string;
-            readonly resource: string;
-            readonly mimeType: string;
-            readonly payTo: string;
-            readonly maxTimeoutSeconds: number;
-            readonly asset: string;
-            readonly extra?: {
-                readonly [x: string]: unknown;
-            } | undefined;
-        }, never>;
-        reason: Schema.refine<string, typeof Schema.Trimmed>;
+        acceptsIndex: Schema.refine<number, typeof Schema.NonNegative>;
+        reason: typeof Schema.NonEmptyTrimmedString;
     }>>;
-    payment: Schema.optional<Schema.NullOr<Schema.Struct<{
-        authorizationData: Schema.SchemaClass<ERC3009AuthorizationData, {
-            readonly nonce: string;
-            readonly from: string;
-            readonly to: string;
-            readonly value: string;
-            readonly validAfter: string;
-            readonly validBefore: string;
-        }, never>;
-        serverSignature: Schema.SchemaClass<string, string, never>;
-        requirement: Schema.SchemaClass<PaymentRequirements, {
-            readonly description: string;
-            readonly scheme: "exact";
-            readonly network: string;
-            readonly maxAmountRequired: string;
-            readonly resource: string;
-            readonly mimeType: string;
-            readonly payTo: string;
-            readonly maxTimeoutSeconds: number;
-            readonly asset: string;
-            readonly extra?: {
-                readonly [x: string]: unknown;
-            } | undefined;
-        }, never>;
-    }>>>;
-}>, never, {
-    readonly authorized: {
-        readonly requirements: readonly {
-            readonly requirement: PaymentRequirements;
-            readonly limits: {
-                readonly dailyRemaining: string;
-                readonly monthlyRemaining: string;
-            };
-        }[];
-        readonly recommended: number | null;
-    };
-} & {
-    readonly rejected: readonly {
-        readonly requirement: PaymentRequirements;
-        readonly reason: string;
-    }[];
-} & {
-    readonly payment?: {
-        readonly authorizationData: ERC3009AuthorizationData;
-        readonly serverSignature: string;
-        readonly requirement: PaymentRequirements;
-    } | null | undefined;
-}, {}, {}>;
-export declare class AgentPaymentAuthResponse extends AgentPaymentAuthResponse_base {
-}
+    suggested: Schema.optional<Schema.Struct<{
+        nonce: Schema.refine<string, typeof Schema.NonEmptyTrimmedString>;
+        validBefore: Schema.refine<string, typeof Schema.NonEmptyTrimmedString>;
+    }>>;
+}>;
+export type AgentAuthorizeResponse = typeof AgentAuthorizeResponse.Type;
 export declare const PaymentEventType: Schema.Union<[Schema.Struct<{
     type: Schema.Literal<["sending"]>;
 }>, Schema.Struct<{
@@ -355,110 +426,63 @@ export declare const PaymentEventType: Schema.Union<[Schema.Struct<{
     reason: Schema.refine<string, typeof Schema.Trimmed>;
 }>]>;
 export type PaymentEventType = typeof PaymentEventType.Type;
-declare const ExactEvmAuthorization_base: Schema.Class<ExactEvmAuthorization, {
-    from: Schema.refine<string, typeof Schema.NonEmptyTrimmedString>;
-    to: Schema.refine<string, typeof Schema.NonEmptyTrimmedString>;
-    value: Schema.refine<string, typeof Schema.Trimmed>;
-    validAfter: Schema.refine<string, typeof Schema.Trimmed>;
-    validBefore: Schema.refine<string, typeof Schema.Trimmed>;
-    nonce: Schema.refine<string, typeof Schema.Trimmed>;
-}, Schema.Struct.Encoded<{
-    from: Schema.refine<string, typeof Schema.NonEmptyTrimmedString>;
-    to: Schema.refine<string, typeof Schema.NonEmptyTrimmedString>;
-    value: Schema.refine<string, typeof Schema.Trimmed>;
-    validAfter: Schema.refine<string, typeof Schema.Trimmed>;
-    validBefore: Schema.refine<string, typeof Schema.Trimmed>;
-    nonce: Schema.refine<string, typeof Schema.Trimmed>;
-}>, never, {
-    readonly nonce: string;
-} & {
-    readonly from: string;
-} & {
-    readonly to: string;
-} & {
-    readonly value: string;
-} & {
-    readonly validAfter: string;
-} & {
-    readonly validBefore: string;
-}, {}, {}>;
-export declare class ExactEvmAuthorization extends ExactEvmAuthorization_base {
-}
-declare const ExactEvmPayload_base: Schema.Class<ExactEvmPayload, {
-    signature: Schema.refine<string, typeof Schema.Trimmed>;
-    authorization: Schema.SchemaClass<ExactEvmAuthorization, {
-        readonly nonce: string;
-        readonly from: string;
-        readonly to: string;
-        readonly value: string;
-        readonly validAfter: string;
-        readonly validBefore: string;
-    }, never>;
-}, Schema.Struct.Encoded<{
-    signature: Schema.refine<string, typeof Schema.Trimmed>;
-    authorization: Schema.SchemaClass<ExactEvmAuthorization, {
-        readonly nonce: string;
-        readonly from: string;
-        readonly to: string;
-        readonly value: string;
-        readonly validAfter: string;
-        readonly validBefore: string;
-    }, never>;
-}>, never, {
-    readonly signature: string;
-} & {
-    readonly authorization: ExactEvmAuthorization;
-}, {}, {}>;
-export declare class ExactEvmPayload extends ExactEvmPayload_base {
-}
-declare const PaymentPayload_base: Schema.Class<PaymentPayload, {
-    x402Version: Schema.SchemaClass<number, number, never>;
-    scheme: Schema.refine<string, typeof Schema.Trimmed>;
-    network: Schema.refine<string, typeof Schema.Trimmed>;
-    payload: Schema.Union<[typeof ExactEvmPayload, typeof Schema.Unknown]>;
-}, Schema.Struct.Encoded<{
-    x402Version: Schema.SchemaClass<number, number, never>;
-    scheme: Schema.refine<string, typeof Schema.Trimmed>;
-    network: Schema.refine<string, typeof Schema.Trimmed>;
-    payload: Schema.Union<[typeof ExactEvmPayload, typeof Schema.Unknown]>;
-}>, never, {
-    readonly scheme: string;
-} & {
-    readonly network: string;
-} & {
-    readonly x402Version: number;
-} & {
-    readonly payload: unknown;
-}, {}, {}>;
-export declare class PaymentPayload extends PaymentPayload_base {
-}
-declare const AgentPaymentEventReport_base: Schema.Class<AgentPaymentEventReport, {
+export type PaymentEvent = PaymentEventType;
+/** Request body for `POST /api/v1/agents/:agent/payment/events`. */
+export declare const AgentPaymentEventReport: Schema.Struct<{
     id: Schema.refine<string, typeof Schema.Trimmed>;
-    payment: Schema.SchemaClass<PaymentPayload, {
-        readonly scheme: string;
-        readonly network: string;
-        readonly x402Version: number;
-        readonly payload: unknown;
-    }, never>;
-    event: Schema.Union<[Schema.Struct<{
-        type: Schema.Literal<["sending"]>;
-    }>, Schema.Struct<{
-        type: Schema.Literal<["accepted"]>;
-    }>, Schema.Struct<{
-        type: Schema.Literal<["rejected"]>;
-        reason: Schema.refine<string, typeof Schema.Trimmed>;
+    payment: Schema.Union<[Schema.Struct<{
+        protocol: Schema.Literal<["x402-v1"]>;
+        data: Schema.Schema<{
+            scheme: string;
+            network: string;
+            x402Version: 1;
+            payload: Record<string, unknown>;
+        }, {
+            scheme: string;
+            network: string;
+            x402Version: 1;
+            payload: Record<string, unknown>;
+        }, never>;
     }>, Schema.Struct<{
-        type: Schema.Literal<["error"]>;
-        reason: Schema.refine<string, typeof Schema.Trimmed>;
+        protocol: Schema.Literal<["x402-v2"]>;
+        data: Schema.Schema<{
+            x402Version: 2;
+            payload: Record<string, unknown>;
+            accepted: {
+                scheme: string;
+                network: string;
+                payTo: string;
+                maxTimeoutSeconds: number;
+                asset: string;
+                amount: string;
+                extra?: Record<string, unknown> | null | undefined;
+            };
+            resource?: {
+                url: string;
+                description?: string | undefined;
+                mimeType?: string | undefined;
+            } | undefined;
+            extensions?: Record<string, unknown> | null | undefined;
+        }, {
+            x402Version: 2;
+            payload: Record<string, unknown>;
+            accepted: {
+                scheme: string;
+                network: string;
+                payTo: string;
+                maxTimeoutSeconds: number;
+                asset: string;
+                amount: string;
+                extra?: Record<string, unknown> | null | undefined;
+            };
+            resource?: {
+                url: string;
+                description?: string | undefined;
+                mimeType?: string | undefined;
+            } | undefined;
+            extensions?: Record<string, unknown> | null | undefined;
+        }, never>;
     }>]>;
-}, Schema.Struct.Encoded<{
-    id: Schema.refine<string, typeof Schema.Trimmed>;
-    payment: Schema.SchemaClass<PaymentPayload, {
-        readonly scheme: string;
-        readonly network: string;
-        readonly x402Version: number;
-        readonly payload: unknown;
-    }, never>;
     event: Schema.Union<[Schema.Struct<{
         type: Schema.Literal<["sending"]>;
     }>, Schema.Struct<{
@@ -470,25 +494,8 @@ declare const AgentPaymentEventReport_base: Schema.Class<AgentPaymentEventReport
         type: Schema.Literal<["error"]>;
         reason: Schema.refine<string, typeof Schema.Trimmed>;
     }>]>;
-}>, never, {
-    readonly payment: PaymentPayload;
-} & {
-    readonly id: string;
-} & {
-    readonly event: {
-        readonly type: "sending";
-    } | {
-        readonly type: "accepted";
-    } | {
-        readonly type: "rejected";
-        readonly reason: string;
-    } | {
-        readonly type: "error";
-        readonly reason: string;
-    };
-}, {}, {}>;
-export declare class AgentPaymentEventReport extends AgentPaymentEventReport_base {
-}
+}>;
+export type AgentPaymentEventReport = typeof AgentPaymentEventReport.Type;
 declare const AgentPaymentEventResponse_base: Schema.Class<AgentPaymentEventResponse, {
     received: Schema.SchemaClass<boolean, boolean, never>;
     paymentId: Schema.optional<typeof Schema.UUID>;
@@ -517,35 +524,42 @@ export declare class ApiError extends Error {
     response?: Response | undefined;
     constructor(message: string, status?: number | undefined, response?: Response | undefined);
 }
-export type PaymentEvent = PaymentEventType;
 export declare const SpendConfigInput: Schema.Struct<{
     auto_topup_allowed: Schema.SchemaClass<boolean, boolean, never>;
     daily_limit: Schema.NullOr<typeof Schema.String>;
     monthly_limit: Schema.NullOr<typeof Schema.String>;
     per_transaction_limit: Schema.NullOr<typeof Schema.String>;
 }>;
-declare const CreateAgentApprovalRequest_base: Schema.Class<CreateAgentApprovalRequest, {
+declare const AgentApprovalRequest_base: Schema.Class<AgentApprovalRequest, {
     name: Schema.NullOr<typeof Schema.String>;
     agent_key_address: Schema.refine<string, typeof Schema.NonEmptyTrimmedString>;
+    key_name: Schema.optional<Schema.SchemaClass<string, string, never>>;
     spend_config: Schema.optional<Schema.NullOr<Schema.Struct<{
         auto_topup_allowed: Schema.SchemaClass<boolean, boolean, never>;
         daily_limit: Schema.NullOr<typeof Schema.String>;
         monthly_limit: Schema.NullOr<typeof Schema.String>;
         per_transaction_limit: Schema.NullOr<typeof Schema.String>;
     }>>>;
+    mode: Schema.optional<Schema.Literal<["create", "connect", "connect_choose"]>>;
+    agent_address: Schema.optional<Schema.refine<string, typeof Schema.NonEmptyTrimmedString>>;
 }, Schema.Struct.Encoded<{
     name: Schema.NullOr<typeof Schema.String>;
     agent_key_address: Schema.refine<string, typeof Schema.NonEmptyTrimmedString>;
+    key_name: Schema.optional<Schema.SchemaClass<string, string, never>>;
     spend_config: Schema.optional<Schema.NullOr<Schema.Struct<{
         auto_topup_allowed: Schema.SchemaClass<boolean, boolean, never>;
         daily_limit: Schema.NullOr<typeof Schema.String>;
         monthly_limit: Schema.NullOr<typeof Schema.String>;
         per_transaction_limit: Schema.NullOr<typeof Schema.String>;
     }>>>;
+    mode: Schema.optional<Schema.Literal<["create", "connect", "connect_choose"]>>;
+    agent_address: Schema.optional<Schema.refine<string, typeof Schema.NonEmptyTrimmedString>>;
 }>, never, {
     readonly name: string | null;
 } & {
     readonly agent_key_address: string;
+} & {
+    readonly key_name?: string | undefined;
 } & {
     readonly spend_config?: {
         readonly auto_topup_allowed: boolean;
@@ -553,8 +567,12 @@ declare const CreateAgentApprovalRequest_base: Schema.Class<CreateAgentApprovalR
         readonly monthly_limit: string | null;
         readonly per_transaction_limit: string | null;
     } | null | undefined;
+} & {
+    readonly mode?: "create" | "connect" | "connect_choose" | undefined;
+} & {
+    readonly agent_address?: string | undefined;
 }, {}, {}>;
-export declare class CreateAgentApprovalRequest extends CreateAgentApprovalRequest_base {
+export declare class AgentApprovalRequest extends AgentApprovalRequest_base {
 }
 declare const ApprovalResponse_base: Schema.Class<ApprovalResponse, {
     token: Schema.refine<string, typeof Schema.Trimmed>;