@compose-market/sdk 0.7.13 → 0.8.1

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`,
   );
 }

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

@@ -10,7 +10,7 @@ import * as types from "../../types/primitives.js";
 import { SDKValidationError } from "../errors/sdk-validation-error.js";
 import * as models from "../index.js";
 
-export type ComposeKeysListRequest = {
+export type KeysListRequest = {
   xSessionUserAddress: string;
   xChainId: number;
 };
@@ -18,11 +18,11 @@ export type ComposeKeysListRequest = {
 /**
  * Keys owned by the wallet.
  */
-export type ComposeKeysListResponseBody = {
-  keys: Array<models.ComposeKeyRecord>;
+export type KeysListResponseBody = {
+  keys: Array<models.KeyRecord>;
 };
 
-export type ComposeKeysListResponse = {
+export type KeysListResponse = {
   /**
    * HTTP response content type for this operation
    */
@@ -38,19 +38,19 @@ export type ComposeKeysListResponse = {
   /**
    * Keys owned by the wallet.
    */
-  object?: ComposeKeysListResponseBody | undefined;
+  object?: KeysListResponseBody | undefined;
 };
 
 /** @internal */
-export type ComposeKeysListRequest$Outbound = {
+export type KeysListRequest$Outbound = {
   "x-session-user-address": string;
   "x-chain-id": number;
 };
 
 /** @internal */
-export const ComposeKeysListRequest$outboundSchema: z.ZodMiniType<
-  ComposeKeysListRequest$Outbound,
-  ComposeKeysListRequest
+export const KeysListRequest$outboundSchema: z.ZodMiniType<
+  KeysListRequest$Outbound,
+  KeysListRequest
 > = z.pipe(
   z.object({
     xSessionUserAddress: z.string(),
@@ -64,35 +64,35 @@ export const ComposeKeysListRequest$outboundSchema: z.ZodMiniType<
   }),
 );
 
-export function composeKeysListRequestToJSON(
-  composeKeysListRequest: ComposeKeysListRequest,
+export function keysListRequestToJSON(
+  keysListRequest: KeysListRequest,
 ): string {
   return JSON.stringify(
-    ComposeKeysListRequest$outboundSchema.parse(composeKeysListRequest),
+    KeysListRequest$outboundSchema.parse(keysListRequest),
   );
 }
 
 /** @internal */
-export const ComposeKeysListResponseBody$inboundSchema: z.ZodMiniType<
-  ComposeKeysListResponseBody,
+export const KeysListResponseBody$inboundSchema: z.ZodMiniType<
+  KeysListResponseBody,
   unknown
 > = z.object({
-  keys: z.array(models.ComposeKeyRecord$inboundSchema),
+  keys: z.array(models.KeyRecord$inboundSchema),
 });
 
-export function composeKeysListResponseBodyFromJSON(
+export function keysListResponseBodyFromJSON(
   jsonString: string,
-): SafeParseResult<ComposeKeysListResponseBody, SDKValidationError> {
+): SafeParseResult<KeysListResponseBody, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => ComposeKeysListResponseBody$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'ComposeKeysListResponseBody' from JSON`,
+    (x) => KeysListResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'KeysListResponseBody' from JSON`,
   );
 }
 
 /** @internal */
-export const ComposeKeysListResponse$inboundSchema: z.ZodMiniType<
-  ComposeKeysListResponse,
+export const KeysListResponse$inboundSchema: z.ZodMiniType<
+  KeysListResponse,
   unknown
 > = z.pipe(
   z.object({
@@ -100,7 +100,7 @@ export const ComposeKeysListResponse$inboundSchema: z.ZodMiniType<
     StatusCode: types.number(),
     RawResponse: z.custom<Response>(x => x instanceof Response),
     object: types.optional(
-      z.lazy(() => ComposeKeysListResponseBody$inboundSchema),
+      z.lazy(() => KeysListResponseBody$inboundSchema),
     ),
   }),
   z.transform((v) => {
@@ -112,12 +112,12 @@ export const ComposeKeysListResponse$inboundSchema: z.ZodMiniType<
   }),
 );
 
-export function composeKeysListResponseFromJSON(
+export function keysListResponseFromJSON(
   jsonString: string,
-): SafeParseResult<ComposeKeysListResponse, SDKValidationError> {
+): SafeParseResult<KeysListResponse, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => ComposeKeysListResponse$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'ComposeKeysListResponse' from JSON`,
+    (x) => KeysListResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'KeysListResponse' from JSON`,
   );
 }

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

@@ -9,19 +9,19 @@ import { Result as SafeParseResult } from "../../types/fp.js";
 import * as types from "../../types/primitives.js";
 import { SDKValidationError } from "../errors/sdk-validation-error.js";
 
-export type ComposeKeysRevokeRequest = {
+export type KeysRevokeRequest = {
   keyId: string;
 };
 
 /**
  * Revocation result.
  */
-export type ComposeKeysRevokeResponseBody = {
+export type KeysRevokeResponseBody = {
   success: boolean;
   keyId: string;
 };
 
-export type ComposeKeysRevokeResponse = {
+export type KeysRevokeResponse = {
   /**
    * HTTP response content type for this operation
    */
@@ -37,52 +37,52 @@ export type ComposeKeysRevokeResponse = {
   /**
    * Revocation result.
    */
-  object?: ComposeKeysRevokeResponseBody | undefined;
+  object?: KeysRevokeResponseBody | undefined;
 };
 
 /** @internal */
-export type ComposeKeysRevokeRequest$Outbound = {
+export type KeysRevokeRequest$Outbound = {
   keyId: string;
 };
 
 /** @internal */
-export const ComposeKeysRevokeRequest$outboundSchema: z.ZodMiniType<
-  ComposeKeysRevokeRequest$Outbound,
-  ComposeKeysRevokeRequest
+export const KeysRevokeRequest$outboundSchema: z.ZodMiniType<
+  KeysRevokeRequest$Outbound,
+  KeysRevokeRequest
 > = z.object({
   keyId: z.string(),
 });
 
-export function composeKeysRevokeRequestToJSON(
-  composeKeysRevokeRequest: ComposeKeysRevokeRequest,
+export function keysRevokeRequestToJSON(
+  keysRevokeRequest: KeysRevokeRequest,
 ): string {
   return JSON.stringify(
-    ComposeKeysRevokeRequest$outboundSchema.parse(composeKeysRevokeRequest),
+    KeysRevokeRequest$outboundSchema.parse(keysRevokeRequest),
   );
 }
 
 /** @internal */
-export const ComposeKeysRevokeResponseBody$inboundSchema: z.ZodMiniType<
-  ComposeKeysRevokeResponseBody,
+export const KeysRevokeResponseBody$inboundSchema: z.ZodMiniType<
+  KeysRevokeResponseBody,
   unknown
 > = z.object({
   success: types.boolean(),
   keyId: types.string(),
 });
 
-export function composeKeysRevokeResponseBodyFromJSON(
+export function keysRevokeResponseBodyFromJSON(
   jsonString: string,
-): SafeParseResult<ComposeKeysRevokeResponseBody, SDKValidationError> {
+): SafeParseResult<KeysRevokeResponseBody, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => ComposeKeysRevokeResponseBody$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'ComposeKeysRevokeResponseBody' from JSON`,
+    (x) => KeysRevokeResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'KeysRevokeResponseBody' from JSON`,
   );
 }
 
 /** @internal */
-export const ComposeKeysRevokeResponse$inboundSchema: z.ZodMiniType<
-  ComposeKeysRevokeResponse,
+export const KeysRevokeResponse$inboundSchema: z.ZodMiniType<
+  KeysRevokeResponse,
   unknown
 > = z.pipe(
   z.object({
@@ -90,7 +90,7 @@ export const ComposeKeysRevokeResponse$inboundSchema: z.ZodMiniType<
     StatusCode: types.number(),
     RawResponse: z.custom<Response>(x => x instanceof Response),
     object: types.optional(
-      z.lazy(() => ComposeKeysRevokeResponseBody$inboundSchema),
+      z.lazy(() => KeysRevokeResponseBody$inboundSchema),
     ),
   }),
   z.transform((v) => {
@@ -102,12 +102,12 @@ export const ComposeKeysRevokeResponse$inboundSchema: z.ZodMiniType<
   }),
 );
 
-export function composeKeysRevokeResponseFromJSON(
+export function keysRevokeResponseFromJSON(
   jsonString: string,
-): SafeParseResult<ComposeKeysRevokeResponse, SDKValidationError> {
+): SafeParseResult<KeysRevokeResponse, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => ComposeKeysRevokeResponse$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'ComposeKeysRevokeResponse' from JSON`,
+    (x) => KeysRevokeResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'KeysRevokeResponse' from JSON`,
   );
 }

package/generated/x402/src/models/operations/payments-prepare.ts

@@ -11,7 +11,7 @@ import { SDKValidationError } from "../errors/sdk-validation-error.js";
 import * as models from "../index.js";
 
 export type PaymentsPrepareSecurity = {
-  composeKeyAuth?: string | undefined;
+  keyAuth?: string | undefined;
   x402Payment?: string | undefined;
 };
 
@@ -44,7 +44,7 @@ export type PaymentsPrepareResponse = {
 
 /** @internal */
 export type PaymentsPrepareSecurity$Outbound = {
-  ComposeKeyAuth?: string | undefined;
+  KeyAuth?: string | undefined;
   X402Payment?: string | undefined;
 };
 
@@ -54,12 +54,12 @@ export const PaymentsPrepareSecurity$outboundSchema: z.ZodMiniType<
   PaymentsPrepareSecurity
 > = z.pipe(
   z.object({
-    composeKeyAuth: z.optional(z.string()),
+    keyAuth: z.optional(z.string()),
     x402Payment: z.optional(z.string()),
   }),
   z.transform((v) => {
     return remap$(v, {
-      composeKeyAuth: "ComposeKeyAuth",
+      keyAuth: "KeyAuth",
       x402Payment: "X402Payment",
     });
   }),

package/generated/x402/src/models/payment-prepare-request.ts

@@ -19,7 +19,7 @@ export type PaymentPrepareRequest = {
    */
   maxAmountWei?: string | undefined;
   meter?: MeteredInput | undefined;
-  composeRunId?: string | undefined;
+  runId?: string | undefined;
   idempotencyKey?: string | undefined;
 };
 
@@ -31,7 +31,7 @@ export type PaymentPrepareRequest$Outbound = {
   method: string;
   maxAmountWei?: string | undefined;
   meter?: MeteredInput$Outbound | undefined;
-  composeRunId?: string | undefined;
+  runId?: string | undefined;
   idempotencyKey?: string | undefined;
 };
 
@@ -46,7 +46,7 @@ export const PaymentPrepareRequest$outboundSchema: z.ZodMiniType<
   method: z.string(),
   maxAmountWei: z.optional(z.string()),
   meter: z.optional(MeteredInput$outboundSchema),
-  composeRunId: z.optional(z.string()),
+  runId: z.optional(z.string()),
   idempotencyKey: z.optional(z.string()),
 });
 

package/generated/x402/src/models/security.ts

@@ -6,12 +6,12 @@ import * as z from "zod/v4-mini";
 import { remap as remap$ } from "../lib/primitives.js";
 
 export type Security = {
-  composeKeyAuth?: string | undefined;
+  keyAuth?: string | undefined;
 };
 
 /** @internal */
 export type Security$Outbound = {
-  ComposeKeyAuth?: string | undefined;
+  KeyAuth?: string | undefined;
 };
 
 /** @internal */
@@ -20,11 +20,11 @@ export const Security$outboundSchema: z.ZodMiniType<
   Security
 > = z.pipe(
   z.object({
-    composeKeyAuth: z.optional(z.string()),
+    keyAuth: z.optional(z.string()),
   }),
   z.transform((v) => {
     return remap$(v, {
-      composeKeyAuth: "ComposeKeyAuth",
+      keyAuth: "KeyAuth",
     });
   }),
 );

package/generated/x402/src/sdk/compose-keys.ts

@@ -2,22 +2,22 @@
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
  */
 
-import { composeKeysCreate } from "../funcs/compose-keys-create.js";
-import { composeKeysGet } from "../funcs/compose-keys-get.js";
-import { composeKeysList } from "../funcs/compose-keys-list.js";
-import { composeKeysRevoke } from "../funcs/compose-keys-revoke.js";
-import { composeKeysSessionEventsSubscribe } from "../funcs/compose-keys-session-events-subscribe.js";
-import { composeKeysSessionGetActive } from "../funcs/compose-keys-session-get-active.js";
+import { keysCreate } from "../funcs/compose-keys-create.js";
+import { keysGet } from "../funcs/compose-keys-get.js";
+import { keysList } from "../funcs/compose-keys-list.js";
+import { keysRevoke } from "../funcs/compose-keys-revoke.js";
+import { keysSessionEventsSubscribe } from "../funcs/compose-keys-session-events-subscribe.js";
+import { keysSessionGetActive } from "../funcs/compose-keys-session-get-active.js";
 import { ClientSDK, RequestOptions } from "../lib/sdks.js";
 import * as operations from "../models/operations/index.js";
 import { unwrapAsync } from "../types/fp.js";
 
-export class ComposeKeys extends ClientSDK {
+export class Keys extends ClientSDK {
   async sessionGetActive(
     request: operations.SessionGetActiveRequest,
     options?: RequestOptions,
   ): Promise<operations.SessionGetActiveResponse> {
-    return unwrapAsync(composeKeysSessionGetActive(
+    return unwrapAsync(keysSessionGetActive(
       this,
       request,
       options,
@@ -28,7 +28,7 @@ export class ComposeKeys extends ClientSDK {
     request: operations.SessionEventsSubscribeRequest,
     options?: RequestOptions,
   ): Promise<operations.SessionEventsSubscribeResponse> {
-    return unwrapAsync(composeKeysSessionEventsSubscribe(
+    return unwrapAsync(keysSessionEventsSubscribe(
       this,
       request,
       options,
@@ -36,10 +36,10 @@ export class ComposeKeys extends ClientSDK {
   }
 
   async create(
-    request: operations.ComposeKeysCreateRequest,
+    request: operations.KeysCreateRequest,
     options?: RequestOptions,
-  ): Promise<operations.ComposeKeysCreateResponse> {
-    return unwrapAsync(composeKeysCreate(
+  ): Promise<operations.KeysCreateResponse> {
+    return unwrapAsync(keysCreate(
       this,
       request,
       options,
@@ -47,10 +47,10 @@ export class ComposeKeys extends ClientSDK {
   }
 
   async list(
-    request: operations.ComposeKeysListRequest,
+    request: operations.KeysListRequest,
     options?: RequestOptions,
-  ): Promise<operations.ComposeKeysListResponse> {
-    return unwrapAsync(composeKeysList(
+  ): Promise<operations.KeysListResponse> {
+    return unwrapAsync(keysList(
       this,
       request,
       options,
@@ -58,10 +58,10 @@ export class ComposeKeys extends ClientSDK {
   }
 
   async get(
-    request: operations.ComposeKeysGetRequest,
+    request: operations.KeysGetRequest,
     options?: RequestOptions,
-  ): Promise<operations.ComposeKeysGetResponse> {
-    return unwrapAsync(composeKeysGet(
+  ): Promise<operations.KeysGetResponse> {
+    return unwrapAsync(keysGet(
       this,
       request,
       options,
@@ -69,10 +69,10 @@ export class ComposeKeys extends ClientSDK {
   }
 
   async revoke(
-    request: operations.ComposeKeysRevokeRequest,
+    request: operations.KeysRevokeRequest,
     options?: RequestOptions,
-  ): Promise<operations.ComposeKeysRevokeResponse> {
-    return unwrapAsync(composeKeysRevoke(
+  ): Promise<operations.KeysRevokeResponse> {
+    return unwrapAsync(keysRevoke(
       this,
       request,
       options,

package/generated/x402/src/sdk/sdk.ts

@@ -3,7 +3,7 @@
  */
 
 import { ClientSDK } from "../lib/sdks.js";
-import { ComposeKeys } from "./compose-keys.js";
+import { Keys } from "./compose-keys.js";
 import { Feedback } from "./feedback.js";
 import { Health } from "./health.js";
 import { Payments } from "./payments.js";
@@ -20,9 +20,9 @@ export class ComposeMarket extends ClientSDK {
     return (this._x402 ??= new X402(this._options));
   }
 
-  private _composeKeys?: ComposeKeys;
-  get composeKeys(): ComposeKeys {
-    return (this._composeKeys ??= new ComposeKeys(this._options));
+  private _keys?: Keys;
+  get keys(): Keys {
+    return (this._keys ??= new Keys(this._options));
   }
 
   private _payments?: Payments;