@ampersend_ai/ampersend-sdk 0.0.22 → 0.0.26

package/dist/ampersend/types.d.ts

@@ -1,136 +1,76 @@
 import { Schema } from "effect";
-export declare const Scheme: Schema.Literal<["exact", "deferred"]>;
+export declare const NonEmptyTrimmedString: Schema.NonEmptyString;
+export type NonEmptyTrimmedString = typeof NonEmptyTrimmedString.Type;
+export declare const NonNegativeInt: Schema.Int;
+export type NonNegativeInt = typeof NonNegativeInt.Type;
+export declare const Scheme: Schema.Literals<readonly ["exact", "deferred"]>;
 export type Scheme = typeof Scheme.Type;
-export declare const Address: Schema.refine<string, typeof Schema.NonEmptyTrimmedString>;
+export declare const Address: Schema.NonEmptyString;
 export type Address = typeof Address.Type;
-export declare const TxHash: Schema.filter<typeof Schema.NonEmptyTrimmedString>;
+export declare const TxHash: Schema.NonEmptyString;
 export type TxHash = typeof TxHash.Type;
-export declare const Caip2ID: Schema.filter<typeof Schema.NonEmptyTrimmedString>;
+export declare const Caip2ID: Schema.NonEmptyString;
 export type Caip2ID = typeof Caip2ID.Type;
-export declare const Hex32Bytes: Schema.filter<typeof Schema.NonEmptyTrimmedString>;
+export declare const Hex32Bytes: Schema.NonEmptyString;
 export type Hex32Bytes = typeof Hex32Bytes.Type;
-export declare const Hex65Bytes: Schema.filter<typeof Schema.NonEmptyTrimmedString>;
+export declare const Hex65Bytes: Schema.NonEmptyString;
 export type Hex65Bytes = typeof Hex65Bytes.Type;
-export declare const NonNegativeIntegerString: Schema.filter<typeof Schema.NonEmptyTrimmedString>;
+export declare const NonNegativeIntegerString: Schema.NonEmptyString;
 export type NonNegativeIntegerString = typeof NonNegativeIntegerString.Type;
-export declare const ID: Schema.brand<typeof Schema.UUID, "ID">;
+export declare const ID: Schema.brand<Schema.String, "ID">;
 export type ID = typeof ID.Type;
-export declare const ConvertedTimestamp: Schema.Union<[Schema.refine<number, typeof Schema.NonNegative>, Schema.filter<Schema.filter<typeof Schema.NumberFromString>>]>;
+export declare const ConvertedTimestamp: Schema.Union<readonly [Schema.Int, Schema.compose<Schema.Int, Schema.NumberFromString>]>;
 export type ConvertedTimestamp = typeof ConvertedTimestamp.Type;
-declare const SIWENonceResponse_base: Schema.Class<SIWENonceResponse, {
-    nonce: Schema.refine<string, typeof Schema.Trimmed>;
-    sessionId: Schema.refine<string, typeof Schema.Trimmed>;
-}, Schema.Struct.Encoded<{
-    nonce: Schema.refine<string, typeof Schema.Trimmed>;
-    sessionId: Schema.refine<string, typeof Schema.Trimmed>;
-}>, never, {
-    readonly nonce: string;
-} & {
-    readonly sessionId: string;
-}, {}, {}>;
-export declare class SIWENonceResponse extends SIWENonceResponse_base {
-}
-declare const SIWELoginRequest_base: Schema.Class<SIWELoginRequest, {
-    signature: Schema.refine<string, typeof Schema.Trimmed>;
-    message: Schema.refine<string, typeof Schema.Trimmed>;
-    sessionId: Schema.refine<string, typeof Schema.Trimmed>;
-    agentAddress: Schema.refine<string, typeof Schema.NonEmptyTrimmedString>;
-}, Schema.Struct.Encoded<{
-    signature: Schema.refine<string, typeof Schema.Trimmed>;
-    message: Schema.refine<string, typeof Schema.Trimmed>;
-    sessionId: Schema.refine<string, typeof Schema.Trimmed>;
-    agentAddress: Schema.refine<string, typeof Schema.NonEmptyTrimmedString>;
-}>, never, {
-    readonly sessionId: string;
-} & {
-    readonly signature: string;
-} & {
-    readonly message: string;
-} & {
-    readonly agentAddress: string;
-}, {}, {}>;
-export declare class SIWELoginRequest extends SIWELoginRequest_base {
-}
-declare const SIWELoginResponse_base: Schema.Class<SIWELoginResponse, {
-    token: Schema.refine<string, typeof Schema.Trimmed>;
-    agentAddress: Schema.refine<string, typeof Schema.NonEmptyTrimmedString>;
-    expiresAt: Schema.transformOrFail<Schema.SchemaClass<string, string, never>, typeof Schema.DateTimeUtcFromSelf, never>;
-}, Schema.Struct.Encoded<{
-    token: Schema.refine<string, typeof Schema.Trimmed>;
-    agentAddress: Schema.refine<string, typeof Schema.NonEmptyTrimmedString>;
-    expiresAt: Schema.transformOrFail<Schema.SchemaClass<string, string, never>, typeof Schema.DateTimeUtcFromSelf, never>;
-}>, never, {
-    readonly agentAddress: string;
-} & {
-    readonly token: string;
-} & {
-    readonly expiresAt: import("effect/DateTime").Utc;
-}, {}, {}>;
-export declare class SIWELoginResponse extends SIWELoginResponse_base {
-}
-declare const ERC3009AuthorizationData_base: Schema.Class<ERC3009AuthorizationData, {
-    from: Schema.refine<string, typeof Schema.NonEmptyTrimmedString>;
-    to: Schema.refine<string, typeof Schema.NonEmptyTrimmedString>;
-    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.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;
-} & {
-    readonly from: string;
-} & {
-    readonly to: string;
-} & {
-    readonly value: string;
-} & {
-    readonly validAfter: string;
-} & {
-    readonly validBefore: string;
-}, {}, {}>;
-export declare class ERC3009AuthorizationData extends ERC3009AuthorizationData_base {
-}
-declare const ServerAuthorizationData_base: Schema.Class<ServerAuthorizationData, {
-    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<{
-    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 authorizationData: ERC3009AuthorizationData;
-} & {
-    readonly serverSignature: string;
-}, {}, {}>;
-export declare class ServerAuthorizationData extends ServerAuthorizationData_base {
-}
+export declare const SIWENonceResponse: Schema.Struct<{
+    readonly nonce: Schema.NonEmptyString;
+    readonly sessionId: Schema.NonEmptyString;
+}>;
+export type SIWENonceResponse = typeof SIWENonceResponse.Type;
+export declare const SIWELoginRequest: Schema.Struct<{
+    readonly signature: Schema.NonEmptyString;
+    readonly message: Schema.NonEmptyString;
+    readonly sessionId: Schema.NonEmptyString;
+    readonly agentAddress: Schema.NonEmptyString;
+}>;
+export type SIWELoginRequest = typeof SIWELoginRequest.Type;
+export declare const SIWELoginResponse: Schema.Struct<{
+    readonly token: Schema.NonEmptyString;
+    readonly agentAddress: Schema.NonEmptyString;
+    readonly expiresAt: Schema.DateTimeUtcFromString;
+}>;
+export type SIWELoginResponse = typeof SIWELoginResponse.Type;
+export declare const SignSiwxResponse: Schema.Struct<{
+    readonly serverSignature: Schema.NonEmptyString;
+}>;
+export type SignSiwxResponse = typeof SignSiwxResponse.Type;
+export declare const ERC3009AuthorizationData: Schema.Struct<{
+    readonly from: Schema.NonEmptyString;
+    readonly to: Schema.NonEmptyString;
+    readonly value: Schema.NonEmptyString;
+    readonly validAfter: Schema.NonEmptyString;
+    readonly validBefore: Schema.NonEmptyString;
+    readonly nonce: Schema.NonEmptyString;
+}>;
+export type ERC3009AuthorizationData = typeof ERC3009AuthorizationData.Type;
+export declare const ServerAuthorizationData: Schema.Struct<{
+    readonly authorizationData: Schema.Struct<{
+        readonly from: Schema.NonEmptyString;
+        readonly to: Schema.NonEmptyString;
+        readonly value: Schema.NonEmptyString;
+        readonly validAfter: Schema.NonEmptyString;
+        readonly validBefore: Schema.NonEmptyString;
+        readonly nonce: Schema.NonEmptyString;
+    }>;
+    readonly serverSignature: Schema.NonEmptyString;
+}>;
+export type ServerAuthorizationData = typeof ServerAuthorizationData.Type;
 /** Dispatch tag on wire envelopes. Distinct from any individual protocol's internal version. */
-export declare const Protocol: Schema.Literal<["x402-v1", "x402-v2"]>;
+export declare const Protocol: Schema.Literals<readonly ["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<{
+export declare const PaymentRequestEnvelope: Schema.Union<readonly [Schema.Struct<{
+    readonly protocol: Schema.Literal<"x402-v1">;
+    readonly data: Schema.Codec<{
         x402Version: 1;
         accepts: {
             description: string;
@@ -162,10 +102,10 @@ export declare const PaymentRequestEnvelope: Schema.Union<[Schema.Struct<{
             extra?: Record<string, unknown> | null | undefined;
         }[];
         error?: string | undefined;
-    }, never>;
+    }, never, never>;
 }>, Schema.Struct<{
-    protocol: Schema.Literal<["x402-v2"]>;
-    data: Schema.Schema<{
+    readonly protocol: Schema.Literal<"x402-v2">;
+    readonly data: Schema.Codec<{
         resource: {
             url: string;
             description?: string | undefined;
@@ -201,13 +141,13 @@ export declare const PaymentRequestEnvelope: Schema.Union<[Schema.Struct<{
         }[];
         error?: string | undefined;
         extensions?: Record<string, unknown> | null | undefined;
-    }, never>;
+    }, never, 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<{
+export declare const PaymentAuthorizationEnvelope: Schema.Union<readonly [Schema.Struct<{
+    readonly protocol: Schema.Literal<"x402-v1">;
+    readonly data: Schema.Codec<{
         scheme: string;
         network: string;
         x402Version: 1;
@@ -217,10 +157,10 @@ export declare const PaymentAuthorizationEnvelope: Schema.Union<[Schema.Struct<{
         network: string;
         x402Version: 1;
         payload: Record<string, unknown>;
-    }, never>;
+    }, never, never>;
 }>, Schema.Struct<{
-    protocol: Schema.Literal<["x402-v2"]>;
-    data: Schema.Schema<{
+    readonly protocol: Schema.Literal<"x402-v2">;
+    readonly data: Schema.Codec<{
         x402Version: 2;
         payload: Record<string, unknown>;
         accepted: {
@@ -256,14 +196,14 @@ export declare const PaymentAuthorizationEnvelope: Schema.Union<[Schema.Struct<{
             mimeType?: string | undefined;
         } | undefined;
         extensions?: Record<string, unknown> | null | undefined;
-    }, never>;
+    }, never, 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<{
+    readonly paymentRequest: Schema.Union<readonly [Schema.Struct<{
+        readonly protocol: Schema.Literal<"x402-v1">;
+        readonly data: Schema.Codec<{
             x402Version: 1;
             accepts: {
                 description: string;
@@ -295,10 +235,10 @@ export declare const AgentAuthorizeRequest: Schema.Struct<{
                 extra?: Record<string, unknown> | null | undefined;
             }[];
             error?: string | undefined;
-        }, never>;
+        }, never, never>;
     }>, Schema.Struct<{
-        protocol: Schema.Literal<["x402-v2"]>;
-        data: Schema.Schema<{
+        readonly protocol: Schema.Literal<"x402-v2">;
+        readonly data: Schema.Codec<{
             resource: {
                 url: string;
                 description?: string | undefined;
@@ -334,46 +274,31 @@ export declare const AgentAuthorizeRequest: Schema.Struct<{
             }[];
             error?: string | undefined;
             extensions?: Record<string, unknown> | null | undefined;
-        }, never>;
+        }, never, never>;
     }>]>;
-    context: Schema.optional<Schema.Struct<{
-        method: Schema.optional<typeof Schema.NonEmptyTrimmedString>;
-        serverUrl: Schema.optional<typeof Schema.NonEmptyTrimmedString>;
-        params: Schema.optional<typeof Schema.Unknown>;
+    readonly context: Schema.optional<Schema.Struct<{
+        readonly method: Schema.optional<Schema.NonEmptyString>;
+        readonly serverUrl: Schema.optional<Schema.NonEmptyString>;
+        readonly params: Schema.optional<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<{
-    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 authorizationData: ERC3009AuthorizationData;
-} & {
-    readonly serverSignature: string;
-}, {}, {}>;
 /**
  * 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 {
-}
+export declare const CoSignature: Schema.Struct<{
+    readonly authorizationData: Schema.Struct<{
+        readonly from: Schema.NonEmptyString;
+        readonly to: Schema.NonEmptyString;
+        readonly value: Schema.NonEmptyString;
+        readonly validAfter: Schema.NonEmptyString;
+        readonly validBefore: Schema.NonEmptyString;
+        readonly nonce: Schema.NonEmptyString;
+    }>;
+    readonly serverSignature: Schema.NonEmptyString;
+}>;
+export type CoSignature = typeof CoSignature.Type;
 /**
  * Response body for `POST /api/v1/agents/:agent/payment/authorize`. Returns
  * *indices* into the request's `accepts[]` — the client has the original
@@ -385,58 +310,75 @@ export declare class CoSignature extends CoSignature_base {
  *     selected: { acceptsIndex, limits, coSignature? } | null,
  *     alternatives: [{ acceptsIndex, limits }],
  *   },
- *   rejected: [{ acceptsIndex, reason }],
+ *   rejected: [{ acceptsIndex, reason, reasonCode? }],
  *   suggested?: { nonce, validBefore },
  * }
  * ```
+ *
+ * `reasonCode` on rejected items is a stable string identifier for the
+ * rejection category (e.g., `per_tx_limit_exceeded`,
+ * `compliance_high_risk`). Optional for backwards compatibility with
+ * older API versions that only emit `reason`; consumers should fall
+ * back to a default branch when an unknown code arrives.
  */
 export declare const AgentAuthorizeResponse: Schema.Struct<{
-    authorized: Schema.Struct<{
-        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>;
+    readonly authorized: Schema.Struct<{
+        readonly selected: Schema.NullOr<Schema.Struct<{
+            readonly acceptsIndex: Schema.Int;
+            readonly limits: Schema.Struct<{
+                readonly dailyRemaining: Schema.NonEmptyString;
+                readonly monthlyRemaining: Schema.NonEmptyString;
             }>;
-            coSignature: Schema.optional<typeof CoSignature>;
+            readonly coSignature: Schema.optional<Schema.Struct<{
+                readonly authorizationData: Schema.Struct<{
+                    readonly from: Schema.NonEmptyString;
+                    readonly to: Schema.NonEmptyString;
+                    readonly value: Schema.NonEmptyString;
+                    readonly validAfter: Schema.NonEmptyString;
+                    readonly validBefore: Schema.NonEmptyString;
+                    readonly nonce: Schema.NonEmptyString;
+                }>;
+                readonly serverSignature: Schema.NonEmptyString;
+            }>>;
         }>>;
-        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>;
+        readonly alternatives: Schema.$Array<Schema.Struct<{
+            readonly acceptsIndex: Schema.Int;
+            readonly limits: Schema.Struct<{
+                readonly dailyRemaining: Schema.NonEmptyString;
+                readonly monthlyRemaining: Schema.NonEmptyString;
             }>;
         }>>;
     }>;
-    rejected: Schema.Array$<Schema.Struct<{
-        acceptsIndex: Schema.refine<number, typeof Schema.NonNegative>;
-        reason: typeof Schema.NonEmptyTrimmedString;
+    readonly rejected: Schema.$Array<Schema.Struct<{
+        readonly acceptsIndex: Schema.Int;
+        readonly reason: Schema.NonEmptyString;
+        readonly reasonCode: Schema.optional<Schema.NonEmptyString>;
     }>>;
-    suggested: Schema.optional<Schema.Struct<{
-        nonce: Schema.refine<string, typeof Schema.NonEmptyTrimmedString>;
-        validBefore: Schema.refine<string, typeof Schema.NonEmptyTrimmedString>;
+    readonly suggested: Schema.optional<Schema.Struct<{
+        readonly nonce: Schema.NonEmptyString;
+        readonly validBefore: Schema.NonEmptyString;
     }>>;
 }>;
 export type AgentAuthorizeResponse = typeof AgentAuthorizeResponse.Type;
-export declare const PaymentEventType: Schema.Union<[Schema.Struct<{
-    type: Schema.Literal<["sending"]>;
+export declare const PaymentEventType: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"sending">;
 }>, Schema.Struct<{
-    type: Schema.Literal<["accepted"]>;
+    readonly type: Schema.Literal<"accepted">;
 }>, Schema.Struct<{
-    type: Schema.Literal<["rejected"]>;
-    reason: Schema.refine<string, typeof Schema.Trimmed>;
+    readonly type: Schema.Literal<"rejected">;
+    readonly reason: Schema.NonEmptyString;
 }>, Schema.Struct<{
-    type: Schema.Literal<["error"]>;
-    reason: Schema.refine<string, typeof Schema.Trimmed>;
+    readonly type: Schema.Literal<"error">;
+    readonly reason: Schema.NonEmptyString;
 }>]>;
 export type PaymentEventType = typeof PaymentEventType.Type;
 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.Union<[Schema.Struct<{
-        protocol: Schema.Literal<["x402-v1"]>;
-        data: Schema.Schema<{
+    readonly id: Schema.NonEmptyString;
+    readonly payment: Schema.Union<readonly [Schema.Struct<{
+        readonly protocol: Schema.Literal<"x402-v1">;
+        readonly data: Schema.Codec<{
             scheme: string;
             network: string;
             x402Version: 1;
@@ -446,10 +388,10 @@ export declare const AgentPaymentEventReport: Schema.Struct<{
             network: string;
             x402Version: 1;
             payload: Record<string, unknown>;
-        }, never>;
+        }, never, never>;
     }>, Schema.Struct<{
-        protocol: Schema.Literal<["x402-v2"]>;
-        data: Schema.Schema<{
+        readonly protocol: Schema.Literal<"x402-v2">;
+        readonly data: Schema.Codec<{
             x402Version: 2;
             payload: Record<string, unknown>;
             accepted: {
@@ -485,39 +427,44 @@ export declare const AgentPaymentEventReport: Schema.Struct<{
                 mimeType?: string | undefined;
             } | undefined;
             extensions?: Record<string, unknown> | null | undefined;
-        }, never>;
+        }, never, never>;
     }>]>;
-    event: Schema.Union<[Schema.Struct<{
-        type: Schema.Literal<["sending"]>;
+    readonly event: Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"sending">;
     }>, Schema.Struct<{
-        type: Schema.Literal<["accepted"]>;
+        readonly type: Schema.Literal<"accepted">;
     }>, Schema.Struct<{
-        type: Schema.Literal<["rejected"]>;
-        reason: Schema.refine<string, typeof Schema.Trimmed>;
+        readonly type: Schema.Literal<"rejected">;
+        readonly reason: Schema.NonEmptyString;
     }>, Schema.Struct<{
-        type: Schema.Literal<["error"]>;
-        reason: Schema.refine<string, typeof Schema.Trimmed>;
+        readonly type: Schema.Literal<"error">;
+        readonly reason: Schema.NonEmptyString;
     }>]>;
 }>;
 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>;
-}, Schema.Struct.Encoded<{
-    received: Schema.SchemaClass<boolean, boolean, never>;
-    paymentId: Schema.optional<typeof Schema.UUID>;
-}>, never, {
-    readonly received: boolean;
-} & {
-    readonly paymentId?: string | undefined;
-}, {}, {}>;
-export declare class AgentPaymentEventResponse extends AgentPaymentEventResponse_base {
-}
+export declare const AgentPaymentEventResponse: Schema.Struct<{
+    readonly received: Schema.Boolean;
+    readonly paymentId: Schema.optional<Schema.String>;
+}>;
+export type AgentPaymentEventResponse = typeof AgentPaymentEventResponse.Type;
 export interface ApiClientOptions {
     baseUrl: string;
     sessionKeyPrivateKey?: `0x${string}`;
-    agentAddress: Address;
+    /**
+     * The agent's smart-account address. Required for any authenticated call
+     * (the SIWE login binds to it); optional when the client is used only for
+     * unauthenticated reads. Authenticated paths throw a clear error if it's
+     * missing — see `ApiClient.performAuthentication`.
+     */
+    agentAddress?: Address;
     timeout?: number;
+    /**
+     * Identifies the calling client for the API's product-analytics
+     * attribution. Sent on every authenticated request as
+     * `Ampersend-Client: <clientName>/<version>`. The `ampersend` CLI passes
+     * `"ampersend-cli"`; library callers default to `"sdk-typescript"`.
+     */
+    clientName?: string;
 }
 export interface AuthenticationState {
     token: string | null;
@@ -529,107 +476,65 @@ export declare class ApiError extends Error {
     constructor(message: string, status?: number | undefined, response?: Response | undefined);
 }
 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>;
+    readonly auto_topup_allowed: Schema.Boolean;
+    readonly daily_limit: Schema.NullOr<Schema.String>;
+    readonly monthly_limit: Schema.NullOr<Schema.String>;
+    readonly per_transaction_limit: Schema.NullOr<Schema.String>;
 }>;
-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>;
+export declare const AgentApprovalRequest: Schema.Struct<{
+    readonly name: Schema.NullOr<Schema.String>;
+    readonly agent_key_address: Schema.NonEmptyString;
+    readonly key_name: Schema.optional<Schema.String>;
+    readonly spend_config: Schema.optional<Schema.NullOr<Schema.Struct<{
+        readonly auto_topup_allowed: Schema.Boolean;
+        readonly daily_limit: Schema.NullOr<Schema.String>;
+        readonly monthly_limit: Schema.NullOr<Schema.String>;
+        readonly per_transaction_limit: Schema.NullOr<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;
-        readonly daily_limit: string | null;
-        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 AgentApprovalRequest extends AgentApprovalRequest_base {
-}
-declare const ApprovalResponse_base: Schema.Class<ApprovalResponse, {
-    token: Schema.refine<string, typeof Schema.Trimmed>;
-    status_url: Schema.refine<string, typeof Schema.Trimmed>;
-    user_approve_url: Schema.refine<string, typeof Schema.Trimmed>;
-}, Schema.Struct.Encoded<{
-    token: Schema.refine<string, typeof Schema.Trimmed>;
-    status_url: Schema.refine<string, typeof Schema.Trimmed>;
-    user_approve_url: Schema.refine<string, typeof Schema.Trimmed>;
-}>, never, {
-    readonly token: string;
-} & {
-    readonly status_url: string;
-} & {
-    readonly user_approve_url: string;
-}, {}, {}>;
-export declare class ApprovalResponse extends ApprovalResponse_base {
-}
+    readonly mode: Schema.optional<Schema.Literals<readonly ["create", "connect", "connect_choose"]>>;
+    readonly agent_address: Schema.optional<Schema.NonEmptyString>;
+}>;
+export type AgentApprovalRequest = typeof AgentApprovalRequest.Type;
+export declare const ApprovalResponse: Schema.Struct<{
+    readonly token: Schema.NonEmptyString;
+    readonly status_url: Schema.NonEmptyString;
+    readonly user_approve_url: Schema.NonEmptyString;
+}>;
+export type ApprovalResponse = typeof ApprovalResponse.Type;
 export declare const ApprovalStatusPending: Schema.Struct<{
-    status: Schema.Literal<["pending"]>;
+    readonly status: Schema.Literal<"pending">;
 }>;
 export declare const ApprovalStatusResolved: Schema.Struct<{
-    status: Schema.Literal<["resolved"]>;
-    agent: Schema.optional<Schema.Struct<{
-        address: Schema.refine<string, typeof Schema.NonEmptyTrimmedString>;
-        agent_key_address: Schema.optional<Schema.refine<string, typeof Schema.NonEmptyTrimmedString>>;
+    readonly status: Schema.Literal<"resolved">;
+    readonly agent: Schema.optional<Schema.Struct<{
+        readonly address: Schema.NonEmptyString;
+        readonly agent_key_address: Schema.optional<Schema.NonEmptyString>;
     }>>;
-    resolved_at: Schema.SchemaClass<string, string, never>;
+    readonly resolved_at: Schema.String;
 }>;
 export declare const ApprovalStatusRejected: Schema.Struct<{
-    status: Schema.Literal<["rejected"]>;
-    resolved_at: Schema.SchemaClass<string, string, never>;
+    readonly status: Schema.Literal<"rejected">;
+    readonly resolved_at: Schema.String;
 }>;
 export declare const ApprovalStatusBlocked: Schema.Struct<{
-    status: Schema.Literal<["blocked"]>;
-    resolved_at: Schema.SchemaClass<string, string, never>;
+    readonly status: Schema.Literal<"blocked">;
+    readonly resolved_at: Schema.String;
 }>;
-export declare const ApprovalStatus: Schema.Union<[Schema.Struct<{
-    status: Schema.Literal<["pending"]>;
+export declare const ApprovalStatus: Schema.Union<readonly [Schema.Struct<{
+    readonly status: Schema.Literal<"pending">;
 }>, Schema.Struct<{
-    status: Schema.Literal<["resolved"]>;
-    agent: Schema.optional<Schema.Struct<{
-        address: Schema.refine<string, typeof Schema.NonEmptyTrimmedString>;
-        agent_key_address: Schema.optional<Schema.refine<string, typeof Schema.NonEmptyTrimmedString>>;
+    readonly status: Schema.Literal<"resolved">;
+    readonly agent: Schema.optional<Schema.Struct<{
+        readonly address: Schema.NonEmptyString;
+        readonly agent_key_address: Schema.optional<Schema.NonEmptyString>;
     }>>;
-    resolved_at: Schema.SchemaClass<string, string, never>;
+    readonly resolved_at: Schema.String;
 }>, Schema.Struct<{
-    status: Schema.Literal<["rejected"]>;
-    resolved_at: Schema.SchemaClass<string, string, never>;
+    readonly status: Schema.Literal<"rejected">;
+    readonly resolved_at: Schema.String;
 }>, Schema.Struct<{
-    status: Schema.Literal<["blocked"]>;
-    resolved_at: Schema.SchemaClass<string, string, never>;
+    readonly status: Schema.Literal<"blocked">;
+    readonly resolved_at: Schema.String;
 }>]>;
 export type ApprovalStatus = typeof ApprovalStatus.Type;
-export {};
 //# sourceMappingURL=types.d.ts.map