@gr4vy/sdk 0.18.16 → 0.18.17

package/bin/mcp-server.js

@@ -4026,9 +4026,9 @@ var init_config = __esm(() => {
   SDK_METADATA = {
     language: "typescript",
     openapiDocVersion: "1.0.0",
-    sdkVersion: "0.18.16",
-    genVersion: "2.593.4",
-    userAgent: "speakeasy-sdk/typescript 0.18.16 2.593.4 1.0.0 @gr4vy/sdk"
+    sdkVersion: "0.18.17",
+    genVersion: "2.597.9",
+    userAgent: "speakeasy-sdk/typescript 0.18.17 2.597.9 1.0.0 @gr4vy/sdk"
   };
 });
 
@@ -34828,26 +34828,22 @@ class ClientSDK {
     }
     cookie = cookie.startsWith("; ") ? cookie.slice(2) : cookie;
     headers.set("cookie", cookie);
-    const userHeaders = new Headers(options?.fetchOptions?.headers);
+    const userHeaders = new Headers(options?.headers ?? options?.fetchOptions?.headers);
     for (const [k2, v2] of userHeaders) {
       headers.set(k2, v2);
     }
     if (!isBrowserLike) {
       headers.set(conf.uaHeader ?? "user-agent", SDK_METADATA.userAgent);
     }
-    let fetchOptions = options?.fetchOptions;
+    const fetchOptions = {
+      ...options?.fetchOptions,
+      ...options
+    };
     if (!fetchOptions?.signal && conf.timeoutMs && conf.timeoutMs > 0) {
       const timeoutSignal = AbortSignal.timeout(conf.timeoutMs);
-      if (!fetchOptions) {
-        fetchOptions = { signal: timeoutSignal };
-      } else {
-        fetchOptions.signal = timeoutSignal;
-      }
+      fetchOptions.signal = timeoutSignal;
     }
     if (conf.body instanceof ReadableStream) {
-      if (!fetchOptions) {
-        fetchOptions = {};
-      }
       Object.assign(fetchOptions, { duplex: "half" });
     }
     let input;
@@ -39236,6 +39232,465 @@ var init_collectionpaymentmethod = __esm(() => {
   })(CollectionPaymentMethod$ ||= {});
 });
 
+// src/models/components/field.ts
+var Field$inboundSchema, Field$outboundSchema, Field$;
+var init_field = __esm(() => {
+  init_lib();
+  Field$inboundSchema = objectType({
+    key: stringType(),
+    value: stringType()
+  });
+  Field$outboundSchema = objectType({
+    key: stringType(),
+    value: stringType()
+  });
+  ((Field$) => {
+    Field$.inboundSchema = Field$inboundSchema;
+    Field$.outboundSchema = Field$outboundSchema;
+  })(Field$ ||= {});
+});
+
+// src/models/components/merchantprofileschemesummary.ts
+var MerchantProfileSchemeSummary$inboundSchema, MerchantProfileSchemeSummary$outboundSchema, MerchantProfileSchemeSummary$;
+var init_merchantprofileschemesummary = __esm(() => {
+  init_lib();
+  init_primitives();
+  MerchantProfileSchemeSummary$inboundSchema = objectType({
+    merchant_acquirer_bin: stringType(),
+    merchant_url: stringType(),
+    merchant_acquirer_id: stringType(),
+    merchant_name: stringType(),
+    merchant_country_code: stringType(),
+    merchant_category_code: stringType(),
+    created_at: stringType().datetime({ offset: true }).transform((v2) => new Date(v2))
+  }).transform((v2) => {
+    return remap(v2, {
+      merchant_acquirer_bin: "merchantAcquirerBin",
+      merchant_url: "merchantUrl",
+      merchant_acquirer_id: "merchantAcquirerId",
+      merchant_name: "merchantName",
+      merchant_country_code: "merchantCountryCode",
+      merchant_category_code: "merchantCategoryCode",
+      created_at: "createdAt"
+    });
+  });
+  MerchantProfileSchemeSummary$outboundSchema = objectType({
+    merchantAcquirerBin: stringType(),
+    merchantUrl: stringType(),
+    merchantAcquirerId: stringType(),
+    merchantName: stringType(),
+    merchantCountryCode: stringType(),
+    merchantCategoryCode: stringType(),
+    createdAt: dateType().transform((v2) => v2.toISOString())
+  }).transform((v2) => {
+    return remap(v2, {
+      merchantAcquirerBin: "merchant_acquirer_bin",
+      merchantUrl: "merchant_url",
+      merchantAcquirerId: "merchant_acquirer_id",
+      merchantName: "merchant_name",
+      merchantCountryCode: "merchant_country_code",
+      merchantCategoryCode: "merchant_category_code",
+      createdAt: "created_at"
+    });
+  });
+  ((MerchantProfileSchemeSummary$) => {
+    MerchantProfileSchemeSummary$.inboundSchema = MerchantProfileSchemeSummary$inboundSchema;
+    MerchantProfileSchemeSummary$.outboundSchema = MerchantProfileSchemeSummary$outboundSchema;
+  })(MerchantProfileSchemeSummary$ ||= {});
+});
+
+// src/models/components/paymentservicestatus.ts
+var PaymentServiceStatus, PaymentServiceStatus$inboundSchema, PaymentServiceStatus$outboundSchema, PaymentServiceStatus$;
+var init_paymentservicestatus = __esm(() => {
+  init_lib();
+  PaymentServiceStatus = {
+    Pending: "pending",
+    Created: "created",
+    Failed: "failed"
+  };
+  PaymentServiceStatus$inboundSchema = unionType([
+    nativeEnumType(PaymentServiceStatus),
+    stringType().transform(catchUnrecognizedEnum)
+  ]);
+  PaymentServiceStatus$outboundSchema = unionType([
+    nativeEnumType(PaymentServiceStatus),
+    stringType().and(custom())
+  ]);
+  ((PaymentServiceStatus$) => {
+    PaymentServiceStatus$.inboundSchema = PaymentServiceStatus$inboundSchema;
+    PaymentServiceStatus$.outboundSchema = PaymentServiceStatus$outboundSchema;
+  })(PaymentServiceStatus$ ||= {});
+});
+
+// src/models/components/paymentservice.ts
+var PaymentService$inboundSchema, PaymentService$outboundSchema, PaymentService$;
+var init_paymentservice = __esm(() => {
+  init_lib();
+  init_primitives();
+  init_field();
+  init_merchantprofileschemesummary();
+  init_method();
+  init_paymentservicestatus();
+  PaymentService$inboundSchema = objectType({
+    type: literalType("payment-service").default("payment-service"),
+    id: stringType().default("The ID of the payment service"),
+    merchant_account_id: stringType(),
+    payment_service_definition_id: stringType(),
+    active: booleanType().default(true),
+    method: Method$inboundSchema,
+    display_name: stringType(),
+    position: numberType().int(),
+    status: PaymentServiceStatus$inboundSchema.optional(),
+    accepted_currencies: arrayType(stringType()),
+    accepted_countries: arrayType(stringType()),
+    payment_method_tokenization_enabled: booleanType(),
+    network_tokens_enabled: booleanType(),
+    open_loop: booleanType(),
+    settlement_reporting_enabled: booleanType(),
+    three_d_secure_enabled: nullableType(booleanType()).optional(),
+    merchant_profile: nullableType(recordType(nullableType(MerchantProfileSchemeSummary$inboundSchema))).optional(),
+    webhook_url: nullableType(stringType()).optional(),
+    fields: nullableType(arrayType(Field$inboundSchema)).optional(),
+    reporting_fields: nullableType(arrayType(Field$inboundSchema)).optional(),
+    is_deleted: booleanType().default(false),
+    created_at: stringType().datetime({ offset: true }).transform((v2) => new Date(v2)),
+    updated_at: stringType().datetime({ offset: true }).transform((v2) => new Date(v2))
+  }).transform((v2) => {
+    return remap(v2, {
+      merchant_account_id: "merchantAccountId",
+      payment_service_definition_id: "paymentServiceDefinitionId",
+      display_name: "displayName",
+      accepted_currencies: "acceptedCurrencies",
+      accepted_countries: "acceptedCountries",
+      payment_method_tokenization_enabled: "paymentMethodTokenizationEnabled",
+      network_tokens_enabled: "networkTokensEnabled",
+      open_loop: "openLoop",
+      settlement_reporting_enabled: "settlementReportingEnabled",
+      three_d_secure_enabled: "threeDSecureEnabled",
+      merchant_profile: "merchantProfile",
+      webhook_url: "webhookUrl",
+      reporting_fields: "reportingFields",
+      is_deleted: "isDeleted",
+      created_at: "createdAt",
+      updated_at: "updatedAt"
+    });
+  });
+  PaymentService$outboundSchema = objectType({
+    type: literalType("payment-service").default("payment-service"),
+    id: stringType().default("The ID of the payment service"),
+    merchantAccountId: stringType(),
+    paymentServiceDefinitionId: stringType(),
+    active: booleanType().default(true),
+    method: Method$outboundSchema,
+    displayName: stringType(),
+    position: numberType().int(),
+    status: PaymentServiceStatus$outboundSchema.optional(),
+    acceptedCurrencies: arrayType(stringType()),
+    acceptedCountries: arrayType(stringType()),
+    paymentMethodTokenizationEnabled: booleanType(),
+    networkTokensEnabled: booleanType(),
+    openLoop: booleanType(),
+    settlementReportingEnabled: booleanType(),
+    threeDSecureEnabled: nullableType(booleanType()).optional(),
+    merchantProfile: nullableType(recordType(nullableType(MerchantProfileSchemeSummary$outboundSchema))).optional(),
+    webhookUrl: nullableType(stringType()).optional(),
+    fields: nullableType(arrayType(Field$outboundSchema)).optional(),
+    reportingFields: nullableType(arrayType(Field$outboundSchema)).optional(),
+    isDeleted: booleanType().default(false),
+    createdAt: dateType().transform((v2) => v2.toISOString()),
+    updatedAt: dateType().transform((v2) => v2.toISOString())
+  }).transform((v2) => {
+    return remap(v2, {
+      merchantAccountId: "merchant_account_id",
+      paymentServiceDefinitionId: "payment_service_definition_id",
+      displayName: "display_name",
+      acceptedCurrencies: "accepted_currencies",
+      acceptedCountries: "accepted_countries",
+      paymentMethodTokenizationEnabled: "payment_method_tokenization_enabled",
+      networkTokensEnabled: "network_tokens_enabled",
+      openLoop: "open_loop",
+      settlementReportingEnabled: "settlement_reporting_enabled",
+      threeDSecureEnabled: "three_d_secure_enabled",
+      merchantProfile: "merchant_profile",
+      webhookUrl: "webhook_url",
+      reportingFields: "reporting_fields",
+      isDeleted: "is_deleted",
+      createdAt: "created_at",
+      updatedAt: "updated_at"
+    });
+  });
+  ((PaymentService$) => {
+    PaymentService$.inboundSchema = PaymentService$inboundSchema;
+    PaymentService$.outboundSchema = PaymentService$outboundSchema;
+  })(PaymentService$ ||= {});
+});
+
+// src/models/components/collectionpaymentservice.ts
+var CollectionPaymentService$inboundSchema, CollectionPaymentService$outboundSchema, CollectionPaymentService$;
+var init_collectionpaymentservice = __esm(() => {
+  init_lib();
+  init_primitives();
+  init_paymentservice();
+  CollectionPaymentService$inboundSchema = objectType({
+    items: arrayType(PaymentService$inboundSchema),
+    limit: numberType().int().default(20),
+    next_cursor: nullableType(stringType()).optional(),
+    previous_cursor: nullableType(stringType()).optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      next_cursor: "nextCursor",
+      previous_cursor: "previousCursor"
+    });
+  });
+  CollectionPaymentService$outboundSchema = objectType({
+    items: arrayType(PaymentService$outboundSchema),
+    limit: numberType().int().default(20),
+    nextCursor: nullableType(stringType()).optional(),
+    previousCursor: nullableType(stringType()).optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      nextCursor: "next_cursor",
+      previousCursor: "previous_cursor"
+    });
+  });
+  ((CollectionPaymentService$) => {
+    CollectionPaymentService$.inboundSchema = CollectionPaymentService$inboundSchema;
+    CollectionPaymentService$.outboundSchema = CollectionPaymentService$outboundSchema;
+  })(CollectionPaymentService$ ||= {});
+});
+
+// src/models/components/definitionfieldformat.ts
+var DefinitionFieldFormat, DefinitionFieldFormat$inboundSchema, DefinitionFieldFormat$outboundSchema, DefinitionFieldFormat$;
+var init_definitionfieldformat = __esm(() => {
+  init_lib();
+  DefinitionFieldFormat = {
+    Text: "text",
+    Multiline: "multiline",
+    Number: "number",
+    Timezone: "timezone",
+    Boolean: "boolean"
+  };
+  DefinitionFieldFormat$inboundSchema = unionType([
+    nativeEnumType(DefinitionFieldFormat),
+    stringType().transform(catchUnrecognizedEnum)
+  ]);
+  DefinitionFieldFormat$outboundSchema = unionType([
+    nativeEnumType(DefinitionFieldFormat),
+    stringType().and(custom())
+  ]);
+  ((DefinitionFieldFormat$) => {
+    DefinitionFieldFormat$.inboundSchema = DefinitionFieldFormat$inboundSchema;
+    DefinitionFieldFormat$.outboundSchema = DefinitionFieldFormat$outboundSchema;
+  })(DefinitionFieldFormat$ ||= {});
+});
+
+// src/models/components/definitionfield.ts
+var DefinitionField$inboundSchema, DefinitionField$outboundSchema, DefinitionField$;
+var init_definitionfield = __esm(() => {
+  init_lib();
+  init_primitives();
+  init_definitionfieldformat();
+  DefinitionField$inboundSchema = objectType({
+    key: stringType(),
+    display_name: stringType(),
+    required: booleanType(),
+    format: DefinitionFieldFormat$inboundSchema,
+    secret: booleanType()
+  }).transform((v2) => {
+    return remap(v2, {
+      display_name: "displayName"
+    });
+  });
+  DefinitionField$outboundSchema = objectType({
+    key: stringType(),
+    displayName: stringType(),
+    required: booleanType(),
+    format: DefinitionFieldFormat$outboundSchema,
+    secret: booleanType()
+  }).transform((v2) => {
+    return remap(v2, {
+      displayName: "display_name"
+    });
+  });
+  ((DefinitionField$) => {
+    DefinitionField$.inboundSchema = DefinitionField$inboundSchema;
+    DefinitionField$.outboundSchema = DefinitionField$outboundSchema;
+  })(DefinitionField$ ||= {});
+});
+
+// src/models/components/paymentserviceconfiguration.ts
+var PaymentServiceConfiguration$inboundSchema, PaymentServiceConfiguration$outboundSchema, PaymentServiceConfiguration$;
+var init_paymentserviceconfiguration = __esm(() => {
+  init_lib();
+  init_primitives();
+  init_approvaltarget();
+  PaymentServiceConfiguration$inboundSchema = objectType({
+    approval_ui_target: ApprovalTarget$inboundSchema,
+    approval_ui_height: stringType(),
+    approval_ui_width: stringType(),
+    cart_items_limit: numberType().int(),
+    cart_items_required: booleanType(),
+    cart_items_should_match_amount: booleanType()
+  }).transform((v2) => {
+    return remap(v2, {
+      approval_ui_target: "approvalUiTarget",
+      approval_ui_height: "approvalUiHeight",
+      approval_ui_width: "approvalUiWidth",
+      cart_items_limit: "cartItemsLimit",
+      cart_items_required: "cartItemsRequired",
+      cart_items_should_match_amount: "cartItemsShouldMatchAmount"
+    });
+  });
+  PaymentServiceConfiguration$outboundSchema = objectType({
+    approvalUiTarget: ApprovalTarget$outboundSchema,
+    approvalUiHeight: stringType(),
+    approvalUiWidth: stringType(),
+    cartItemsLimit: numberType().int(),
+    cartItemsRequired: booleanType(),
+    cartItemsShouldMatchAmount: booleanType()
+  }).transform((v2) => {
+    return remap(v2, {
+      approvalUiTarget: "approval_ui_target",
+      approvalUiHeight: "approval_ui_height",
+      approvalUiWidth: "approval_ui_width",
+      cartItemsLimit: "cart_items_limit",
+      cartItemsRequired: "cart_items_required",
+      cartItemsShouldMatchAmount: "cart_items_should_match_amount"
+    });
+  });
+  ((PaymentServiceConfiguration$) => {
+    PaymentServiceConfiguration$.inboundSchema = PaymentServiceConfiguration$inboundSchema;
+    PaymentServiceConfiguration$.outboundSchema = PaymentServiceConfiguration$outboundSchema;
+  })(PaymentServiceConfiguration$ ||= {});
+});
+
+// src/models/components/requiredcheckoutfields.ts
+var RequiredCheckoutFields$inboundSchema, RequiredCheckoutFields$outboundSchema, RequiredCheckoutFields$;
+var init_requiredcheckoutfields = __esm(() => {
+  init_lib();
+  init_primitives();
+  RequiredCheckoutFields$inboundSchema = objectType({
+    required_fields: arrayType(stringType()),
+    conditions: nullableType(recordType(anyType())).optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      required_fields: "requiredFields"
+    });
+  });
+  RequiredCheckoutFields$outboundSchema = objectType({
+    requiredFields: arrayType(stringType()),
+    conditions: nullableType(recordType(anyType())).optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      requiredFields: "required_fields"
+    });
+  });
+  ((RequiredCheckoutFields$) => {
+    RequiredCheckoutFields$.inboundSchema = RequiredCheckoutFields$inboundSchema;
+    RequiredCheckoutFields$.outboundSchema = RequiredCheckoutFields$outboundSchema;
+  })(RequiredCheckoutFields$ ||= {});
+});
+
+// src/models/components/paymentservicedefinition.ts
+var PaymentServiceDefinition$inboundSchema, PaymentServiceDefinition$outboundSchema, PaymentServiceDefinition$;
+var init_paymentservicedefinition = __esm(() => {
+  init_lib();
+  init_primitives();
+  init_definitionfield();
+  init_method();
+  init_mode();
+  init_paymentserviceconfiguration();
+  init_requiredcheckoutfields();
+  PaymentServiceDefinition$inboundSchema = objectType({
+    id: stringType(),
+    type: literalType("payment-service-definition").default("payment-service-definition"),
+    display_name: stringType(),
+    method: Method$inboundSchema,
+    fields: arrayType(DefinitionField$inboundSchema),
+    reporting_fields: arrayType(DefinitionField$inboundSchema),
+    supported_currencies: arrayType(stringType()),
+    supported_countries: arrayType(stringType()),
+    mode: Mode$inboundSchema,
+    icon_url: nullableType(stringType()).optional(),
+    supported_features: recordType(booleanType()),
+    required_checkout_fields: arrayType(RequiredCheckoutFields$inboundSchema),
+    configuration: PaymentServiceConfiguration$inboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      display_name: "displayName",
+      reporting_fields: "reportingFields",
+      supported_currencies: "supportedCurrencies",
+      supported_countries: "supportedCountries",
+      icon_url: "iconUrl",
+      supported_features: "supportedFeatures",
+      required_checkout_fields: "requiredCheckoutFields"
+    });
+  });
+  PaymentServiceDefinition$outboundSchema = objectType({
+    id: stringType(),
+    type: literalType("payment-service-definition").default("payment-service-definition"),
+    displayName: stringType(),
+    method: Method$outboundSchema,
+    fields: arrayType(DefinitionField$outboundSchema),
+    reportingFields: arrayType(DefinitionField$outboundSchema),
+    supportedCurrencies: arrayType(stringType()),
+    supportedCountries: arrayType(stringType()),
+    mode: Mode$outboundSchema,
+    iconUrl: nullableType(stringType()).optional(),
+    supportedFeatures: recordType(booleanType()),
+    requiredCheckoutFields: arrayType(RequiredCheckoutFields$outboundSchema),
+    configuration: PaymentServiceConfiguration$outboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      displayName: "display_name",
+      reportingFields: "reporting_fields",
+      supportedCurrencies: "supported_currencies",
+      supportedCountries: "supported_countries",
+      iconUrl: "icon_url",
+      supportedFeatures: "supported_features",
+      requiredCheckoutFields: "required_checkout_fields"
+    });
+  });
+  ((PaymentServiceDefinition$) => {
+    PaymentServiceDefinition$.inboundSchema = PaymentServiceDefinition$inboundSchema;
+    PaymentServiceDefinition$.outboundSchema = PaymentServiceDefinition$outboundSchema;
+  })(PaymentServiceDefinition$ ||= {});
+});
+
+// src/models/components/collectionpaymentservicedefinition.ts
+var CollectionPaymentServiceDefinition$inboundSchema, CollectionPaymentServiceDefinition$outboundSchema, CollectionPaymentServiceDefinition$;
+var init_collectionpaymentservicedefinition = __esm(() => {
+  init_lib();
+  init_primitives();
+  init_paymentservicedefinition();
+  CollectionPaymentServiceDefinition$inboundSchema = objectType({
+    items: arrayType(PaymentServiceDefinition$inboundSchema),
+    limit: numberType().int().default(20),
+    next_cursor: nullableType(stringType()).optional(),
+    previous_cursor: nullableType(stringType()).optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      next_cursor: "nextCursor",
+      previous_cursor: "previousCursor"
+    });
+  });
+  CollectionPaymentServiceDefinition$outboundSchema = objectType({
+    items: arrayType(PaymentServiceDefinition$outboundSchema),
+    limit: numberType().int().default(20),
+    nextCursor: nullableType(stringType()).optional(),
+    previousCursor: nullableType(stringType()).optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      nextCursor: "next_cursor",
+      previousCursor: "previous_cursor"
+    });
+  });
+  ((CollectionPaymentServiceDefinition$) => {
+    CollectionPaymentServiceDefinition$.inboundSchema = CollectionPaymentServiceDefinition$inboundSchema;
+    CollectionPaymentServiceDefinition$.outboundSchema = CollectionPaymentServiceDefinition$outboundSchema;
+  })(CollectionPaymentServiceDefinition$ ||= {});
+});
+
 // src/models/components/payoutcategory.ts
 var PayoutCategory, PayoutCategory$inboundSchema, PayoutCategory$outboundSchema, PayoutCategory$;
 var init_payoutcategory = __esm(() => {
@@ -40035,6 +40490,64 @@ var init_connectionoptions = __esm(() => {
   })(ConnectionOptions$ ||= {});
 });
 
+// src/models/components/createsessionstatus.ts
+var CreateSessionStatus, CreateSessionStatus$inboundSchema, CreateSessionStatus$outboundSchema, CreateSessionStatus$;
+var init_createsessionstatus = __esm(() => {
+  init_lib();
+  CreateSessionStatus = {
+    Succeeded: "succeeded",
+    Failed: "failed"
+  };
+  CreateSessionStatus$inboundSchema = unionType([
+    nativeEnumType(CreateSessionStatus),
+    stringType().transform(catchUnrecognizedEnum)
+  ]);
+  CreateSessionStatus$outboundSchema = unionType([
+    nativeEnumType(CreateSessionStatus),
+    stringType().and(custom())
+  ]);
+  ((CreateSessionStatus$) => {
+    CreateSessionStatus$.inboundSchema = CreateSessionStatus$inboundSchema;
+    CreateSessionStatus$.outboundSchema = CreateSessionStatus$outboundSchema;
+  })(CreateSessionStatus$ ||= {});
+});
+
+// src/models/components/createsession.ts
+var CreateSession$inboundSchema, CreateSession$outboundSchema, CreateSession$;
+var init_createsession = __esm(() => {
+  init_lib();
+  init_primitives();
+  init_createsessionstatus();
+  CreateSession$inboundSchema = objectType({
+    type: literalType("payment-service-session").default("payment-service-session"),
+    status: CreateSessionStatus$inboundSchema,
+    code: nullableType(stringType()).optional(),
+    status_code: nullableType(numberType().int()).optional(),
+    response_body: nullableType(recordType(anyType())).optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      status_code: "statusCode",
+      response_body: "responseBody"
+    });
+  });
+  CreateSession$outboundSchema = objectType({
+    type: literalType("payment-service-session").default("payment-service-session"),
+    status: CreateSessionStatus$outboundSchema,
+    code: nullableType(stringType()).optional(),
+    statusCode: nullableType(numberType().int()).optional(),
+    responseBody: nullableType(recordType(anyType())).optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      statusCode: "status_code",
+      responseBody: "response_body"
+    });
+  });
+  ((CreateSession$) => {
+    CreateSession$.inboundSchema = CreateSession$inboundSchema;
+    CreateSession$.outboundSchema = CreateSession$outboundSchema;
+  })(CreateSession$ ||= {});
+});
+
 // src/models/components/cryptogram.ts
 var Cryptogram$inboundSchema, Cryptogram$outboundSchema, Cryptogram$;
 var init_cryptogram = __esm(() => {
@@ -40806,6 +41319,51 @@ var init_merchantaccountupdate = __esm(() => {
   })(MerchantAccountUpdate$ ||= {});
 });
 
+// src/models/components/merchantprofilescheme.ts
+var MerchantProfileScheme$inboundSchema, MerchantProfileScheme$outboundSchema, MerchantProfileScheme$;
+var init_merchantprofilescheme = __esm(() => {
+  init_lib();
+  init_primitives();
+  MerchantProfileScheme$inboundSchema = objectType({
+    merchant_acquirer_bin: stringType(),
+    merchant_url: stringType(),
+    merchant_acquirer_id: stringType(),
+    merchant_name: stringType(),
+    merchant_country_code: stringType(),
+    merchant_category_code: stringType()
+  }).transform((v2) => {
+    return remap(v2, {
+      merchant_acquirer_bin: "merchantAcquirerBin",
+      merchant_url: "merchantUrl",
+      merchant_acquirer_id: "merchantAcquirerId",
+      merchant_name: "merchantName",
+      merchant_country_code: "merchantCountryCode",
+      merchant_category_code: "merchantCategoryCode"
+    });
+  });
+  MerchantProfileScheme$outboundSchema = objectType({
+    merchantAcquirerBin: stringType(),
+    merchantUrl: stringType(),
+    merchantAcquirerId: stringType(),
+    merchantName: stringType(),
+    merchantCountryCode: stringType(),
+    merchantCategoryCode: stringType()
+  }).transform((v2) => {
+    return remap(v2, {
+      merchantAcquirerBin: "merchant_acquirer_bin",
+      merchantUrl: "merchant_url",
+      merchantAcquirerId: "merchant_acquirer_id",
+      merchantName: "merchant_name",
+      merchantCountryCode: "merchant_country_code",
+      merchantCategoryCode: "merchant_category_code"
+    });
+  });
+  ((MerchantProfileScheme$) => {
+    MerchantProfileScheme$.inboundSchema = MerchantProfileScheme$inboundSchema;
+    MerchantProfileScheme$.outboundSchema = MerchantProfileScheme$outboundSchema;
+  })(MerchantProfileScheme$ ||= {});
+});
+
 // src/models/components/networktokencreate.ts
 var NetworkTokenCreate$inboundSchema, NetworkTokenCreate$outboundSchema, NetworkTokenCreate$;
 var init_networktokencreate = __esm(() => {
@@ -41001,6 +41559,79 @@ var init_paymentoptionrequest = __esm(() => {
   })(PaymentOptionRequest$ ||= {});
 });
 
+// src/models/components/paymentservicecreate.ts
+var PaymentServiceCreate$inboundSchema, PaymentServiceCreate$outboundSchema, PaymentServiceCreate$;
+var init_paymentservicecreate = __esm(() => {
+  init_lib();
+  init_primitives();
+  init_field();
+  init_merchantprofilescheme();
+  PaymentServiceCreate$inboundSchema = objectType({
+    display_name: stringType(),
+    payment_service_definition_id: stringType(),
+    fields: arrayType(Field$inboundSchema),
+    reporting_fields: nullableType(arrayType(Field$inboundSchema)).optional(),
+    position: nullableType(numberType().int()).optional(),
+    accepted_currencies: arrayType(stringType()),
+    accepted_countries: arrayType(stringType()),
+    active: nullableType(booleanType()).optional(),
+    three_d_secure_enabled: booleanType().default(false),
+    merchant_profile: nullableType(recordType(nullableType(MerchantProfileScheme$inboundSchema))).optional(),
+    payment_method_tokenization_enabled: nullableType(booleanType()).optional(),
+    network_tokens_enabled: nullableType(booleanType()).optional(),
+    open_loop: nullableType(booleanType()).optional(),
+    settlement_reporting_enabled: booleanType().default(false)
+  }).transform((v2) => {
+    return remap(v2, {
+      display_name: "displayName",
+      payment_service_definition_id: "paymentServiceDefinitionId",
+      reporting_fields: "reportingFields",
+      accepted_currencies: "acceptedCurrencies",
+      accepted_countries: "acceptedCountries",
+      three_d_secure_enabled: "threeDSecureEnabled",
+      merchant_profile: "merchantProfile",
+      payment_method_tokenization_enabled: "paymentMethodTokenizationEnabled",
+      network_tokens_enabled: "networkTokensEnabled",
+      open_loop: "openLoop",
+      settlement_reporting_enabled: "settlementReportingEnabled"
+    });
+  });
+  PaymentServiceCreate$outboundSchema = objectType({
+    displayName: stringType(),
+    paymentServiceDefinitionId: stringType(),
+    fields: arrayType(Field$outboundSchema),
+    reportingFields: nullableType(arrayType(Field$outboundSchema)).optional(),
+    position: nullableType(numberType().int()).optional(),
+    acceptedCurrencies: arrayType(stringType()),
+    acceptedCountries: arrayType(stringType()),
+    active: nullableType(booleanType()).optional(),
+    threeDSecureEnabled: booleanType().default(false),
+    merchantProfile: nullableType(recordType(nullableType(MerchantProfileScheme$outboundSchema))).optional(),
+    paymentMethodTokenizationEnabled: nullableType(booleanType()).optional(),
+    networkTokensEnabled: nullableType(booleanType()).optional(),
+    openLoop: nullableType(booleanType()).optional(),
+    settlementReportingEnabled: booleanType().default(false)
+  }).transform((v2) => {
+    return remap(v2, {
+      displayName: "display_name",
+      paymentServiceDefinitionId: "payment_service_definition_id",
+      reportingFields: "reporting_fields",
+      acceptedCurrencies: "accepted_currencies",
+      acceptedCountries: "accepted_countries",
+      threeDSecureEnabled: "three_d_secure_enabled",
+      merchantProfile: "merchant_profile",
+      paymentMethodTokenizationEnabled: "payment_method_tokenization_enabled",
+      networkTokensEnabled: "network_tokens_enabled",
+      openLoop: "open_loop",
+      settlementReportingEnabled: "settlement_reporting_enabled"
+    });
+  });
+  ((PaymentServiceCreate$) => {
+    PaymentServiceCreate$.inboundSchema = PaymentServiceCreate$inboundSchema;
+    PaymentServiceCreate$.outboundSchema = PaymentServiceCreate$outboundSchema;
+  })(PaymentServiceCreate$ ||= {});
+});
+
 // src/models/components/paymentservicetokencreate.ts
 var PaymentServiceTokenCreate$inboundSchema, PaymentServiceTokenCreate$outboundSchema, PaymentServiceTokenCreate$;
 var init_paymentservicetokencreate = __esm(() => {
@@ -41034,6 +41665,93 @@ var init_paymentservicetokencreate = __esm(() => {
   })(PaymentServiceTokenCreate$ ||= {});
 });
 
+// src/models/components/voidablefield.ts
+var VoidableField$inboundSchema, VoidableField$outboundSchema, VoidableField$;
+var init_voidablefield = __esm(() => {
+  init_lib();
+  VoidableField$inboundSchema = objectType({
+    key: stringType(),
+    value: stringType()
+  });
+  VoidableField$outboundSchema = objectType({
+    key: stringType(),
+    value: stringType()
+  });
+  ((VoidableField$) => {
+    VoidableField$.inboundSchema = VoidableField$inboundSchema;
+    VoidableField$.outboundSchema = VoidableField$outboundSchema;
+  })(VoidableField$ ||= {});
+});
+
+// src/models/components/paymentserviceupdate.ts
+var PaymentServiceUpdate$inboundSchema, PaymentServiceUpdate$outboundSchema, PaymentServiceUpdate$;
+var init_paymentserviceupdate = __esm(() => {
+  init_lib();
+  init_primitives();
+  init_merchantprofilescheme();
+  init_voidablefield();
+  PaymentServiceUpdate$inboundSchema = objectType({
+    display_name: nullableType(stringType()).optional(),
+    fields: nullableType(arrayType(VoidableField$inboundSchema)).optional(),
+    reporting_fields: nullableType(arrayType(VoidableField$inboundSchema)).optional(),
+    position: nullableType(numberType().int()).optional(),
+    accepted_currencies: nullableType(arrayType(stringType())).optional(),
+    accepted_countries: nullableType(arrayType(stringType())).optional(),
+    active: nullableType(booleanType()).optional(),
+    three_d_secure_enabled: nullableType(booleanType()).optional(),
+    merchant_profile: nullableType(recordType(nullableType(MerchantProfileScheme$inboundSchema))).optional(),
+    payment_method_tokenization_enabled: nullableType(booleanType()).optional(),
+    network_tokens_enabled: nullableType(booleanType()).optional(),
+    open_loop: nullableType(booleanType()).optional(),
+    settlement_reporting_enabled: booleanType().default(false)
+  }).transform((v2) => {
+    return remap(v2, {
+      display_name: "displayName",
+      reporting_fields: "reportingFields",
+      accepted_currencies: "acceptedCurrencies",
+      accepted_countries: "acceptedCountries",
+      three_d_secure_enabled: "threeDSecureEnabled",
+      merchant_profile: "merchantProfile",
+      payment_method_tokenization_enabled: "paymentMethodTokenizationEnabled",
+      network_tokens_enabled: "networkTokensEnabled",
+      open_loop: "openLoop",
+      settlement_reporting_enabled: "settlementReportingEnabled"
+    });
+  });
+  PaymentServiceUpdate$outboundSchema = objectType({
+    displayName: nullableType(stringType()).optional(),
+    fields: nullableType(arrayType(VoidableField$outboundSchema)).optional(),
+    reportingFields: nullableType(arrayType(VoidableField$outboundSchema)).optional(),
+    position: nullableType(numberType().int()).optional(),
+    acceptedCurrencies: nullableType(arrayType(stringType())).optional(),
+    acceptedCountries: nullableType(arrayType(stringType())).optional(),
+    active: nullableType(booleanType()).optional(),
+    threeDSecureEnabled: nullableType(booleanType()).optional(),
+    merchantProfile: nullableType(recordType(nullableType(MerchantProfileScheme$outboundSchema))).optional(),
+    paymentMethodTokenizationEnabled: nullableType(booleanType()).optional(),
+    networkTokensEnabled: nullableType(booleanType()).optional(),
+    openLoop: nullableType(booleanType()).optional(),
+    settlementReportingEnabled: booleanType().default(false)
+  }).transform((v2) => {
+    return remap(v2, {
+      displayName: "display_name",
+      reportingFields: "reporting_fields",
+      acceptedCurrencies: "accepted_currencies",
+      acceptedCountries: "accepted_countries",
+      threeDSecureEnabled: "three_d_secure_enabled",
+      merchantProfile: "merchant_profile",
+      paymentMethodTokenizationEnabled: "payment_method_tokenization_enabled",
+      networkTokensEnabled: "network_tokens_enabled",
+      openLoop: "open_loop",
+      settlementReportingEnabled: "settlement_reporting_enabled"
+    });
+  });
+  ((PaymentServiceUpdate$) => {
+    PaymentServiceUpdate$.inboundSchema = PaymentServiceUpdate$inboundSchema;
+    PaymentServiceUpdate$.outboundSchema = PaymentServiceUpdate$outboundSchema;
+  })(PaymentServiceUpdate$ ||= {});
+});
+
 // src/models/components/payoutmerchant.ts
 var PayoutMerchant$inboundSchema, PayoutMerchant$outboundSchema, PayoutMerchant$;
 var init_payoutmerchant = __esm(() => {
@@ -42364,6 +43082,38 @@ var init_validationerror = __esm(() => {
   })(ValidationError$ ||= {});
 });
 
+// src/models/components/verifycredentials.ts
+var VerifyCredentials$inboundSchema, VerifyCredentials$outboundSchema, VerifyCredentials$;
+var init_verifycredentials = __esm(() => {
+  init_lib();
+  init_primitives();
+  init_field();
+  VerifyCredentials$inboundSchema = objectType({
+    payment_service_definition_id: stringType(),
+    payment_service_id: nullableType(stringType()).optional(),
+    fields: arrayType(Field$inboundSchema)
+  }).transform((v2) => {
+    return remap(v2, {
+      payment_service_definition_id: "paymentServiceDefinitionId",
+      payment_service_id: "paymentServiceId"
+    });
+  });
+  VerifyCredentials$outboundSchema = objectType({
+    paymentServiceDefinitionId: stringType(),
+    paymentServiceId: nullableType(stringType()).optional(),
+    fields: arrayType(Field$outboundSchema)
+  }).transform((v2) => {
+    return remap(v2, {
+      paymentServiceDefinitionId: "payment_service_definition_id",
+      paymentServiceId: "payment_service_id"
+    });
+  });
+  ((VerifyCredentials$) => {
+    VerifyCredentials$.inboundSchema = VerifyCredentials$inboundSchema;
+    VerifyCredentials$.outboundSchema = VerifyCredentials$outboundSchema;
+  })(VerifyCredentials$ ||= {});
+});
+
 // src/models/components/index.ts
 var init_components = __esm(() => {
   init_accountupdaterinquirysummary();
@@ -42420,14 +43170,20 @@ var init_components = __esm(() => {
   init_collectionnocursorrefund();
   init_collectionnocursorshippingdetails();
   init_collectionpaymentmethod();
+  init_collectionpaymentservice();
+  init_collectionpaymentservicedefinition();
   init_collectionpayoutsummary();
   init_collectionrefund();
   init_collectiontransactionsummary();
   init_connectionoptions();
+  init_createsession();
+  init_createsessionstatus();
   init_creator();
   init_cryptogram();
   init_cryptogramcreate();
   init_cvvresponsecode();
+  init_definitionfield();
+  init_definitionfieldformat();
   init_digitalwallet();
   init_digitalwalletcreate();
   init_digitalwalletdomain();
@@ -42435,6 +43191,7 @@ var init_components = __esm(() => {
   init_digitalwalletupdate();
   init_errordetail();
   init_errorlocation();
+  init_field();
   init_giftcard();
   init_giftcardbalancerequest();
   init_giftcardcreate();
@@ -42460,6 +43217,8 @@ var init_components = __esm(() => {
   init_merchantaccount();
   init_merchantaccountcreate();
   init_merchantaccountupdate();
+  init_merchantprofilescheme();
+  init_merchantprofileschemesummary();
   init_method();
   init_mode();
   init_networktoken();
@@ -42476,8 +43235,14 @@ var init_components = __esm(() => {
   init_paymentoptioncontext();
   init_paymentoptioncontextapprovalui();
   init_paymentoptionrequest();
+  init_paymentservice();
+  init_paymentserviceconfiguration();
+  init_paymentservicecreate();
+  init_paymentservicedefinition();
+  init_paymentservicestatus();
   init_paymentservicetoken();
   init_paymentservicetokencreate();
+  init_paymentserviceupdate();
   init_payoutcategory();
   init_payoutcreate();
   init_payoutmerchant();
@@ -42491,6 +43256,7 @@ var init_components = __esm(() => {
   init_refund();
   init_refundstatus();
   init_refundtargettype();
+  init_requiredcheckoutfields();
   init_security2();
   init_shippingdetails();
   init_shippingdetailscreate();
@@ -42523,6 +43289,8 @@ var init_components = __esm(() => {
   init_transactionthreedsecuresummary();
   init_userstatus();
   init_validationerror();
+  init_verifycredentials();
+  init_voidablefield();
   init_walletpaymentoptioncontext();
 });
 
@@ -43038,6 +43806,75 @@ var init_createpaymentmethodpaymentservicetoken = __esm(() => {
   })(CreatePaymentMethodPaymentServiceTokenResponse403CreatePaymentMethodPaymentServiceToken$ ||= {});
 });
 
+// src/models/errors/createpaymentservice.ts
+var CreatePaymentServiceResponse403CreatePaymentService$inboundSchema, CreatePaymentServiceResponse403CreatePaymentService$outboundSchema, CreatePaymentServiceResponse403CreatePaymentService$;
+var init_createpaymentservice = __esm(() => {
+  init_lib();
+  init_error403();
+  init_error403active();
+  init_error403forbidden();
+  CreatePaymentServiceResponse403CreatePaymentService$inboundSchema = unionType([
+    Error403$inboundSchema,
+    Error403Forbidden$inboundSchema,
+    Error403Active$inboundSchema
+  ]);
+  CreatePaymentServiceResponse403CreatePaymentService$outboundSchema = unionType([
+    Error403$outboundSchema,
+    Error403Forbidden$outboundSchema,
+    Error403Active$outboundSchema
+  ]);
+  ((CreatePaymentServiceResponse403CreatePaymentService$) => {
+    CreatePaymentServiceResponse403CreatePaymentService$.inboundSchema = CreatePaymentServiceResponse403CreatePaymentService$inboundSchema;
+    CreatePaymentServiceResponse403CreatePaymentService$.outboundSchema = CreatePaymentServiceResponse403CreatePaymentService$outboundSchema;
+  })(CreatePaymentServiceResponse403CreatePaymentService$ ||= {});
+});
+
+// src/models/errors/createpaymentservicedefinitionsession.ts
+var CreatePaymentServiceDefinitionSessionResponse403CreatePaymentServiceDefinitionSession$inboundSchema, CreatePaymentServiceDefinitionSessionResponse403CreatePaymentServiceDefinitionSession$outboundSchema, CreatePaymentServiceDefinitionSessionResponse403CreatePaymentServiceDefinitionSession$;
+var init_createpaymentservicedefinitionsession = __esm(() => {
+  init_lib();
+  init_error403();
+  init_error403active();
+  init_error403forbidden();
+  CreatePaymentServiceDefinitionSessionResponse403CreatePaymentServiceDefinitionSession$inboundSchema = unionType([
+    Error403$inboundSchema,
+    Error403Forbidden$inboundSchema,
+    Error403Active$inboundSchema
+  ]);
+  CreatePaymentServiceDefinitionSessionResponse403CreatePaymentServiceDefinitionSession$outboundSchema = unionType([
+    Error403$outboundSchema,
+    Error403Forbidden$outboundSchema,
+    Error403Active$outboundSchema
+  ]);
+  ((CreatePaymentServiceDefinitionSessionResponse403CreatePaymentServiceDefinitionSession$) => {
+    CreatePaymentServiceDefinitionSessionResponse403CreatePaymentServiceDefinitionSession$.inboundSchema = CreatePaymentServiceDefinitionSessionResponse403CreatePaymentServiceDefinitionSession$inboundSchema;
+    CreatePaymentServiceDefinitionSessionResponse403CreatePaymentServiceDefinitionSession$.outboundSchema = CreatePaymentServiceDefinitionSessionResponse403CreatePaymentServiceDefinitionSession$outboundSchema;
+  })(CreatePaymentServiceDefinitionSessionResponse403CreatePaymentServiceDefinitionSession$ ||= {});
+});
+
+// src/models/errors/createpaymentservicesession.ts
+var CreatePaymentServiceSessionResponse403CreatePaymentServiceSession$inboundSchema, CreatePaymentServiceSessionResponse403CreatePaymentServiceSession$outboundSchema, CreatePaymentServiceSessionResponse403CreatePaymentServiceSession$;
+var init_createpaymentservicesession = __esm(() => {
+  init_lib();
+  init_error403();
+  init_error403active();
+  init_error403forbidden();
+  CreatePaymentServiceSessionResponse403CreatePaymentServiceSession$inboundSchema = unionType([
+    Error403$inboundSchema,
+    Error403Forbidden$inboundSchema,
+    Error403Active$inboundSchema
+  ]);
+  CreatePaymentServiceSessionResponse403CreatePaymentServiceSession$outboundSchema = unionType([
+    Error403$outboundSchema,
+    Error403Forbidden$outboundSchema,
+    Error403Active$outboundSchema
+  ]);
+  ((CreatePaymentServiceSessionResponse403CreatePaymentServiceSession$) => {
+    CreatePaymentServiceSessionResponse403CreatePaymentServiceSession$.inboundSchema = CreatePaymentServiceSessionResponse403CreatePaymentServiceSession$inboundSchema;
+    CreatePaymentServiceSessionResponse403CreatePaymentServiceSession$.outboundSchema = CreatePaymentServiceSessionResponse403CreatePaymentServiceSession$outboundSchema;
+  })(CreatePaymentServiceSessionResponse403CreatePaymentServiceSession$ ||= {});
+});
+
 // src/models/errors/createpayout.ts
 var CreatePayoutResponse403CreatePayout$inboundSchema, CreatePayoutResponse403CreatePayout$outboundSchema, CreatePayoutResponse403CreatePayout$;
 var init_createpayout = __esm(() => {
@@ -43291,6 +44128,29 @@ var init_deletepaymentmethodpaymentservicetoken = __esm(() => {
   })(DeletePaymentMethodPaymentServiceTokenResponse403DeletePaymentMethodPaymentServiceToken$ ||= {});
 });
 
+// src/models/errors/deletepaymentservice.ts
+var DeletePaymentServiceResponse403DeletePaymentService$inboundSchema, DeletePaymentServiceResponse403DeletePaymentService$outboundSchema, DeletePaymentServiceResponse403DeletePaymentService$;
+var init_deletepaymentservice = __esm(() => {
+  init_lib();
+  init_error403();
+  init_error403active();
+  init_error403forbidden();
+  DeletePaymentServiceResponse403DeletePaymentService$inboundSchema = unionType([
+    Error403$inboundSchema,
+    Error403Forbidden$inboundSchema,
+    Error403Active$inboundSchema
+  ]);
+  DeletePaymentServiceResponse403DeletePaymentService$outboundSchema = unionType([
+    Error403$outboundSchema,
+    Error403Forbidden$outboundSchema,
+    Error403Active$outboundSchema
+  ]);
+  ((DeletePaymentServiceResponse403DeletePaymentService$) => {
+    DeletePaymentServiceResponse403DeletePaymentService$.inboundSchema = DeletePaymentServiceResponse403DeletePaymentService$inboundSchema;
+    DeletePaymentServiceResponse403DeletePaymentService$.outboundSchema = DeletePaymentServiceResponse403DeletePaymentService$outboundSchema;
+  })(DeletePaymentServiceResponse403DeletePaymentService$ ||= {});
+});
+
 // src/models/errors/error400.ts
 var Error400, Error400$inboundSchema, Error400$outboundSchema, Error400$;
 var init_error400 = __esm(() => {
@@ -43932,6 +44792,52 @@ var init_getpaymentmethod = __esm(() => {
   })(GetPaymentMethodResponse403GetPaymentMethod$ ||= {});
 });
 
+// src/models/errors/getpaymentservice.ts
+var GetPaymentServiceResponse403GetPaymentService$inboundSchema, GetPaymentServiceResponse403GetPaymentService$outboundSchema, GetPaymentServiceResponse403GetPaymentService$;
+var init_getpaymentservice = __esm(() => {
+  init_lib();
+  init_error403();
+  init_error403active();
+  init_error403forbidden();
+  GetPaymentServiceResponse403GetPaymentService$inboundSchema = unionType([
+    Error403$inboundSchema,
+    Error403Forbidden$inboundSchema,
+    Error403Active$inboundSchema
+  ]);
+  GetPaymentServiceResponse403GetPaymentService$outboundSchema = unionType([
+    Error403$outboundSchema,
+    Error403Forbidden$outboundSchema,
+    Error403Active$outboundSchema
+  ]);
+  ((GetPaymentServiceResponse403GetPaymentService$) => {
+    GetPaymentServiceResponse403GetPaymentService$.inboundSchema = GetPaymentServiceResponse403GetPaymentService$inboundSchema;
+    GetPaymentServiceResponse403GetPaymentService$.outboundSchema = GetPaymentServiceResponse403GetPaymentService$outboundSchema;
+  })(GetPaymentServiceResponse403GetPaymentService$ ||= {});
+});
+
+// src/models/errors/getpaymentservicedefinition.ts
+var GetPaymentServiceDefinitionResponse403GetPaymentServiceDefinition$inboundSchema, GetPaymentServiceDefinitionResponse403GetPaymentServiceDefinition$outboundSchema, GetPaymentServiceDefinitionResponse403GetPaymentServiceDefinition$;
+var init_getpaymentservicedefinition = __esm(() => {
+  init_lib();
+  init_error403();
+  init_error403active();
+  init_error403forbidden();
+  GetPaymentServiceDefinitionResponse403GetPaymentServiceDefinition$inboundSchema = unionType([
+    Error403$inboundSchema,
+    Error403Forbidden$inboundSchema,
+    Error403Active$inboundSchema
+  ]);
+  GetPaymentServiceDefinitionResponse403GetPaymentServiceDefinition$outboundSchema = unionType([
+    Error403$outboundSchema,
+    Error403Forbidden$outboundSchema,
+    Error403Active$outboundSchema
+  ]);
+  ((GetPaymentServiceDefinitionResponse403GetPaymentServiceDefinition$) => {
+    GetPaymentServiceDefinitionResponse403GetPaymentServiceDefinition$.inboundSchema = GetPaymentServiceDefinitionResponse403GetPaymentServiceDefinition$inboundSchema;
+    GetPaymentServiceDefinitionResponse403GetPaymentServiceDefinition$.outboundSchema = GetPaymentServiceDefinitionResponse403GetPaymentServiceDefinition$outboundSchema;
+  })(GetPaymentServiceDefinitionResponse403GetPaymentServiceDefinition$ ||= {});
+});
+
 // src/models/errors/getpayout.ts
 var GetPayoutResponse403GetPayout$inboundSchema, GetPayoutResponse403GetPayout$outboundSchema, GetPayoutResponse403GetPayout$;
 var init_getpayout = __esm(() => {
@@ -44400,6 +45306,52 @@ var init_listpaymentoptions = __esm(() => {
   })(ListPaymentOptionsResponse403ListPaymentOptions$ ||= {});
 });
 
+// src/models/errors/listpaymentservicedefinitions.ts
+var ListPaymentServiceDefinitionsResponse403ListPaymentServiceDefinitions$inboundSchema, ListPaymentServiceDefinitionsResponse403ListPaymentServiceDefinitions$outboundSchema, ListPaymentServiceDefinitionsResponse403ListPaymentServiceDefinitions$;
+var init_listpaymentservicedefinitions = __esm(() => {
+  init_lib();
+  init_error403();
+  init_error403active();
+  init_error403forbidden();
+  ListPaymentServiceDefinitionsResponse403ListPaymentServiceDefinitions$inboundSchema = unionType([
+    Error403$inboundSchema,
+    Error403Forbidden$inboundSchema,
+    Error403Active$inboundSchema
+  ]);
+  ListPaymentServiceDefinitionsResponse403ListPaymentServiceDefinitions$outboundSchema = unionType([
+    Error403$outboundSchema,
+    Error403Forbidden$outboundSchema,
+    Error403Active$outboundSchema
+  ]);
+  ((ListPaymentServiceDefinitionsResponse403ListPaymentServiceDefinitions$) => {
+    ListPaymentServiceDefinitionsResponse403ListPaymentServiceDefinitions$.inboundSchema = ListPaymentServiceDefinitionsResponse403ListPaymentServiceDefinitions$inboundSchema;
+    ListPaymentServiceDefinitionsResponse403ListPaymentServiceDefinitions$.outboundSchema = ListPaymentServiceDefinitionsResponse403ListPaymentServiceDefinitions$outboundSchema;
+  })(ListPaymentServiceDefinitionsResponse403ListPaymentServiceDefinitions$ ||= {});
+});
+
+// src/models/errors/listpaymentservices.ts
+var ListPaymentServicesResponse403ListPaymentServices$inboundSchema, ListPaymentServicesResponse403ListPaymentServices$outboundSchema, ListPaymentServicesResponse403ListPaymentServices$;
+var init_listpaymentservices = __esm(() => {
+  init_lib();
+  init_error403();
+  init_error403active();
+  init_error403forbidden();
+  ListPaymentServicesResponse403ListPaymentServices$inboundSchema = unionType([
+    Error403$inboundSchema,
+    Error403Forbidden$inboundSchema,
+    Error403Active$inboundSchema
+  ]);
+  ListPaymentServicesResponse403ListPaymentServices$outboundSchema = unionType([
+    Error403$outboundSchema,
+    Error403Forbidden$outboundSchema,
+    Error403Active$outboundSchema
+  ]);
+  ((ListPaymentServicesResponse403ListPaymentServices$) => {
+    ListPaymentServicesResponse403ListPaymentServices$.inboundSchema = ListPaymentServicesResponse403ListPaymentServices$inboundSchema;
+    ListPaymentServicesResponse403ListPaymentServices$.outboundSchema = ListPaymentServicesResponse403ListPaymentServices$outboundSchema;
+  })(ListPaymentServicesResponse403ListPaymentServices$ ||= {});
+});
+
 // src/models/errors/listpayouts.ts
 var ListPayoutsResponse403ListPayouts$inboundSchema, ListPayoutsResponse403ListPayouts$outboundSchema, ListPayoutsResponse403ListPayouts$;
 var init_listpayouts = __esm(() => {
@@ -44699,6 +45651,52 @@ var init_updatemerchantaccount = __esm(() => {
   })(UpdateMerchantAccountResponse403UpdateMerchantAccount$ ||= {});
 });
 
+// src/models/errors/updatepaymentservice.ts
+var UpdatePaymentServiceResponse403UpdatePaymentService$inboundSchema, UpdatePaymentServiceResponse403UpdatePaymentService$outboundSchema, UpdatePaymentServiceResponse403UpdatePaymentService$;
+var init_updatepaymentservice = __esm(() => {
+  init_lib();
+  init_error403();
+  init_error403active();
+  init_error403forbidden();
+  UpdatePaymentServiceResponse403UpdatePaymentService$inboundSchema = unionType([
+    Error403$inboundSchema,
+    Error403Forbidden$inboundSchema,
+    Error403Active$inboundSchema
+  ]);
+  UpdatePaymentServiceResponse403UpdatePaymentService$outboundSchema = unionType([
+    Error403$outboundSchema,
+    Error403Forbidden$outboundSchema,
+    Error403Active$outboundSchema
+  ]);
+  ((UpdatePaymentServiceResponse403UpdatePaymentService$) => {
+    UpdatePaymentServiceResponse403UpdatePaymentService$.inboundSchema = UpdatePaymentServiceResponse403UpdatePaymentService$inboundSchema;
+    UpdatePaymentServiceResponse403UpdatePaymentService$.outboundSchema = UpdatePaymentServiceResponse403UpdatePaymentService$outboundSchema;
+  })(UpdatePaymentServiceResponse403UpdatePaymentService$ ||= {});
+});
+
+// src/models/errors/verifypaymentservicecredentials.ts
+var VerifyPaymentServiceCredentialsResponse403VerifyPaymentServiceCredentials$inboundSchema, VerifyPaymentServiceCredentialsResponse403VerifyPaymentServiceCredentials$outboundSchema, VerifyPaymentServiceCredentialsResponse403VerifyPaymentServiceCredentials$;
+var init_verifypaymentservicecredentials = __esm(() => {
+  init_lib();
+  init_error403();
+  init_error403active();
+  init_error403forbidden();
+  VerifyPaymentServiceCredentialsResponse403VerifyPaymentServiceCredentials$inboundSchema = unionType([
+    Error403$inboundSchema,
+    Error403Forbidden$inboundSchema,
+    Error403Active$inboundSchema
+  ]);
+  VerifyPaymentServiceCredentialsResponse403VerifyPaymentServiceCredentials$outboundSchema = unionType([
+    Error403$outboundSchema,
+    Error403Forbidden$outboundSchema,
+    Error403Active$outboundSchema
+  ]);
+  ((VerifyPaymentServiceCredentialsResponse403VerifyPaymentServiceCredentials$) => {
+    VerifyPaymentServiceCredentialsResponse403VerifyPaymentServiceCredentials$.inboundSchema = VerifyPaymentServiceCredentialsResponse403VerifyPaymentServiceCredentials$inboundSchema;
+    VerifyPaymentServiceCredentialsResponse403VerifyPaymentServiceCredentials$.outboundSchema = VerifyPaymentServiceCredentialsResponse403VerifyPaymentServiceCredentials$outboundSchema;
+  })(VerifyPaymentServiceCredentialsResponse403VerifyPaymentServiceCredentials$ ||= {});
+});
+
 // src/models/errors/voidtransaction.ts
 var VoidTransactionResponse403VoidTransaction$inboundSchema, VoidTransactionResponse403VoidTransaction$outboundSchema, VoidTransactionResponse403VoidTransaction$;
 var init_voidtransaction = __esm(() => {
@@ -44740,6 +45738,9 @@ var init_errors = __esm(() => {
   init_createpaymentmethodnetworktoken();
   init_createpaymentmethodnetworktokencryptogram();
   init_createpaymentmethodpaymentservicetoken();
+  init_createpaymentservice();
+  init_createpaymentservicedefinitionsession();
+  init_createpaymentservicesession();
   init_createpayout();
   init_createtransaction();
   init_createtransactionrefund();
@@ -44751,6 +45752,7 @@ var init_errors = __esm(() => {
   init_deletepaymentmethod();
   init_deletepaymentmethodnetworktoken();
   init_deletepaymentmethodpaymentservicetoken();
+  init_deletepaymentservice();
   init_error400();
   init_error401();
   init_error403();
@@ -44771,6 +45773,8 @@ var init_errors = __esm(() => {
   init_getgiftcard();
   init_getmerchantaccount();
   init_getpaymentmethod();
+  init_getpaymentservice();
+  init_getpaymentservicedefinition();
   init_getpayout();
   init_getrefund();
   init_gettransaction();
@@ -44792,6 +45796,8 @@ var init_errors = __esm(() => {
   init_listpaymentmethodpaymentservicetokens();
   init_listpaymentmethods();
   init_listpaymentoptions();
+  init_listpaymentservicedefinitions();
+  init_listpaymentservices();
   init_listpayouts();
   init_listtransactionrefunds();
   init_listtransactions();
@@ -44807,6 +45813,8 @@ var init_errors = __esm(() => {
   init_updatecheckoutsession();
   init_updatedigitalwallet();
   init_updatemerchantaccount();
+  init_updatepaymentservice();
+  init_verifypaymentservicecredentials();
   init_voidtransaction();
 });
 
@@ -45488,6 +46496,118 @@ var init_createpaymentmethodpaymentservicetoken2 = __esm(() => {
   })(CreatePaymentMethodPaymentServiceTokenRequest$ ||= {});
 });
 
+// src/models/operations/createpaymentservice.ts
+var CreatePaymentServiceGlobals$inboundSchema, CreatePaymentServiceGlobals$outboundSchema, CreatePaymentServiceGlobals$, CreatePaymentServiceRequest$inboundSchema, CreatePaymentServiceRequest$outboundSchema, CreatePaymentServiceRequest$;
+var init_createpaymentservice2 = __esm(() => {
+  init_lib();
+  init_primitives();
+  init_components();
+  CreatePaymentServiceGlobals$inboundSchema = objectType({
+    merchantAccountId: stringType().optional()
+  });
+  CreatePaymentServiceGlobals$outboundSchema = objectType({
+    merchantAccountId: stringType().optional()
+  });
+  ((CreatePaymentServiceGlobals$) => {
+    CreatePaymentServiceGlobals$.inboundSchema = CreatePaymentServiceGlobals$inboundSchema;
+    CreatePaymentServiceGlobals$.outboundSchema = CreatePaymentServiceGlobals$outboundSchema;
+  })(CreatePaymentServiceGlobals$ ||= {});
+  CreatePaymentServiceRequest$inboundSchema = objectType({
+    payment_service_id: stringType(),
+    merchantAccountId: nullableType(stringType()).optional(),
+    PaymentServiceUpdate: PaymentServiceUpdate$inboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      payment_service_id: "paymentServiceId",
+      PaymentServiceUpdate: "paymentServiceUpdate"
+    });
+  });
+  CreatePaymentServiceRequest$outboundSchema = objectType({
+    paymentServiceId: stringType(),
+    merchantAccountId: nullableType(stringType()).optional(),
+    paymentServiceUpdate: PaymentServiceUpdate$outboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      paymentServiceId: "payment_service_id",
+      paymentServiceUpdate: "PaymentServiceUpdate"
+    });
+  });
+  ((CreatePaymentServiceRequest$) => {
+    CreatePaymentServiceRequest$.inboundSchema = CreatePaymentServiceRequest$inboundSchema;
+    CreatePaymentServiceRequest$.outboundSchema = CreatePaymentServiceRequest$outboundSchema;
+  })(CreatePaymentServiceRequest$ ||= {});
+});
+
+// src/models/operations/createpaymentservicedefinitionsession.ts
+var CreatePaymentServiceDefinitionSessionRequest$inboundSchema, CreatePaymentServiceDefinitionSessionRequest$outboundSchema, CreatePaymentServiceDefinitionSessionRequest$;
+var init_createpaymentservicedefinitionsession2 = __esm(() => {
+  init_lib();
+  init_primitives();
+  CreatePaymentServiceDefinitionSessionRequest$inboundSchema = objectType({
+    payment_service_definition_id: stringType(),
+    RequestBody: recordType(anyType())
+  }).transform((v2) => {
+    return remap(v2, {
+      payment_service_definition_id: "paymentServiceDefinitionId",
+      RequestBody: "requestBody"
+    });
+  });
+  CreatePaymentServiceDefinitionSessionRequest$outboundSchema = objectType({
+    paymentServiceDefinitionId: stringType(),
+    requestBody: recordType(anyType())
+  }).transform((v2) => {
+    return remap(v2, {
+      paymentServiceDefinitionId: "payment_service_definition_id",
+      requestBody: "RequestBody"
+    });
+  });
+  ((CreatePaymentServiceDefinitionSessionRequest$) => {
+    CreatePaymentServiceDefinitionSessionRequest$.inboundSchema = CreatePaymentServiceDefinitionSessionRequest$inboundSchema;
+    CreatePaymentServiceDefinitionSessionRequest$.outboundSchema = CreatePaymentServiceDefinitionSessionRequest$outboundSchema;
+  })(CreatePaymentServiceDefinitionSessionRequest$ ||= {});
+});
+
+// src/models/operations/createpaymentservicesession.ts
+var CreatePaymentServiceSessionGlobals$inboundSchema, CreatePaymentServiceSessionGlobals$outboundSchema, CreatePaymentServiceSessionGlobals$, CreatePaymentServiceSessionRequest$inboundSchema, CreatePaymentServiceSessionRequest$outboundSchema, CreatePaymentServiceSessionRequest$;
+var init_createpaymentservicesession2 = __esm(() => {
+  init_lib();
+  init_primitives();
+  CreatePaymentServiceSessionGlobals$inboundSchema = objectType({
+    merchantAccountId: stringType().optional()
+  });
+  CreatePaymentServiceSessionGlobals$outboundSchema = objectType({
+    merchantAccountId: stringType().optional()
+  });
+  ((CreatePaymentServiceSessionGlobals$) => {
+    CreatePaymentServiceSessionGlobals$.inboundSchema = CreatePaymentServiceSessionGlobals$inboundSchema;
+    CreatePaymentServiceSessionGlobals$.outboundSchema = CreatePaymentServiceSessionGlobals$outboundSchema;
+  })(CreatePaymentServiceSessionGlobals$ ||= {});
+  CreatePaymentServiceSessionRequest$inboundSchema = objectType({
+    payment_service_id: stringType(),
+    merchantAccountId: nullableType(stringType()).optional(),
+    RequestBody: recordType(anyType())
+  }).transform((v2) => {
+    return remap(v2, {
+      payment_service_id: "paymentServiceId",
+      RequestBody: "requestBody"
+    });
+  });
+  CreatePaymentServiceSessionRequest$outboundSchema = objectType({
+    paymentServiceId: stringType(),
+    merchantAccountId: nullableType(stringType()).optional(),
+    requestBody: recordType(anyType())
+  }).transform((v2) => {
+    return remap(v2, {
+      paymentServiceId: "payment_service_id",
+      requestBody: "RequestBody"
+    });
+  });
+  ((CreatePaymentServiceSessionRequest$) => {
+    CreatePaymentServiceSessionRequest$.inboundSchema = CreatePaymentServiceSessionRequest$inboundSchema;
+    CreatePaymentServiceSessionRequest$.outboundSchema = CreatePaymentServiceSessionRequest$outboundSchema;
+  })(CreatePaymentServiceSessionRequest$ ||= {});
+});
+
 // src/models/operations/createpayout.ts
 var CreatePayoutGlobals$inboundSchema, CreatePayoutGlobals$outboundSchema, CreatePayoutGlobals$, CreatePayoutRequest$inboundSchema, CreatePayoutRequest$outboundSchema, CreatePayoutRequest$;
 var init_createpayout2 = __esm(() => {
@@ -45964,6 +47084,47 @@ var init_deletepaymentmethodpaymentservicetoken2 = __esm(() => {
   })(DeletePaymentMethodPaymentServiceTokenRequest$ ||= {});
 });
 
+// src/models/operations/deletepaymentservice.ts
+var DeletePaymentServiceGlobals$inboundSchema, DeletePaymentServiceGlobals$outboundSchema, DeletePaymentServiceGlobals$, DeletePaymentServiceRequest$inboundSchema, DeletePaymentServiceRequest$outboundSchema, DeletePaymentServiceRequest$;
+var init_deletepaymentservice2 = __esm(() => {
+  init_lib();
+  init_primitives();
+  DeletePaymentServiceGlobals$inboundSchema = objectType({
+    merchantAccountId: stringType().optional()
+  });
+  DeletePaymentServiceGlobals$outboundSchema = objectType({
+    merchantAccountId: stringType().optional()
+  });
+  ((DeletePaymentServiceGlobals$) => {
+    DeletePaymentServiceGlobals$.inboundSchema = DeletePaymentServiceGlobals$inboundSchema;
+    DeletePaymentServiceGlobals$.outboundSchema = DeletePaymentServiceGlobals$outboundSchema;
+  })(DeletePaymentServiceGlobals$ ||= {});
+  DeletePaymentServiceRequest$inboundSchema = objectType({
+    payment_service_id: stringType(),
+    timeout_in_seconds: numberType().default(1),
+    merchantAccountId: nullableType(stringType()).optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      payment_service_id: "paymentServiceId",
+      timeout_in_seconds: "timeoutInSeconds"
+    });
+  });
+  DeletePaymentServiceRequest$outboundSchema = objectType({
+    paymentServiceId: stringType(),
+    timeoutInSeconds: numberType().default(1),
+    merchantAccountId: nullableType(stringType()).optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      paymentServiceId: "payment_service_id",
+      timeoutInSeconds: "timeout_in_seconds"
+    });
+  });
+  ((DeletePaymentServiceRequest$) => {
+    DeletePaymentServiceRequest$.inboundSchema = DeletePaymentServiceRequest$inboundSchema;
+    DeletePaymentServiceRequest$.outboundSchema = DeletePaymentServiceRequest$outboundSchema;
+  })(DeletePaymentServiceRequest$ ||= {});
+});
+
 // src/models/operations/getbuyer.ts
 var GetBuyerGlobals$inboundSchema, GetBuyerGlobals$outboundSchema, GetBuyerGlobals$, GetBuyerRequest$inboundSchema, GetBuyerRequest$outboundSchema, GetBuyerRequest$;
 var init_getbuyer2 = __esm(() => {
@@ -46219,6 +47380,68 @@ var init_getpaymentmethod2 = __esm(() => {
   })(GetPaymentMethodRequest$ ||= {});
 });
 
+// src/models/operations/getpaymentservice.ts
+var GetPaymentServiceGlobals$inboundSchema, GetPaymentServiceGlobals$outboundSchema, GetPaymentServiceGlobals$, GetPaymentServiceRequest$inboundSchema, GetPaymentServiceRequest$outboundSchema, GetPaymentServiceRequest$;
+var init_getpaymentservice2 = __esm(() => {
+  init_lib();
+  init_primitives();
+  GetPaymentServiceGlobals$inboundSchema = objectType({
+    merchantAccountId: stringType().optional()
+  });
+  GetPaymentServiceGlobals$outboundSchema = objectType({
+    merchantAccountId: stringType().optional()
+  });
+  ((GetPaymentServiceGlobals$) => {
+    GetPaymentServiceGlobals$.inboundSchema = GetPaymentServiceGlobals$inboundSchema;
+    GetPaymentServiceGlobals$.outboundSchema = GetPaymentServiceGlobals$outboundSchema;
+  })(GetPaymentServiceGlobals$ ||= {});
+  GetPaymentServiceRequest$inboundSchema = objectType({
+    payment_service_id: stringType(),
+    merchantAccountId: nullableType(stringType()).optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      payment_service_id: "paymentServiceId"
+    });
+  });
+  GetPaymentServiceRequest$outboundSchema = objectType({
+    paymentServiceId: stringType(),
+    merchantAccountId: nullableType(stringType()).optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      paymentServiceId: "payment_service_id"
+    });
+  });
+  ((GetPaymentServiceRequest$) => {
+    GetPaymentServiceRequest$.inboundSchema = GetPaymentServiceRequest$inboundSchema;
+    GetPaymentServiceRequest$.outboundSchema = GetPaymentServiceRequest$outboundSchema;
+  })(GetPaymentServiceRequest$ ||= {});
+});
+
+// src/models/operations/getpaymentservicedefinition.ts
+var GetPaymentServiceDefinitionRequest$inboundSchema, GetPaymentServiceDefinitionRequest$outboundSchema, GetPaymentServiceDefinitionRequest$;
+var init_getpaymentservicedefinition2 = __esm(() => {
+  init_lib();
+  init_primitives();
+  GetPaymentServiceDefinitionRequest$inboundSchema = objectType({
+    payment_service_definition_id: stringType()
+  }).transform((v2) => {
+    return remap(v2, {
+      payment_service_definition_id: "paymentServiceDefinitionId"
+    });
+  });
+  GetPaymentServiceDefinitionRequest$outboundSchema = objectType({
+    paymentServiceDefinitionId: stringType()
+  }).transform((v2) => {
+    return remap(v2, {
+      paymentServiceDefinitionId: "payment_service_definition_id"
+    });
+  });
+  ((GetPaymentServiceDefinitionRequest$) => {
+    GetPaymentServiceDefinitionRequest$.inboundSchema = GetPaymentServiceDefinitionRequest$inboundSchema;
+    GetPaymentServiceDefinitionRequest$.outboundSchema = GetPaymentServiceDefinitionRequest$outboundSchema;
+  })(GetPaymentServiceDefinitionRequest$ ||= {});
+});
+
 // src/models/operations/getpayout.ts
 var GetPayoutGlobals$inboundSchema, GetPayoutGlobals$outboundSchema, GetPayoutGlobals$, GetPayoutRequest$inboundSchema, GetPayoutRequest$outboundSchema, GetPayoutRequest$;
 var init_getpayout2 = __esm(() => {
@@ -47071,6 +48294,98 @@ var init_listpaymentoptions2 = __esm(() => {
   })(ListPaymentOptionsRequest$ ||= {});
 });
 
+// src/models/operations/listpaymentservicedefinitions.ts
+var ListPaymentServiceDefinitionsRequest$inboundSchema, ListPaymentServiceDefinitionsRequest$outboundSchema, ListPaymentServiceDefinitionsRequest$, ListPaymentServiceDefinitionsResponse$inboundSchema, ListPaymentServiceDefinitionsResponse$outboundSchema, ListPaymentServiceDefinitionsResponse$;
+var init_listpaymentservicedefinitions2 = __esm(() => {
+  init_lib();
+  init_primitives();
+  init_components();
+  ListPaymentServiceDefinitionsRequest$inboundSchema = objectType({
+    cursor: nullableType(stringType()).optional(),
+    limit: numberType().int().default(20)
+  });
+  ListPaymentServiceDefinitionsRequest$outboundSchema = objectType({
+    cursor: nullableType(stringType()).optional(),
+    limit: numberType().int().default(20)
+  });
+  ((ListPaymentServiceDefinitionsRequest$) => {
+    ListPaymentServiceDefinitionsRequest$.inboundSchema = ListPaymentServiceDefinitionsRequest$inboundSchema;
+    ListPaymentServiceDefinitionsRequest$.outboundSchema = ListPaymentServiceDefinitionsRequest$outboundSchema;
+  })(ListPaymentServiceDefinitionsRequest$ ||= {});
+  ListPaymentServiceDefinitionsResponse$inboundSchema = objectType({
+    Result: CollectionPaymentServiceDefinition$inboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      Result: "result"
+    });
+  });
+  ListPaymentServiceDefinitionsResponse$outboundSchema = objectType({
+    result: CollectionPaymentServiceDefinition$outboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      result: "Result"
+    });
+  });
+  ((ListPaymentServiceDefinitionsResponse$) => {
+    ListPaymentServiceDefinitionsResponse$.inboundSchema = ListPaymentServiceDefinitionsResponse$inboundSchema;
+    ListPaymentServiceDefinitionsResponse$.outboundSchema = ListPaymentServiceDefinitionsResponse$outboundSchema;
+  })(ListPaymentServiceDefinitionsResponse$ ||= {});
+});
+
+// src/models/operations/listpaymentservices.ts
+var ListPaymentServicesGlobals$inboundSchema, ListPaymentServicesGlobals$outboundSchema, ListPaymentServicesGlobals$, ListPaymentServicesRequest$inboundSchema, ListPaymentServicesRequest$outboundSchema, ListPaymentServicesRequest$, ListPaymentServicesResponse$inboundSchema, ListPaymentServicesResponse$outboundSchema, ListPaymentServicesResponse$;
+var init_listpaymentservices2 = __esm(() => {
+  init_lib();
+  init_primitives();
+  init_components();
+  ListPaymentServicesGlobals$inboundSchema = objectType({
+    merchantAccountId: stringType().optional()
+  });
+  ListPaymentServicesGlobals$outboundSchema = objectType({
+    merchantAccountId: stringType().optional()
+  });
+  ((ListPaymentServicesGlobals$) => {
+    ListPaymentServicesGlobals$.inboundSchema = ListPaymentServicesGlobals$inboundSchema;
+    ListPaymentServicesGlobals$.outboundSchema = ListPaymentServicesGlobals$outboundSchema;
+  })(ListPaymentServicesGlobals$ ||= {});
+  ListPaymentServicesRequest$inboundSchema = objectType({
+    method: nullableType(Method$inboundSchema).optional(),
+    cursor: nullableType(stringType()).optional(),
+    limit: numberType().int().default(20),
+    deleted: nullableType(booleanType()).optional(),
+    merchantAccountId: nullableType(stringType()).optional()
+  });
+  ListPaymentServicesRequest$outboundSchema = objectType({
+    method: nullableType(Method$outboundSchema).optional(),
+    cursor: nullableType(stringType()).optional(),
+    limit: numberType().int().default(20),
+    deleted: nullableType(booleanType()).optional(),
+    merchantAccountId: nullableType(stringType()).optional()
+  });
+  ((ListPaymentServicesRequest$) => {
+    ListPaymentServicesRequest$.inboundSchema = ListPaymentServicesRequest$inboundSchema;
+    ListPaymentServicesRequest$.outboundSchema = ListPaymentServicesRequest$outboundSchema;
+  })(ListPaymentServicesRequest$ ||= {});
+  ListPaymentServicesResponse$inboundSchema = objectType({
+    Result: CollectionPaymentService$inboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      Result: "result"
+    });
+  });
+  ListPaymentServicesResponse$outboundSchema = objectType({
+    result: CollectionPaymentService$outboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      result: "Result"
+    });
+  });
+  ((ListPaymentServicesResponse$) => {
+    ListPaymentServicesResponse$.inboundSchema = ListPaymentServicesResponse$inboundSchema;
+    ListPaymentServicesResponse$.outboundSchema = ListPaymentServicesResponse$outboundSchema;
+  })(ListPaymentServicesResponse$ ||= {});
+});
+
 // src/models/operations/listpayouts.ts
 var ListPayoutsGlobals$inboundSchema, ListPayoutsGlobals$outboundSchema, ListPayoutsGlobals$, ListPayoutsRequest$inboundSchema, ListPayoutsRequest$outboundSchema, ListPayoutsRequest$, ListPayoutsResponse$inboundSchema, ListPayoutsResponse$outboundSchema, ListPayoutsResponse$;
 var init_listpayouts2 = __esm(() => {
@@ -47787,6 +49102,86 @@ var init_updatemerchantaccount2 = __esm(() => {
   })(UpdateMerchantAccountRequest$ ||= {});
 });
 
+// src/models/operations/updatepaymentservice.ts
+var UpdatePaymentServiceGlobals$inboundSchema, UpdatePaymentServiceGlobals$outboundSchema, UpdatePaymentServiceGlobals$, UpdatePaymentServiceRequest$inboundSchema, UpdatePaymentServiceRequest$outboundSchema, UpdatePaymentServiceRequest$;
+var init_updatepaymentservice2 = __esm(() => {
+  init_lib();
+  init_primitives();
+  init_components();
+  UpdatePaymentServiceGlobals$inboundSchema = objectType({
+    merchantAccountId: stringType().optional()
+  });
+  UpdatePaymentServiceGlobals$outboundSchema = objectType({
+    merchantAccountId: stringType().optional()
+  });
+  ((UpdatePaymentServiceGlobals$) => {
+    UpdatePaymentServiceGlobals$.inboundSchema = UpdatePaymentServiceGlobals$inboundSchema;
+    UpdatePaymentServiceGlobals$.outboundSchema = UpdatePaymentServiceGlobals$outboundSchema;
+  })(UpdatePaymentServiceGlobals$ ||= {});
+  UpdatePaymentServiceRequest$inboundSchema = objectType({
+    merchantAccountId: nullableType(stringType()).optional(),
+    PaymentServiceCreate: PaymentServiceCreate$inboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      PaymentServiceCreate: "paymentServiceCreate"
+    });
+  });
+  UpdatePaymentServiceRequest$outboundSchema = objectType({
+    merchantAccountId: nullableType(stringType()).optional(),
+    paymentServiceCreate: PaymentServiceCreate$outboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      paymentServiceCreate: "PaymentServiceCreate"
+    });
+  });
+  ((UpdatePaymentServiceRequest$) => {
+    UpdatePaymentServiceRequest$.inboundSchema = UpdatePaymentServiceRequest$inboundSchema;
+    UpdatePaymentServiceRequest$.outboundSchema = UpdatePaymentServiceRequest$outboundSchema;
+  })(UpdatePaymentServiceRequest$ ||= {});
+});
+
+// src/models/operations/verifypaymentservicecredentials.ts
+var VerifyPaymentServiceCredentialsGlobals$inboundSchema, VerifyPaymentServiceCredentialsGlobals$outboundSchema, VerifyPaymentServiceCredentialsGlobals$, VerifyPaymentServiceCredentialsRequest$inboundSchema, VerifyPaymentServiceCredentialsRequest$outboundSchema, VerifyPaymentServiceCredentialsRequest$;
+var init_verifypaymentservicecredentials2 = __esm(() => {
+  init_lib();
+  init_primitives();
+  init_components();
+  VerifyPaymentServiceCredentialsGlobals$inboundSchema = objectType({
+    merchantAccountId: stringType().optional()
+  });
+  VerifyPaymentServiceCredentialsGlobals$outboundSchema = objectType({
+    merchantAccountId: stringType().optional()
+  });
+  ((VerifyPaymentServiceCredentialsGlobals$) => {
+    VerifyPaymentServiceCredentialsGlobals$.inboundSchema = VerifyPaymentServiceCredentialsGlobals$inboundSchema;
+    VerifyPaymentServiceCredentialsGlobals$.outboundSchema = VerifyPaymentServiceCredentialsGlobals$outboundSchema;
+  })(VerifyPaymentServiceCredentialsGlobals$ ||= {});
+  VerifyPaymentServiceCredentialsRequest$inboundSchema = objectType({
+    timeout_in_seconds: numberType().default(1),
+    merchantAccountId: nullableType(stringType()).optional(),
+    VerifyCredentials: VerifyCredentials$inboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      timeout_in_seconds: "timeoutInSeconds",
+      VerifyCredentials: "verifyCredentials"
+    });
+  });
+  VerifyPaymentServiceCredentialsRequest$outboundSchema = objectType({
+    timeoutInSeconds: numberType().default(1),
+    merchantAccountId: nullableType(stringType()).optional(),
+    verifyCredentials: VerifyCredentials$outboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      timeoutInSeconds: "timeout_in_seconds",
+      verifyCredentials: "VerifyCredentials"
+    });
+  });
+  ((VerifyPaymentServiceCredentialsRequest$) => {
+    VerifyPaymentServiceCredentialsRequest$.inboundSchema = VerifyPaymentServiceCredentialsRequest$inboundSchema;
+    VerifyPaymentServiceCredentialsRequest$.outboundSchema = VerifyPaymentServiceCredentialsRequest$outboundSchema;
+  })(VerifyPaymentServiceCredentialsRequest$ ||= {});
+});
+
 // src/models/operations/voidtransaction.ts
 var VoidTransactionGlobals$inboundSchema, VoidTransactionGlobals$outboundSchema, VoidTransactionGlobals$, VoidTransactionRequest$inboundSchema, VoidTransactionRequest$outboundSchema, VoidTransactionRequest$;
 var init_voidtransaction2 = __esm(() => {
@@ -47845,6 +49240,9 @@ var init_operations = __esm(() => {
   init_createpaymentmethodnetworktoken2();
   init_createpaymentmethodnetworktokencryptogram2();
   init_createpaymentmethodpaymentservicetoken2();
+  init_createpaymentservice2();
+  init_createpaymentservicedefinitionsession2();
+  init_createpaymentservicesession2();
   init_createpayout2();
   init_createtransaction2();
   init_createtransactionrefund2();
@@ -47856,6 +49254,7 @@ var init_operations = __esm(() => {
   init_deletepaymentmethod2();
   init_deletepaymentmethodnetworktoken2();
   init_deletepaymentmethodpaymentservicetoken2();
+  init_deletepaymentservice2();
   init_getbuyer2();
   init_getbuyershippingdetails2();
   init_getcheckoutsession2();
@@ -47863,6 +49262,8 @@ var init_operations = __esm(() => {
   init_getgiftcard2();
   init_getmerchantaccount2();
   init_getpaymentmethod2();
+  init_getpaymentservice2();
+  init_getpaymentservicedefinition2();
   init_getpayout2();
   init_getrefund2();
   init_gettransaction2();
@@ -47882,6 +49283,8 @@ var init_operations = __esm(() => {
   init_listpaymentmethodpaymentservicetokens2();
   init_listpaymentmethods2();
   init_listpaymentoptions2();
+  init_listpaymentservicedefinitions2();
+  init_listpaymentservices2();
   init_listpayouts2();
   init_listtransactionrefunds2();
   init_listtransactions2();
@@ -47895,6 +49298,8 @@ var init_operations = __esm(() => {
   init_updatecheckoutsession2();
   init_updatedigitalwallet2();
   init_updatemerchantaccount2();
+  init_updatepaymentservice2();
+  init_verifypaymentservicecredentials2();
   init_voidtransaction2();
 });
 
@@ -54994,168 +56399,33 @@ List the payment options available at checkout. filtering by country, currency,
   };
 });
 
-// src/funcs/payoutsCreate.ts
-function payoutsCreate(client, payoutCreate, timeoutInSeconds, merchantAccountId, options) {
-  return new APIPromise($do53(client, payoutCreate, timeoutInSeconds, merchantAccountId, options));
-}
-async function $do53(client, payoutCreate, timeoutInSeconds, merchantAccountId, options) {
-  const input = {
-    payoutCreate,
-    timeoutInSeconds,
-    merchantAccountId
-  };
-  const parsed = safeParse(input, (value) => CreatePayoutRequest$outboundSchema.parse(value), "Input validation failed");
-  if (!parsed.ok) {
-    return [parsed, { status: "invalid" }];
-  }
-  const payload = parsed.value;
-  const body = encodeJSON("body", payload.PayoutCreate, { explode: true });
-  const path = pathToFunc("/payouts")();
-  const query = encodeFormQuery({
-    timeout_in_seconds: payload.timeout_in_seconds
-  });
-  const headers = new Headers(compactMap({
-    "Content-Type": "application/json",
-    Accept: "application/json",
-    "x-gr4vy-merchant-account-id": encodeSimple("x-gr4vy-merchant-account-id", payload.merchantAccountId ?? client._options.merchantAccountId, { explode: false, charEncoding: "none" })
-  }));
-  const secConfig = await extractSecurity(client._options.bearerAuth);
-  const securityInput = secConfig == null ? {} : { bearerAuth: secConfig };
-  const requestSecurity = resolveGlobalSecurity(securityInput);
-  const context = {
-    baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "create_payout",
-    oAuth2Scopes: [],
-    resolvedSecurity: requestSecurity,
-    securitySource: client._options.bearerAuth,
-    retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
-    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
-  };
-  const requestRes = client._createRequest(context, {
-    security: requestSecurity,
-    method: "POST",
-    baseURL: options?.serverURL,
-    path,
-    headers,
-    query,
-    body,
-    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
-  }, options);
-  if (!requestRes.ok) {
-    return [requestRes, { status: "invalid" }];
-  }
-  const req = requestRes.value;
-  const doResult = await client._do(req, {
-    context,
-    errorCodes: [
-      "400",
-      "401",
-      "403",
-      "404",
-      "405",
-      "409",
-      "422",
-      "425",
-      "429",
-      "4XX",
-      "500",
-      "502",
-      "504",
-      "5XX"
-    ],
-    retryConfig: context.retryConfig,
-    retryCodes: context.retryCodes
-  });
-  if (!doResult.ok) {
-    return [doResult, { status: "request-error", request: req }];
-  }
-  const response = doResult.value;
-  const responseFields = {
-    HttpMeta: { Response: response, Request: req }
-  };
-  const [result] = await match(json(201, PayoutSummary$inboundSchema), jsonErr(400, Error400$inboundSchema), jsonErr(401, Error401$inboundSchema), jsonErr(403, CreatePayoutResponse403CreatePayout$inboundSchema), jsonErr(404, Error404$inboundSchema), jsonErr(405, Error405$inboundSchema), jsonErr(409, Error409$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), jsonErr(425, Error425$inboundSchema), jsonErr(429, Error429$inboundSchema), jsonErr(500, Error500$inboundSchema), jsonErr(502, Error502$inboundSchema), jsonErr(504, Error504$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
-  if (!result.ok) {
-    return [result, { status: "complete", request: req, response }];
-  }
-  return [result, { status: "complete", request: req, response }];
-}
-var init_payoutsCreate = __esm(() => {
-  init_encodings();
-  init_matchers();
-  init_primitives();
-  init_schemas();
-  init_security();
-  init_url();
-  init_components();
-  init_errors();
-  init_operations();
-  init_async();
-});
-
-// src/mcp-server/tools/payoutsCreate.ts
-var args53, tool$payoutsCreate;
-var init_payoutsCreate2 = __esm(() => {
-  init_lib();
-  init_payoutsCreate();
-  init_components();
-  init_tools();
-  args53 = {
-    payoutCreate: PayoutCreate$inboundSchema,
-    timeoutInSeconds: numberType().default(1),
-    merchantAccountId: nullableType(stringType()).optional()
-  };
-  tool$payoutsCreate = {
-    name: "payouts-create",
-    description: `Create a payout.
-
-Creates a new payout.`,
-    args: args53,
-    tool: async (client, args54, ctx) => {
-      const [result, apiCall] = await payoutsCreate(client, args54.payoutCreate, args54.timeoutInSeconds, args54.merchantAccountId, { fetchOptions: { signal: ctx.signal } }).$inspect();
-      if (!result.ok) {
-        return {
-          content: [{ type: "text", text: result.error.message }],
-          isError: true
-        };
-      }
-      const value = result.value;
-      return formatResult(value, apiCall);
-    }
-  };
-});
-
-// src/funcs/payoutsGet.ts
-function payoutsGet(client, payoutId, merchantAccountId, options) {
-  return new APIPromise($do54(client, payoutId, merchantAccountId, options));
+// src/funcs/paymentServiceDefinitionsGet.ts
+function paymentServiceDefinitionsGet(client, paymentServiceDefinitionId, options) {
+  return new APIPromise($do53(client, paymentServiceDefinitionId, options));
 }
-async function $do54(client, payoutId, merchantAccountId, options) {
+async function $do53(client, paymentServiceDefinitionId, options) {
   const input = {
-    payoutId,
-    merchantAccountId
+    paymentServiceDefinitionId
   };
-  const parsed = safeParse(input, (value) => GetPayoutRequest$outboundSchema.parse(value), "Input validation failed");
+  const parsed = safeParse(input, (value) => GetPaymentServiceDefinitionRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
   }
   const payload = parsed.value;
   const body = null;
   const pathParams = {
-    payout_id: encodeSimple("payout_id", payload.payout_id, {
-      explode: false,
-      charEncoding: "percent"
-    })
+    payment_service_definition_id: encodeSimple("payment_service_definition_id", payload.payment_service_definition_id, { explode: false, charEncoding: "percent" })
   };
-  const path = pathToFunc("/payouts/{payout_id}")(pathParams);
+  const path = pathToFunc("/payment-service-definitions/{payment_service_definition_id}")(pathParams);
   const headers = new Headers(compactMap({
-    Accept: "application/json",
-    "x-gr4vy-merchant-account-id": encodeSimple("x-gr4vy-merchant-account-id", payload.merchantAccountId ?? client._options.merchantAccountId, { explode: false, charEncoding: "none" })
+    Accept: "application/json"
   }));
   const secConfig = await extractSecurity(client._options.bearerAuth);
   const securityInput = secConfig == null ? {} : { bearerAuth: secConfig };
   const requestSecurity = resolveGlobalSecurity(securityInput);
   const context = {
     baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "get_payout",
+    operationID: "get_payment_service_definition",
     oAuth2Scopes: [],
     resolvedSecurity: requestSecurity,
     securitySource: client._options.bearerAuth,
@@ -55212,13 +56482,13 @@ async function $do54(client, payoutId, merchantAccountId, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(json(200, PayoutSummary$inboundSchema), jsonErr(400, Error400$inboundSchema), jsonErr(401, Error401$inboundSchema), jsonErr(403, GetPayoutResponse403GetPayout$inboundSchema), jsonErr(404, Error404$inboundSchema), jsonErr(405, Error405$inboundSchema), jsonErr(409, Error409$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), jsonErr(425, Error425$inboundSchema), jsonErr(429, Error429$inboundSchema), jsonErr(500, Error500$inboundSchema), jsonErr(502, Error502$inboundSchema), jsonErr(504, Error504$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
+  const [result] = await match(json(200, PaymentServiceDefinition$inboundSchema), jsonErr(400, Error400$inboundSchema), jsonErr(401, Error401$inboundSchema), jsonErr(403, GetPaymentServiceDefinitionResponse403GetPaymentServiceDefinition$inboundSchema), jsonErr(404, Error404$inboundSchema), jsonErr(405, Error405$inboundSchema), jsonErr(409, Error409$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), jsonErr(425, Error425$inboundSchema), jsonErr(429, Error429$inboundSchema), jsonErr(500, Error500$inboundSchema), jsonErr(502, Error502$inboundSchema), jsonErr(504, Error504$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
   if (!result.ok) {
     return [result, { status: "complete", request: req, response }];
   }
   return [result, { status: "complete", request: req, response }];
 }
-var init_payoutsGet = __esm(() => {
+var init_paymentServiceDefinitionsGet = __esm(() => {
   init_encodings();
   init_matchers();
   init_primitives();
@@ -55231,24 +56501,23 @@ var init_payoutsGet = __esm(() => {
   init_async();
 });
 
-// src/mcp-server/tools/payoutsGet.ts
-var args54, tool$payoutsGet;
-var init_payoutsGet2 = __esm(() => {
+// src/mcp-server/tools/paymentServiceDefinitionsGet.ts
+var args53, tool$paymentServiceDefinitionsGet;
+var init_paymentServiceDefinitionsGet2 = __esm(() => {
   init_lib();
-  init_payoutsGet();
+  init_paymentServiceDefinitionsGet();
   init_tools();
-  args54 = {
-    payoutId: stringType(),
-    merchantAccountId: nullableType(stringType()).optional()
+  args53 = {
+    paymentServiceDefinitionId: stringType()
   };
-  tool$payoutsGet = {
-    name: "payouts-get",
-    description: `Get a payout.
+  tool$paymentServiceDefinitionsGet = {
+    name: "payment-service-definitions-get",
+    description: `Get a payment service definition
 
-Retreives a payout.`,
-    args: args54,
-    tool: async (client, args55, ctx) => {
-      const [result, apiCall] = await payoutsGet(client, args55.payoutId, args55.merchantAccountId, { fetchOptions: { signal: ctx.signal } }).$inspect();
+Get the definition of a payment service that can be configured.`,
+    args: args53,
+    tool: async (client, args54, ctx) => {
+      const [result, apiCall] = await paymentServiceDefinitionsGet(client, args54.paymentServiceDefinitionId, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -55261,37 +56530,35 @@ Retreives a payout.`,
   };
 });
 
-// src/funcs/payoutsList.ts
-function payoutsList(client, cursor, limit, merchantAccountId, options) {
-  return new APIPromise($do55(client, cursor, limit, merchantAccountId, options));
+// src/funcs/paymentServiceDefinitionsList.ts
+function paymentServiceDefinitionsList(client, cursor, limit, options) {
+  return new APIPromise($do54(client, cursor, limit, options));
 }
-async function $do55(client, cursor, limit, merchantAccountId, options) {
+async function $do54(client, cursor, limit, options) {
   const input = {
     cursor,
-    limit,
-    merchantAccountId
+    limit
   };
-  const parsed = safeParse(input, (value) => ListPayoutsRequest$outboundSchema.optional().parse(value), "Input validation failed");
+  const parsed = safeParse(input, (value) => ListPaymentServiceDefinitionsRequest$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [haltIterator(parsed), { status: "invalid" }];
   }
   const payload = parsed.value;
   const body = null;
-  const path = pathToFunc("/payouts")();
+  const path = pathToFunc("/payment-service-definitions")();
   const query = encodeFormQuery({
     cursor: payload?.cursor,
     limit: payload?.limit
   });
   const headers = new Headers(compactMap({
-    Accept: "application/json",
-    "x-gr4vy-merchant-account-id": encodeSimple("x-gr4vy-merchant-account-id", payload?.merchantAccountId ?? client._options.merchantAccountId, { explode: false, charEncoding: "none" })
+    Accept: "application/json"
   }));
   const secConfig = await extractSecurity(client._options.bearerAuth);
   const securityInput = secConfig == null ? {} : { bearerAuth: secConfig };
   const requestSecurity = resolveGlobalSecurity(securityInput);
   const context = {
     baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "list_payouts",
+    operationID: "list_payment_service_definitions",
     oAuth2Scopes: [],
     resolvedSecurity: requestSecurity,
     securitySource: client._options.bearerAuth,
@@ -55349,9 +56616,7 @@ async function $do55(client, cursor, limit, merchantAccountId, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result, raw] = await match(json(200, ListPayoutsResponse$inboundSchema, {
-    key: "Result"
-  }), jsonErr(400, Error400$inboundSchema), jsonErr(401, Error401$inboundSchema), jsonErr(403, ListPayoutsResponse403ListPayouts$inboundSchema), jsonErr(404, Error404$inboundSchema), jsonErr(405, Error405$inboundSchema), jsonErr(409, Error409$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), jsonErr(425, Error425$inboundSchema), jsonErr(429, Error429$inboundSchema), jsonErr(500, Error500$inboundSchema), jsonErr(502, Error502$inboundSchema), jsonErr(504, Error504$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
+  const [result, raw] = await match(json(200, ListPaymentServiceDefinitionsResponse$inboundSchema, { key: "Result" }), jsonErr(400, Error400$inboundSchema), jsonErr(401, Error401$inboundSchema), jsonErr(403, ListPaymentServiceDefinitionsResponse403ListPaymentServiceDefinitions$inboundSchema), jsonErr(404, Error404$inboundSchema), jsonErr(405, Error405$inboundSchema), jsonErr(409, Error409$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), jsonErr(425, Error425$inboundSchema), jsonErr(429, Error429$inboundSchema), jsonErr(500, Error500$inboundSchema), jsonErr(502, Error502$inboundSchema), jsonErr(504, Error504$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
   if (!result.ok) {
     return [haltIterator(result), {
       status: "complete",
@@ -55364,7 +56629,7 @@ async function $do55(client, cursor, limit, merchantAccountId, options) {
     if (typeof nextCursor !== "string") {
       return { next: () => null };
     }
-    const nextVal = () => payoutsList(client, nextCursor, limit, merchantAccountId, options);
+    const nextVal = () => paymentServiceDefinitionsList(client, nextCursor, limit, options);
     return { next: nextVal, "~next": { cursor: nextCursor } };
   };
   const page = { ...result, ...nextFunc(raw) };
@@ -55374,7 +56639,7 @@ async function $do55(client, cursor, limit, merchantAccountId, options) {
     response
   }];
 }
-var init_payoutsList = __esm(() => {
+var init_paymentServiceDefinitionsList = __esm(() => {
   init_encodings();
   init_matchers();
   init_primitives();
@@ -55387,25 +56652,24 @@ var init_payoutsList = __esm(() => {
   init_operations2();
 });
 
-// src/mcp-server/tools/payoutsList.ts
-var args55, tool$payoutsList;
-var init_payoutsList2 = __esm(() => {
+// src/mcp-server/tools/paymentServiceDefinitionsList.ts
+var args54, tool$paymentServiceDefinitionsList;
+var init_paymentServiceDefinitionsList2 = __esm(() => {
   init_lib();
-  init_payoutsList();
+  init_paymentServiceDefinitionsList();
   init_tools();
-  args55 = {
+  args54 = {
     cursor: nullableType(stringType()).optional(),
-    limit: numberType().int().default(20),
-    merchantAccountId: nullableType(stringType()).optional()
+    limit: numberType().int().default(20)
   };
-  tool$payoutsList = {
-    name: "payouts-list",
-    description: `List payouts created.
+  tool$paymentServiceDefinitionsList = {
+    name: "payment-service-definitions-list",
+    description: `List payment service definitions
 
-Returns a list of payouts made.`,
-    args: args55,
-    tool: async (client, args56, ctx) => {
-      const [result, apiCall] = await payoutsList(client, args56.cursor, args56.limit, args56.merchantAccountId, { fetchOptions: { signal: ctx.signal } }).$inspect();
+List the definitions of each payment service that can be configured.`,
+    args: args54,
+    tool: async (client, args55, ctx) => {
+      const [result, apiCall] = await paymentServiceDefinitionsList(client, args55.cursor, args55.limit, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -55418,29 +56682,151 @@ Returns a list of payouts made.`,
   };
 });
 
-// src/funcs/refundsGet.ts
-function refundsGet(client, refundId, merchantAccountId, options) {
-  return new APIPromise($do56(client, refundId, merchantAccountId, options));
+// src/funcs/paymentServiceDefinitionsSession.ts
+function paymentServiceDefinitionsSession(client, requestBody, paymentServiceDefinitionId, options) {
+  return new APIPromise($do55(client, requestBody, paymentServiceDefinitionId, options));
 }
-async function $do56(client, refundId, merchantAccountId, options) {
+async function $do55(client, requestBody, paymentServiceDefinitionId, options) {
   const input = {
-    refundId,
-    merchantAccountId
+    requestBody,
+    paymentServiceDefinitionId
   };
-  const parsed = safeParse(input, (value) => GetRefundRequest$outboundSchema.parse(value), "Input validation failed");
+  const parsed = safeParse(input, (value) => CreatePaymentServiceDefinitionSessionRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
   }
   const payload = parsed.value;
-  const body = null;
+  const body = encodeJSON("body", payload.RequestBody, { explode: true });
   const pathParams = {
-    refund_id: encodeSimple("refund_id", payload.refund_id, {
-      explode: false,
-      charEncoding: "percent"
-    })
+    payment_service_definition_id: encodeSimple("payment_service_definition_id", payload.payment_service_definition_id, { explode: false, charEncoding: "percent" })
   };
-  const path = pathToFunc("/refunds/{refund_id}")(pathParams);
+  const path = pathToFunc("/payment-service-definitions/{payment_service_definition_id}/sessions")(pathParams);
   const headers = new Headers(compactMap({
+    "Content-Type": "application/json",
+    Accept: "application/json"
+  }));
+  const secConfig = await extractSecurity(client._options.bearerAuth);
+  const securityInput = secConfig == null ? {} : { bearerAuth: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "create_payment_service_definition_session",
+    oAuth2Scopes: [],
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.bearerAuth,
+    retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
+  };
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "POST",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    body,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+  const doResult = await client._do(req, {
+    context,
+    errorCodes: [
+      "400",
+      "401",
+      "403",
+      "404",
+      "405",
+      "409",
+      "422",
+      "425",
+      "429",
+      "4XX",
+      "500",
+      "502",
+      "504",
+      "5XX"
+    ],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req }
+  };
+  const [result] = await match(json(200, CreateSession$inboundSchema), jsonErr(400, Error400$inboundSchema), jsonErr(401, Error401$inboundSchema), jsonErr(403, CreatePaymentServiceDefinitionSessionResponse403CreatePaymentServiceDefinitionSession$inboundSchema), jsonErr(404, Error404$inboundSchema), jsonErr(405, Error405$inboundSchema), jsonErr(409, Error409$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), jsonErr(425, Error425$inboundSchema), jsonErr(429, Error429$inboundSchema), jsonErr(500, Error500$inboundSchema), jsonErr(502, Error502$inboundSchema), jsonErr(504, Error504$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+  return [result, { status: "complete", request: req, response }];
+}
+var init_paymentServiceDefinitionsSession = __esm(() => {
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas();
+  init_security();
+  init_url();
+  init_components();
+  init_errors();
+  init_operations();
+  init_async();
+});
+
+// src/mcp-server/tools/paymentServiceDefinitionsSession.ts
+var args55, tool$paymentServiceDefinitionsSession;
+var init_paymentServiceDefinitionsSession2 = __esm(() => {
+  init_lib();
+  init_paymentServiceDefinitionsSession();
+  init_tools();
+  args55 = {
+    requestBody: recordType(anyType()),
+    paymentServiceDefinitionId: stringType()
+  };
+  tool$paymentServiceDefinitionsSession = {
+    name: "payment-service-definitions-session",
+    description: `Create a session for apayment service definition
+
+Creates a session for a payment service that supports sessions.`,
+    args: args55,
+    tool: async (client, args56, ctx) => {
+      const [result, apiCall] = await paymentServiceDefinitionsSession(client, args56.requestBody, args56.paymentServiceDefinitionId, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      const value = result.value;
+      return formatResult(value, apiCall);
+    }
+  };
+});
+
+// src/funcs/paymentServicesCreate.ts
+function paymentServicesCreate(client, paymentServiceCreate, merchantAccountId, options) {
+  return new APIPromise($do56(client, paymentServiceCreate, merchantAccountId, options));
+}
+async function $do56(client, paymentServiceCreate, merchantAccountId, options) {
+  const input = {
+    paymentServiceCreate,
+    merchantAccountId
+  };
+  const parsed = safeParse(input, (value) => UpdatePaymentServiceRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = encodeJSON("body", payload.PaymentServiceCreate, {
+    explode: true
+  });
+  const path = pathToFunc("/payment-services")();
+  const headers = new Headers(compactMap({
+    "Content-Type": "application/json",
     Accept: "application/json",
     "x-gr4vy-merchant-account-id": encodeSimple("x-gr4vy-merchant-account-id", payload.merchantAccountId ?? client._options.merchantAccountId, { explode: false, charEncoding: "none" })
   }));
@@ -55449,25 +56835,16 @@ async function $do56(client, refundId, merchantAccountId, options) {
   const requestSecurity = resolveGlobalSecurity(securityInput);
   const context = {
     baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "get_refund",
+    operationID: "update_payment_service",
     oAuth2Scopes: [],
     resolvedSecurity: requestSecurity,
     securitySource: client._options.bearerAuth,
-    retryConfig: options?.retries || client._options.retryConfig || {
-      strategy: "backoff",
-      backoff: {
-        initialInterval: 200,
-        maxInterval: 200,
-        exponent: 1,
-        maxElapsedTime: 1000
-      },
-      retryConnectionErrors: true
-    },
-    retryCodes: options?.retryCodes || ["5XX"]
+    retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
   };
   const requestRes = client._createRequest(context, {
     security: requestSecurity,
-    method: "GET",
+    method: "POST",
     baseURL: options?.serverURL,
     path,
     headers,
@@ -55506,13 +56883,13 @@ async function $do56(client, refundId, merchantAccountId, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(json(200, Refund$inboundSchema), jsonErr(400, Error400$inboundSchema), jsonErr(401, Error401$inboundSchema), jsonErr(403, GetRefundResponse403GetRefund$inboundSchema), jsonErr(404, Error404$inboundSchema), jsonErr(405, Error405$inboundSchema), jsonErr(409, Error409$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), jsonErr(425, Error425$inboundSchema), jsonErr(429, Error429$inboundSchema), jsonErr(500, Error500$inboundSchema), jsonErr(502, Error502$inboundSchema), jsonErr(504, Error504$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
+  const [result] = await match(json(201, PaymentService$inboundSchema), jsonErr(400, Error400$inboundSchema), jsonErr(401, Error401$inboundSchema), jsonErr(403, UpdatePaymentServiceResponse403UpdatePaymentService$inboundSchema), jsonErr(404, Error404$inboundSchema), jsonErr(405, Error405$inboundSchema), jsonErr(409, Error409$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), jsonErr(425, Error425$inboundSchema), jsonErr(429, Error429$inboundSchema), jsonErr(500, Error500$inboundSchema), jsonErr(502, Error502$inboundSchema), jsonErr(504, Error504$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
   if (!result.ok) {
     return [result, { status: "complete", request: req, response }];
   }
   return [result, { status: "complete", request: req, response }];
 }
-var init_refundsGet = __esm(() => {
+var init_paymentServicesCreate = __esm(() => {
   init_encodings();
   init_matchers();
   init_primitives();
@@ -55525,24 +56902,25 @@ var init_refundsGet = __esm(() => {
   init_async();
 });
 
-// src/mcp-server/tools/refundsGet.ts
-var args56, tool$refundsGet;
-var init_refundsGet2 = __esm(() => {
+// src/mcp-server/tools/paymentServicesCreate.ts
+var args56, tool$paymentServicesCreate;
+var init_paymentServicesCreate2 = __esm(() => {
   init_lib();
-  init_refundsGet();
+  init_paymentServicesCreate();
+  init_components();
   init_tools();
   args56 = {
-    refundId: stringType(),
+    paymentServiceCreate: PaymentServiceCreate$inboundSchema,
     merchantAccountId: nullableType(stringType()).optional()
   };
-  tool$refundsGet = {
-    name: "refunds-get",
-    description: `Get refund
+  tool$paymentServicesCreate = {
+    name: "payment-services-create",
+    description: `Update a configured payment service
 
-Fetch a refund.`,
+Updates the configuration of a payment service.`,
     args: args56,
     tool: async (client, args57, ctx) => {
-      const [result, apiCall] = await refundsGet(client, args57.refundId, args57.merchantAccountId, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      const [result, apiCall] = await paymentServicesCreate(client, args57.paymentServiceCreate, args57.merchantAccountId, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -55555,37 +56933,30 @@ Fetch a refund.`,
   };
 });
 
-// src/funcs/transactionRefundsAllCreate.ts
-function transactionRefundsAllCreate(client, transactionId, transactionRefundAllCreate, timeoutInSeconds, merchantAccountId, options) {
-  return new APIPromise($do57(client, transactionId, transactionRefundAllCreate, timeoutInSeconds, merchantAccountId, options));
+// src/funcs/paymentServicesDelete.ts
+function paymentServicesDelete(client, paymentServiceId, timeoutInSeconds, merchantAccountId, options) {
+  return new APIPromise($do57(client, paymentServiceId, timeoutInSeconds, merchantAccountId, options));
 }
-async function $do57(client, transactionId, transactionRefundAllCreate, timeoutInSeconds, merchantAccountId, options) {
+async function $do57(client, paymentServiceId, timeoutInSeconds, merchantAccountId, options) {
   const input = {
-    transactionId,
-    transactionRefundAllCreate,
+    paymentServiceId,
     timeoutInSeconds,
     merchantAccountId
   };
-  const parsed = safeParse(input, (value) => CreateFullTransactionRefundRequest$outboundSchema.parse(value), "Input validation failed");
+  const parsed = safeParse(input, (value) => DeletePaymentServiceRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
   }
   const payload = parsed.value;
-  const body = encodeJSON("body", payload.TransactionRefundAllCreate, {
-    explode: true
-  });
+  const body = null;
   const pathParams = {
-    transaction_id: encodeSimple("transaction_id", payload.transaction_id, {
-      explode: false,
-      charEncoding: "percent"
-    })
+    payment_service_id: encodeSimple("payment_service_id", payload.payment_service_id, { explode: false, charEncoding: "percent" })
   };
-  const path = pathToFunc("/transactions/{transaction_id}/refunds/all")(pathParams);
+  const path = pathToFunc("/payment-services/{payment_service_id}")(pathParams);
   const query = encodeFormQuery({
     timeout_in_seconds: payload.timeout_in_seconds
   });
   const headers = new Headers(compactMap({
-    "Content-Type": "application/json",
     Accept: "application/json",
     "x-gr4vy-merchant-account-id": encodeSimple("x-gr4vy-merchant-account-id", payload.merchantAccountId ?? client._options.merchantAccountId, { explode: false, charEncoding: "none" })
   }));
@@ -55594,7 +56965,7 @@ async function $do57(client, transactionId, transactionRefundAllCreate, timeoutI
   const requestSecurity = resolveGlobalSecurity(securityInput);
   const context = {
     baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "create_full_transaction_refund",
+    operationID: "delete_payment_service",
     oAuth2Scopes: [],
     resolvedSecurity: requestSecurity,
     securitySource: client._options.bearerAuth,
@@ -55603,7 +56974,7 @@ async function $do57(client, transactionId, transactionRefundAllCreate, timeoutI
   };
   const requestRes = client._createRequest(context, {
     security: requestSecurity,
-    method: "POST",
+    method: "DELETE",
     baseURL: options?.serverURL,
     path,
     headers,
@@ -55643,46 +57014,44 @@ async function $do57(client, transactionId, transactionRefundAllCreate, timeoutI
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(json(201, CollectionNoCursorRefund$inboundSchema), jsonErr(400, Error400$inboundSchema), jsonErr(401, Error401$inboundSchema), jsonErr(403, CreateFullTransactionRefundResponse403CreateFullTransactionRefund$inboundSchema), jsonErr(404, Error404$inboundSchema), jsonErr(405, Error405$inboundSchema), jsonErr(409, Error409$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), jsonErr(425, Error425$inboundSchema), jsonErr(429, Error429$inboundSchema), jsonErr(500, Error500$inboundSchema), jsonErr(502, Error502$inboundSchema), jsonErr(504, Error504$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
+  const [result] = await match(json(200, anyType()), jsonErr(400, Error400$inboundSchema), jsonErr(401, Error401$inboundSchema), jsonErr(403, DeletePaymentServiceResponse403DeletePaymentService$inboundSchema), jsonErr(404, Error404$inboundSchema), jsonErr(405, Error405$inboundSchema), jsonErr(409, Error409$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), jsonErr(425, Error425$inboundSchema), jsonErr(429, Error429$inboundSchema), jsonErr(500, Error500$inboundSchema), jsonErr(502, Error502$inboundSchema), jsonErr(504, Error504$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
   if (!result.ok) {
     return [result, { status: "complete", request: req, response }];
   }
   return [result, { status: "complete", request: req, response }];
 }
-var init_transactionRefundsAllCreate = __esm(() => {
+var init_paymentServicesDelete = __esm(() => {
+  init_lib();
   init_encodings();
   init_matchers();
   init_primitives();
   init_schemas();
   init_security();
   init_url();
-  init_components();
   init_errors();
   init_operations();
   init_async();
 });
 
-// src/mcp-server/tools/transactionRefundsAllCreate.ts
-var args57, tool$transactionRefundsAllCreate;
-var init_transactionRefundsAllCreate2 = __esm(() => {
+// src/mcp-server/tools/paymentServicesDelete.ts
+var args57, tool$paymentServicesDelete;
+var init_paymentServicesDelete2 = __esm(() => {
   init_lib();
-  init_transactionRefundsAllCreate();
-  init_components();
+  init_paymentServicesDelete();
   init_tools();
   args57 = {
-    transactionId: stringType(),
-    transactionRefundAllCreate: nullableType(TransactionRefundAllCreate$inboundSchema).optional(),
+    paymentServiceId: stringType(),
     timeoutInSeconds: numberType().default(1),
     merchantAccountId: nullableType(stringType()).optional()
   };
-  tool$transactionRefundsAllCreate = {
-    name: "transaction-refunds-all-create",
-    description: `Create batch transaction refund
+  tool$paymentServicesDelete = {
+    name: "payment-services-delete",
+    description: `Delete a configured payment service
 
-Create a refund for all instruments on a transaction.`,
+Deletes all the configuration of a payment service.`,
     args: args57,
     tool: async (client, args58, ctx) => {
-      const [result, apiCall] = await transactionRefundsAllCreate(client, args58.transactionId, args58.transactionRefundAllCreate, args58.timeoutInSeconds, args58.merchantAccountId, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      const [result, apiCall] = await paymentServicesDelete(client, args58.paymentServiceId, args58.timeoutInSeconds, args58.merchantAccountId, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -55695,37 +57064,26 @@ Create a refund for all instruments on a transaction.`,
   };
 });
 
-// src/funcs/transactionRefundsCreate.ts
-function transactionRefundsCreate(client, transactionRefundCreate, transactionId, timeoutInSeconds, merchantAccountId, options) {
-  return new APIPromise($do58(client, transactionRefundCreate, transactionId, timeoutInSeconds, merchantAccountId, options));
+// src/funcs/paymentServicesGet.ts
+function paymentServicesGet(client, paymentServiceId, merchantAccountId, options) {
+  return new APIPromise($do58(client, paymentServiceId, merchantAccountId, options));
 }
-async function $do58(client, transactionRefundCreate, transactionId, timeoutInSeconds, merchantAccountId, options) {
+async function $do58(client, paymentServiceId, merchantAccountId, options) {
   const input = {
-    transactionRefundCreate,
-    transactionId,
-    timeoutInSeconds,
+    paymentServiceId,
     merchantAccountId
   };
-  const parsed = safeParse(input, (value) => CreateTransactionRefundRequest$outboundSchema.parse(value), "Input validation failed");
+  const parsed = safeParse(input, (value) => GetPaymentServiceRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
   }
   const payload = parsed.value;
-  const body = encodeJSON("body", payload.TransactionRefundCreate, {
-    explode: true
-  });
+  const body = null;
   const pathParams = {
-    transaction_id: encodeSimple("transaction_id", payload.transaction_id, {
-      explode: false,
-      charEncoding: "percent"
-    })
+    payment_service_id: encodeSimple("payment_service_id", payload.payment_service_id, { explode: false, charEncoding: "percent" })
   };
-  const path = pathToFunc("/transactions/{transaction_id}/refunds")(pathParams);
-  const query = encodeFormQuery({
-    timeout_in_seconds: payload.timeout_in_seconds
-  });
+  const path = pathToFunc("/payment-services/{payment_service_id}")(pathParams);
   const headers = new Headers(compactMap({
-    "Content-Type": "application/json",
     Accept: "application/json",
     "x-gr4vy-merchant-account-id": encodeSimple("x-gr4vy-merchant-account-id", payload.merchantAccountId ?? client._options.merchantAccountId, { explode: false, charEncoding: "none" })
   }));
@@ -55734,20 +57092,1410 @@ async function $do58(client, transactionRefundCreate, transactionId, timeoutInSe
   const requestSecurity = resolveGlobalSecurity(securityInput);
   const context = {
     baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "create_transaction_refund",
+    operationID: "get_payment_service",
     oAuth2Scopes: [],
     resolvedSecurity: requestSecurity,
     securitySource: client._options.bearerAuth,
-    retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
-    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
+    retryConfig: options?.retries || client._options.retryConfig || {
+      strategy: "backoff",
+      backoff: {
+        initialInterval: 200,
+        maxInterval: 200,
+        exponent: 1,
+        maxElapsedTime: 1000
+      },
+      retryConnectionErrors: true
+    },
+    retryCodes: options?.retryCodes || ["5XX"]
   };
   const requestRes = client._createRequest(context, {
     security: requestSecurity,
-    method: "POST",
+    method: "GET",
     baseURL: options?.serverURL,
     path,
     headers,
-    query,
+    body,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+  const doResult = await client._do(req, {
+    context,
+    errorCodes: [
+      "400",
+      "401",
+      "403",
+      "404",
+      "405",
+      "409",
+      "422",
+      "425",
+      "429",
+      "4XX",
+      "500",
+      "502",
+      "504",
+      "5XX"
+    ],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req }
+  };
+  const [result] = await match(json(200, PaymentService$inboundSchema), jsonErr(400, Error400$inboundSchema), jsonErr(401, Error401$inboundSchema), jsonErr(403, GetPaymentServiceResponse403GetPaymentService$inboundSchema), jsonErr(404, Error404$inboundSchema), jsonErr(405, Error405$inboundSchema), jsonErr(409, Error409$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), jsonErr(425, Error425$inboundSchema), jsonErr(429, Error429$inboundSchema), jsonErr(500, Error500$inboundSchema), jsonErr(502, Error502$inboundSchema), jsonErr(504, Error504$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+  return [result, { status: "complete", request: req, response }];
+}
+var init_paymentServicesGet = __esm(() => {
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas();
+  init_security();
+  init_url();
+  init_components();
+  init_errors();
+  init_operations();
+  init_async();
+});
+
+// src/mcp-server/tools/paymentServicesGet.ts
+var args58, tool$paymentServicesGet;
+var init_paymentServicesGet2 = __esm(() => {
+  init_lib();
+  init_paymentServicesGet();
+  init_tools();
+  args58 = {
+    paymentServiceId: stringType(),
+    merchantAccountId: nullableType(stringType()).optional()
+  };
+  tool$paymentServicesGet = {
+    name: "payment-services-get",
+    description: `Get payment service
+
+Get the details of a configured payment service.`,
+    args: args58,
+    tool: async (client, args59, ctx) => {
+      const [result, apiCall] = await paymentServicesGet(client, args59.paymentServiceId, args59.merchantAccountId, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      const value = result.value;
+      return formatResult(value, apiCall);
+    }
+  };
+});
+
+// src/funcs/paymentServicesList.ts
+function paymentServicesList(client, request, options) {
+  return new APIPromise($do59(client, request, options));
+}
+async function $do59(client, request, options) {
+  const parsed = safeParse(request, (value) => ListPaymentServicesRequest$outboundSchema.optional().parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [haltIterator(parsed), { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = null;
+  const path = pathToFunc("/payment-services")();
+  const query = encodeFormQuery({
+    cursor: payload?.cursor,
+    deleted: payload?.deleted,
+    limit: payload?.limit,
+    method: payload?.method
+  });
+  const headers = new Headers(compactMap({
+    Accept: "application/json",
+    "x-gr4vy-merchant-account-id": encodeSimple("x-gr4vy-merchant-account-id", payload?.merchantAccountId ?? client._options.merchantAccountId, { explode: false, charEncoding: "none" })
+  }));
+  const secConfig = await extractSecurity(client._options.bearerAuth);
+  const securityInput = secConfig == null ? {} : { bearerAuth: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "list_payment_services",
+    oAuth2Scopes: [],
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.bearerAuth,
+    retryConfig: options?.retries || client._options.retryConfig || {
+      strategy: "backoff",
+      backoff: {
+        initialInterval: 200,
+        maxInterval: 200,
+        exponent: 1,
+        maxElapsedTime: 1000
+      },
+      retryConnectionErrors: true
+    },
+    retryCodes: options?.retryCodes || ["5XX"]
+  };
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "GET",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    query,
+    body,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [haltIterator(requestRes), { status: "invalid" }];
+  }
+  const req = requestRes.value;
+  const doResult = await client._do(req, {
+    context,
+    errorCodes: [
+      "400",
+      "401",
+      "403",
+      "404",
+      "405",
+      "409",
+      "422",
+      "425",
+      "429",
+      "4XX",
+      "500",
+      "502",
+      "504",
+      "5XX"
+    ],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [haltIterator(doResult), { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req }
+  };
+  const [result, raw] = await match(json(200, ListPaymentServicesResponse$inboundSchema, {
+    key: "Result"
+  }), jsonErr(400, Error400$inboundSchema), jsonErr(401, Error401$inboundSchema), jsonErr(403, ListPaymentServicesResponse403ListPaymentServices$inboundSchema), jsonErr(404, Error404$inboundSchema), jsonErr(405, Error405$inboundSchema), jsonErr(409, Error409$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), jsonErr(425, Error425$inboundSchema), jsonErr(429, Error429$inboundSchema), jsonErr(500, Error500$inboundSchema), jsonErr(502, Error502$inboundSchema), jsonErr(504, Error504$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
+  if (!result.ok) {
+    return [haltIterator(result), {
+      status: "complete",
+      request: req,
+      response
+    }];
+  }
+  const nextFunc = (responseData) => {
+    const nextCursor = dlv(responseData, "next_cursor");
+    if (typeof nextCursor !== "string") {
+      return { next: () => null };
+    }
+    const nextVal = () => paymentServicesList(client, {
+      ...request,
+      cursor: nextCursor
+    }, options);
+    return { next: nextVal, "~next": { cursor: nextCursor } };
+  };
+  const page = { ...result, ...nextFunc(raw) };
+  return [{ ...page, ...createPageIterator(page, (v2) => !v2.ok) }, {
+    status: "complete",
+    request: req,
+    response
+  }];
+}
+var init_paymentServicesList = __esm(() => {
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas();
+  init_security();
+  init_url();
+  init_errors();
+  init_operations();
+  init_async();
+  init_operations2();
+});
+
+// src/mcp-server/tools/paymentServicesList.ts
+var args59, tool$paymentServicesList;
+var init_paymentServicesList2 = __esm(() => {
+  init_paymentServicesList();
+  init_operations();
+  init_tools();
+  args59 = {
+    request: ListPaymentServicesRequest$inboundSchema.optional()
+  };
+  tool$paymentServicesList = {
+    name: "payment-services-list",
+    description: `List payment services
+
+List the configured payment services.`,
+    args: args59,
+    tool: async (client, args60, ctx) => {
+      const [result, apiCall] = await paymentServicesList(client, args60.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      const value = result.value.result;
+      return formatResult(value, apiCall);
+    }
+  };
+});
+
+// src/funcs/paymentServicesSession.ts
+function paymentServicesSession(client, requestBody, paymentServiceId, merchantAccountId, options) {
+  return new APIPromise($do60(client, requestBody, paymentServiceId, merchantAccountId, options));
+}
+async function $do60(client, requestBody, paymentServiceId, merchantAccountId, options) {
+  const input = {
+    requestBody,
+    paymentServiceId,
+    merchantAccountId
+  };
+  const parsed = safeParse(input, (value) => CreatePaymentServiceSessionRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = encodeJSON("body", payload.RequestBody, { explode: true });
+  const pathParams = {
+    payment_service_id: encodeSimple("payment_service_id", payload.payment_service_id, { explode: false, charEncoding: "percent" })
+  };
+  const path = pathToFunc("/payment-services/{payment_service_id}/sessions")(pathParams);
+  const headers = new Headers(compactMap({
+    "Content-Type": "application/json",
+    Accept: "application/json",
+    "x-gr4vy-merchant-account-id": encodeSimple("x-gr4vy-merchant-account-id", payload.merchantAccountId ?? client._options.merchantAccountId, { explode: false, charEncoding: "none" })
+  }));
+  const secConfig = await extractSecurity(client._options.bearerAuth);
+  const securityInput = secConfig == null ? {} : { bearerAuth: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "create_payment_service_session",
+    oAuth2Scopes: [],
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.bearerAuth,
+    retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
+  };
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "POST",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    body,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+  const doResult = await client._do(req, {
+    context,
+    errorCodes: [
+      "400",
+      "401",
+      "403",
+      "404",
+      "405",
+      "409",
+      "422",
+      "425",
+      "429",
+      "4XX",
+      "500",
+      "502",
+      "504",
+      "5XX"
+    ],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req }
+  };
+  const [result] = await match(json(200, CreateSession$inboundSchema), jsonErr(400, Error400$inboundSchema), jsonErr(401, Error401$inboundSchema), jsonErr(403, CreatePaymentServiceSessionResponse403CreatePaymentServiceSession$inboundSchema), jsonErr(404, Error404$inboundSchema), jsonErr(405, Error405$inboundSchema), jsonErr(409, Error409$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), jsonErr(425, Error425$inboundSchema), jsonErr(429, Error429$inboundSchema), jsonErr(500, Error500$inboundSchema), jsonErr(502, Error502$inboundSchema), jsonErr(504, Error504$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+  return [result, { status: "complete", request: req, response }];
+}
+var init_paymentServicesSession = __esm(() => {
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas();
+  init_security();
+  init_url();
+  init_components();
+  init_errors();
+  init_operations();
+  init_async();
+});
+
+// src/mcp-server/tools/paymentServicesSession.ts
+var args60, tool$paymentServicesSession;
+var init_paymentServicesSession2 = __esm(() => {
+  init_lib();
+  init_paymentServicesSession();
+  init_tools();
+  args60 = {
+    requestBody: recordType(anyType()),
+    paymentServiceId: stringType(),
+    merchantAccountId: nullableType(stringType()).optional()
+  };
+  tool$paymentServicesSession = {
+    name: "payment-services-session",
+    description: `Create a session for apayment service definition
+
+Creates a session for a payment service that supports sessions.`,
+    args: args60,
+    tool: async (client, args61, ctx) => {
+      const [result, apiCall] = await paymentServicesSession(client, args61.requestBody, args61.paymentServiceId, args61.merchantAccountId, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      const value = result.value;
+      return formatResult(value, apiCall);
+    }
+  };
+});
+
+// src/funcs/paymentServicesUpdate.ts
+function paymentServicesUpdate(client, paymentServiceUpdate, paymentServiceId, merchantAccountId, options) {
+  return new APIPromise($do61(client, paymentServiceUpdate, paymentServiceId, merchantAccountId, options));
+}
+async function $do61(client, paymentServiceUpdate, paymentServiceId, merchantAccountId, options) {
+  const input = {
+    paymentServiceUpdate,
+    paymentServiceId,
+    merchantAccountId
+  };
+  const parsed = safeParse(input, (value) => CreatePaymentServiceRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = encodeJSON("body", payload.PaymentServiceUpdate, {
+    explode: true
+  });
+  const pathParams = {
+    payment_service_id: encodeSimple("payment_service_id", payload.payment_service_id, { explode: false, charEncoding: "percent" })
+  };
+  const path = pathToFunc("/payment-services/{payment_service_id}")(pathParams);
+  const headers = new Headers(compactMap({
+    "Content-Type": "application/json",
+    Accept: "application/json",
+    "x-gr4vy-merchant-account-id": encodeSimple("x-gr4vy-merchant-account-id", payload.merchantAccountId ?? client._options.merchantAccountId, { explode: false, charEncoding: "none" })
+  }));
+  const secConfig = await extractSecurity(client._options.bearerAuth);
+  const securityInput = secConfig == null ? {} : { bearerAuth: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "create_payment_service",
+    oAuth2Scopes: [],
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.bearerAuth,
+    retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
+  };
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "PUT",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    body,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+  const doResult = await client._do(req, {
+    context,
+    errorCodes: [
+      "400",
+      "401",
+      "403",
+      "404",
+      "405",
+      "409",
+      "422",
+      "425",
+      "429",
+      "4XX",
+      "500",
+      "502",
+      "504",
+      "5XX"
+    ],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req }
+  };
+  const [result] = await match(json(200, PaymentService$inboundSchema), jsonErr(400, Error400$inboundSchema), jsonErr(401, Error401$inboundSchema), jsonErr(403, CreatePaymentServiceResponse403CreatePaymentService$inboundSchema), jsonErr(404, Error404$inboundSchema), jsonErr(405, Error405$inboundSchema), jsonErr(409, Error409$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), jsonErr(425, Error425$inboundSchema), jsonErr(429, Error429$inboundSchema), jsonErr(500, Error500$inboundSchema), jsonErr(502, Error502$inboundSchema), jsonErr(504, Error504$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+  return [result, { status: "complete", request: req, response }];
+}
+var init_paymentServicesUpdate = __esm(() => {
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas();
+  init_security();
+  init_url();
+  init_components();
+  init_errors();
+  init_operations();
+  init_async();
+});
+
+// src/mcp-server/tools/paymentServicesUpdate.ts
+var args61, tool$paymentServicesUpdate;
+var init_paymentServicesUpdate2 = __esm(() => {
+  init_lib();
+  init_paymentServicesUpdate();
+  init_components();
+  init_tools();
+  args61 = {
+    paymentServiceUpdate: PaymentServiceUpdate$inboundSchema,
+    paymentServiceId: stringType(),
+    merchantAccountId: nullableType(stringType()).optional()
+  };
+  tool$paymentServicesUpdate = {
+    name: "payment-services-update",
+    description: `Configure a payment service
+
+Configures a new payment service for use by merchants.`,
+    args: args61,
+    tool: async (client, args62, ctx) => {
+      const [result, apiCall] = await paymentServicesUpdate(client, args62.paymentServiceUpdate, args62.paymentServiceId, args62.merchantAccountId, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      const value = result.value;
+      return formatResult(value, apiCall);
+    }
+  };
+});
+
+// src/funcs/paymentServicesVerify.ts
+function paymentServicesVerify(client, verifyCredentials, timeoutInSeconds, merchantAccountId, options) {
+  return new APIPromise($do62(client, verifyCredentials, timeoutInSeconds, merchantAccountId, options));
+}
+async function $do62(client, verifyCredentials, timeoutInSeconds, merchantAccountId, options) {
+  const input = {
+    verifyCredentials,
+    timeoutInSeconds,
+    merchantAccountId
+  };
+  const parsed = safeParse(input, (value) => VerifyPaymentServiceCredentialsRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = encodeJSON("body", payload.VerifyCredentials, { explode: true });
+  const path = pathToFunc("/payment-services/verify")();
+  const query = encodeFormQuery({
+    timeout_in_seconds: payload.timeout_in_seconds
+  });
+  const headers = new Headers(compactMap({
+    "Content-Type": "application/json",
+    Accept: "application/json",
+    "x-gr4vy-merchant-account-id": encodeSimple("x-gr4vy-merchant-account-id", payload.merchantAccountId ?? client._options.merchantAccountId, { explode: false, charEncoding: "none" })
+  }));
+  const secConfig = await extractSecurity(client._options.bearerAuth);
+  const securityInput = secConfig == null ? {} : { bearerAuth: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "verify_payment_service_credentials",
+    oAuth2Scopes: [],
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.bearerAuth,
+    retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
+  };
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "POST",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    query,
+    body,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+  const doResult = await client._do(req, {
+    context,
+    errorCodes: [
+      "400",
+      "401",
+      "403",
+      "404",
+      "405",
+      "409",
+      "422",
+      "425",
+      "429",
+      "4XX",
+      "500",
+      "502",
+      "504",
+      "5XX"
+    ],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req }
+  };
+  const [result] = await match(json(200, anyType()), jsonErr(400, Error400$inboundSchema), jsonErr(401, Error401$inboundSchema), jsonErr(403, VerifyPaymentServiceCredentialsResponse403VerifyPaymentServiceCredentials$inboundSchema), jsonErr(404, Error404$inboundSchema), jsonErr(405, Error405$inboundSchema), jsonErr(409, Error409$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), jsonErr(425, Error425$inboundSchema), jsonErr(429, Error429$inboundSchema), jsonErr(500, Error500$inboundSchema), jsonErr(502, Error502$inboundSchema), jsonErr(504, Error504$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+  return [result, { status: "complete", request: req, response }];
+}
+var init_paymentServicesVerify = __esm(() => {
+  init_lib();
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas();
+  init_security();
+  init_url();
+  init_errors();
+  init_operations();
+  init_async();
+});
+
+// src/mcp-server/tools/paymentServicesVerify.ts
+var args62, tool$paymentServicesVerify;
+var init_paymentServicesVerify2 = __esm(() => {
+  init_lib();
+  init_paymentServicesVerify();
+  init_components();
+  init_tools();
+  args62 = {
+    verifyCredentials: VerifyCredentials$inboundSchema,
+    timeoutInSeconds: numberType().default(1),
+    merchantAccountId: nullableType(stringType()).optional()
+  };
+  tool$paymentServicesVerify = {
+    name: "payment-services-verify",
+    description: `Verify payment service credentials
+
+Verify the credentials of a configured payment service`,
+    args: args62,
+    tool: async (client, args63, ctx) => {
+      const [result, apiCall] = await paymentServicesVerify(client, args63.verifyCredentials, args63.timeoutInSeconds, args63.merchantAccountId, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      const value = result.value;
+      return formatResult(value, apiCall);
+    }
+  };
+});
+
+// src/funcs/payoutsCreate.ts
+function payoutsCreate(client, payoutCreate, timeoutInSeconds, merchantAccountId, options) {
+  return new APIPromise($do63(client, payoutCreate, timeoutInSeconds, merchantAccountId, options));
+}
+async function $do63(client, payoutCreate, timeoutInSeconds, merchantAccountId, options) {
+  const input = {
+    payoutCreate,
+    timeoutInSeconds,
+    merchantAccountId
+  };
+  const parsed = safeParse(input, (value) => CreatePayoutRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = encodeJSON("body", payload.PayoutCreate, { explode: true });
+  const path = pathToFunc("/payouts")();
+  const query = encodeFormQuery({
+    timeout_in_seconds: payload.timeout_in_seconds
+  });
+  const headers = new Headers(compactMap({
+    "Content-Type": "application/json",
+    Accept: "application/json",
+    "x-gr4vy-merchant-account-id": encodeSimple("x-gr4vy-merchant-account-id", payload.merchantAccountId ?? client._options.merchantAccountId, { explode: false, charEncoding: "none" })
+  }));
+  const secConfig = await extractSecurity(client._options.bearerAuth);
+  const securityInput = secConfig == null ? {} : { bearerAuth: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "create_payout",
+    oAuth2Scopes: [],
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.bearerAuth,
+    retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
+  };
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "POST",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    query,
+    body,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+  const doResult = await client._do(req, {
+    context,
+    errorCodes: [
+      "400",
+      "401",
+      "403",
+      "404",
+      "405",
+      "409",
+      "422",
+      "425",
+      "429",
+      "4XX",
+      "500",
+      "502",
+      "504",
+      "5XX"
+    ],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req }
+  };
+  const [result] = await match(json(201, PayoutSummary$inboundSchema), jsonErr(400, Error400$inboundSchema), jsonErr(401, Error401$inboundSchema), jsonErr(403, CreatePayoutResponse403CreatePayout$inboundSchema), jsonErr(404, Error404$inboundSchema), jsonErr(405, Error405$inboundSchema), jsonErr(409, Error409$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), jsonErr(425, Error425$inboundSchema), jsonErr(429, Error429$inboundSchema), jsonErr(500, Error500$inboundSchema), jsonErr(502, Error502$inboundSchema), jsonErr(504, Error504$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+  return [result, { status: "complete", request: req, response }];
+}
+var init_payoutsCreate = __esm(() => {
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas();
+  init_security();
+  init_url();
+  init_components();
+  init_errors();
+  init_operations();
+  init_async();
+});
+
+// src/mcp-server/tools/payoutsCreate.ts
+var args63, tool$payoutsCreate;
+var init_payoutsCreate2 = __esm(() => {
+  init_lib();
+  init_payoutsCreate();
+  init_components();
+  init_tools();
+  args63 = {
+    payoutCreate: PayoutCreate$inboundSchema,
+    timeoutInSeconds: numberType().default(1),
+    merchantAccountId: nullableType(stringType()).optional()
+  };
+  tool$payoutsCreate = {
+    name: "payouts-create",
+    description: `Create a payout.
+
+Creates a new payout.`,
+    args: args63,
+    tool: async (client, args64, ctx) => {
+      const [result, apiCall] = await payoutsCreate(client, args64.payoutCreate, args64.timeoutInSeconds, args64.merchantAccountId, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      const value = result.value;
+      return formatResult(value, apiCall);
+    }
+  };
+});
+
+// src/funcs/payoutsGet.ts
+function payoutsGet(client, payoutId, merchantAccountId, options) {
+  return new APIPromise($do64(client, payoutId, merchantAccountId, options));
+}
+async function $do64(client, payoutId, merchantAccountId, options) {
+  const input = {
+    payoutId,
+    merchantAccountId
+  };
+  const parsed = safeParse(input, (value) => GetPayoutRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = null;
+  const pathParams = {
+    payout_id: encodeSimple("payout_id", payload.payout_id, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path = pathToFunc("/payouts/{payout_id}")(pathParams);
+  const headers = new Headers(compactMap({
+    Accept: "application/json",
+    "x-gr4vy-merchant-account-id": encodeSimple("x-gr4vy-merchant-account-id", payload.merchantAccountId ?? client._options.merchantAccountId, { explode: false, charEncoding: "none" })
+  }));
+  const secConfig = await extractSecurity(client._options.bearerAuth);
+  const securityInput = secConfig == null ? {} : { bearerAuth: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "get_payout",
+    oAuth2Scopes: [],
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.bearerAuth,
+    retryConfig: options?.retries || client._options.retryConfig || {
+      strategy: "backoff",
+      backoff: {
+        initialInterval: 200,
+        maxInterval: 200,
+        exponent: 1,
+        maxElapsedTime: 1000
+      },
+      retryConnectionErrors: true
+    },
+    retryCodes: options?.retryCodes || ["5XX"]
+  };
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "GET",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    body,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+  const doResult = await client._do(req, {
+    context,
+    errorCodes: [
+      "400",
+      "401",
+      "403",
+      "404",
+      "405",
+      "409",
+      "422",
+      "425",
+      "429",
+      "4XX",
+      "500",
+      "502",
+      "504",
+      "5XX"
+    ],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req }
+  };
+  const [result] = await match(json(200, PayoutSummary$inboundSchema), jsonErr(400, Error400$inboundSchema), jsonErr(401, Error401$inboundSchema), jsonErr(403, GetPayoutResponse403GetPayout$inboundSchema), jsonErr(404, Error404$inboundSchema), jsonErr(405, Error405$inboundSchema), jsonErr(409, Error409$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), jsonErr(425, Error425$inboundSchema), jsonErr(429, Error429$inboundSchema), jsonErr(500, Error500$inboundSchema), jsonErr(502, Error502$inboundSchema), jsonErr(504, Error504$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+  return [result, { status: "complete", request: req, response }];
+}
+var init_payoutsGet = __esm(() => {
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas();
+  init_security();
+  init_url();
+  init_components();
+  init_errors();
+  init_operations();
+  init_async();
+});
+
+// src/mcp-server/tools/payoutsGet.ts
+var args64, tool$payoutsGet;
+var init_payoutsGet2 = __esm(() => {
+  init_lib();
+  init_payoutsGet();
+  init_tools();
+  args64 = {
+    payoutId: stringType(),
+    merchantAccountId: nullableType(stringType()).optional()
+  };
+  tool$payoutsGet = {
+    name: "payouts-get",
+    description: `Get a payout.
+
+Retreives a payout.`,
+    args: args64,
+    tool: async (client, args65, ctx) => {
+      const [result, apiCall] = await payoutsGet(client, args65.payoutId, args65.merchantAccountId, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      const value = result.value;
+      return formatResult(value, apiCall);
+    }
+  };
+});
+
+// src/funcs/payoutsList.ts
+function payoutsList(client, cursor, limit, merchantAccountId, options) {
+  return new APIPromise($do65(client, cursor, limit, merchantAccountId, options));
+}
+async function $do65(client, cursor, limit, merchantAccountId, options) {
+  const input = {
+    cursor,
+    limit,
+    merchantAccountId
+  };
+  const parsed = safeParse(input, (value) => ListPayoutsRequest$outboundSchema.optional().parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [haltIterator(parsed), { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = null;
+  const path = pathToFunc("/payouts")();
+  const query = encodeFormQuery({
+    cursor: payload?.cursor,
+    limit: payload?.limit
+  });
+  const headers = new Headers(compactMap({
+    Accept: "application/json",
+    "x-gr4vy-merchant-account-id": encodeSimple("x-gr4vy-merchant-account-id", payload?.merchantAccountId ?? client._options.merchantAccountId, { explode: false, charEncoding: "none" })
+  }));
+  const secConfig = await extractSecurity(client._options.bearerAuth);
+  const securityInput = secConfig == null ? {} : { bearerAuth: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "list_payouts",
+    oAuth2Scopes: [],
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.bearerAuth,
+    retryConfig: options?.retries || client._options.retryConfig || {
+      strategy: "backoff",
+      backoff: {
+        initialInterval: 200,
+        maxInterval: 200,
+        exponent: 1,
+        maxElapsedTime: 1000
+      },
+      retryConnectionErrors: true
+    },
+    retryCodes: options?.retryCodes || ["5XX"]
+  };
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "GET",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    query,
+    body,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [haltIterator(requestRes), { status: "invalid" }];
+  }
+  const req = requestRes.value;
+  const doResult = await client._do(req, {
+    context,
+    errorCodes: [
+      "400",
+      "401",
+      "403",
+      "404",
+      "405",
+      "409",
+      "422",
+      "425",
+      "429",
+      "4XX",
+      "500",
+      "502",
+      "504",
+      "5XX"
+    ],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [haltIterator(doResult), { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req }
+  };
+  const [result, raw] = await match(json(200, ListPayoutsResponse$inboundSchema, {
+    key: "Result"
+  }), jsonErr(400, Error400$inboundSchema), jsonErr(401, Error401$inboundSchema), jsonErr(403, ListPayoutsResponse403ListPayouts$inboundSchema), jsonErr(404, Error404$inboundSchema), jsonErr(405, Error405$inboundSchema), jsonErr(409, Error409$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), jsonErr(425, Error425$inboundSchema), jsonErr(429, Error429$inboundSchema), jsonErr(500, Error500$inboundSchema), jsonErr(502, Error502$inboundSchema), jsonErr(504, Error504$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
+  if (!result.ok) {
+    return [haltIterator(result), {
+      status: "complete",
+      request: req,
+      response
+    }];
+  }
+  const nextFunc = (responseData) => {
+    const nextCursor = dlv(responseData, "next_cursor");
+    if (typeof nextCursor !== "string") {
+      return { next: () => null };
+    }
+    const nextVal = () => payoutsList(client, nextCursor, limit, merchantAccountId, options);
+    return { next: nextVal, "~next": { cursor: nextCursor } };
+  };
+  const page = { ...result, ...nextFunc(raw) };
+  return [{ ...page, ...createPageIterator(page, (v2) => !v2.ok) }, {
+    status: "complete",
+    request: req,
+    response
+  }];
+}
+var init_payoutsList = __esm(() => {
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas();
+  init_security();
+  init_url();
+  init_errors();
+  init_operations();
+  init_async();
+  init_operations2();
+});
+
+// src/mcp-server/tools/payoutsList.ts
+var args65, tool$payoutsList;
+var init_payoutsList2 = __esm(() => {
+  init_lib();
+  init_payoutsList();
+  init_tools();
+  args65 = {
+    cursor: nullableType(stringType()).optional(),
+    limit: numberType().int().default(20),
+    merchantAccountId: nullableType(stringType()).optional()
+  };
+  tool$payoutsList = {
+    name: "payouts-list",
+    description: `List payouts created.
+
+Returns a list of payouts made.`,
+    args: args65,
+    tool: async (client, args66, ctx) => {
+      const [result, apiCall] = await payoutsList(client, args66.cursor, args66.limit, args66.merchantAccountId, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      const value = result.value.result;
+      return formatResult(value, apiCall);
+    }
+  };
+});
+
+// src/funcs/refundsGet.ts
+function refundsGet(client, refundId, merchantAccountId, options) {
+  return new APIPromise($do66(client, refundId, merchantAccountId, options));
+}
+async function $do66(client, refundId, merchantAccountId, options) {
+  const input = {
+    refundId,
+    merchantAccountId
+  };
+  const parsed = safeParse(input, (value) => GetRefundRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = null;
+  const pathParams = {
+    refund_id: encodeSimple("refund_id", payload.refund_id, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path = pathToFunc("/refunds/{refund_id}")(pathParams);
+  const headers = new Headers(compactMap({
+    Accept: "application/json",
+    "x-gr4vy-merchant-account-id": encodeSimple("x-gr4vy-merchant-account-id", payload.merchantAccountId ?? client._options.merchantAccountId, { explode: false, charEncoding: "none" })
+  }));
+  const secConfig = await extractSecurity(client._options.bearerAuth);
+  const securityInput = secConfig == null ? {} : { bearerAuth: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "get_refund",
+    oAuth2Scopes: [],
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.bearerAuth,
+    retryConfig: options?.retries || client._options.retryConfig || {
+      strategy: "backoff",
+      backoff: {
+        initialInterval: 200,
+        maxInterval: 200,
+        exponent: 1,
+        maxElapsedTime: 1000
+      },
+      retryConnectionErrors: true
+    },
+    retryCodes: options?.retryCodes || ["5XX"]
+  };
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "GET",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    body,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+  const doResult = await client._do(req, {
+    context,
+    errorCodes: [
+      "400",
+      "401",
+      "403",
+      "404",
+      "405",
+      "409",
+      "422",
+      "425",
+      "429",
+      "4XX",
+      "500",
+      "502",
+      "504",
+      "5XX"
+    ],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req }
+  };
+  const [result] = await match(json(200, Refund$inboundSchema), jsonErr(400, Error400$inboundSchema), jsonErr(401, Error401$inboundSchema), jsonErr(403, GetRefundResponse403GetRefund$inboundSchema), jsonErr(404, Error404$inboundSchema), jsonErr(405, Error405$inboundSchema), jsonErr(409, Error409$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), jsonErr(425, Error425$inboundSchema), jsonErr(429, Error429$inboundSchema), jsonErr(500, Error500$inboundSchema), jsonErr(502, Error502$inboundSchema), jsonErr(504, Error504$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+  return [result, { status: "complete", request: req, response }];
+}
+var init_refundsGet = __esm(() => {
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas();
+  init_security();
+  init_url();
+  init_components();
+  init_errors();
+  init_operations();
+  init_async();
+});
+
+// src/mcp-server/tools/refundsGet.ts
+var args66, tool$refundsGet;
+var init_refundsGet2 = __esm(() => {
+  init_lib();
+  init_refundsGet();
+  init_tools();
+  args66 = {
+    refundId: stringType(),
+    merchantAccountId: nullableType(stringType()).optional()
+  };
+  tool$refundsGet = {
+    name: "refunds-get",
+    description: `Get refund
+
+Fetch a refund.`,
+    args: args66,
+    tool: async (client, args67, ctx) => {
+      const [result, apiCall] = await refundsGet(client, args67.refundId, args67.merchantAccountId, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      const value = result.value;
+      return formatResult(value, apiCall);
+    }
+  };
+});
+
+// src/funcs/transactionRefundsAllCreate.ts
+function transactionRefundsAllCreate(client, transactionId, transactionRefundAllCreate, timeoutInSeconds, merchantAccountId, options) {
+  return new APIPromise($do67(client, transactionId, transactionRefundAllCreate, timeoutInSeconds, merchantAccountId, options));
+}
+async function $do67(client, transactionId, transactionRefundAllCreate, timeoutInSeconds, merchantAccountId, options) {
+  const input = {
+    transactionId,
+    transactionRefundAllCreate,
+    timeoutInSeconds,
+    merchantAccountId
+  };
+  const parsed = safeParse(input, (value) => CreateFullTransactionRefundRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = encodeJSON("body", payload.TransactionRefundAllCreate, {
+    explode: true
+  });
+  const pathParams = {
+    transaction_id: encodeSimple("transaction_id", payload.transaction_id, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path = pathToFunc("/transactions/{transaction_id}/refunds/all")(pathParams);
+  const query = encodeFormQuery({
+    timeout_in_seconds: payload.timeout_in_seconds
+  });
+  const headers = new Headers(compactMap({
+    "Content-Type": "application/json",
+    Accept: "application/json",
+    "x-gr4vy-merchant-account-id": encodeSimple("x-gr4vy-merchant-account-id", payload.merchantAccountId ?? client._options.merchantAccountId, { explode: false, charEncoding: "none" })
+  }));
+  const secConfig = await extractSecurity(client._options.bearerAuth);
+  const securityInput = secConfig == null ? {} : { bearerAuth: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "create_full_transaction_refund",
+    oAuth2Scopes: [],
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.bearerAuth,
+    retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
+  };
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "POST",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    query,
+    body,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+  const doResult = await client._do(req, {
+    context,
+    errorCodes: [
+      "400",
+      "401",
+      "403",
+      "404",
+      "405",
+      "409",
+      "422",
+      "425",
+      "429",
+      "4XX",
+      "500",
+      "502",
+      "504",
+      "5XX"
+    ],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req }
+  };
+  const [result] = await match(json(201, CollectionNoCursorRefund$inboundSchema), jsonErr(400, Error400$inboundSchema), jsonErr(401, Error401$inboundSchema), jsonErr(403, CreateFullTransactionRefundResponse403CreateFullTransactionRefund$inboundSchema), jsonErr(404, Error404$inboundSchema), jsonErr(405, Error405$inboundSchema), jsonErr(409, Error409$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), jsonErr(425, Error425$inboundSchema), jsonErr(429, Error429$inboundSchema), jsonErr(500, Error500$inboundSchema), jsonErr(502, Error502$inboundSchema), jsonErr(504, Error504$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+  return [result, { status: "complete", request: req, response }];
+}
+var init_transactionRefundsAllCreate = __esm(() => {
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas();
+  init_security();
+  init_url();
+  init_components();
+  init_errors();
+  init_operations();
+  init_async();
+});
+
+// src/mcp-server/tools/transactionRefundsAllCreate.ts
+var args67, tool$transactionRefundsAllCreate;
+var init_transactionRefundsAllCreate2 = __esm(() => {
+  init_lib();
+  init_transactionRefundsAllCreate();
+  init_components();
+  init_tools();
+  args67 = {
+    transactionId: stringType(),
+    transactionRefundAllCreate: nullableType(TransactionRefundAllCreate$inboundSchema).optional(),
+    timeoutInSeconds: numberType().default(1),
+    merchantAccountId: nullableType(stringType()).optional()
+  };
+  tool$transactionRefundsAllCreate = {
+    name: "transaction-refunds-all-create",
+    description: `Create batch transaction refund
+
+Create a refund for all instruments on a transaction.`,
+    args: args67,
+    tool: async (client, args68, ctx) => {
+      const [result, apiCall] = await transactionRefundsAllCreate(client, args68.transactionId, args68.transactionRefundAllCreate, args68.timeoutInSeconds, args68.merchantAccountId, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      const value = result.value;
+      return formatResult(value, apiCall);
+    }
+  };
+});
+
+// src/funcs/transactionRefundsCreate.ts
+function transactionRefundsCreate(client, transactionRefundCreate, transactionId, timeoutInSeconds, merchantAccountId, options) {
+  return new APIPromise($do68(client, transactionRefundCreate, transactionId, timeoutInSeconds, merchantAccountId, options));
+}
+async function $do68(client, transactionRefundCreate, transactionId, timeoutInSeconds, merchantAccountId, options) {
+  const input = {
+    transactionRefundCreate,
+    transactionId,
+    timeoutInSeconds,
+    merchantAccountId
+  };
+  const parsed = safeParse(input, (value) => CreateTransactionRefundRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = encodeJSON("body", payload.TransactionRefundCreate, {
+    explode: true
+  });
+  const pathParams = {
+    transaction_id: encodeSimple("transaction_id", payload.transaction_id, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path = pathToFunc("/transactions/{transaction_id}/refunds")(pathParams);
+  const query = encodeFormQuery({
+    timeout_in_seconds: payload.timeout_in_seconds
+  });
+  const headers = new Headers(compactMap({
+    "Content-Type": "application/json",
+    Accept: "application/json",
+    "x-gr4vy-merchant-account-id": encodeSimple("x-gr4vy-merchant-account-id", payload.merchantAccountId ?? client._options.merchantAccountId, { explode: false, charEncoding: "none" })
+  }));
+  const secConfig = await extractSecurity(client._options.bearerAuth);
+  const securityInput = secConfig == null ? {} : { bearerAuth: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "create_transaction_refund",
+    oAuth2Scopes: [],
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.bearerAuth,
+    retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
+  };
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "POST",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    query,
     body,
     timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
   }, options);
@@ -55803,13 +58551,13 @@ var init_transactionRefundsCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/transactionRefundsCreate.ts
-var args58, tool$transactionRefundsCreate;
+var args68, tool$transactionRefundsCreate;
 var init_transactionRefundsCreate2 = __esm(() => {
   init_lib();
   init_transactionRefundsCreate();
   init_components();
   init_tools();
-  args58 = {
+  args68 = {
     transactionRefundCreate: TransactionRefundCreate$inboundSchema,
     transactionId: stringType(),
     timeoutInSeconds: numberType().default(1),
@@ -55820,9 +58568,9 @@ var init_transactionRefundsCreate2 = __esm(() => {
     description: `Create transaction refund
 
 Create a refund for a transaction.`,
-    args: args58,
-    tool: async (client, args59, ctx) => {
-      const [result, apiCall] = await transactionRefundsCreate(client, args59.transactionRefundCreate, args59.transactionId, args59.timeoutInSeconds, args59.merchantAccountId, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args68,
+    tool: async (client, args69, ctx) => {
+      const [result, apiCall] = await transactionRefundsCreate(client, args69.transactionRefundCreate, args69.transactionId, args69.timeoutInSeconds, args69.merchantAccountId, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -55837,9 +58585,9 @@ Create a refund for a transaction.`,
 
 // src/funcs/transactionsCapture.ts
 function transactionsCapture(client, transactionCapture, transactionId, timeoutInSeconds, merchantAccountId, options) {
-  return new APIPromise($do59(client, transactionCapture, transactionId, timeoutInSeconds, merchantAccountId, options));
+  return new APIPromise($do69(client, transactionCapture, transactionId, timeoutInSeconds, merchantAccountId, options));
 }
-async function $do59(client, transactionCapture, transactionId, timeoutInSeconds, merchantAccountId, options) {
+async function $do69(client, transactionCapture, transactionId, timeoutInSeconds, merchantAccountId, options) {
   const input = {
     transactionCapture,
     transactionId,
@@ -55943,13 +58691,13 @@ var init_transactionsCapture = __esm(() => {
 });
 
 // src/mcp-server/tools/transactionsCapture.ts
-var args59, tool$transactionsCapture;
+var args69, tool$transactionsCapture;
 var init_transactionsCapture2 = __esm(() => {
   init_lib();
   init_transactionsCapture();
   init_components();
   init_tools();
-  args59 = {
+  args69 = {
     transactionCapture: TransactionCapture$inboundSchema,
     transactionId: stringType(),
     timeoutInSeconds: numberType().default(1),
@@ -55960,9 +58708,9 @@ var init_transactionsCapture2 = __esm(() => {
     description: `Capture transaction
 
 Capture a previously authorized transaction.`,
-    args: args59,
-    tool: async (client, args60, ctx) => {
-      const [result, apiCall] = await transactionsCapture(client, args60.transactionCapture, args60.transactionId, args60.timeoutInSeconds, args60.merchantAccountId, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args69,
+    tool: async (client, args70, ctx) => {
+      const [result, apiCall] = await transactionsCapture(client, args70.transactionCapture, args70.transactionId, args70.timeoutInSeconds, args70.merchantAccountId, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -55977,9 +58725,9 @@ Capture a previously authorized transaction.`,
 
 // src/funcs/transactionsCreate.ts
 function transactionsCreate(client, transactionCreate, timeoutInSeconds, merchantAccountId, idempotencyKey, options) {
-  return new APIPromise($do60(client, transactionCreate, timeoutInSeconds, merchantAccountId, idempotencyKey, options));
+  return new APIPromise($do70(client, transactionCreate, timeoutInSeconds, merchantAccountId, idempotencyKey, options));
 }
-async function $do60(client, transactionCreate, timeoutInSeconds, merchantAccountId, idempotencyKey, options) {
+async function $do70(client, transactionCreate, timeoutInSeconds, merchantAccountId, idempotencyKey, options) {
   const input = {
     transactionCreate,
     timeoutInSeconds,
@@ -56075,13 +58823,13 @@ var init_transactionsCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/transactionsCreate.ts
-var args60, tool$transactionsCreate;
+var args70, tool$transactionsCreate;
 var init_transactionsCreate2 = __esm(() => {
   init_lib();
   init_transactionsCreate();
   init_components();
   init_tools();
-  args60 = {
+  args70 = {
     transactionCreate: TransactionCreate$inboundSchema,
     timeoutInSeconds: numberType().default(1),
     merchantAccountId: nullableType(stringType()).optional(),
@@ -56092,9 +58840,9 @@ var init_transactionsCreate2 = __esm(() => {
     description: `Create transaction
 
 Create a transaction.`,
-    args: args60,
-    tool: async (client, args61, ctx) => {
-      const [result, apiCall] = await transactionsCreate(client, args61.transactionCreate, args61.timeoutInSeconds, args61.merchantAccountId, args61.idempotencyKey, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args70,
+    tool: async (client, args71, ctx) => {
+      const [result, apiCall] = await transactionsCreate(client, args71.transactionCreate, args71.timeoutInSeconds, args71.merchantAccountId, args71.idempotencyKey, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -56109,9 +58857,9 @@ Create a transaction.`,
 
 // src/funcs/transactionsGet.ts
 function transactionsGet(client, transactionId, merchantAccountId, options) {
-  return new APIPromise($do61(client, transactionId, merchantAccountId, options));
+  return new APIPromise($do71(client, transactionId, merchantAccountId, options));
 }
-async function $do61(client, transactionId, merchantAccountId, options) {
+async function $do71(client, transactionId, merchantAccountId, options) {
   const input = {
     transactionId,
     merchantAccountId
@@ -56215,12 +58963,12 @@ var init_transactionsGet = __esm(() => {
 });
 
 // src/mcp-server/tools/transactionsGet.ts
-var args61, tool$transactionsGet;
+var args71, tool$transactionsGet;
 var init_transactionsGet2 = __esm(() => {
   init_lib();
   init_transactionsGet();
   init_tools();
-  args61 = {
+  args71 = {
     transactionId: stringType(),
     merchantAccountId: nullableType(stringType()).optional()
   };
@@ -56229,9 +58977,9 @@ var init_transactionsGet2 = __esm(() => {
     description: `Get transaction
 
 Fetch a single transaction by its ID.`,
-    args: args61,
-    tool: async (client, args62, ctx) => {
-      const [result, apiCall] = await transactionsGet(client, args62.transactionId, args62.merchantAccountId, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args71,
+    tool: async (client, args72, ctx) => {
+      const [result, apiCall] = await transactionsGet(client, args72.transactionId, args72.merchantAccountId, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -56246,9 +58994,9 @@ Fetch a single transaction by its ID.`,
 
 // src/funcs/transactionsList.ts
 function transactionsList(client, request, options) {
-  return new APIPromise($do62(client, request, options));
+  return new APIPromise($do72(client, request, options));
 }
-async function $do62(client, request, options) {
+async function $do72(client, request, options) {
   const parsed = safeParse(request, (value) => ListTransactionsRequest$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [haltIterator(parsed), { status: "invalid" }];
@@ -56404,12 +59152,12 @@ var init_transactionsList = __esm(() => {
 });
 
 // src/mcp-server/tools/transactionsList.ts
-var args62, tool$transactionsList;
+var args72, tool$transactionsList;
 var init_transactionsList2 = __esm(() => {
   init_transactionsList();
   init_operations();
   init_tools();
-  args62 = {
+  args72 = {
     request: ListTransactionsRequest$inboundSchema.optional()
   };
   tool$transactionsList = {
@@ -56417,9 +59165,9 @@ var init_transactionsList2 = __esm(() => {
     description: `List transactions
 
 List all transactions for a specific merchant account sorted by most recently created.`,
-    args: args62,
-    tool: async (client, args63, ctx) => {
-      const [result, apiCall] = await transactionsList(client, args63.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args72,
+    tool: async (client, args73, ctx) => {
+      const [result, apiCall] = await transactionsList(client, args73.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -56434,9 +59182,9 @@ List all transactions for a specific merchant account sorted by most recently cr
 
 // src/funcs/transactionsRefundsGet.ts
 function transactionsRefundsGet(client, transactionId, refundId, merchantAccountId, options) {
-  return new APIPromise($do63(client, transactionId, refundId, merchantAccountId, options));
+  return new APIPromise($do73(client, transactionId, refundId, merchantAccountId, options));
 }
-async function $do63(client, transactionId, refundId, merchantAccountId, options) {
+async function $do73(client, transactionId, refundId, merchantAccountId, options) {
   const input = {
     transactionId,
     refundId,
@@ -56545,12 +59293,12 @@ var init_transactionsRefundsGet = __esm(() => {
 });
 
 // src/mcp-server/tools/transactionsRefundsGet.ts
-var args63, tool$transactionsRefundsGet;
+var args73, tool$transactionsRefundsGet;
 var init_transactionsRefundsGet2 = __esm(() => {
   init_lib();
   init_transactionsRefundsGet();
   init_tools();
-  args63 = {
+  args73 = {
     transactionId: stringType(),
     refundId: stringType(),
     merchantAccountId: nullableType(stringType()).optional()
@@ -56560,9 +59308,9 @@ var init_transactionsRefundsGet2 = __esm(() => {
     description: `Get transaction refund
 
 Fetch refund for a transaction.`,
-    args: args63,
-    tool: async (client, args64, ctx) => {
-      const [result, apiCall] = await transactionsRefundsGet(client, args64.transactionId, args64.refundId, args64.merchantAccountId, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args73,
+    tool: async (client, args74, ctx) => {
+      const [result, apiCall] = await transactionsRefundsGet(client, args74.transactionId, args74.refundId, args74.merchantAccountId, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -56577,9 +59325,9 @@ Fetch refund for a transaction.`,
 
 // src/funcs/transactionsRefundsList.ts
 function transactionsRefundsList(client, transactionId, merchantAccountId, options) {
-  return new APIPromise($do64(client, transactionId, merchantAccountId, options));
+  return new APIPromise($do74(client, transactionId, merchantAccountId, options));
 }
-async function $do64(client, transactionId, merchantAccountId, options) {
+async function $do74(client, transactionId, merchantAccountId, options) {
   const input = {
     transactionId,
     merchantAccountId
@@ -56683,12 +59431,12 @@ var init_transactionsRefundsList = __esm(() => {
 });
 
 // src/mcp-server/tools/transactionsRefundsList.ts
-var args64, tool$transactionsRefundsList;
+var args74, tool$transactionsRefundsList;
 var init_transactionsRefundsList2 = __esm(() => {
   init_lib();
   init_transactionsRefundsList();
   init_tools();
-  args64 = {
+  args74 = {
     transactionId: stringType(),
     merchantAccountId: nullableType(stringType()).optional()
   };
@@ -56697,9 +59445,9 @@ var init_transactionsRefundsList2 = __esm(() => {
     description: `List transaction refunds
 
 List refunds for a transaction.`,
-    args: args64,
-    tool: async (client, args65, ctx) => {
-      const [result, apiCall] = await transactionsRefundsList(client, args65.transactionId, args65.merchantAccountId, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args74,
+    tool: async (client, args75, ctx) => {
+      const [result, apiCall] = await transactionsRefundsList(client, args75.transactionId, args75.merchantAccountId, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -56714,9 +59462,9 @@ List refunds for a transaction.`,
 
 // src/funcs/transactionsSummary.ts
 function transactionsSummary(client, transactionId, merchantAccountId, options) {
-  return new APIPromise($do65(client, transactionId, merchantAccountId, options));
+  return new APIPromise($do75(client, transactionId, merchantAccountId, options));
 }
-async function $do65(client, transactionId, merchantAccountId, options) {
+async function $do75(client, transactionId, merchantAccountId, options) {
   const input = {
     transactionId,
     merchantAccountId
@@ -56820,12 +59568,12 @@ var init_transactionsSummary = __esm(() => {
 });
 
 // src/mcp-server/tools/transactionsSummary.ts
-var args65, tool$transactionsSummary;
+var args75, tool$transactionsSummary;
 var init_transactionsSummary2 = __esm(() => {
   init_lib();
   init_transactionsSummary();
   init_tools();
-  args65 = {
+  args75 = {
     transactionId: stringType(),
     merchantAccountId: nullableType(stringType()).optional()
   };
@@ -56834,9 +59582,9 @@ var init_transactionsSummary2 = __esm(() => {
     description: `Get transaction summary
 
 Fetch a summary for a transaction.`,
-    args: args65,
-    tool: async (client, args66, ctx) => {
-      const [result, apiCall] = await transactionsSummary(client, args66.transactionId, args66.merchantAccountId, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args75,
+    tool: async (client, args76, ctx) => {
+      const [result, apiCall] = await transactionsSummary(client, args76.transactionId, args76.merchantAccountId, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -56851,9 +59599,9 @@ Fetch a summary for a transaction.`,
 
 // src/funcs/transactionsSync.ts
 function transactionsSync(client, transactionId, timeoutInSeconds, merchantAccountId, options) {
-  return new APIPromise($do66(client, transactionId, timeoutInSeconds, merchantAccountId, options));
+  return new APIPromise($do76(client, transactionId, timeoutInSeconds, merchantAccountId, options));
 }
-async function $do66(client, transactionId, timeoutInSeconds, merchantAccountId, options) {
+async function $do76(client, transactionId, timeoutInSeconds, merchantAccountId, options) {
   const input = {
     transactionId,
     timeoutInSeconds,
@@ -56953,12 +59701,12 @@ var init_transactionsSync = __esm(() => {
 });
 
 // src/mcp-server/tools/transactionsSync.ts
-var args66, tool$transactionsSync;
+var args76, tool$transactionsSync;
 var init_transactionsSync2 = __esm(() => {
   init_lib();
   init_transactionsSync();
   init_tools();
-  args66 = {
+  args76 = {
     transactionId: stringType(),
     timeoutInSeconds: numberType().default(1),
     merchantAccountId: nullableType(stringType()).optional()
@@ -56968,9 +59716,9 @@ var init_transactionsSync2 = __esm(() => {
     description: `Sync transaction
 
 Fetch the latest status for a transaction.`,
-    args: args66,
-    tool: async (client, args67, ctx) => {
-      const [result, apiCall] = await transactionsSync(client, args67.transactionId, args67.timeoutInSeconds, args67.merchantAccountId, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args76,
+    tool: async (client, args77, ctx) => {
+      const [result, apiCall] = await transactionsSync(client, args77.transactionId, args77.timeoutInSeconds, args77.merchantAccountId, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -56985,9 +59733,9 @@ Fetch the latest status for a transaction.`,
 
 // src/funcs/transactionsVoid.ts
 function transactionsVoid(client, transactionId, timeoutInSeconds, merchantAccountId, options) {
-  return new APIPromise($do67(client, transactionId, timeoutInSeconds, merchantAccountId, options));
+  return new APIPromise($do77(client, transactionId, timeoutInSeconds, merchantAccountId, options));
 }
-async function $do67(client, transactionId, timeoutInSeconds, merchantAccountId, options) {
+async function $do77(client, transactionId, timeoutInSeconds, merchantAccountId, options) {
   const input = {
     transactionId,
     timeoutInSeconds,
@@ -57087,12 +59835,12 @@ var init_transactionsVoid = __esm(() => {
 });
 
 // src/mcp-server/tools/transactionsVoid.ts
-var args67, tool$transactionsVoid;
+var args77, tool$transactionsVoid;
 var init_transactionsVoid2 = __esm(() => {
   init_lib();
   init_transactionsVoid();
   init_tools();
-  args67 = {
+  args77 = {
     transactionId: stringType(),
     timeoutInSeconds: numberType().default(1),
     merchantAccountId: nullableType(stringType()).optional()
@@ -57102,9 +59850,9 @@ var init_transactionsVoid2 = __esm(() => {
     description: `Void transaction
 
 Void a previously authorized transaction.`,
-    args: args67,
-    tool: async (client, args68, ctx) => {
-      const [result, apiCall] = await transactionsVoid(client, args68.transactionId, args68.timeoutInSeconds, args68.merchantAccountId, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args77,
+    tool: async (client, args78, ctx) => {
+      const [result, apiCall] = await transactionsVoid(client, args78.transactionId, args78.timeoutInSeconds, args78.merchantAccountId, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -57121,7 +59869,7 @@ Void a previously authorized transaction.`,
 function createMCPServer(deps) {
   const server = new McpServer({
     name: "Gr4vy",
-    version: "0.18.16"
+    version: "0.18.17"
   });
   const client = new Gr4vyCore({
     bearerAuth: deps.bearerAuth,
@@ -57165,6 +59913,16 @@ function createMCPServer(deps) {
   tool(tool$transactionsSync);
   tool(tool$refundsGet);
   tool(tool$paymentOptionsList);
+  tool(tool$paymentServiceDefinitionsList);
+  tool(tool$paymentServiceDefinitionsGet);
+  tool(tool$paymentServiceDefinitionsSession);
+  tool(tool$paymentServicesList);
+  tool(tool$paymentServicesCreate);
+  tool(tool$paymentServicesGet);
+  tool(tool$paymentServicesUpdate);
+  tool(tool$paymentServicesDelete);
+  tool(tool$paymentServicesVerify);
+  tool(tool$paymentServicesSession);
   tool(tool$auditLogsList);
   tool(tool$checkoutSessionsCreate);
   tool(tool$checkoutSessionsUpdate);
@@ -57263,6 +60021,16 @@ var init_server2 = __esm(() => {
   init_paymentMethodsPaymentServiceTokensDelete2();
   init_paymentMethodsPaymentServiceTokensList2();
   init_paymentOptionsList2();
+  init_paymentServiceDefinitionsGet2();
+  init_paymentServiceDefinitionsList2();
+  init_paymentServiceDefinitionsSession2();
+  init_paymentServicesCreate2();
+  init_paymentServicesDelete2();
+  init_paymentServicesGet2();
+  init_paymentServicesList2();
+  init_paymentServicesSession2();
+  init_paymentServicesUpdate2();
+  init_paymentServicesVerify2();
   init_payoutsCreate2();
   init_payoutsGet2();
   init_payoutsList2();
@@ -58487,7 +61255,7 @@ var routes = an({
 var app = He(routes, {
   name: "mcp",
   versionInfo: {
-    currentVersion: "0.18.16"
+    currentVersion: "0.18.17"
   }
 });
 zt(app, process3.argv.slice(2), buildContext(process3));
@@ -58495,5 +61263,5 @@ export {
   app
 };
 
-//# debugId=E7F60D996201A2C464756E2164756E21
+//# debugId=7D0E1A3225E6B1FC64756E2164756E21
 //# sourceMappingURL=mcp-server.js.map