@distilled.cloud/coinbase 0.27.0 → 0.28.1

package/src/operations/signEvmHash.ts

@@ -3,21 +3,28 @@ import { API } from "../client.ts";
 import * as T from "../traits.ts";
 
 // Input Schema
+export interface SignEvmHashInput {
+  address: string;
+  hash: string;
+}
 export const SignEvmHashInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   address: Schema.String.pipe(T.PathParam()),
   hash: Schema.String,
-}).pipe(T.Http({ method: "POST", path: "/v2/evm/accounts/{address}/sign" }));
-export type SignEvmHashInput = typeof SignEvmHashInput.Type;
+}).pipe(
+  T.Http({ method: "POST", path: "/v2/evm/accounts/{address}/sign" }),
+) as unknown as Schema.Codec<SignEvmHashInput>;
 
 // Output Schema
+export interface SignEvmHashOutput {
+  signature: string;
+}
 export const SignEvmHashOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   signature: Schema.String,
-});
-export type SignEvmHashOutput = typeof SignEvmHashOutput.Type;
+}) as unknown as Schema.Codec<SignEvmHashOutput>;
 
 // The operation
 /**
- * Sign a hash
+ * Sign hash
  *
  * Signs an arbitrary 32 byte hash with the given EVM account.
  *

package/src/operations/signEvmMessage.ts

@@ -3,23 +3,28 @@ import { API } from "../client.ts";
 import * as T from "../traits.ts";
 
 // Input Schema
+export interface SignEvmMessageInput {
+  address: string;
+  message: string;
+}
 export const SignEvmMessageInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   address: Schema.String.pipe(T.PathParam()),
   message: Schema.String,
 }).pipe(
   T.Http({ method: "POST", path: "/v2/evm/accounts/{address}/sign/message" }),
-);
-export type SignEvmMessageInput = typeof SignEvmMessageInput.Type;
+) as unknown as Schema.Codec<SignEvmMessageInput>;
 
 // Output Schema
+export interface SignEvmMessageOutput {
+  signature: string;
+}
 export const SignEvmMessageOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   signature: Schema.String,
-});
-export type SignEvmMessageOutput = typeof SignEvmMessageOutput.Type;
+}) as unknown as Schema.Codec<SignEvmMessageOutput>;
 
 // The operation
 /**
- * Sign an EIP-191 message
+ * Sign EIP-191 message
  *
  * Signs an [EIP-191](https://eips.ethereum.org/EIPS/eip-191) message with the given EVM account.
  * Per the specification, the message in the request body is prepended with `0x19 <0x45 (E)> <thereum Signed Message:\\n" + len(message)>` before being signed.

package/src/operations/signEvmMessageWithEndUserAccount.ts

@@ -3,6 +3,13 @@ import { API } from "../client.ts";
 import * as T from "../traits.ts";
 
 // Input Schema
+export interface SignEvmMessageWithEndUserAccountInput {
+  userId: string;
+  projectID?: string;
+  address: string;
+  message: string;
+  walletSecretId?: string;
+}
 export const SignEvmMessageWithEndUserAccountInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     userId: Schema.String.pipe(T.PathParam()),
@@ -15,21 +22,20 @@ export const SignEvmMessageWithEndUserAccountInput =
       method: "POST",
       path: "/v2/embedded-wallet-api/end-users/{userId}/evm/sign/message",
     }),
-  );
-export type SignEvmMessageWithEndUserAccountInput =
-  typeof SignEvmMessageWithEndUserAccountInput.Type;
+  ) as unknown as Schema.Codec<SignEvmMessageWithEndUserAccountInput>;
 
 // Output Schema
+export interface SignEvmMessageWithEndUserAccountOutput {
+  signature: string;
+}
 export const SignEvmMessageWithEndUserAccountOutput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     signature: Schema.String,
-  });
-export type SignEvmMessageWithEndUserAccountOutput =
-  typeof SignEvmMessageWithEndUserAccountOutput.Type;
+  }) as unknown as Schema.Codec<SignEvmMessageWithEndUserAccountOutput>;
 
 // The operation
 /**
- * Sign an EIP-191 message with end user EVM account
+ * Sign EIP-191 message via end user EVM account
  *
  * Signs an [EIP-191](https://eips.ethereum.org/EIPS/eip-191) message with the given end user EVM account.
  * Per the specification, the message in the request body is prepended with `0x19 <0x45 (E)> <thereum Signed Message:\\n" + len(message)>` before being signed.

package/src/operations/signEvmTransaction.ts

@@ -3,6 +3,10 @@ import { API } from "../client.ts";
 import * as T from "../traits.ts";
 
 // Input Schema
+export interface SignEvmTransactionInput {
+  address: string;
+  transaction: string;
+}
 export const SignEvmTransactionInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     address: Schema.String.pipe(T.PathParam()),
@@ -12,19 +16,20 @@ export const SignEvmTransactionInput =
       method: "POST",
       path: "/v2/evm/accounts/{address}/sign/transaction",
     }),
-  );
-export type SignEvmTransactionInput = typeof SignEvmTransactionInput.Type;
+  ) as unknown as Schema.Codec<SignEvmTransactionInput>;
 
 // Output Schema
+export interface SignEvmTransactionOutput {
+  signedTransaction: string;
+}
 export const SignEvmTransactionOutput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     signedTransaction: Schema.String,
-  });
-export type SignEvmTransactionOutput = typeof SignEvmTransactionOutput.Type;
+  }) as unknown as Schema.Codec<SignEvmTransactionOutput>;
 
 // The operation
 /**
- * Sign a transaction
+ * Sign transaction
  *
  * Signs a transaction with the given EVM account.
  * The transaction should be serialized as a hex string using [RLP](https://ethereum.org/en/developers/docs/data-structures-and-encoding/rlp/).

package/src/operations/signEvmTransactionWithEndUserAccount.ts

@@ -3,6 +3,13 @@ import { API } from "../client.ts";
 import * as T from "../traits.ts";
 
 // Input Schema
+export interface SignEvmTransactionWithEndUserAccountInput {
+  userId: string;
+  projectID?: string;
+  address: string;
+  transaction: string;
+  walletSecretId?: string;
+}
 export const SignEvmTransactionWithEndUserAccountInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     userId: Schema.String.pipe(T.PathParam()),
@@ -15,21 +22,20 @@ export const SignEvmTransactionWithEndUserAccountInput =
       method: "POST",
       path: "/v2/embedded-wallet-api/end-users/{userId}/evm/sign/transaction",
     }),
-  );
-export type SignEvmTransactionWithEndUserAccountInput =
-  typeof SignEvmTransactionWithEndUserAccountInput.Type;
+  ) as unknown as Schema.Codec<SignEvmTransactionWithEndUserAccountInput>;
 
 // Output Schema
+export interface SignEvmTransactionWithEndUserAccountOutput {
+  signedTransaction: string;
+}
 export const SignEvmTransactionWithEndUserAccountOutput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     signedTransaction: Schema.String,
-  });
-export type SignEvmTransactionWithEndUserAccountOutput =
-  typeof SignEvmTransactionWithEndUserAccountOutput.Type;
+  }) as unknown as Schema.Codec<SignEvmTransactionWithEndUserAccountOutput>;
 
 // The operation
 /**
- * Sign a transaction with end user EVM account
+ * Sign transaction via end user EVM account
  *
  * Signs a transaction with the given end user EVM account.
  * The transaction should be serialized as a hex string using [RLP](https://ethereum.org/en/developers/docs/data-structures-and-encoding/rlp/).

package/src/operations/signEvmTypedData.ts

@@ -3,6 +3,19 @@ import { API } from "../client.ts";
 import * as T from "../traits.ts";
 
 // Input Schema
+export interface SignEvmTypedDataInput {
+  address: string;
+  domain: {
+    name?: string;
+    version?: string;
+    chainId?: number;
+    verifyingContract?: string;
+    salt?: string;
+  };
+  types: unknown;
+  primaryType: string;
+  message: unknown;
+}
 export const SignEvmTypedDataInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   address: Schema.String.pipe(T.PathParam()),
   domain: Schema.Struct({
@@ -20,16 +33,17 @@ export const SignEvmTypedDataInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     method: "POST",
     path: "/v2/evm/accounts/{address}/sign/typed-data",
   }),
-);
-export type SignEvmTypedDataInput = typeof SignEvmTypedDataInput.Type;
+) as unknown as Schema.Codec<SignEvmTypedDataInput>;
 
 // Output Schema
+export interface SignEvmTypedDataOutput {
+  signature: string;
+}
 export const SignEvmTypedDataOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
   {
     signature: Schema.String,
   },
-);
-export type SignEvmTypedDataOutput = typeof SignEvmTypedDataOutput.Type;
+) as unknown as Schema.Codec<SignEvmTypedDataOutput>;
 
 // The operation
 /**

package/src/operations/signEvmTypedDataWithEndUserAccount.ts

@@ -3,6 +3,24 @@ import { API } from "../client.ts";
 import * as T from "../traits.ts";
 
 // Input Schema
+export interface SignEvmTypedDataWithEndUserAccountInput {
+  userId: string;
+  projectID?: string;
+  address: string;
+  typedData: {
+    domain: {
+      name?: string;
+      version?: string;
+      chainId?: number;
+      verifyingContract?: string;
+      salt?: string;
+    };
+    types: unknown;
+    primaryType: string;
+    message: unknown;
+  };
+  walletSecretId?: string;
+}
 export const SignEvmTypedDataWithEndUserAccountInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     userId: Schema.String.pipe(T.PathParam()),
@@ -26,21 +44,20 @@ export const SignEvmTypedDataWithEndUserAccountInput =
       method: "POST",
       path: "/v2/embedded-wallet-api/end-users/{userId}/evm/sign/typed-data",
     }),
-  );
-export type SignEvmTypedDataWithEndUserAccountInput =
-  typeof SignEvmTypedDataWithEndUserAccountInput.Type;
+  ) as unknown as Schema.Codec<SignEvmTypedDataWithEndUserAccountInput>;
 
 // Output Schema
+export interface SignEvmTypedDataWithEndUserAccountOutput {
+  signature: string;
+}
 export const SignEvmTypedDataWithEndUserAccountOutput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     signature: Schema.String,
-  });
-export type SignEvmTypedDataWithEndUserAccountOutput =
-  typeof SignEvmTypedDataWithEndUserAccountOutput.Type;
+  }) as unknown as Schema.Codec<SignEvmTypedDataWithEndUserAccountOutput>;
 
 // The operation
 /**
- * Sign EIP-712 typed data with end user EVM account
+ * Sign EIP-712 typed data via end user EVM account
  *
  * Signs [EIP-712](https://eips.ethereum.org/EIPS/eip-712) typed data with the given end user EVM account.
  *

package/src/operations/signSolanaMessage.ts

@@ -3,6 +3,10 @@ import { API } from "../client.ts";
 import * as T from "../traits.ts";
 
 // Input Schema
+export interface SignSolanaMessageInput {
+  address: string;
+  message: string;
+}
 export const SignSolanaMessageInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
   {
     address: Schema.String.pipe(T.PathParam()),
@@ -13,19 +17,20 @@ export const SignSolanaMessageInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
     method: "POST",
     path: "/v2/solana/accounts/{address}/sign/message",
   }),
-);
-export type SignSolanaMessageInput = typeof SignSolanaMessageInput.Type;
+) as unknown as Schema.Codec<SignSolanaMessageInput>;
 
 // Output Schema
+export interface SignSolanaMessageOutput {
+  signature: string;
+}
 export const SignSolanaMessageOutput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     signature: Schema.String,
-  });
-export type SignSolanaMessageOutput = typeof SignSolanaMessageOutput.Type;
+  }) as unknown as Schema.Codec<SignSolanaMessageOutput>;
 
 // The operation
 /**
- * Sign a message
+ * Sign message
  *
  * Signs an arbitrary message with the given Solana account.
  * **WARNING:** Never sign a message that you didn't generate, as it can be an arbitrary transaction. For example, it might send all of your funds to an attacker.

package/src/operations/signSolanaMessageWithEndUserAccount.ts

@@ -3,6 +3,13 @@ import { API } from "../client.ts";
 import * as T from "../traits.ts";
 
 // Input Schema
+export interface SignSolanaMessageWithEndUserAccountInput {
+  userId: string;
+  projectID?: string;
+  address: string;
+  message: string;
+  walletSecretId?: string;
+}
 export const SignSolanaMessageWithEndUserAccountInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     userId: Schema.String.pipe(T.PathParam()),
@@ -15,21 +22,20 @@ export const SignSolanaMessageWithEndUserAccountInput =
       method: "POST",
       path: "/v2/embedded-wallet-api/end-users/{userId}/solana/sign/message",
     }),
-  );
-export type SignSolanaMessageWithEndUserAccountInput =
-  typeof SignSolanaMessageWithEndUserAccountInput.Type;
+  ) as unknown as Schema.Codec<SignSolanaMessageWithEndUserAccountInput>;
 
 // Output Schema
+export interface SignSolanaMessageWithEndUserAccountOutput {
+  signature: string;
+}
 export const SignSolanaMessageWithEndUserAccountOutput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     signature: Schema.String,
-  });
-export type SignSolanaMessageWithEndUserAccountOutput =
-  typeof SignSolanaMessageWithEndUserAccountOutput.Type;
+  }) as unknown as Schema.Codec<SignSolanaMessageWithEndUserAccountOutput>;
 
 // The operation
 /**
- * Sign a Base64 encoded message
+ * Sign Base64-encoded message
  *
  * Signs an arbitrary Base64 encoded message with the given Solana account.
  * **WARNING:**  Never sign a message that you didn't generate as it may put your funds at risk.

package/src/operations/signSolanaTransaction.ts

@@ -3,6 +3,10 @@ import { API } from "../client.ts";
 import * as T from "../traits.ts";
 
 // Input Schema
+export interface SignSolanaTransactionInput {
+  address: string;
+  transaction: string;
+}
 export const SignSolanaTransactionInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     address: Schema.String.pipe(T.PathParam()),
@@ -12,20 +16,20 @@ export const SignSolanaTransactionInput =
       method: "POST",
       path: "/v2/solana/accounts/{address}/sign/transaction",
     }),
-  );
-export type SignSolanaTransactionInput = typeof SignSolanaTransactionInput.Type;
+  ) as unknown as Schema.Codec<SignSolanaTransactionInput>;
 
 // Output Schema
+export interface SignSolanaTransactionOutput {
+  signedTransaction: string;
+}
 export const SignSolanaTransactionOutput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     signedTransaction: Schema.String,
-  });
-export type SignSolanaTransactionOutput =
-  typeof SignSolanaTransactionOutput.Type;
+  }) as unknown as Schema.Codec<SignSolanaTransactionOutput>;
 
 // The operation
 /**
- * Sign a transaction
+ * Sign transaction
  *
  * Signs a transaction with the given Solana account.
  * The unsigned transaction should be serialized into a byte array and then encoded as base64.

package/src/operations/signSolanaTransactionWithEndUserAccount.ts

@@ -3,6 +3,13 @@ import { API } from "../client.ts";
 import * as T from "../traits.ts";
 
 // Input Schema
+export interface SignSolanaTransactionWithEndUserAccountInput {
+  userId: string;
+  projectID?: string;
+  address: string;
+  transaction: string;
+  walletSecretId?: string;
+}
 export const SignSolanaTransactionWithEndUserAccountInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     userId: Schema.String.pipe(T.PathParam()),
@@ -15,21 +22,20 @@ export const SignSolanaTransactionWithEndUserAccountInput =
       method: "POST",
       path: "/v2/embedded-wallet-api/end-users/{userId}/solana/sign/transaction",
     }),
-  );
-export type SignSolanaTransactionWithEndUserAccountInput =
-  typeof SignSolanaTransactionWithEndUserAccountInput.Type;
+  ) as unknown as Schema.Codec<SignSolanaTransactionWithEndUserAccountInput>;
 
 // Output Schema
+export interface SignSolanaTransactionWithEndUserAccountOutput {
+  signedTransaction: string;
+}
 export const SignSolanaTransactionWithEndUserAccountOutput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     signedTransaction: Schema.String,
-  });
-export type SignSolanaTransactionWithEndUserAccountOutput =
-  typeof SignSolanaTransactionWithEndUserAccountOutput.Type;
+  }) as unknown as Schema.Codec<SignSolanaTransactionWithEndUserAccountOutput>;
 
 // The operation
 /**
- * Sign a transaction with end user Solana account
+ * Sign transaction via end user Solana account
  *
  * Signs a transaction with the given end user Solana account.
  * The unsigned transaction should be serialized into a byte array and then encoded as base64.

package/src/operations/submitDepositTravelRule.ts

@@ -0,0 +1,103 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client.ts";
+import * as T from "../traits.ts";
+
+// Input Schema
+export interface SubmitDepositTravelRuleInput {
+  transferId: string;
+  originator?: {
+    name?: string;
+    address?: {
+      line1?: string;
+      line2?: string;
+      city?: string;
+      state?: string;
+      postCode?: string;
+      countryCode?: string;
+    };
+    walletType?: "custodial" | "self_custody";
+    virtualAssetServiceProvider?: { identifier?: string; name?: string };
+    personalId?: string;
+    dateOfBirth?: { day?: string; month?: string; year?: string };
+  };
+  beneficiary?: { name?: string };
+  isSelf?: boolean;
+}
+export const SubmitDepositTravelRuleInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    transferId: Schema.String.pipe(T.PathParam()),
+    originator: Schema.optional(
+      Schema.Struct({
+        name: Schema.optional(Schema.String),
+        address: Schema.optional(
+          Schema.Struct({
+            line1: Schema.optional(Schema.String),
+            line2: Schema.optional(Schema.String),
+            city: Schema.optional(Schema.String),
+            state: Schema.optional(Schema.String),
+            postCode: Schema.optional(Schema.String),
+            countryCode: Schema.optional(Schema.String),
+          }),
+        ),
+        walletType: Schema.optional(
+          Schema.Literals(["custodial", "self_custody"]),
+        ),
+        virtualAssetServiceProvider: Schema.optional(
+          Schema.Struct({
+            identifier: Schema.optional(Schema.String),
+            name: Schema.optional(Schema.String),
+          }),
+        ),
+        personalId: Schema.optional(Schema.String),
+        dateOfBirth: Schema.optional(
+          Schema.Struct({
+            day: Schema.optional(Schema.String),
+            month: Schema.optional(Schema.String),
+            year: Schema.optional(Schema.String),
+          }),
+        ),
+      }),
+    ),
+    beneficiary: Schema.optional(
+      Schema.Struct({
+        name: Schema.optional(Schema.String),
+      }),
+    ),
+    isSelf: Schema.optional(Schema.Boolean),
+  }).pipe(
+    T.Http({ method: "POST", path: "/v2/transfers/{transferId}/travel-rule" }),
+  ) as unknown as Schema.Codec<SubmitDepositTravelRuleInput>;
+
+// Output Schema
+export interface SubmitDepositTravelRuleOutput {
+  status: "incomplete" | "completed";
+  missingFields?: string[];
+  reason?: string;
+}
+export const SubmitDepositTravelRuleOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    status: Schema.Literals(["incomplete", "completed"]),
+    missingFields: Schema.optional(Schema.Array(Schema.String)),
+    reason: Schema.optional(Schema.String),
+  }) as unknown as Schema.Codec<SubmitDepositTravelRuleOutput>;
+
+// The operation
+/**
+ * Submit deposit travel rule information
+ *
+ * Submit travel rule information for a deposit transfer held pending compliance review.
+ * Required fields vary by jurisdiction and may include originator name, address, date of birth, personal ID, and VASP information.
+ * If the submitted information satisfies all jurisdictional requirements, `status` will be `completed` and the transfer will proceed. Otherwise, `status` will be `incomplete` and `missingFields` will indicate which fields still need to be provided.
+ *
+ * @param transferId - The unique identifier of the transfer.
+ * @param X-Idempotency-Key - An optional string request header for making requests safely retryable.
+When included, duplicate requests with the same key will return identical responses.
+Refer to our [Idempotency docs](https://docs.cdp.coinbase.com/api-reference/v2/idempotency) for more information on using idempotency keys.
+
+ */
+export const submitDepositTravelRule = /*@__PURE__*/ /*#__PURE__*/ API.make(
+  () => ({
+    inputSchema: SubmitDepositTravelRuleInput,
+    outputSchema: SubmitDepositTravelRuleOutput,
+  }),
+);

package/src/operations/submitOnrampVerification.ts

@@ -0,0 +1,51 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client.ts";
+import * as T from "../traits.ts";
+
+// Input Schema
+export interface SubmitOnrampVerificationInput {
+  verificationId: string;
+  otpCode: string;
+}
+export const SubmitOnrampVerificationInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    verificationId: Schema.String.pipe(T.PathParam()),
+    otpCode: Schema.String,
+  }).pipe(
+    T.Http({
+      method: "POST",
+      path: "/v2/onramp/verifications/{verificationId}/submit",
+    }),
+  ) as unknown as Schema.Codec<SubmitOnrampVerificationInput>;
+
+// Output Schema
+export interface SubmitOnrampVerificationOutput {
+  verificationId: string;
+  verificationExpiresAt: string;
+}
+export const SubmitOnrampVerificationOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    verificationId: Schema.String,
+    verificationExpiresAt: Schema.String,
+  }) as unknown as Schema.Codec<SubmitOnrampVerificationOutput>;
+
+// The operation
+/**
+ * Submit onramp verification
+ *
+ * Submits the OTP code to complete verification. On success, marks the verification as verified and returns the same `verificationId`. The destination does not need to be re-sent. Onramp uses the value captured at initiation time.
+ * The returned `verificationId` should be stored on the user's device and passed to the Create Onramp Order endpoint. It is valid for 60 days.
+ * **Access to this API requires allowlisting.** During Onramp Headless API onboarding, contact the Onramp team to enable Onramp-managed verification for your application.
+ *
+ * @param verificationId - The verification ID returned by the Initiate Onramp Verification endpoint.
+ * @param X-Idempotency-Key - An optional string request header for making requests safely retryable.
+When included, duplicate requests with the same key will return identical responses.
+Refer to our [Idempotency docs](https://docs.cdp.coinbase.com/api-reference/v2/idempotency) for more information on using idempotency keys.
+
+ */
+export const submitOnrampVerification = /*@__PURE__*/ /*#__PURE__*/ API.make(
+  () => ({
+    inputSchema: SubmitOnrampVerificationInput,
+    outputSchema: SubmitOnrampVerificationOutput,
+  }),
+);

package/src/operations/supportedX402PaymentKinds.ts

@@ -3,29 +3,52 @@ import { API } from "../client.ts";
 import * as T from "../traits.ts";
 
 // Input Schema
+export interface SupportedX402PaymentKindsInput {}
 export const SupportedX402PaymentKindsInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({}).pipe(
     T.Http({ method: "GET", path: "/v2/x402/supported" }),
-  );
-export type SupportedX402PaymentKindsInput =
-  typeof SupportedX402PaymentKindsInput.Type;
+  ) as unknown as Schema.Codec<SupportedX402PaymentKindsInput>;
 
 // Output Schema
+export interface SupportedX402PaymentKindsOutput {
+  kinds: {
+    x402Version: 1 | 2;
+    scheme: "exact" | "upto" | "batch-settlement";
+    network:
+      | "base-sepolia"
+      | "base"
+      | "solana-devnet"
+      | "solana"
+      | "eip155:8453"
+      | "eip155:84532"
+      | "eip155:137"
+      | "eip155:42161"
+      | "eip155:480"
+      | "eip155:4801"
+      | "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp"
+      | "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1";
+    extra?: Record<string, unknown>;
+  }[];
+  extensions: string[];
+  signers: Record<string, string[]>;
+}
 export const SupportedX402PaymentKindsOutput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     kinds: Schema.Array(
       Schema.Struct({
         x402Version: Schema.Literals([1, 2]),
-        scheme: Schema.Literals(["exact", "upto"]),
+        scheme: Schema.Literals(["exact", "upto", "batch-settlement"]),
         network: Schema.Literals([
           "base-sepolia",
           "base",
           "solana-devnet",
           "solana",
-          "polygon",
           "eip155:8453",
           "eip155:84532",
           "eip155:137",
+          "eip155:42161",
+          "eip155:480",
+          "eip155:4801",
           "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp",
           "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1",
         ]),
@@ -34,9 +57,7 @@ export const SupportedX402PaymentKindsOutput =
     ),
     extensions: Schema.Array(Schema.String),
     signers: Schema.Record(Schema.String, Schema.Array(Schema.String)),
-  });
-export type SupportedX402PaymentKindsOutput =
-  typeof SupportedX402PaymentKindsOutput.Type;
+  }) as unknown as Schema.Codec<SupportedX402PaymentKindsOutput>;
 
 // The operation
 /**