@distilled.cloud/coinbase 0.27.0 → 0.28.1

package/src/operations/searchX402Resources.ts

@@ -0,0 +1,194 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client.ts";
+import * as T from "../traits.ts";
+
+// Input Schema
+export interface SearchX402ResourcesInput {
+  query?: string;
+  network?: string;
+  asset?: string;
+  scheme?: string;
+  payTo?: string;
+  urlSubstring?: string;
+  maxUsdPrice?: string;
+  extensions?: string;
+  limit?: number;
+}
+export const SearchX402ResourcesInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    query: Schema.optional(Schema.String),
+    network: Schema.optional(Schema.String),
+    asset: Schema.optional(Schema.String),
+    scheme: Schema.optional(Schema.String),
+    payTo: Schema.optional(Schema.String),
+    urlSubstring: Schema.optional(Schema.String),
+    maxUsdPrice: Schema.optional(Schema.String),
+    extensions: Schema.optional(Schema.String),
+    limit: Schema.optional(Schema.Number),
+  }).pipe(
+    T.Http({ method: "GET", path: "/v2/x402/discovery/search" }),
+  ) as unknown as Schema.Codec<SearchX402ResourcesInput>;
+
+// Output Schema
+export interface SearchX402ResourcesOutput {
+  resources: {
+    resource: string;
+    description?: string;
+    type: "http" | "mcp";
+    x402Version: 1 | 2;
+    lastUpdated?: string;
+    accepts?: (
+      | {
+          scheme: "exact" | "upto" | "batch-settlement";
+          network:
+            | "eip155:8453"
+            | "eip155:84532"
+            | "eip155:137"
+            | "eip155:42161"
+            | "eip155:480"
+            | "eip155:4801"
+            | "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp"
+            | "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1";
+          asset: string;
+          amount: string;
+          payTo: string;
+          maxTimeoutSeconds: number;
+          extra?: Record<string, unknown>;
+        }
+      | {
+          scheme: "exact";
+          network: "base" | "base-sepolia" | "solana" | "solana-devnet";
+          maxAmountRequired: string;
+          resource: string;
+          description: string;
+          mimeType: string;
+          outputSchema?: Record<string, unknown>;
+          payTo: string;
+          maxTimeoutSeconds: number;
+          asset: string;
+          extra?: Record<string, unknown>;
+        }
+    )[];
+    extensions?: Record<string, unknown>;
+    quality?: {
+      l30DaysTotalCalls?: number;
+      l30DaysUniquePayers?: number;
+      lastCalledAt?: string;
+    };
+    serviceName?: string;
+    tags?: string[];
+    iconUrl?: string;
+  }[];
+  partialResults: boolean;
+  searchMethod?: "text" | "vector" | "hybrid";
+  x402Version: 1 | 2;
+}
+export const SearchX402ResourcesOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    resources: Schema.Array(
+      Schema.Struct({
+        resource: Schema.String,
+        description: Schema.optional(Schema.String),
+        type: Schema.Literals(["http", "mcp"]),
+        x402Version: Schema.Literals([1, 2]),
+        lastUpdated: Schema.optional(Schema.String),
+        accepts: Schema.optional(
+          Schema.Array(
+            Schema.Union([
+              Schema.Struct({
+                scheme: Schema.Literals(["exact", "upto", "batch-settlement"]),
+                network: Schema.Literals([
+                  "eip155:8453",
+                  "eip155:84532",
+                  "eip155:137",
+                  "eip155:42161",
+                  "eip155:480",
+                  "eip155:4801",
+                  "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp",
+                  "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1",
+                ]),
+                asset: Schema.String,
+                amount: Schema.String,
+                payTo: Schema.String,
+                maxTimeoutSeconds: Schema.Number,
+                extra: Schema.optional(
+                  Schema.Record(Schema.String, Schema.Unknown),
+                ),
+              }),
+              Schema.Struct({
+                scheme: Schema.Literals(["exact"]),
+                network: Schema.Literals([
+                  "base",
+                  "base-sepolia",
+                  "solana",
+                  "solana-devnet",
+                ]),
+                maxAmountRequired: Schema.String,
+                resource: Schema.String,
+                description: Schema.String,
+                mimeType: Schema.String,
+                outputSchema: Schema.optional(
+                  Schema.Record(Schema.String, Schema.Unknown),
+                ),
+                payTo: Schema.String,
+                maxTimeoutSeconds: Schema.Number,
+                asset: Schema.String,
+                extra: Schema.optional(
+                  Schema.Record(Schema.String, Schema.Unknown),
+                ),
+              }),
+            ]),
+          ),
+        ),
+        extensions: Schema.optional(
+          Schema.Record(Schema.String, Schema.Unknown),
+        ),
+        quality: Schema.optional(
+          Schema.Struct({
+            l30DaysTotalCalls: Schema.optional(Schema.Number),
+            l30DaysUniquePayers: Schema.optional(Schema.Number),
+            lastCalledAt: Schema.optional(Schema.String),
+          }),
+        ),
+        serviceName: Schema.optional(Schema.String),
+        tags: Schema.optional(Schema.Array(Schema.String)),
+        iconUrl: Schema.optional(Schema.String),
+      }),
+    ),
+    partialResults: Schema.Boolean,
+    searchMethod: Schema.optional(
+      Schema.Literals(["text", "vector", "hybrid"]),
+    ),
+    x402Version: Schema.Literals([1, 2]),
+  }) as unknown as Schema.Codec<SearchX402ResourcesOutput>;
+
+// The operation
+/**
+ * Search x402 resources
+ *
+ * Searches for active x402 resources using a text query and optional filters.
+ * Supports both text-based and vector-based search depending on availability. Results are sorted by relevance and quality score.
+ * Legacy network names (e.g., `base`, `base-sepolia`, `solana`) are automatically normalized to their CAIP-2 equivalents.
+ * The response is limited to 20 items per request. If more results exist, `partialResults` will be `true`.
+ *
+ * @param query - Full-text or semantic search query to find matching resources.
+ * @param network - Filter results by network in CAIP-2 format (e.g., `eip155:8453`) or legacy name (e.g., `base`, `base-sepolia`, `solana`).
+Legacy names are normalized to their CAIP-2 equivalents before filtering.
+ * @param asset - Filter results by asset address.
+For EVM networks, provide a 0x-prefixed EVM address. For Solana networks, provide a base58-encoded address.
+Matching is case-insensitive.
+ * @param scheme - Filter results by payment scheme (e.g., `exact`).
+ * @param payTo - Filter results by the merchant's payment address.
+For EVM networks, provide a 0x-prefixed EVM address. For Solana networks, provide a base58-encoded address.
+ * @param urlSubstring - Filter results to resources whose URL contains this value (case-insensitive substring match against the resource URL).
+Useful for narrowing results to a specific domain, subdomain, or path segment. Combine with `query` to perform semantic search restricted to a URL subset.
+Tip: include enough of the URL to disambiguate (e.g. `api.example.com` rather than `example`) — a short substring may also match resources whose path contains the same string.
+ * @param maxUsdPrice - Filter results to resources with a USD price at or below this value.
+ * @param extensions - Filter results to resources that support the specified protocol extensions. Can be specified multiple times to filter by multiple extensions.
+ * @param limit - Maximum number of resources to return. Must be a positive integer no greater than 20.
+Defaults to 20.
+ */
+export const searchX402Resources = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: SearchX402ResourcesInput,
+  outputSchema: SearchX402ResourcesOutput,
+}));

package/src/operations/sendEvmAssetWithEndUserAccount.ts

@@ -3,6 +3,30 @@ import { API } from "../client.ts";
 import * as T from "../traits.ts";
 
 // Input Schema
+export interface SendEvmAssetWithEndUserAccountInput {
+  userId: string;
+  address: string;
+  asset: "usdc";
+  projectID?: string;
+  to: string;
+  amount: string;
+  network:
+    | "base"
+    | "base-sepolia"
+    | "ethereum"
+    | "ethereum-sepolia"
+    | "avalanche"
+    | "polygon"
+    | "optimism"
+    | "arbitrum"
+    | "arbitrum-sepolia"
+    | "world"
+    | "world-sepolia";
+  useCdpPaymaster?: boolean;
+  paymasterUrl?: string;
+  paymasterContext?: Record<string, unknown>;
+  walletSecretId?: string;
+}
 export const SendEvmAssetWithEndUserAccountInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     userId: Schema.String.pipe(T.PathParam()),
@@ -26,24 +50,27 @@ export const SendEvmAssetWithEndUserAccountInput =
     ]),
     useCdpPaymaster: Schema.optional(Schema.Boolean),
     paymasterUrl: Schema.optional(Schema.String),
+    paymasterContext: Schema.optional(
+      Schema.Record(Schema.String, Schema.Unknown),
+    ),
     walletSecretId: Schema.optional(Schema.String),
   }).pipe(
     T.Http({
       method: "POST",
       path: "/v2/embedded-wallet-api/end-users/{userId}/evm/{address}/send/{asset}",
     }),
-  );
-export type SendEvmAssetWithEndUserAccountInput =
-  typeof SendEvmAssetWithEndUserAccountInput.Type;
+  ) as unknown as Schema.Codec<SendEvmAssetWithEndUserAccountInput>;
 
 // Output Schema
+export interface SendEvmAssetWithEndUserAccountOutput {
+  transactionHash?: string | null;
+  userOpHash?: string | null;
+}
 export const SendEvmAssetWithEndUserAccountOutput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     transactionHash: Schema.optional(Schema.NullOr(Schema.String)),
     userOpHash: Schema.optional(Schema.NullOr(Schema.String)),
-  });
-export type SendEvmAssetWithEndUserAccountOutput =
-  typeof SendEvmAssetWithEndUserAccountOutput.Type;
+  }) as unknown as Schema.Codec<SendEvmAssetWithEndUserAccountOutput>;
 
 // The operation
 /**

package/src/operations/sendEvmTransaction.ts

@@ -3,6 +3,22 @@ import { API } from "../client.ts";
 import * as T from "../traits.ts";
 
 // Input Schema
+export interface SendEvmTransactionInput {
+  address: string;
+  network:
+    | "base"
+    | "base-sepolia"
+    | "ethereum"
+    | "ethereum-sepolia"
+    | "avalanche"
+    | "polygon"
+    | "optimism"
+    | "arbitrum"
+    | "arbitrum-sepolia"
+    | "world"
+    | "world-sepolia";
+  transaction: string;
+}
 export const SendEvmTransactionInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     address: Schema.String.pipe(T.PathParam()),
@@ -15,6 +31,9 @@ export const SendEvmTransactionInput =
       "polygon",
       "optimism",
       "arbitrum",
+      "arbitrum-sepolia",
+      "world",
+      "world-sepolia",
     ]),
     transaction: Schema.String,
   }).pipe(
@@ -22,19 +41,20 @@ export const SendEvmTransactionInput =
       method: "POST",
       path: "/v2/evm/accounts/{address}/send/transaction",
     }),
-  );
-export type SendEvmTransactionInput = typeof SendEvmTransactionInput.Type;
+  ) as unknown as Schema.Codec<SendEvmTransactionInput>;
 
 // Output Schema
+export interface SendEvmTransactionOutput {
+  transactionHash: string;
+}
 export const SendEvmTransactionOutput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     transactionHash: Schema.String,
-  });
-export type SendEvmTransactionOutput = typeof SendEvmTransactionOutput.Type;
+  }) as unknown as Schema.Codec<SendEvmTransactionOutput>;
 
 // The operation
 /**
- * Send a transaction
+ * Send transaction
  *
  * Signs a transaction with the given EVM account and sends it to the indicated supported network. This API handles nonce management and gas estimation, leaving the developer to provide only the minimal set of fields necessary to send the transaction. The transaction should be serialized as a hex string using [RLP](https://ethereum.org/en/developers/docs/data-structures-and-encoding/rlp/).
  * The transaction must be an [EIP-1559 dynamic fee transaction](https://github.com/ethereum/EIPs/blob/master/EIPS/eip-1559.md).

package/src/operations/sendEvmTransactionWithEndUserAccount.ts

@@ -3,6 +3,25 @@ import { API } from "../client.ts";
 import * as T from "../traits.ts";
 
 // Input Schema
+export interface SendEvmTransactionWithEndUserAccountInput {
+  userId: string;
+  projectID?: string;
+  address: string;
+  network:
+    | "base"
+    | "base-sepolia"
+    | "ethereum"
+    | "ethereum-sepolia"
+    | "avalanche"
+    | "polygon"
+    | "optimism"
+    | "arbitrum"
+    | "arbitrum-sepolia"
+    | "world"
+    | "world-sepolia";
+  walletSecretId?: string;
+  transaction: string;
+}
 export const SendEvmTransactionWithEndUserAccountInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     userId: Schema.String.pipe(T.PathParam()),
@@ -28,21 +47,20 @@ export const SendEvmTransactionWithEndUserAccountInput =
       method: "POST",
       path: "/v2/embedded-wallet-api/end-users/{userId}/evm/send/transaction",
     }),
-  );
-export type SendEvmTransactionWithEndUserAccountInput =
-  typeof SendEvmTransactionWithEndUserAccountInput.Type;
+  ) as unknown as Schema.Codec<SendEvmTransactionWithEndUserAccountInput>;
 
 // Output Schema
+export interface SendEvmTransactionWithEndUserAccountOutput {
+  transactionHash: string;
+}
 export const SendEvmTransactionWithEndUserAccountOutput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     transactionHash: Schema.String,
-  });
-export type SendEvmTransactionWithEndUserAccountOutput =
-  typeof SendEvmTransactionWithEndUserAccountOutput.Type;
+  }) as unknown as Schema.Codec<SendEvmTransactionWithEndUserAccountOutput>;
 
 // The operation
 /**
- * Send a transaction with end user EVM account
+ * Send transaction via end user EVM account
  *
  * Signs a transaction with the given end user EVM account and sends it to the indicated supported network. This API handles nonce management and gas estimation, leaving the developer to provide only the minimal set of fields necessary to send the transaction. The transaction should be serialized as a hex string using [RLP](https://ethereum.org/en/developers/docs/data-structures-and-encoding/rlp/).
  * The transaction must be an [EIP-1559 dynamic fee transaction](https://github.com/ethereum/EIPs/blob/master/EIPS/eip-1559.md).

package/src/operations/sendSolanaAssetWithEndUserAccount.ts

@@ -3,6 +3,18 @@ import { API } from "../client.ts";
 import * as T from "../traits.ts";
 
 // Input Schema
+export interface SendSolanaAssetWithEndUserAccountInput {
+  userId: string;
+  address: string;
+  asset: "usdc";
+  projectID?: string;
+  to: string;
+  amount: string;
+  network: "solana" | "solana-devnet";
+  createRecipientAta?: boolean;
+  walletSecretId?: string;
+  useCdpSponsor?: boolean;
+}
 export const SendSolanaAssetWithEndUserAccountInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     userId: Schema.String.pipe(T.PathParam()),
@@ -20,17 +32,16 @@ export const SendSolanaAssetWithEndUserAccountInput =
       method: "POST",
       path: "/v2/embedded-wallet-api/end-users/{userId}/solana/{address}/send/{asset}",
     }),
-  );
-export type SendSolanaAssetWithEndUserAccountInput =
-  typeof SendSolanaAssetWithEndUserAccountInput.Type;
+  ) as unknown as Schema.Codec<SendSolanaAssetWithEndUserAccountInput>;
 
 // Output Schema
+export interface SendSolanaAssetWithEndUserAccountOutput {
+  transactionSignature: string;
+}
 export const SendSolanaAssetWithEndUserAccountOutput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     transactionSignature: Schema.String,
-  });
-export type SendSolanaAssetWithEndUserAccountOutput =
-  typeof SendSolanaAssetWithEndUserAccountOutput.Type;
+  }) as unknown as Schema.Codec<SendSolanaAssetWithEndUserAccountOutput>;
 
 // The operation
 /**

package/src/operations/sendSolanaTransaction.ts

@@ -3,6 +3,11 @@ import { API } from "../client.ts";
 import * as T from "../traits.ts";
 
 // Input Schema
+export interface SendSolanaTransactionInput {
+  network: "solana" | "solana-devnet";
+  transaction: string;
+  useCdpSponsor?: boolean;
+}
 export const SendSolanaTransactionInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     network: Schema.Literals(["solana", "solana-devnet"]),
@@ -10,20 +15,20 @@ export const SendSolanaTransactionInput =
     useCdpSponsor: Schema.optional(Schema.Boolean),
   }).pipe(
     T.Http({ method: "POST", path: "/v2/solana/accounts/send/transaction" }),
-  );
-export type SendSolanaTransactionInput = typeof SendSolanaTransactionInput.Type;
+  ) as unknown as Schema.Codec<SendSolanaTransactionInput>;
 
 // Output Schema
+export interface SendSolanaTransactionOutput {
+  transactionSignature: string;
+}
 export const SendSolanaTransactionOutput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     transactionSignature: Schema.String,
-  });
-export type SendSolanaTransactionOutput =
-  typeof SendSolanaTransactionOutput.Type;
+  }) as unknown as Schema.Codec<SendSolanaTransactionOutput>;
 
 // The operation
 /**
- * Send a Solana transaction
+ * Send Solana transaction
  *
  * Signs and sends a single Solana transaction using multiple Solana accounts. The transaction may contain contain several instructions, each of which may require signatures from different account keys.
  * The transaction should be serialized into a byte array and base64 encoded. The API handles recent blockhash management and fee estimation, leaving the developer to provide only the minimal set of fields necessary to send the transaction.

package/src/operations/sendSolanaTransactionWithEndUserAccount.ts

@@ -3,6 +3,15 @@ import { API } from "../client.ts";
 import * as T from "../traits.ts";
 
 // Input Schema
+export interface SendSolanaTransactionWithEndUserAccountInput {
+  userId: string;
+  projectID?: string;
+  address: string;
+  network: "solana" | "solana-devnet";
+  walletSecretId?: string;
+  transaction: string;
+  useCdpSponsor?: boolean;
+}
 export const SendSolanaTransactionWithEndUserAccountInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     userId: Schema.String.pipe(T.PathParam()),
@@ -17,21 +26,20 @@ export const SendSolanaTransactionWithEndUserAccountInput =
       method: "POST",
       path: "/v2/embedded-wallet-api/end-users/{userId}/solana/send/transaction",
     }),
-  );
-export type SendSolanaTransactionWithEndUserAccountInput =
-  typeof SendSolanaTransactionWithEndUserAccountInput.Type;
+  ) as unknown as Schema.Codec<SendSolanaTransactionWithEndUserAccountInput>;
 
 // Output Schema
+export interface SendSolanaTransactionWithEndUserAccountOutput {
+  transactionSignature: string;
+}
 export const SendSolanaTransactionWithEndUserAccountOutput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     transactionSignature: Schema.String,
-  });
-export type SendSolanaTransactionWithEndUserAccountOutput =
-  typeof SendSolanaTransactionWithEndUserAccountOutput.Type;
+  }) as unknown as Schema.Codec<SendSolanaTransactionWithEndUserAccountOutput>;
 
 // The operation
 /**
- * Send a transaction with end user Solana account
+ * Send transaction via end user Solana account
  *
  * Signs a transaction with the given end user Solana account and sends it to the indicated supported network.
  * The API handles recent blockhash management and fee estimation, leaving the developer to provide only the minimal set of fields necessary to send the transaction.

package/src/operations/sendUserOperation.ts

@@ -3,6 +3,11 @@ import { API } from "../client.ts";
 import * as T from "../traits.ts";
 
 // Input Schema
+export interface SendUserOperationInput {
+  address: string;
+  userOpHash: string;
+  signature: string;
+}
 export const SendUserOperationInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
   {
     address: Schema.String.pipe(T.PathParam()),
@@ -14,10 +19,45 @@ export const SendUserOperationInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
     method: "POST",
     path: "/v2/evm/smart-accounts/{address}/user-operations/{userOpHash}/send",
   }),
-);
-export type SendUserOperationInput = typeof SendUserOperationInput.Type;
+) as unknown as Schema.Codec<SendUserOperationInput>;
 
 // Output Schema
+export interface SendUserOperationOutput {
+  network:
+    | "base-sepolia"
+    | "base"
+    | "arbitrum"
+    | "optimism"
+    | "zora"
+    | "polygon"
+    | "bnb"
+    | "avalanche"
+    | "ethereum"
+    | "ethereum-sepolia";
+  userOpHash: string;
+  calls: {
+    to: string;
+    value: string;
+    data: string;
+    overrideGasLimit?: string;
+  }[];
+  status:
+    | "pending"
+    | "signed"
+    | "broadcast"
+    | "complete"
+    | "dropped"
+    | "failed";
+  transactionHash?: string;
+  receipts?: {
+    revert?: { data: string; message: string };
+    transactionHash?: string;
+    blockHash?: string;
+    blockNumber?: number;
+    gasUsed?: string;
+  }[];
+  expiresAt?: string;
+}
 export const SendUserOperationOutput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     network: Schema.Literals([
@@ -66,12 +106,12 @@ export const SendUserOperationOutput =
         }),
       ),
     ),
-  });
-export type SendUserOperationOutput = typeof SendUserOperationOutput.Type;
+    expiresAt: Schema.optional(Schema.String),
+  }) as unknown as Schema.Codec<SendUserOperationOutput>;
 
 // The operation
 /**
- * Send a user operation
+ * Send user operation
  *
  * Sends a user operation with a signature.
  * The payload to sign must be the `userOpHash` field of the user operation. This hash should be signed directly (not using `personal_sign` or EIP-191 message hashing).

package/src/operations/sendUserOperationWithEndUserAccount.ts

@@ -3,6 +3,33 @@ import { API } from "../client.ts";
 import * as T from "../traits.ts";
 
 // Input Schema
+export interface SendUserOperationWithEndUserAccountInput {
+  userId: string;
+  address: string;
+  projectID?: string;
+  network:
+    | "base-sepolia"
+    | "base"
+    | "arbitrum"
+    | "optimism"
+    | "zora"
+    | "polygon"
+    | "bnb"
+    | "avalanche"
+    | "ethereum"
+    | "ethereum-sepolia";
+  calls: {
+    to: string;
+    value: string;
+    data: string;
+    overrideGasLimit?: string;
+  }[];
+  useCdpPaymaster: boolean;
+  paymasterUrl?: string;
+  paymasterContext?: Record<string, unknown>;
+  walletSecretId?: string;
+  dataSuffix?: string;
+}
 export const SendUserOperationWithEndUserAccountInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     userId: Schema.String.pipe(T.PathParam()),
@@ -30,6 +57,9 @@ export const SendUserOperationWithEndUserAccountInput =
     ),
     useCdpPaymaster: Schema.Boolean,
     paymasterUrl: Schema.optional(Schema.String),
+    paymasterContext: Schema.optional(
+      Schema.Record(Schema.String, Schema.Unknown),
+    ),
     walletSecretId: Schema.optional(Schema.String),
     dataSuffix: Schema.optional(Schema.String),
   }).pipe(
@@ -37,11 +67,45 @@ export const SendUserOperationWithEndUserAccountInput =
       method: "POST",
       path: "/v2/embedded-wallet-api/end-users/{userId}/evm/smart-accounts/{address}/send",
     }),
-  );
-export type SendUserOperationWithEndUserAccountInput =
-  typeof SendUserOperationWithEndUserAccountInput.Type;
+  ) as unknown as Schema.Codec<SendUserOperationWithEndUserAccountInput>;
 
 // Output Schema
+export interface SendUserOperationWithEndUserAccountOutput {
+  network:
+    | "base-sepolia"
+    | "base"
+    | "arbitrum"
+    | "optimism"
+    | "zora"
+    | "polygon"
+    | "bnb"
+    | "avalanche"
+    | "ethereum"
+    | "ethereum-sepolia";
+  userOpHash: string;
+  calls: {
+    to: string;
+    value: string;
+    data: string;
+    overrideGasLimit?: string;
+  }[];
+  status:
+    | "pending"
+    | "signed"
+    | "broadcast"
+    | "complete"
+    | "dropped"
+    | "failed";
+  transactionHash?: string;
+  receipts?: {
+    revert?: { data: string; message: string };
+    transactionHash?: string;
+    blockHash?: string;
+    blockNumber?: number;
+    gasUsed?: string;
+  }[];
+  expiresAt?: string;
+}
 export const SendUserOperationWithEndUserAccountOutput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     network: Schema.Literals([
@@ -90,13 +154,12 @@ export const SendUserOperationWithEndUserAccountOutput =
         }),
       ),
     ),
-  });
-export type SendUserOperationWithEndUserAccountOutput =
-  typeof SendUserOperationWithEndUserAccountOutput.Type;
+    expiresAt: Schema.optional(Schema.String),
+  }) as unknown as Schema.Codec<SendUserOperationWithEndUserAccountOutput>;
 
 // The operation
 /**
- * Send a user operation for end user Smart Account
+ * Send user operation for end user Smart Account
  *
  * Prepares, signs, and sends a user operation for an end user's Smart Account.
  *