@compose-market/sdk 0.7.11 → 0.8.0

package/generated/x402/src/models/compose-key-create-request.ts

@@ -4,23 +4,23 @@
 
 import * as z from "zod/v4-mini";
 import {
-  ComposeKeyPurpose,
-  ComposeKeyPurpose$outboundSchema,
+  KeyPurpose,
+  KeyPurpose$outboundSchema,
 } from "./compose-key-purpose.js";
 
-export type ComposeKeyCreateRequest = {
+export type KeyCreateRequest = {
   /**
    * Non-negative integer amount in USDC atomic units.
    */
   budgetLimit: string;
   expiresAt: number;
-  purpose: ComposeKeyPurpose;
+  purpose: KeyPurpose;
   chainId: number;
   name?: string | undefined;
 };
 
 /** @internal */
-export type ComposeKeyCreateRequest$Outbound = {
+export type KeyCreateRequest$Outbound = {
   budgetLimit: string;
   expiresAt: number;
   purpose: string;
@@ -29,21 +29,21 @@ export type ComposeKeyCreateRequest$Outbound = {
 };
 
 /** @internal */
-export const ComposeKeyCreateRequest$outboundSchema: z.ZodMiniType<
-  ComposeKeyCreateRequest$Outbound,
-  ComposeKeyCreateRequest
+export const KeyCreateRequest$outboundSchema: z.ZodMiniType<
+  KeyCreateRequest$Outbound,
+  KeyCreateRequest
 > = z.object({
   budgetLimit: z.string(),
   expiresAt: z.int(),
-  purpose: ComposeKeyPurpose$outboundSchema,
+  purpose: KeyPurpose$outboundSchema,
   chainId: z.int(),
   name: z.optional(z.string()),
 });
 
-export function composeKeyCreateRequestToJSON(
-  composeKeyCreateRequest: ComposeKeyCreateRequest,
+export function keyCreateRequestToJSON(
+  keyCreateRequest: KeyCreateRequest,
 ): string {
   return JSON.stringify(
-    ComposeKeyCreateRequest$outboundSchema.parse(composeKeyCreateRequest),
+    KeyCreateRequest$outboundSchema.parse(keyCreateRequest),
   );
 }

package/generated/x402/src/models/compose-key-create-response.ts

@@ -7,15 +7,15 @@ import { safeParse } from "../lib/schemas.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import * as types from "../types/primitives.js";
 import {
-  ComposeKeyPurpose,
-  ComposeKeyPurpose$inboundSchema,
+  KeyPurpose,
+  KeyPurpose$inboundSchema,
 } from "./compose-key-purpose.js";
 import { SDKValidationError } from "./errors/sdk-validation-error.js";
 
-export type ComposeKeyCreateResponse = {
+export type KeyCreateResponse = {
   keyId: string;
   token: string;
-  purpose: ComposeKeyPurpose;
+  purpose: KeyPurpose;
   /**
    * Non-negative integer amount in USDC atomic units.
    */
@@ -35,13 +35,13 @@ export type ComposeKeyCreateResponse = {
 };
 
 /** @internal */
-export const ComposeKeyCreateResponse$inboundSchema: z.ZodMiniType<
-  ComposeKeyCreateResponse,
+export const KeyCreateResponse$inboundSchema: z.ZodMiniType<
+  KeyCreateResponse,
   unknown
 > = z.object({
   keyId: types.string(),
   token: types.string(),
-  purpose: ComposeKeyPurpose$inboundSchema,
+  purpose: KeyPurpose$inboundSchema,
   budgetLimit: types.string(),
   budgetUsed: types.string(),
   budgetRemaining: types.string(),
@@ -51,12 +51,12 @@ export const ComposeKeyCreateResponse$inboundSchema: z.ZodMiniType<
   name: types.optional(types.string()),
 });
 
-export function composeKeyCreateResponseFromJSON(
+export function keyCreateResponseFromJSON(
   jsonString: string,
-): SafeParseResult<ComposeKeyCreateResponse, SDKValidationError> {
+): SafeParseResult<KeyCreateResponse, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => ComposeKeyCreateResponse$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'ComposeKeyCreateResponse' from JSON`,
+    (x) => KeyCreateResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'KeyCreateResponse' from JSON`,
   );
 }

package/generated/x402/src/models/compose-key-purpose.ts

@@ -6,19 +6,19 @@ import * as z from "zod/v4-mini";
 import * as openEnums from "../types/enums.js";
 import { OpenEnum } from "../types/enums.js";
 
-export const ComposeKeyPurpose = {
+export const KeyPurpose = {
   Session: "session",
   Api: "api",
 } as const;
-export type ComposeKeyPurpose = OpenEnum<typeof ComposeKeyPurpose>;
+export type KeyPurpose = OpenEnum<typeof KeyPurpose>;
 
 /** @internal */
-export const ComposeKeyPurpose$inboundSchema: z.ZodMiniType<
-  ComposeKeyPurpose,
+export const KeyPurpose$inboundSchema: z.ZodMiniType<
+  KeyPurpose,
   unknown
-> = openEnums.inboundSchema(ComposeKeyPurpose);
+> = openEnums.inboundSchema(KeyPurpose);
 /** @internal */
-export const ComposeKeyPurpose$outboundSchema: z.ZodMiniType<
+export const KeyPurpose$outboundSchema: z.ZodMiniType<
   string,
-  ComposeKeyPurpose
-> = openEnums.outboundSchema(ComposeKeyPurpose);
+  KeyPurpose
+> = openEnums.outboundSchema(KeyPurpose);

package/generated/x402/src/models/compose-key-record.ts

@@ -7,14 +7,14 @@ import { safeParse } from "../lib/schemas.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import * as types from "../types/primitives.js";
 import {
-  ComposeKeyPurpose,
-  ComposeKeyPurpose$inboundSchema,
+  KeyPurpose,
+  KeyPurpose$inboundSchema,
 } from "./compose-key-purpose.js";
 import { SDKValidationError } from "./errors/sdk-validation-error.js";
 
-export type ComposeKeyRecord = {
+export type KeyRecord = {
   keyId: string;
-  purpose: ComposeKeyPurpose;
+  purpose: KeyPurpose;
   /**
    * Non-negative integer amount in USDC atomic units.
    */
@@ -40,12 +40,12 @@ export type ComposeKeyRecord = {
 };
 
 /** @internal */
-export const ComposeKeyRecord$inboundSchema: z.ZodMiniType<
-  ComposeKeyRecord,
+export const KeyRecord$inboundSchema: z.ZodMiniType<
+  KeyRecord,
   unknown
 > = z.object({
   keyId: types.string(),
-  purpose: ComposeKeyPurpose$inboundSchema,
+  purpose: KeyPurpose$inboundSchema,
   budgetLimit: types.string(),
   budgetUsed: types.string(),
   budgetReserved: types.optional(types.string()),
@@ -58,12 +58,12 @@ export const ComposeKeyRecord$inboundSchema: z.ZodMiniType<
   chainId: types.optional(types.number()),
 });
 
-export function composeKeyRecordFromJSON(
+export function keyRecordFromJSON(
   jsonString: string,
-): SafeParseResult<ComposeKeyRecord, SDKValidationError> {
+): SafeParseResult<KeyRecord, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => ComposeKeyRecord$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'ComposeKeyRecord' from JSON`,
+    (x) => KeyRecord$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'KeyRecord' from JSON`,
   );
 }

package/generated/x402/src/models/errors/compose-market-default-error.ts

@@ -2,10 +2,10 @@
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
  */
 
-import { ComposeMarketError } from "./compose-market-error.js";
+import { Error } from "./compose-market-error.js";
 
 /** The fallback error class if no more specific error class is matched */
-export class ComposeMarketDefaultError extends ComposeMarketError {
+export class DefaultError extends Error {
   constructor(
     message: string,
     httpMeta: {
@@ -20,9 +20,8 @@ export class ComposeMarketDefaultError extends ComposeMarketError {
     message += `Status ${httpMeta.response.status}`;
     const contentType = httpMeta.response.headers.get("content-type") || `""`;
     if (contentType !== "application/json") {
-      message += ` Content-Type ${
-        contentType.includes(" ") ? `"${contentType}"` : contentType
-      }`;
+      message += ` Content-Type ${contentType.includes(" ") ? `"${contentType}"` : contentType
+        }`;
     }
     const body = httpMeta.body || `""`;
     message += body.length > 100 ? "\n" : ". ";
@@ -35,6 +34,6 @@ export class ComposeMarketDefaultError extends ComposeMarketError {
     message += `Body: ${bodyDisplay}`;
     message = message.trim();
     super(message, httpMeta);
-    this.name = "ComposeMarketDefaultError";
+    this.name = "DefaultError";
   }
 }

package/generated/x402/src/models/errors/compose-market-error.ts

@@ -3,7 +3,8 @@
  */
 
 /** The base class for all HTTP error responses */
-export class ComposeMarketError extends Error {
+const NativeError = globalThis.Error;
+export class Error extends NativeError {
   /** HTTP status code */
   public readonly statusCode: number;
   /** HTTP body */
@@ -30,6 +31,6 @@ export class ComposeMarketError extends Error {
     this.contentType = httpMeta.response.headers.get("content-type") || "";
     this.rawResponse = httpMeta.response;
 
-    this.name = "ComposeMarketError";
+    this.name = "Error";
   }
 }

package/generated/x402/src/models/errors/error-envelope.ts

@@ -6,7 +6,7 @@ import * as z from "zod/v4-mini";
 import { remap as remap$ } from "../../lib/primitives.js";
 import * as types from "../../types/primitives.js";
 import * as models from "../index.js";
-import { ComposeMarketError } from "./compose-market-error.js";
+import { Error } from "./compose-market-error.js";
 
 export type ErrorEnvelopeData = {
   error: models.ErrorT;
@@ -16,7 +16,7 @@ export type ErrorEnvelopeData = {
   rawResponse?: Response | undefined;
 };
 
-export class ErrorEnvelope extends ComposeMarketError {
+export class ErrorEnvelope extends Error {
   error: models.ErrorT;
 
   /** The original data that was passed to this error instance. */

package/generated/x402/src/models/errors/legacy-error.ts

@@ -5,7 +5,7 @@
 import * as z from "zod/v4-mini";
 import { remap as remap$ } from "../../lib/primitives.js";
 import * as types from "../../types/primitives.js";
-import { ComposeMarketError } from "./compose-market-error.js";
+import { Error } from "./compose-market-error.js";
 
 export type LegacyErrorData = {
   error?: string | undefined;
@@ -19,7 +19,7 @@ export type LegacyErrorData = {
   [additionalProperties: string]: unknown;
 };
 
-export class LegacyError extends ComposeMarketError {
+export class LegacyError extends Error {
   error?: string | undefined;
   code?: string | undefined;
 

package/generated/x402/src/models/errors/payment-required-error.ts

@@ -6,7 +6,7 @@ import * as z from "zod/v4-mini";
 import { remap as remap$ } from "../../lib/primitives.js";
 import * as types from "../../types/primitives.js";
 import * as models from "../index.js";
-import { ComposeMarketError } from "./compose-market-error.js";
+import { Error } from "./compose-market-error.js";
 
 export type PaymentRequiredErrorData = {
   x402Version: 2;
@@ -20,7 +20,7 @@ export type PaymentRequiredErrorData = {
   rawResponse?: Response | undefined;
 };
 
-export class PaymentRequiredError extends ComposeMarketError {
+export class PaymentRequiredError extends Error {
   x402Version: 2;
   error?: string | undefined;
   resource: models.PaymentRequiredResource;

package/generated/x402/src/models/errors/response-validation-error.ts

@@ -3,10 +3,10 @@
  */
 
 import * as z from "zod/v4/core";
-import { ComposeMarketError } from "./compose-market-error.js";
+import { Error } from "./compose-market-error.js";
 import { formatZodError } from "./sdk-validation-error.js";
 
-export class ResponseValidationError extends ComposeMarketError {
+export class ResponseValidationError extends Error {
   /**
    * The raw value that failed validation.
    */

package/generated/x402/src/models/feedback-context.ts

@@ -31,7 +31,7 @@ export type SDK = {
 export type FeedbackContext = {
   requestId?: string | undefined;
   paymentIntentId?: string | undefined;
-  composeRunId?: string | undefined;
+  runId?: string | undefined;
   chainId?: number | undefined;
   modelId?: string | undefined;
   provider?: string | undefined;
@@ -150,7 +150,7 @@ export const FeedbackContext$inboundSchema: z.ZodMiniType<
 > = z.object({
   requestId: types.optional(types.string()),
   paymentIntentId: types.optional(types.string()),
-  composeRunId: types.optional(types.string()),
+  runId: types.optional(types.string()),
   chainId: types.optional(types.number()),
   modelId: types.optional(types.string()),
   provider: types.optional(types.string()),
@@ -164,7 +164,7 @@ export const FeedbackContext$inboundSchema: z.ZodMiniType<
 export type FeedbackContext$Outbound = {
   requestId?: string | undefined;
   paymentIntentId?: string | undefined;
-  composeRunId?: string | undefined;
+  runId?: string | undefined;
   chainId?: number | undefined;
   modelId?: string | undefined;
   provider?: string | undefined;
@@ -182,7 +182,7 @@ export const FeedbackContext$outboundSchema: z.ZodMiniType<
 > = z.object({
   requestId: z.optional(z.string()),
   paymentIntentId: z.optional(z.string()),
-  composeRunId: z.optional(z.string()),
+  runId: z.optional(z.string()),
   chainId: z.optional(z.int()),
   modelId: z.optional(z.string()),
   provider: z.optional(z.string()),

package/generated/x402/src/models/feedback-summary.ts

@@ -28,7 +28,7 @@ export type Ratings = {
 export type Verification = {
   anonymous: number;
   walletHeader: number;
-  composeKey: number;
+  key: number;
 };
 
 export type FeedbackSummary = {
@@ -83,7 +83,7 @@ export const Verification$inboundSchema: z.ZodMiniType<Verification, unknown> =
     z.transform((v) => {
       return remap$(v, {
         "wallet_header": "walletHeader",
-        "compose_key": "composeKey",
+        "compose_key": "key",
       });
     }),
   );

package/generated/x402/src/models/feedback-verification-kind.ts

@@ -9,7 +9,7 @@ import { OpenEnum } from "../types/enums.js";
 export const FeedbackVerificationKind = {
   Anonymous: "anonymous",
   WalletHeader: "wallet_header",
-  ComposeKey: "compose_key",
+  Key: "compose_key",
 } as const;
 export type FeedbackVerificationKind = OpenEnum<
   typeof FeedbackVerificationKind

package/generated/x402/src/models/operations/compose-keys-create.ts

@@ -10,13 +10,13 @@ import * as types from "../../types/primitives.js";
 import { SDKValidationError } from "../errors/sdk-validation-error.js";
 import * as models from "../index.js";
 
-export type ComposeKeysCreateRequest = {
+export type KeysCreateRequest = {
   xSessionUserAddress: string;
   xChainId: number;
-  body: models.ComposeKeyCreateRequest;
+  body: models.KeyCreateRequest;
 };
 
-export type ComposeKeysCreateResponse = {
+export type KeysCreateResponse = {
   /**
    * HTTP response content type for this operation
    */
@@ -32,25 +32,25 @@ export type ComposeKeysCreateResponse = {
   /**
    * Compose Key token, returned exactly once.
    */
-  composeKeyCreateResponse?: models.ComposeKeyCreateResponse | undefined;
+  keyCreateResponse?: models.KeyCreateResponse | undefined;
 };
 
 /** @internal */
-export type ComposeKeysCreateRequest$Outbound = {
+export type KeysCreateRequest$Outbound = {
   "x-session-user-address": string;
   "x-chain-id": number;
-  body: models.ComposeKeyCreateRequest$Outbound;
+  body: models.KeyCreateRequest$Outbound;
 };
 
 /** @internal */
-export const ComposeKeysCreateRequest$outboundSchema: z.ZodMiniType<
-  ComposeKeysCreateRequest$Outbound,
-  ComposeKeysCreateRequest
+export const KeysCreateRequest$outboundSchema: z.ZodMiniType<
+  KeysCreateRequest$Outbound,
+  KeysCreateRequest
 > = z.pipe(
   z.object({
     xSessionUserAddress: z.string(),
     xChainId: z.int(),
-    body: models.ComposeKeyCreateRequest$outboundSchema,
+    body: models.KeyCreateRequest$outboundSchema,
   }),
   z.transform((v) => {
     return remap$(v, {
@@ -60,25 +60,25 @@ export const ComposeKeysCreateRequest$outboundSchema: z.ZodMiniType<
   }),
 );
 
-export function composeKeysCreateRequestToJSON(
-  composeKeysCreateRequest: ComposeKeysCreateRequest,
+export function keysCreateRequestToJSON(
+  keysCreateRequest: KeysCreateRequest,
 ): string {
   return JSON.stringify(
-    ComposeKeysCreateRequest$outboundSchema.parse(composeKeysCreateRequest),
+    KeysCreateRequest$outboundSchema.parse(keysCreateRequest),
   );
 }
 
 /** @internal */
-export const ComposeKeysCreateResponse$inboundSchema: z.ZodMiniType<
-  ComposeKeysCreateResponse,
+export const KeysCreateResponse$inboundSchema: z.ZodMiniType<
+  KeysCreateResponse,
   unknown
 > = z.pipe(
   z.object({
     ContentType: types.string(),
     StatusCode: types.number(),
     RawResponse: z.custom<Response>(x => x instanceof Response),
-    ComposeKeyCreateResponse: types.optional(
-      models.ComposeKeyCreateResponse$inboundSchema,
+    KeyCreateResponse: types.optional(
+      models.KeyCreateResponse$inboundSchema,
     ),
   }),
   z.transform((v) => {
@@ -86,17 +86,17 @@ export const ComposeKeysCreateResponse$inboundSchema: z.ZodMiniType<
       "ContentType": "contentType",
       "StatusCode": "statusCode",
       "RawResponse": "rawResponse",
-      "ComposeKeyCreateResponse": "composeKeyCreateResponse",
+      "KeyCreateResponse": "keyCreateResponse",
     });
   }),
 );
 
-export function composeKeysCreateResponseFromJSON(
+export function keysCreateResponseFromJSON(
   jsonString: string,
-): SafeParseResult<ComposeKeysCreateResponse, SDKValidationError> {
+): SafeParseResult<KeysCreateResponse, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => ComposeKeysCreateResponse$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'ComposeKeysCreateResponse' from JSON`,
+    (x) => KeysCreateResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'KeysCreateResponse' from JSON`,
   );
 }

package/generated/x402/src/models/operations/compose-keys-get.ts

@@ -10,11 +10,11 @@ import * as types from "../../types/primitives.js";
 import { SDKValidationError } from "../errors/sdk-validation-error.js";
 import * as models from "../index.js";
 
-export type ComposeKeysGetRequest = {
+export type KeysGetRequest = {
   keyId: string;
 };
 
-export type ComposeKeysGetResponse = {
+export type KeysGetResponse = {
   /**
    * HTTP response content type for this operation
    */
@@ -30,57 +30,57 @@ export type ComposeKeysGetResponse = {
   /**
    * Key details.
    */
-  composeKeyRecord?: models.ComposeKeyRecord | undefined;
+  keyRecord?: models.KeyRecord | undefined;
 };
 
 /** @internal */
-export type ComposeKeysGetRequest$Outbound = {
+export type KeysGetRequest$Outbound = {
   keyId: string;
 };
 
 /** @internal */
-export const ComposeKeysGetRequest$outboundSchema: z.ZodMiniType<
-  ComposeKeysGetRequest$Outbound,
-  ComposeKeysGetRequest
+export const KeysGetRequest$outboundSchema: z.ZodMiniType<
+  KeysGetRequest$Outbound,
+  KeysGetRequest
 > = z.object({
   keyId: z.string(),
 });
 
-export function composeKeysGetRequestToJSON(
-  composeKeysGetRequest: ComposeKeysGetRequest,
+export function keysGetRequestToJSON(
+  keysGetRequest: KeysGetRequest,
 ): string {
   return JSON.stringify(
-    ComposeKeysGetRequest$outboundSchema.parse(composeKeysGetRequest),
+    KeysGetRequest$outboundSchema.parse(keysGetRequest),
   );
 }
 
 /** @internal */
-export const ComposeKeysGetResponse$inboundSchema: z.ZodMiniType<
-  ComposeKeysGetResponse,
+export const KeysGetResponse$inboundSchema: z.ZodMiniType<
+  KeysGetResponse,
   unknown
 > = z.pipe(
   z.object({
     ContentType: types.string(),
     StatusCode: types.number(),
     RawResponse: z.custom<Response>(x => x instanceof Response),
-    ComposeKeyRecord: types.optional(models.ComposeKeyRecord$inboundSchema),
+    KeyRecord: types.optional(models.KeyRecord$inboundSchema),
   }),
   z.transform((v) => {
     return remap$(v, {
       "ContentType": "contentType",
       "StatusCode": "statusCode",
       "RawResponse": "rawResponse",
-      "ComposeKeyRecord": "composeKeyRecord",
+      "KeyRecord": "keyRecord",
     });
   }),
 );
 
-export function composeKeysGetResponseFromJSON(
+export function keysGetResponseFromJSON(
   jsonString: string,
-): SafeParseResult<ComposeKeysGetResponse, SDKValidationError> {
+): SafeParseResult<KeysGetResponse, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => ComposeKeysGetResponse$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'ComposeKeysGetResponse' from JSON`,
+    (x) => KeysGetResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'KeysGetResponse' from JSON`,
   );
 }