@distilled.cloud/coinbase 0.27.0 → 0.28.0

package/src/operations/addEndUserEvmAccount.ts

@@ -3,25 +3,31 @@ import { API } from "../client.ts";
 import * as T from "../traits.ts";
 
 // Input Schema
+export interface AddEndUserEvmAccountInput {
+  userId: string;
+}
 export const AddEndUserEvmAccountInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     userId: Schema.String.pipe(T.PathParam()),
-  }).pipe(T.Http({ method: "POST", path: "/v2/end-users/{userId}/evm" }));
-export type AddEndUserEvmAccountInput = typeof AddEndUserEvmAccountInput.Type;
+  }).pipe(
+    T.Http({ method: "POST", path: "/v2/end-users/{userId}/evm" }),
+  ) as unknown as Schema.Codec<AddEndUserEvmAccountInput>;
 
 // Output Schema
+export interface AddEndUserEvmAccountOutput {
+  evmAccount: { address: string; createdAt: string };
+}
 export const AddEndUserEvmAccountOutput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     evmAccount: Schema.Struct({
       address: Schema.String,
       createdAt: Schema.String,
     }),
-  });
-export type AddEndUserEvmAccountOutput = typeof AddEndUserEvmAccountOutput.Type;
+  }) as unknown as Schema.Codec<AddEndUserEvmAccountOutput>;
 
 // The operation
 /**
- * Add an EVM account to an end user
+ * Add EVM account to end user
  *
  * Adds a new EVM EOA account to an existing end user. End users can have up to 10 EVM accounts.
  * 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/addEndUserEvmSmartAccount.ts

@@ -3,6 +3,10 @@ import { API } from "../client.ts";
 import * as T from "../traits.ts";
 
 // Input Schema
+export interface AddEndUserEvmSmartAccountInput {
+  userId: string;
+  enableSpendPermissions?: boolean;
+}
 export const AddEndUserEvmSmartAccountInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     userId: Schema.String.pipe(T.PathParam()),
@@ -12,11 +16,16 @@ export const AddEndUserEvmSmartAccountInput =
       method: "POST",
       path: "/v2/end-users/{userId}/evm-smart-account",
     }),
-  );
-export type AddEndUserEvmSmartAccountInput =
-  typeof AddEndUserEvmSmartAccountInput.Type;
+  ) as unknown as Schema.Codec<AddEndUserEvmSmartAccountInput>;
 
 // Output Schema
+export interface AddEndUserEvmSmartAccountOutput {
+  evmSmartAccount: {
+    address: string;
+    ownerAddresses: string[];
+    createdAt: string;
+  };
+}
 export const AddEndUserEvmSmartAccountOutput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     evmSmartAccount: Schema.Struct({
@@ -24,13 +33,11 @@ export const AddEndUserEvmSmartAccountOutput =
       ownerAddresses: Schema.Array(Schema.String),
       createdAt: Schema.String,
     }),
-  });
-export type AddEndUserEvmSmartAccountOutput =
-  typeof AddEndUserEvmSmartAccountOutput.Type;
+  }) as unknown as Schema.Codec<AddEndUserEvmSmartAccountOutput>;
 
 // The operation
 /**
- * Add an EVM smart account to an end user
+ * Add EVM smart account to end user
  *
  * Creates an EVM smart account for an existing end user. The backend will create a new EVM EOA account to serve as the owner of the smart account.
  * 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/addEndUserSolanaAccount.ts

@@ -3,29 +3,33 @@ import { API } from "../client.ts";
 import * as T from "../traits.ts";
 
 // Input Schema
+export interface AddEndUserSolanaAccountInput {
+  userId: string;
+}
 export const AddEndUserSolanaAccountInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     userId: Schema.String.pipe(T.PathParam()),
-  }).pipe(T.Http({ method: "POST", path: "/v2/end-users/{userId}/solana" }));
-export type AddEndUserSolanaAccountInput =
-  typeof AddEndUserSolanaAccountInput.Type;
+  }).pipe(
+    T.Http({ method: "POST", path: "/v2/end-users/{userId}/solana" }),
+  ) as unknown as Schema.Codec<AddEndUserSolanaAccountInput>;
 
 // Output Schema
+export interface AddEndUserSolanaAccountOutput {
+  solanaAccount: { address: string; createdAt: string };
+}
 export const AddEndUserSolanaAccountOutput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     solanaAccount: Schema.Struct({
       address: Schema.String,
       createdAt: Schema.String,
     }),
-  });
-export type AddEndUserSolanaAccountOutput =
-  typeof AddEndUserSolanaAccountOutput.Type;
+  }) as unknown as Schema.Codec<AddEndUserSolanaAccountOutput>;
 
 // The operation
 /**
- * Add a Solana account to an end user
+ * Add Solana account to end user
  *
- * Adds a new Solana account to an existing end user. End users can have  up to 10 Solana accounts.
+ * Adds a new Solana account to an existing end user. End users can have up to 10 Solana accounts.
  * This API is intended to be used by the developer's own backend, and is authenticated using the developer's CDP API key.
  *
  * @param userId - The ID of the end user to add the account to.

package/src/operations/createDelegationForEndUserAccount.ts

@@ -0,0 +1,60 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client.ts";
+import * as T from "../traits.ts";
+
+// Input Schema
+export interface CreateDelegationForEndUserAccountInput {
+  userId: string;
+  address: string;
+  projectID?: string;
+  expiresAt: string;
+  walletSecretId: string;
+}
+export const CreateDelegationForEndUserAccountInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    userId: Schema.String.pipe(T.PathParam()),
+    address: Schema.String.pipe(T.PathParam()),
+    projectID: Schema.optional(Schema.String),
+    expiresAt: Schema.String,
+    walletSecretId: Schema.String,
+  }).pipe(
+    T.Http({
+      method: "POST",
+      path: "/v2/embedded-wallet-api/end-users/{userId}/address/{address}/delegation",
+    }),
+  ) as unknown as Schema.Codec<CreateDelegationForEndUserAccountInput>;
+
+// Output Schema
+export interface CreateDelegationForEndUserAccountOutput {
+  expiresAt: string;
+}
+export const CreateDelegationForEndUserAccountOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    expiresAt: Schema.String,
+  }) as unknown as Schema.Codec<CreateDelegationForEndUserAccountOutput>;
+
+// The operation
+/**
+ * Create account-scoped delegation for end user
+ *
+ * Creates an account-scoped delegation that allows a developer to sign on behalf of an end user for a single blockchain account (identified by its address) for the specified duration. The end user must be authenticated to authorize this delegation.
+ * Multiple account-scoped delegations may exist concurrently for a single end user (one per canonical account address). Account-scoped and user-scoped delegations cannot coexist for the same user.
+ * When the address corresponds to an EVM Smart Account, the delegation is scoped to the Smart Account's owner EOA rather than the Smart Account address itself. This means `/address/{smartAccountAddress}/delegation` and `/address/{ownerEoaAddress}/delegation` resolve to the same delegation, and the 409 `account_scoped_delegation_active` error may be returned when creating via either address if one already exists for the canonical owner.
+ *
+ * @param X-Wallet-Auth - A JWT signed using your Wallet Secret, encoded in base64. Refer to the
+[Generate Wallet Token](https://docs.cdp.coinbase.com/api-reference/v2/authentication#2-generate-wallet-token)
+section of our Authentication docs for more details on how to generate your Wallet Token.
+
+ * @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.
+
+ * @param userId - The ID of the end user.
+ * @param address - The blockchain address of the end user account to scope this delegation to. Format varies by network (e.g., 0x-prefixed for EVM, base58 for Solana). For EVM addresses, matching is case-insensitive.
+ * @param projectID - The ID of the CDP Project. Required for end users authenticated using custom auth (i.e. a non-CDP JWT provider).
+ */
+export const createDelegationForEndUserAccount =
+  /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+    inputSchema: CreateDelegationForEndUserAccountInput,
+    outputSchema: CreateDelegationForEndUserAccountOutput,
+  }));

package/src/operations/createDepositDestination.ts

@@ -0,0 +1,85 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client.ts";
+import * as T from "../traits.ts";
+
+// Input Schema
+export interface CreateDepositDestinationInput {}
+export const CreateDepositDestinationInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({}).pipe(
+    T.Http({ method: "POST", path: "/v2/deposit-destinations" }),
+  ) as unknown as Schema.Codec<CreateDepositDestinationInput>;
+
+// Output Schema
+export interface CreateDepositDestinationOutput {
+  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 CreateDepositDestinationOutput =
+  /*@__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<CreateDepositDestinationOutput>;
+
+// The operation
+/**
+ * Create deposit destination
+ *
+ * Create a new deposit destination for an account. A deposit destination is a cryptocurrency address that can be used to receive funds. The address will be generated for the specified network.
+ *
+ * @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 createDepositDestination = /*@__PURE__*/ /*#__PURE__*/ API.make(
+  () => ({
+    inputSchema: CreateDepositDestinationInput,
+    outputSchema: CreateDepositDestinationOutput,
+  }),
+);

package/src/operations/createEndUser.ts

@@ -3,9 +3,75 @@ import { API } from "../client.ts";
 import * as T from "../traits.ts";
 
 // Input Schema
+export interface CreateEndUserInput {
+  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 }
+  )[];
+  evmAccount?: {
+    createSmartAccount?: boolean;
+    enableSpendPermissions?: boolean;
+  };
+  solanaAccount?: { createSmartAccount?: boolean };
+}
 export const CreateEndUserInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   userId: Schema.optional(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,
+      }),
+    ]),
+  ),
   evmAccount: Schema.optional(
     Schema.Struct({
       createSmartAccount: Schema.optional(Schema.Boolean),
@@ -17,13 +83,91 @@ export const CreateEndUserInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
       createSmartAccount: Schema.optional(Schema.Boolean),
     }),
   ),
-}).pipe(T.Http({ method: "POST", path: "/v2/end-users" }));
-export type CreateEndUserInput = typeof CreateEndUserInput.Type;
+}).pipe(
+  T.Http({ method: "POST", path: "/v2/end-users" }),
+) as unknown as Schema.Codec<CreateEndUserInput>;
 
 // Output Schema
+export interface CreateEndUserOutput {
+  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 CreateEndUserOutput = /*@__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),
@@ -62,12 +206,11 @@ export const CreateEndUserOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     }),
   ),
   createdAt: Schema.String,
-});
-export type CreateEndUserOutput = typeof CreateEndUserOutput.Type;
+}) as unknown as Schema.Codec<CreateEndUserOutput>;
 
 // The operation
 /**
- * Create an end user
+ * Create end user
  *
  * Creates an end user. An end user is an entity that can own CDP EVM accounts, EVM smart accounts, and/or Solana accounts. 1 or more authentication methods must be associated with an end user. By default, no accounts are created unless the optional `evmAccount` and/or `solanaAccount` fields are provided.
  * 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/createEvmAccount.ts

@@ -3,13 +3,25 @@ import { API } from "../client.ts";
 import * as T from "../traits.ts";
 
 // Input Schema
+export interface CreateEvmAccountInput {
+  name?: string;
+  accountPolicy?: string;
+}
 export const CreateEvmAccountInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   name: Schema.optional(Schema.String),
   accountPolicy: Schema.optional(Schema.String),
-}).pipe(T.Http({ method: "POST", path: "/v2/evm/accounts" }));
-export type CreateEvmAccountInput = typeof CreateEvmAccountInput.Type;
+}).pipe(
+  T.Http({ method: "POST", path: "/v2/evm/accounts" }),
+) as unknown as Schema.Codec<CreateEvmAccountInput>;
 
 // Output Schema
+export interface CreateEvmAccountOutput {
+  address: string;
+  name?: string;
+  policies?: string[];
+  createdAt?: string;
+  updatedAt?: string;
+}
 export const CreateEvmAccountOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
   {
     address: Schema.String,
@@ -18,12 +30,11 @@ export const CreateEvmAccountOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
     createdAt: Schema.optional(Schema.String),
     updatedAt: Schema.optional(Schema.String),
   },
-);
-export type CreateEvmAccountOutput = typeof CreateEvmAccountOutput.Type;
+) as unknown as Schema.Codec<CreateEvmAccountOutput>;
 
 // The operation
 /**
- * Create an EVM account
+ * Create EVM account
  *
  * Creates a new EVM account.
  *

package/src/operations/createEvmEip7702Delegation.ts

@@ -3,6 +3,18 @@ import { API } from "../client.ts";
 import * as T from "../traits.ts";
 
 // Input Schema
+export interface CreateEvmEip7702DelegationInput {
+  address: string;
+  network:
+    | "base-sepolia"
+    | "base"
+    | "arbitrum"
+    | "optimism"
+    | "polygon"
+    | "ethereum"
+    | "ethereum-sepolia";
+  enableSpendPermissions?: boolean;
+}
 export const CreateEvmEip7702DelegationInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     address: Schema.String.pipe(T.PathParam()),
@@ -21,17 +33,16 @@ export const CreateEvmEip7702DelegationInput =
       method: "POST",
       path: "/v2/evm/accounts/{address}/eip7702/delegation",
     }),
-  );
-export type CreateEvmEip7702DelegationInput =
-  typeof CreateEvmEip7702DelegationInput.Type;
+  ) as unknown as Schema.Codec<CreateEvmEip7702DelegationInput>;
 
 // Output Schema
+export interface CreateEvmEip7702DelegationOutput {
+  delegationOperationId: string;
+}
 export const CreateEvmEip7702DelegationOutput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     delegationOperationId: Schema.String,
-  });
-export type CreateEvmEip7702DelegationOutput =
-  typeof CreateEvmEip7702DelegationOutput.Type;
+  }) as unknown as Schema.Codec<CreateEvmEip7702DelegationOutput>;
 
 // The operation
 /**

package/src/operations/createEvmEip7702DelegationWithEndUserAccount.ts

@@ -3,6 +3,21 @@ import { API } from "../client.ts";
 import * as T from "../traits.ts";
 
 // Input Schema
+export interface CreateEvmEip7702DelegationWithEndUserAccountInput {
+  userId: string;
+  projectID?: string;
+  address: string;
+  network:
+    | "base-sepolia"
+    | "base"
+    | "arbitrum"
+    | "optimism"
+    | "polygon"
+    | "ethereum"
+    | "ethereum-sepolia";
+  enableSpendPermissions?: boolean;
+  walletSecretId?: string;
+}
 export const CreateEvmEip7702DelegationWithEndUserAccountInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     userId: Schema.String.pipe(T.PathParam()),
@@ -24,17 +39,16 @@ export const CreateEvmEip7702DelegationWithEndUserAccountInput =
       method: "POST",
       path: "/v2/embedded-wallet-api/end-users/{userId}/evm/eip7702/delegation",
     }),
-  );
-export type CreateEvmEip7702DelegationWithEndUserAccountInput =
-  typeof CreateEvmEip7702DelegationWithEndUserAccountInput.Type;
+  ) as unknown as Schema.Codec<CreateEvmEip7702DelegationWithEndUserAccountInput>;
 
 // Output Schema
+export interface CreateEvmEip7702DelegationWithEndUserAccountOutput {
+  delegationOperationId: string;
+}
 export const CreateEvmEip7702DelegationWithEndUserAccountOutput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     delegationOperationId: Schema.String,
-  });
-export type CreateEvmEip7702DelegationWithEndUserAccountOutput =
-  typeof CreateEvmEip7702DelegationWithEndUserAccountOutput.Type;
+  }) as unknown as Schema.Codec<CreateEvmEip7702DelegationWithEndUserAccountOutput>;
 
 // The operation
 /**

package/src/operations/createEvmSmartAccount.ts

@@ -3,14 +3,27 @@ import { API } from "../client.ts";
 import * as T from "../traits.ts";
 
 // Input Schema
+export interface CreateEvmSmartAccountInput {
+  owners: string[];
+  name?: string;
+}
 export const CreateEvmSmartAccountInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     owners: Schema.Array(Schema.String),
     name: Schema.optional(Schema.String),
-  }).pipe(T.Http({ method: "POST", path: "/v2/evm/smart-accounts" }));
-export type CreateEvmSmartAccountInput = typeof CreateEvmSmartAccountInput.Type;
+  }).pipe(
+    T.Http({ method: "POST", path: "/v2/evm/smart-accounts" }),
+  ) as unknown as Schema.Codec<CreateEvmSmartAccountInput>;
 
 // Output Schema
+export interface CreateEvmSmartAccountOutput {
+  address: string;
+  owners: string[];
+  name?: string;
+  policies?: string[];
+  createdAt?: string;
+  updatedAt?: string;
+}
 export const CreateEvmSmartAccountOutput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     address: Schema.String,
@@ -19,13 +32,11 @@ export const CreateEvmSmartAccountOutput =
     policies: Schema.optional(Schema.Array(Schema.String)),
     createdAt: Schema.optional(Schema.String),
     updatedAt: Schema.optional(Schema.String),
-  });
-export type CreateEvmSmartAccountOutput =
-  typeof CreateEvmSmartAccountOutput.Type;
+  }) as unknown as Schema.Codec<CreateEvmSmartAccountOutput>;
 
 // The operation
 /**
- * Create a Smart Account
+ * Create Smart Account
  *
  * Creates a new Smart Account.
  *