@distilled.cloud/coinbase 0.27.0 → 0.28.0

package/src/operations/getDepositDestinationById.ts

@@ -0,0 +1,89 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client.ts";
+import * as T from "../traits.ts";
+
+// Input Schema
+export interface GetDepositDestinationByIdInput {
+  depositDestinationId: string;
+}
+export const GetDepositDestinationByIdInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    depositDestinationId: Schema.String.pipe(T.PathParam()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      path: "/v2/deposit-destinations/{depositDestinationId}",
+    }),
+  ) as unknown as Schema.Codec<GetDepositDestinationByIdInput>;
+
+// Output Schema
+export interface GetDepositDestinationByIdOutput {
+  depositDestinationId: string;
+  accountId: string;
+  type: "crypto";
+  crypto: {
+    network:
+      | "base"
+      | "ethereum"
+      | "solana"
+      | "aptos"
+      | "arbitrum"
+      | "arbitrum-sepolia"
+      | "optimism"
+      | "polygon"
+      | "world"
+      | "world-sepolia";
+    address: string;
+  };
+  target?: { accountId?: string; asset: string };
+  status: "active" | "inactive" | "pending";
+  metadata?: Record<string, string>;
+  createdAt: string;
+  updatedAt: string;
+}
+export const GetDepositDestinationByIdOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    depositDestinationId: Schema.String,
+    accountId: Schema.String,
+    type: Schema.Literals(["crypto"]),
+    crypto: Schema.Struct({
+      network: Schema.Literals([
+        "base",
+        "ethereum",
+        "solana",
+        "aptos",
+        "arbitrum",
+        "arbitrum-sepolia",
+        "optimism",
+        "polygon",
+        "world",
+        "world-sepolia",
+      ]),
+      address: Schema.String,
+    }),
+    target: Schema.optional(
+      Schema.Struct({
+        accountId: Schema.optional(Schema.String),
+        asset: Schema.String,
+      }),
+    ),
+    status: Schema.Literals(["active", "inactive", "pending"]),
+    metadata: Schema.optional(Schema.Record(Schema.String, Schema.String)),
+    createdAt: Schema.String,
+    updatedAt: Schema.String,
+  }) as unknown as Schema.Codec<GetDepositDestinationByIdOutput>;
+
+// The operation
+/**
+ * Get deposit destination
+ *
+ * Get a specific deposit destination by its ID.
+ *
+ * @param depositDestinationId - The ID of the deposit address to retrieve.
+ */
+export const getDepositDestinationById = /*@__PURE__*/ /*#__PURE__*/ API.make(
+  () => ({
+    inputSchema: GetDepositDestinationByIdInput,
+    outputSchema: GetDepositDestinationByIdOutput,
+  }),
+);

package/src/operations/getEndUser.ts

@@ -3,15 +3,96 @@ import { API } from "../client.ts";
 import * as T from "../traits.ts";
 
 // Input Schema
+export interface GetEndUserInput {
+  userId: string;
+}
 export const GetEndUserInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   userId: Schema.String.pipe(T.PathParam()),
-}).pipe(T.Http({ method: "GET", path: "/v2/end-users/{userId}" }));
-export type GetEndUserInput = typeof GetEndUserInput.Type;
+}).pipe(
+  T.Http({ method: "GET", path: "/v2/end-users/{userId}" }),
+) as unknown as Schema.Codec<GetEndUserInput>;
 
 // Output Schema
+export interface GetEndUserOutput {
+  userId: string;
+  authenticationMethods: (
+    | { type: "email"; email: string }
+    | { type: "sms"; phoneNumber: string }
+    | { type: "jwt"; kid: string; sub: string }
+    | {
+        type: "google" | "apple" | "x" | "telegram" | "github";
+        sub: string;
+        email?: string;
+        name?: string;
+        username?: string;
+      }
+    | {
+        type: "google" | "apple" | "x" | "telegram" | "github";
+        id: number;
+        firstName?: string;
+        lastName?: string;
+        photoUrl?: string;
+        authDate: number;
+        username?: string;
+      }
+    | { type: "siwe"; address: string }
+  )[];
+  mfaMethods?: {
+    enrollmentPromptedAt?: string;
+    totp?: { enrolledAt: string };
+    sms?: { enrolledAt: string };
+  };
+  evmAccounts: string[];
+  evmAccountObjects: { address: string; createdAt: string }[];
+  evmSmartAccounts: string[];
+  evmSmartAccountObjects: {
+    address: string;
+    ownerAddresses: string[];
+    createdAt: string;
+  }[];
+  solanaAccounts: string[];
+  solanaAccountObjects: { address: string; createdAt: string }[];
+  createdAt: string;
+}
 export const GetEndUserOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   userId: Schema.String,
-  authenticationMethods: Schema.Array(Schema.Unknown),
+  authenticationMethods: Schema.Array(
+    Schema.Union([
+      Schema.Struct({
+        type: Schema.Literals(["email"]),
+        email: Schema.String,
+      }),
+      Schema.Struct({
+        type: Schema.Literals(["sms"]),
+        phoneNumber: Schema.String,
+      }),
+      Schema.Struct({
+        type: Schema.Literals(["jwt"]),
+        kid: Schema.String,
+        sub: Schema.String,
+      }),
+      Schema.Struct({
+        type: Schema.Literals(["google", "apple", "x", "telegram", "github"]),
+        sub: Schema.String,
+        email: Schema.optional(Schema.String),
+        name: Schema.optional(Schema.String),
+        username: Schema.optional(Schema.String),
+      }),
+      Schema.Struct({
+        type: Schema.Literals(["google", "apple", "x", "telegram", "github"]),
+        id: Schema.Number,
+        firstName: Schema.optional(Schema.String),
+        lastName: Schema.optional(Schema.String),
+        photoUrl: Schema.optional(Schema.String),
+        authDate: Schema.Number,
+        username: Schema.optional(Schema.String),
+      }),
+      Schema.Struct({
+        type: Schema.Literals(["siwe"]),
+        address: Schema.String,
+      }),
+    ]),
+  ),
   mfaMethods: Schema.optional(
     Schema.Struct({
       enrollmentPromptedAt: Schema.optional(Schema.String),
@@ -50,12 +131,11 @@ export const GetEndUserOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     }),
   ),
   createdAt: Schema.String,
-});
-export type GetEndUserOutput = typeof GetEndUserOutput.Type;
+}) as unknown as Schema.Codec<GetEndUserOutput>;
 
 // The operation
 /**
- * Get an end user
+ * Get end user
  *
  * Gets an end user by ID.
  * This API is intended to be used by the developer's own backend, and is authenticated using the developer's CDP API key.

package/src/operations/getEvmAccount.ts

@@ -3,24 +3,34 @@ import { API } from "../client.ts";
 import * as T from "../traits.ts";
 
 // Input Schema
+export interface GetEvmAccountInput {
+  address: string;
+}
 export const GetEvmAccountInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   address: Schema.String.pipe(T.PathParam()),
-}).pipe(T.Http({ method: "GET", path: "/v2/evm/accounts/{address}" }));
-export type GetEvmAccountInput = typeof GetEvmAccountInput.Type;
+}).pipe(
+  T.Http({ method: "GET", path: "/v2/evm/accounts/{address}" }),
+) as unknown as Schema.Codec<GetEvmAccountInput>;
 
 // Output Schema
+export interface GetEvmAccountOutput {
+  address: string;
+  name?: string;
+  policies?: string[];
+  createdAt?: string;
+  updatedAt?: string;
+}
 export const GetEvmAccountOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   address: Schema.String,
   name: Schema.optional(Schema.String),
   policies: Schema.optional(Schema.Array(Schema.String)),
   createdAt: Schema.optional(Schema.String),
   updatedAt: Schema.optional(Schema.String),
-});
-export type GetEvmAccountOutput = typeof GetEvmAccountOutput.Type;
+}) as unknown as Schema.Codec<GetEvmAccountOutput>;
 
 // The operation
 /**
- * Get an EVM account by address
+ * Get EVM account by address
  *
  * Gets an EVM account by its address.
  *

package/src/operations/getEvmAccountByName.ts

@@ -3,13 +3,24 @@ import { API } from "../client.ts";
 import * as T from "../traits.ts";
 
 // Input Schema
+export interface GetEvmAccountByNameInput {
+  name: string;
+}
 export const GetEvmAccountByNameInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     name: Schema.String.pipe(T.PathParam()),
-  }).pipe(T.Http({ method: "GET", path: "/v2/evm/accounts/by-name/{name}" }));
-export type GetEvmAccountByNameInput = typeof GetEvmAccountByNameInput.Type;
+  }).pipe(
+    T.Http({ method: "GET", path: "/v2/evm/accounts/by-name/{name}" }),
+  ) as unknown as Schema.Codec<GetEvmAccountByNameInput>;
 
 // Output Schema
+export interface GetEvmAccountByNameOutput {
+  address: string;
+  name?: string;
+  policies?: string[];
+  createdAt?: string;
+  updatedAt?: string;
+}
 export const GetEvmAccountByNameOutput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     address: Schema.String,
@@ -17,12 +28,11 @@ export const GetEvmAccountByNameOutput =
     policies: Schema.optional(Schema.Array(Schema.String)),
     createdAt: Schema.optional(Schema.String),
     updatedAt: Schema.optional(Schema.String),
-  });
-export type GetEvmAccountByNameOutput = typeof GetEvmAccountByNameOutput.Type;
+  }) as unknown as Schema.Codec<GetEvmAccountByNameOutput>;
 
 // The operation
 /**
- * Get an EVM account by name
+ * Get EVM account by name
  *
  * Gets an EVM account by its name.
  *

package/src/operations/getEvmEip7702DelegationOperationById.ts

@@ -3,6 +3,9 @@ import { API } from "../client.ts";
 import * as T from "../traits.ts";
 
 // Input Schema
+export interface GetEvmEip7702DelegationOperationByIdInput {
+  delegationOperationId: string;
+}
 export const GetEvmEip7702DelegationOperationByIdInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     delegationOperationId: Schema.String.pipe(T.PathParam()),
@@ -11,11 +14,23 @@ export const GetEvmEip7702DelegationOperationByIdInput =
       method: "GET",
       path: "/v2/evm/eip7702/delegation-operations/{delegationOperationId}",
     }),
-  );
-export type GetEvmEip7702DelegationOperationByIdInput =
-  typeof GetEvmEip7702DelegationOperationByIdInput.Type;
+  ) as unknown as Schema.Codec<GetEvmEip7702DelegationOperationByIdInput>;
 
 // Output Schema
+export interface GetEvmEip7702DelegationOperationByIdOutput {
+  delegationOperationId: string;
+  status: "UNSPECIFIED" | "PENDING" | "SUBMITTED" | "COMPLETED" | "FAILED";
+  transactionHash?: string;
+  network:
+    | "base-sepolia"
+    | "base"
+    | "arbitrum"
+    | "optimism"
+    | "polygon"
+    | "ethereum"
+    | "ethereum-sepolia";
+  delegateAddress?: string;
+}
 export const GetEvmEip7702DelegationOperationByIdOutput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     delegationOperationId: Schema.String,
@@ -37,13 +52,11 @@ export const GetEvmEip7702DelegationOperationByIdOutput =
       "ethereum-sepolia",
     ]),
     delegateAddress: Schema.optional(Schema.String),
-  });
-export type GetEvmEip7702DelegationOperationByIdOutput =
-  typeof GetEvmEip7702DelegationOperationByIdOutput.Type;
+  }) as unknown as Schema.Codec<GetEvmEip7702DelegationOperationByIdOutput>;
 
 // The operation
 /**
- * Get EIP-7702 delegation operation for an operationID
+ * Get EIP-7702 delegation operation by ID
  *
  * Returns the EIP-7702 delegation operation. Use the delegationOperationId returned by the Create EIP-7702 delegation endpoint to poll for operation completion.
  *

package/src/operations/getEvmSmartAccount.ts

@@ -3,13 +3,25 @@ import { API } from "../client.ts";
 import * as T from "../traits.ts";
 
 // Input Schema
+export interface GetEvmSmartAccountInput {
+  address: string;
+}
 export const GetEvmSmartAccountInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     address: Schema.String.pipe(T.PathParam()),
-  }).pipe(T.Http({ method: "GET", path: "/v2/evm/smart-accounts/{address}" }));
-export type GetEvmSmartAccountInput = typeof GetEvmSmartAccountInput.Type;
+  }).pipe(
+    T.Http({ method: "GET", path: "/v2/evm/smart-accounts/{address}" }),
+  ) as unknown as Schema.Codec<GetEvmSmartAccountInput>;
 
 // Output Schema
+export interface GetEvmSmartAccountOutput {
+  address: string;
+  owners: string[];
+  name?: string;
+  policies?: string[];
+  createdAt?: string;
+  updatedAt?: string;
+}
 export const GetEvmSmartAccountOutput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     address: Schema.String,
@@ -18,12 +30,11 @@ export const GetEvmSmartAccountOutput =
     policies: Schema.optional(Schema.Array(Schema.String)),
     createdAt: Schema.optional(Schema.String),
     updatedAt: Schema.optional(Schema.String),
-  });
-export type GetEvmSmartAccountOutput = typeof GetEvmSmartAccountOutput.Type;
+  }) as unknown as Schema.Codec<GetEvmSmartAccountOutput>;
 
 // The operation
 /**
- * Get a Smart Account by address
+ * Get Smart Account by address
  *
  * Gets a Smart Account by its address.
  *

package/src/operations/getEvmSmartAccountByName.ts

@@ -3,16 +3,25 @@ import { API } from "../client.ts";
 import * as T from "../traits.ts";
 
 // Input Schema
+export interface GetEvmSmartAccountByNameInput {
+  name: string;
+}
 export const GetEvmSmartAccountByNameInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     name: Schema.String.pipe(T.PathParam()),
   }).pipe(
     T.Http({ method: "GET", path: "/v2/evm/smart-accounts/by-name/{name}" }),
-  );
-export type GetEvmSmartAccountByNameInput =
-  typeof GetEvmSmartAccountByNameInput.Type;
+  ) as unknown as Schema.Codec<GetEvmSmartAccountByNameInput>;
 
 // Output Schema
+export interface GetEvmSmartAccountByNameOutput {
+  address: string;
+  owners: string[];
+  name?: string;
+  policies?: string[];
+  createdAt?: string;
+  updatedAt?: string;
+}
 export const GetEvmSmartAccountByNameOutput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     address: Schema.String,
@@ -21,13 +30,11 @@ export const GetEvmSmartAccountByNameOutput =
     policies: Schema.optional(Schema.Array(Schema.String)),
     createdAt: Schema.optional(Schema.String),
     updatedAt: Schema.optional(Schema.String),
-  });
-export type GetEvmSmartAccountByNameOutput =
-  typeof GetEvmSmartAccountByNameOutput.Type;
+  }) as unknown as Schema.Codec<GetEvmSmartAccountByNameOutput>;
 
 // The operation
 /**
- * Get a Smart Account by name
+ * Get Smart Account by name
  *
  * Gets a Smart Account by its name.
  *

package/src/operations/getEvmSwapPrice.ts

@@ -3,6 +3,16 @@ import { API } from "../client.ts";
 import * as T from "../traits.ts";
 
 // Input Schema
+export interface GetEvmSwapPriceInput {
+  network: string;
+  toToken: string;
+  fromToken: string;
+  fromAmount: string;
+  taker: string;
+  signerAddress?: string;
+  gasPrice?: string;
+  slippageBps?: string;
+}
 export const GetEvmSwapPriceInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   network: Schema.String,
   toToken: Schema.String,
@@ -12,16 +22,87 @@ export const GetEvmSwapPriceInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   signerAddress: Schema.optional(Schema.String),
   gasPrice: Schema.optional(Schema.String),
   slippageBps: Schema.optional(Schema.String),
-}).pipe(T.Http({ method: "GET", path: "/v2/evm/swaps/quote" }));
-export type GetEvmSwapPriceInput = typeof GetEvmSwapPriceInput.Type;
+}).pipe(
+  T.Http({ method: "GET", path: "/v2/evm/swaps/quote" }),
+) as unknown as Schema.Codec<GetEvmSwapPriceInput>;
 
 // Output Schema
-export const GetEvmSwapPriceOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Unknown;
-export type GetEvmSwapPriceOutput = typeof GetEvmSwapPriceOutput.Type;
+export type GetEvmSwapPriceOutput =
+  | {
+      blockNumber: string;
+      toAmount: string;
+      toToken: string;
+      fees: {
+        gasFee: { amount: string; token: string } | null;
+        protocolFee: { amount: string; token: string } | null;
+      };
+      issues: {
+        allowance: { currentAllowance: string; spender: string } | null;
+        balance: {
+          token: string;
+          currentBalance: string;
+          requiredBalance: string;
+        } | null;
+        simulationIncomplete: boolean;
+      };
+      liquidityAvailable: true;
+      minToAmount: string;
+      fromAmount: string;
+      fromToken: string;
+      gas: string | null;
+      gasPrice: string;
+    }
+  | { liquidityAvailable: false };
+export const GetEvmSwapPriceOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Union([
+  Schema.Struct({
+    blockNumber: Schema.String,
+    toAmount: Schema.String,
+    toToken: Schema.String,
+    fees: Schema.Struct({
+      gasFee: Schema.NullOr(
+        Schema.Struct({
+          amount: Schema.String,
+          token: Schema.String,
+        }),
+      ),
+      protocolFee: Schema.NullOr(
+        Schema.Struct({
+          amount: Schema.String,
+          token: Schema.String,
+        }),
+      ),
+    }),
+    issues: Schema.Struct({
+      allowance: Schema.NullOr(
+        Schema.Struct({
+          currentAllowance: Schema.String,
+          spender: Schema.String,
+        }),
+      ),
+      balance: Schema.NullOr(
+        Schema.Struct({
+          token: Schema.String,
+          currentBalance: Schema.String,
+          requiredBalance: Schema.String,
+        }),
+      ),
+      simulationIncomplete: Schema.Boolean,
+    }),
+    liquidityAvailable: Schema.Literals([true]),
+    minToAmount: Schema.String,
+    fromAmount: Schema.String,
+    fromToken: Schema.String,
+    gas: Schema.NullOr(Schema.String),
+    gasPrice: Schema.String,
+  }),
+  Schema.Struct({
+    liquidityAvailable: Schema.Literals([false]),
+  }),
+]) as unknown as Schema.Codec<GetEvmSwapPriceOutput>;
 
 // The operation
 /**
- * Get a price estimate for a swap
+ * Get swap price estimate
  *
  * Get a price estimate for a swap between two tokens on an EVM network.
  */

package/src/operations/getFoundationAccountById.ts

@@ -0,0 +1,48 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client.ts";
+import * as T from "../traits.ts";
+
+// Input Schema
+export interface GetFoundationAccountByIdInput {
+  accountId: string;
+}
+export const GetFoundationAccountByIdInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    accountId: Schema.String.pipe(T.PathParam()),
+  }).pipe(
+    T.Http({ method: "GET", path: "/v2/accounts/{accountId}" }),
+  ) as unknown as Schema.Codec<GetFoundationAccountByIdInput>;
+
+// Output Schema
+export interface GetFoundationAccountByIdOutput {
+  accountId: string;
+  type: "prime" | "business" | "cdp";
+  owner: string;
+  name?: string;
+  createdAt: string;
+  updatedAt: string;
+}
+export const GetFoundationAccountByIdOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    accountId: Schema.String,
+    type: Schema.Literals(["prime", "business", "cdp"]),
+    owner: Schema.String,
+    name: Schema.optional(Schema.String),
+    createdAt: Schema.String,
+    updatedAt: Schema.String,
+  }) as unknown as Schema.Codec<GetFoundationAccountByIdOutput>;
+
+// The operation
+/**
+ * Get account
+ *
+ * Get an account by its ID.
+ *
+ * @param accountId - The ID of the account to retrieve.
+ */
+export const getFoundationAccountById = /*@__PURE__*/ /*#__PURE__*/ API.make(
+  () => ({
+    inputSchema: GetFoundationAccountByIdInput,
+    outputSchema: GetFoundationAccountByIdOutput,
+  }),
+);

package/src/operations/getOnrampOrderById.ts

@@ -3,13 +3,46 @@ import { API } from "../client.ts";
 import * as T from "../traits.ts";
 
 // Input Schema
+export interface GetOnrampOrderByIdInput {
+  orderId: string;
+}
 export const GetOnrampOrderByIdInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     orderId: Schema.String.pipe(T.PathParam()),
-  }).pipe(T.Http({ method: "GET", path: "/v2/onramp/orders/{orderId}" }));
-export type GetOnrampOrderByIdInput = typeof GetOnrampOrderByIdInput.Type;
+  }).pipe(
+    T.Http({ method: "GET", path: "/v2/onramp/orders/{orderId}" }),
+  ) as unknown as Schema.Codec<GetOnrampOrderByIdInput>;
 
 // Output Schema
+export interface GetOnrampOrderByIdOutput {
+  order: {
+    orderId: string;
+    paymentTotal: string;
+    paymentSubtotal: string;
+    paymentCurrency: string;
+    paymentMethod: "GUEST_CHECKOUT_APPLE_PAY" | "GUEST_CHECKOUT_GOOGLE_PAY";
+    purchaseAmount: string;
+    purchaseCurrency: string;
+    fees: {
+      type: "FEE_TYPE_NETWORK" | "FEE_TYPE_EXCHANGE";
+      amount: string;
+      currency: string;
+    }[];
+    exchangeRate: string;
+    destinationAddress: string;
+    destinationNetwork: string;
+    status:
+      | "ONRAMP_ORDER_STATUS_PENDING_AUTH"
+      | "ONRAMP_ORDER_STATUS_PENDING_PAYMENT"
+      | "ONRAMP_ORDER_STATUS_PROCESSING"
+      | "ONRAMP_ORDER_STATUS_COMPLETED"
+      | "ONRAMP_ORDER_STATUS_FAILED";
+    txHash?: string;
+    createdAt: string;
+    updatedAt: string;
+    partnerUserRef?: string;
+  };
+}
 export const GetOnrampOrderByIdOutput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     order: Schema.Struct({
@@ -45,8 +78,7 @@ export const GetOnrampOrderByIdOutput =
       updatedAt: Schema.String,
       partnerUserRef: Schema.optional(Schema.String),
     }),
-  });
-export type GetOnrampOrderByIdOutput = typeof GetOnrampOrderByIdOutput.Type;
+  }) as unknown as Schema.Codec<GetOnrampOrderByIdOutput>;
 
 // The operation
 /**

package/src/operations/getOnrampUserLimits.ts

@@ -3,6 +3,11 @@ import { API } from "../client.ts";
 import * as T from "../traits.ts";
 
 // Input Schema
+export interface GetOnrampUserLimitsInput {
+  paymentMethodType: "GUEST_CHECKOUT_APPLE_PAY" | "GUEST_CHECKOUT_GOOGLE_PAY";
+  userId: string;
+  userIdType: "phone_number";
+}
 export const GetOnrampUserLimitsInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     paymentMethodType: Schema.Literals([
@@ -11,10 +16,19 @@ export const GetOnrampUserLimitsInput =
     ]),
     userId: Schema.String,
     userIdType: Schema.Literals(["phone_number"]),
-  }).pipe(T.Http({ method: "POST", path: "/v2/onramp/limits" }));
-export type GetOnrampUserLimitsInput = typeof GetOnrampUserLimitsInput.Type;
+  }).pipe(
+    T.Http({ method: "POST", path: "/v2/onramp/limits" }),
+  ) as unknown as Schema.Codec<GetOnrampUserLimitsInput>;
 
 // Output Schema
+export interface GetOnrampUserLimitsOutput {
+  limits: {
+    limitType: "weekly_spending" | "lifetime_transactions";
+    currency?: string;
+    limit: string;
+    remaining: string;
+  }[];
+}
 export const GetOnrampUserLimitsOutput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     limits: Schema.Array(
@@ -28,8 +42,7 @@ export const GetOnrampUserLimitsOutput =
         remaining: Schema.String,
       }),
     ),
-  });
-export type GetOnrampUserLimitsOutput = typeof GetOnrampUserLimitsOutput.Type;
+  }) as unknown as Schema.Codec<GetOnrampUserLimitsOutput>;
 
 // The operation
 /**