@epcc-sdk/sdks-cart-checkout-order 0.4.0 → 0.5.1

package/dist/client/mcp.gen.cjs

@@ -0,0 +1,2426 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var mcp_gen_exports = {};
+__export(mcp_gen_exports, {
+  addCustomDiscountToCartItemTool: () => addCustomDiscountToCartItemTool,
+  addTaxItemToCartItemComponentTool: () => addTaxItemToCartItemComponentTool,
+  addTaxItemToCartTool: () => addTaxItemToCartTool,
+  anonymizeOrdersTool: () => anonymizeOrdersTool,
+  bulkAddCustomDiscountsToCartTool: () => bulkAddCustomDiscountsToCartTool,
+  bulkAddTaxItemsToCartTool: () => bulkAddTaxItemsToCartTool,
+  bulkDeleteCustomDiscountsFromCartTool: () => bulkDeleteCustomDiscountsFromCartTool,
+  bulkDeleteTaxItemsFromCartTool: () => bulkDeleteTaxItemsFromCartTool,
+  bulkUpdateItemsInCartTool: () => bulkUpdateItemsInCartTool,
+  cancelATransactionTool: () => cancelATransactionTool,
+  captureATransactionTool: () => captureATransactionTool,
+  checkoutApiTool: () => checkoutApiTool,
+  confirmOrderTool: () => confirmOrderTool,
+  confirmPaymentTool: () => confirmPaymentTool,
+  createACartTool: () => createACartTool,
+  createAccountCartAssociationTool: () => createAccountCartAssociationTool,
+  createCartPaymentIntentTool: () => createCartPaymentIntentTool,
+  createCustomerCartAssociationTool: () => createCustomerCartAssociationTool,
+  createOrderShippingGroupTool: () => createOrderShippingGroupTool,
+  createShippingGroupTool: () => createShippingGroupTool,
+  deleteACartItemTool: () => deleteACartItemTool,
+  deleteACartTool: () => deleteACartTool,
+  deleteAPromotionViaPromotionCodeTool: () => deleteAPromotionViaPromotionCodeTool,
+  deleteATaxItemTool: () => deleteATaxItemTool,
+  deleteAccountCartAssociationTool: () => deleteAccountCartAssociationTool,
+  deleteAllCartItemsTool: () => deleteAllCartItemsTool,
+  deleteCartShippingGroupTool: () => deleteCartShippingGroupTool,
+  deleteCustomDiscountFromCartItemTool: () => deleteCustomDiscountFromCartItemTool,
+  deleteCustomDiscountFromCartTool: () => deleteCustomDiscountFromCartTool,
+  deleteCustomerCartAssociationTool: () => deleteCustomerCartAssociationTool,
+  deleteTaxItemFromCartItemComponentTool: () => deleteTaxItemFromCartItemComponentTool,
+  getACartTool: () => getACartTool,
+  getATransactionTool: () => getATransactionTool,
+  getAnOrderTool: () => getAnOrderTool,
+  getCartItemsTool: () => getCartItemsTool,
+  getCartsTool: () => getCartsTool,
+  getCustomerOrdersTool: () => getCustomerOrdersTool,
+  getOrderItemsTool: () => getOrderItemsTool,
+  getOrderShippingGroupsTool: () => getOrderShippingGroupsTool,
+  getOrderTransactionsTool: () => getOrderTransactionsTool,
+  getShippingGroupByIdTool: () => getShippingGroupByIdTool,
+  getShippingGroupsByIdTool: () => getShippingGroupsByIdTool,
+  getShippingGroupsTool: () => getShippingGroupsTool,
+  getV2SettingsCartStoreIdTool: () => getV2SettingsCartStoreIdTool,
+  getV2SettingsCartTool: () => getV2SettingsCartTool,
+  manageCartsTool: () => manageCartsTool,
+  paymentSetupTool: () => paymentSetupTool,
+  putShippingGroupByIdTool: () => putShippingGroupByIdTool,
+  putV2SettingsCartStoreIdTool: () => putV2SettingsCartStoreIdTool,
+  putV2SettingsCartTool: () => putV2SettingsCartTool,
+  refundATransactionTool: () => refundATransactionTool,
+  tools: () => tools,
+  updateACartItemTool: () => updateACartItemTool,
+  updateACartTool: () => updateACartTool,
+  updateATaxItemTool: () => updateATaxItemTool,
+  updateAnOrderTool: () => updateAnOrderTool,
+  updateCartPaymentIntentTool: () => updateCartPaymentIntentTool,
+  updateCustomDiscountForCartItemTool: () => updateCustomDiscountForCartItemTool,
+  updateCustomDiscountForCartTool: () => updateCustomDiscountForCartTool,
+  updateShippingGroupTool: () => updateShippingGroupTool,
+  updateTaxItemFromCartItemComponentTool: () => updateTaxItemFromCartItemComponentTool
+});
+module.exports = __toCommonJS(mcp_gen_exports);
+var z = __toESM(require("zod"), 1);
+var import_mcp_support = require('./mcp-support.gen.cjs');
+var import_sdk = require('./sdk.gen.cjs');
+var import_zod = require('./zod.gen.cjs');
+const getCartsInput = z.object({
+  query: import_zod.zGetCartsQuery.strict().optional(),
+  headers: import_zod.zGetCartsHeaders.strict().optional()
+}).strict();
+const getCartsTool = (options) => {
+  const handler = (args, extra) => (0, import_mcp_support.toToolResult)(
+    (0, import_sdk.getCarts)({
+      ...args,
+      client: options?.client,
+      signal: extra.signal,
+      throwOnError: false
+    })
+  );
+  return {
+    name: "cart_checkout_order_get_carts",
+    config: {
+      title: "Get Carts",
+      description: "Lists carts, most recently updated first. Which carts come back depends on the token: a customer token gives that customer's carts, an account token that account's carts, and client credentials all carts or only registered ones, as the show_all_carts cart setting decides. To read one cart, get it by ID.",
+      inputSchema: getCartsInput,
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true
+      },
+      _meta: {
+        "com.elasticpath/operation": {
+          id: "cart_checkout_order.getCarts",
+          method: "GET",
+          path: "/v2/carts",
+          risk: "read"
+        }
+      }
+    },
+    handler
+  };
+};
+const createACartInput = z.object({
+  headers: import_zod.zCreateACartHeaders.strict().optional(),
+  body: (0, import_mcp_support.loose)(import_zod.zCreateACartBody).optional()
+}).strict();
+const createACartTool = (options) => {
+  const handler = (args, extra) => (0, import_mcp_support.toToolResult)(
+    (0, import_sdk.createACart)({
+      ...args,
+      client: options?.client,
+      signal: extra.signal,
+      throwOnError: false
+    })
+  );
+  return {
+    name: "cart_checkout_order_create_a_cart",
+    config: {
+      title: "Create a Cart",
+      description: "Creates a new, empty cart. A shopper can have several carts and check each out without affecting the others. It can set a name, custom attributes for promotions, a contact email for a guest cart, and whether custom discounts or deferred inventory checks apply. A cart with a snapshot_date is a promotion preview cart and cannot be checked out.",
+      inputSchema: createACartInput,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: true
+      },
+      _meta: {
+        "com.elasticpath/operation": {
+          id: "cart_checkout_order.createACart",
+          method: "POST",
+          path: "/v2/carts",
+          risk: "create"
+        }
+      }
+    },
+    handler
+  };
+};
+const deleteACartInput = z.object({
+  path: import_zod.zDeleteACartPath.strict()
+}).strict();
+const deleteACartTool = (options) => {
+  const handler = (args, extra) => (0, import_mcp_support.toToolResult)(
+    (0, import_sdk.deleteACart)({
+      ...args,
+      client: options?.client,
+      signal: extra.signal,
+      throwOnError: false
+    })
+  );
+  return {
+    name: "cart_checkout_order_delete_a_cart",
+    config: {
+      title: "Delete a Cart",
+      description: "Deletes a cart with its items, name and description, and removes all its associations. Fails with 400 when it is the last cart associated with a customer. To empty a cart but keep it, delete all its items instead.",
+      inputSchema: deleteACartInput,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: true,
+        openWorldHint: true
+      },
+      _meta: {
+        "com.elasticpath/operation": {
+          id: "cart_checkout_order.deleteACart",
+          method: "DELETE",
+          path: "/v2/carts/{cartID}",
+          risk: "delete"
+        }
+      }
+    },
+    handler
+  };
+};
+const getACartInput = z.object({
+  path: import_zod.zGetACartPath.strict(),
+  query: import_zod.zGetACartQuery.strict().optional()
+}).strict();
+const getACartTool = (options) => {
+  const handler = (args, extra) => (0, import_mcp_support.toToolResult)(
+    (0, import_sdk.getACart)({
+      ...args,
+      client: options?.client,
+      signal: extra.signal,
+      throwOnError: false
+    })
+  );
+  return {
+    name: "cart_checkout_order_get_a_cart",
+    config: {
+      title: "Get a Cart",
+      description: "Gets one cart by ID, optionally including its custom discounts or promotions. A cart ID that does not exist creates a new, empty cart instead of returning an error. To list the cart's items, get the cart items.",
+      inputSchema: getACartInput,
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true
+      },
+      _meta: {
+        "com.elasticpath/operation": {
+          id: "cart_checkout_order.getACart",
+          method: "GET",
+          path: "/v2/carts/{cartID}",
+          risk: "read"
+        }
+      }
+    },
+    handler
+  };
+};
+const updateACartInput = z.object({
+  path: import_zod.zUpdateACartPath.strict(),
+  body: (0, import_mcp_support.loose)(import_zod.zUpdateACartBody).optional()
+}).strict();
+const updateACartTool = (options) => {
+  const handler = (args, extra) => (0, import_mcp_support.toToolResult)(
+    (0, import_sdk.updateACart)({
+      ...args,
+      client: options?.client,
+      signal: extra.signal,
+      throwOnError: false
+    })
+  );
+  return {
+    name: "cart_checkout_order_update_a_cart",
+    config: {
+      title: "Update a Cart",
+      description: "Updates one cart's own properties, such as its name, custom attributes, and whether custom discounts or deferred inventory checks apply. It does not change the cart's items; update the cart items for that.",
+      inputSchema: updateACartInput,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: true,
+        openWorldHint: true
+      },
+      _meta: {
+        "com.elasticpath/operation": {
+          id: "cart_checkout_order.updateACart",
+          method: "PUT",
+          path: "/v2/carts/{cartID}",
+          risk: "update"
+        }
+      }
+    },
+    handler
+  };
+};
+const deleteAllCartItemsInput = z.object({
+  path: import_zod.zDeleteAllCartItemsPath.strict()
+}).strict();
+const deleteAllCartItemsTool = (options) => {
+  const handler = (args, extra) => (0, import_mcp_support.toToolResult)(
+    (0, import_sdk.deleteAllCartItems)({
+      ...args,
+      client: options?.client,
+      signal: extra.signal,
+      throwOnError: false
+    })
+  );
+  return {
+    name: "cart_checkout_order_delete_all_cart_items",
+    config: {
+      title: "Delete all Cart Items",
+      description: "Removes every item from a cart, including custom items and promotions. The cart itself stays, with its ID, name, description and any account or customer associations, and can be filled again. To remove one item, delete that item; to remove the cart too, delete the cart.",
+      inputSchema: deleteAllCartItemsInput,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: true,
+        openWorldHint: true
+      },
+      _meta: {
+        "com.elasticpath/operation": {
+          id: "cart_checkout_order.deleteAllCartItems",
+          method: "DELETE",
+          path: "/v2/carts/{cartID}/items",
+          risk: "delete"
+        }
+      }
+    },
+    handler
+  };
+};
+const getCartItemsInput = z.object({
+  path: import_zod.zGetCartItemsPath.strict(),
+  query: import_zod.zGetCartItemsQuery.strict().optional()
+}).strict();
+const getCartItemsTool = (options) => {
+  const handler = (args, extra) => (0, import_mcp_support.toToolResult)(
+    (0, import_sdk.getCartItems)({
+      ...args,
+      client: options?.client,
+      signal: extra.signal,
+      throwOnError: false
+    })
+  );
+  return {
+    name: "cart_checkout_order_get_cart_items",
+    config: {
+      title: "Get Cart Items",
+      description: "Lists the items in a cart, with each item's discounts broken down by promotion and any shipping group IDs. Can include tax items, custom discounts or promotions. Use it when you need the items rather than the cart's own details.",
+      inputSchema: getCartItemsInput,
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true
+      },
+      _meta: {
+        "com.elasticpath/operation": {
+          id: "cart_checkout_order.getCartItems",
+          method: "GET",
+          path: "/v2/carts/{cartID}/items",
+          risk: "read"
+        }
+      }
+    },
+    handler
+  };
+};
+const manageCartsInput = z.object({
+  path: import_zod.zManageCartsPath.strict(),
+  body: (0, import_mcp_support.loose)(import_zod.zManageCartsBody).optional()
+}).strict();
+const manageCartsTool = (options) => {
+  const handler = (args, extra) => (0, import_mcp_support.toToolResult)(
+    (0, import_sdk.manageCarts)({
+      ...args,
+      client: options?.client,
+      signal: extra.signal,
+      throwOnError: false
+    })
+  );
+  return {
+    name: "cart_checkout_order_manage_carts",
+    config: {
+      title: "Add Items to Cart",
+      description: "Adds to a cart: catalog products or bundles by product ID, custom items, subscription items, promotion codes, the items of a previous order (re-order), or the items of another cart (merge). Use it for every kind of addition. To change items already in the cart, update them instead.",
+      inputSchema: manageCartsInput,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: true
+      },
+      _meta: {
+        "com.elasticpath/operation": {
+          id: "cart_checkout_order.manageCarts",
+          method: "POST",
+          path: "/v2/carts/{cartID}/items",
+          risk: "create"
+        }
+      }
+    },
+    handler
+  };
+};
+const bulkUpdateItemsInCartInput = z.object({
+  path: import_zod.zBulkUpdateItemsInCartPath.strict(),
+  body: (0, import_mcp_support.loose)(import_zod.zBulkUpdateItemsInCartBody).optional()
+}).strict();
+const bulkUpdateItemsInCartTool = (options) => {
+  const handler = (args, extra) => (0, import_mcp_support.toToolResult)(
+    (0, import_sdk.bulkUpdateItemsInCart)({
+      ...args,
+      client: options?.client,
+      signal: extra.signal,
+      throwOnError: false
+    })
+  );
+  return {
+    name: "cart_checkout_order_bulk_update_items_in_cart",
+    config: {
+      title: "Bulk Update Items in Cart",
+      description: "Updates several existing cart items in one request: their quantity, shipping group or custom inputs. Free gifts for eligible products update automatically. To change a single item, update that item instead.",
+      inputSchema: bulkUpdateItemsInCartInput,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: true,
+        openWorldHint: true
+      },
+      _meta: {
+        "com.elasticpath/operation": {
+          id: "cart_checkout_order.bulkUpdateItemsInCart",
+          method: "PUT",
+          path: "/v2/carts/{cartID}/items",
+          risk: "update"
+        }
+      }
+    },
+    handler
+  };
+};
+const deleteACartItemInput = z.object({
+  path: import_zod.zDeleteACartItemPath.strict()
+}).strict();
+const deleteACartItemTool = (options) => {
+  const handler = (args, extra) => (0, import_mcp_support.toToolResult)(
+    (0, import_sdk.deleteACartItem)({
+      ...args,
+      client: options?.client,
+      signal: extra.signal,
+      throwOnError: false
+    })
+  );
+  return {
+    name: "cart_checkout_order_delete_a_cart_item",
+    config: {
+      title: "Delete a Cart Item",
+      description: "Removes one item from a cart, by cart ID and cart item ID; the rest of the cart stays. To empty the whole cart, delete all its items instead.",
+      inputSchema: deleteACartItemInput,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: true,
+        openWorldHint: true
+      },
+      _meta: {
+        "com.elasticpath/operation": {
+          id: "cart_checkout_order.deleteACartItem",
+          method: "DELETE",
+          path: "/v2/carts/{cartID}/items/{cartitemID}",
+          risk: "delete"
+        }
+      }
+    },
+    handler
+  };
+};
+const updateACartItemInput = z.object({
+  path: import_zod.zUpdateACartItemPath.strict(),
+  body: (0, import_mcp_support.loose)(import_zod.zUpdateACartItemBody).optional()
+}).strict();
+const updateACartItemTool = (options) => {
+  const handler = (args, extra) => (0, import_mcp_support.toToolResult)(
+    (0, import_sdk.updateACartItem)({
+      ...args,
+      client: options?.client,
+      signal: extra.signal,
+      throwOnError: false
+    })
+  );
+  return {
+    name: "cart_checkout_order_update_a_cart_item",
+    config: {
+      title: "Update a Cart Item",
+      description: "Updates one item in a cart, such as its quantity or custom inputs, by cart ID and cart item ID, and returns the cart's items. To update several items in one request, update them in bulk instead.",
+      inputSchema: updateACartItemInput,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: true,
+        openWorldHint: true
+      },
+      _meta: {
+        "com.elasticpath/operation": {
+          id: "cart_checkout_order.updateACartItem",
+          method: "PUT",
+          path: "/v2/carts/{cartID}/items/{cartitemID}",
+          risk: "update"
+        }
+      }
+    },
+    handler
+  };
+};
+const deleteAccountCartAssociationInput = z.object({
+  path: import_zod.zDeleteAccountCartAssociationPath.strict(),
+  headers: import_zod.zDeleteAccountCartAssociationHeaders.strict().optional(),
+  body: (0, import_mcp_support.loose)(import_zod.zDeleteAccountCartAssociationBody).optional()
+}).strict();
+const deleteAccountCartAssociationTool = (options) => {
+  const handler = (args, extra) => (0, import_mcp_support.toToolResult)(
+    (0, import_sdk.deleteAccountCartAssociation)({
+      ...args,
+      client: options?.client,
+      signal: extra.signal,
+      throwOnError: false
+    })
+  );
+  return {
+    name: "cart_checkout_order_delete_account_cart_association",
+    config: {
+      title: "Delete Account Cart Association",
+      description: "Removes the association between a cart and an account, so the account no longer reaches the cart through it. The cart itself is not deleted.",
+      inputSchema: deleteAccountCartAssociationInput,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: true,
+        openWorldHint: true
+      },
+      _meta: {
+        "com.elasticpath/operation": {
+          id: "cart_checkout_order.deleteAccountCartAssociation",
+          method: "DELETE",
+          path: "/v2/carts/{cartID}/relationships/accounts",
+          risk: "delete"
+        }
+      }
+    },
+    handler
+  };
+};
+const createAccountCartAssociationInput = z.object({
+  path: import_zod.zCreateAccountCartAssociationPath.strict(),
+  headers: import_zod.zCreateAccountCartAssociationHeaders.strict().optional(),
+  body: (0, import_mcp_support.loose)(import_zod.zCreateAccountCartAssociationBody).optional()
+}).strict();
+const createAccountCartAssociationTool = (options) => {
+  const handler = (args, extra) => (0, import_mcp_support.toToolResult)(
+    (0, import_sdk.createAccountCartAssociation)({
+      ...args,
+      client: options?.client,
+      signal: extra.signal,
+      throwOnError: false
+    })
+  );
+  return {
+    name: "cart_checkout_order_create_account_cart_association",
+    config: {
+      title: "Create an Account Cart Association",
+      description: "Associates a cart with an account, so the account can reach the cart from any device. Use it for an account; for an individual customer, associate the cart with the customer instead.",
+      inputSchema: createAccountCartAssociationInput,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: true
+      },
+      _meta: {
+        "com.elasticpath/operation": {
+          id: "cart_checkout_order.createAccountCartAssociation",
+          method: "POST",
+          path: "/v2/carts/{cartID}/relationships/accounts",
+          risk: "create"
+        }
+      }
+    },
+    handler
+  };
+};
+const deleteCustomerCartAssociationInput = z.object({
+  path: import_zod.zDeleteCustomerCartAssociationPath.strict(),
+  headers: import_zod.zDeleteCustomerCartAssociationHeaders.strict().optional(),
+  body: (0, import_mcp_support.loose)(import_zod.zDeleteCustomerCartAssociationBody).optional()
+}).strict();
+const deleteCustomerCartAssociationTool = (options) => {
+  const handler = (args, extra) => (0, import_mcp_support.toToolResult)(
+    (0, import_sdk.deleteCustomerCartAssociation)({
+      ...args,
+      client: options?.client,
+      signal: extra.signal,
+      throwOnError: false
+    })
+  );
+  return {
+    name: "cart_checkout_order_delete_customer_cart_association",
+    config: {
+      title: "Delete Customer Cart Association",
+      description: "Removes the association between a cart and a customer, so the customer no longer reaches the cart through it. The cart itself is not deleted.",
+      inputSchema: deleteCustomerCartAssociationInput,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: true,
+        openWorldHint: true
+      },
+      _meta: {
+        "com.elasticpath/operation": {
+          id: "cart_checkout_order.deleteCustomerCartAssociation",
+          method: "DELETE",
+          path: "/v2/carts/{cartID}/relationships/customers",
+          risk: "delete"
+        }
+      }
+    },
+    handler
+  };
+};
+const createCustomerCartAssociationInput = z.object({
+  path: import_zod.zCreateCustomerCartAssociationPath.strict(),
+  headers: import_zod.zCreateCustomerCartAssociationHeaders.strict().optional(),
+  body: (0, import_mcp_support.loose)(import_zod.zCreateCustomerCartAssociationBody).optional()
+}).strict();
+const createCustomerCartAssociationTool = (options) => {
+  const handler = (args, extra) => (0, import_mcp_support.toToolResult)(
+    (0, import_sdk.createCustomerCartAssociation)({
+      ...args,
+      client: options?.client,
+      signal: extra.signal,
+      throwOnError: false
+    })
+  );
+  return {
+    name: "cart_checkout_order_create_customer_cart_association",
+    config: {
+      title: "Create a Customer Cart Association",
+      description: "Associates a cart with a customer, so the customer can reach the cart from any device. Use it for an individual customer; for an account, associate the cart with the account instead.",
+      inputSchema: createCustomerCartAssociationInput,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: true
+      },
+      _meta: {
+        "com.elasticpath/operation": {
+          id: "cart_checkout_order.createCustomerCartAssociation",
+          method: "POST",
+          path: "/v2/carts/{cartID}/relationships/customers",
+          risk: "create"
+        }
+      }
+    },
+    handler
+  };
+};
+const deleteAPromotionViaPromotionCodeInput = z.object({
+  path: import_zod.zDeleteAPromotionViaPromotionCodePath.strict()
+}).strict();
+const deleteAPromotionViaPromotionCodeTool = (options) => {
+  const handler = (args, extra) => (0, import_mcp_support.toToolResult)(
+    (0, import_sdk.deleteAPromotionViaPromotionCode)({
+      ...args,
+      client: options?.client,
+      signal: extra.signal,
+      throwOnError: false
+    })
+  );
+  return {
+    name: "cart_checkout_order_delete_a_promotion_via_promotion_code",
+    config: {
+      title: "Delete a Promotion via Promotion Code",
+      description: "Removes a promotion code from a cart. Works only for codes applied manually; promotions applied automatically cannot be removed this way.",
+      inputSchema: deleteAPromotionViaPromotionCodeInput,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: true,
+        openWorldHint: true
+      },
+      _meta: {
+        "com.elasticpath/operation": {
+          id: "cart_checkout_order.deleteAPromotionViaPromotionCode",
+          method: "DELETE",
+          path: "/v2/carts/{cartID}/discounts/{promoCode}",
+          risk: "delete"
+        }
+      }
+    },
+    handler
+  };
+};
+const addTaxItemToCartInput = z.object({
+  path: import_zod.zAddTaxItemToCartPath.strict(),
+  body: (0, import_mcp_support.loose)(import_zod.zAddTaxItemToCartBody)
+}).strict();
+const addTaxItemToCartTool = (options) => {
+  const handler = (args, extra) => (0, import_mcp_support.toToolResult)(
+    (0, import_sdk.addTaxItemToCart)({
+      ...args,
+      client: options?.client,
+      signal: extra.signal,
+      throwOnError: false
+    })
+  );
+  return {
+    name: "cart_checkout_order_add_tax_item_to_cart",
+    config: {
+      title: "Add Tax Item to Cart Item",
+      description: "Adds a tax item to one cart item. Use it for a single cart item, not a bundle component or many items at once. A cart item can have up to 5 unique tax items.",
+      inputSchema: addTaxItemToCartInput,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: true
+      },
+      _meta: {
+        "com.elasticpath/operation": {
+          id: "cart_checkout_order.addTaxItemToCart",
+          method: "POST",
+          path: "/v2/carts/{cartID}/items/{cartitemID}/taxes",
+          risk: "create"
+        }
+      }
+    },
+    handler
+  };
+};
+const addTaxItemToCartItemComponentInput = z.object({
+  path: import_zod.zAddTaxItemToCartItemComponentPath.strict(),
+  body: (0, import_mcp_support.loose)(import_zod.zAddTaxItemToCartItemComponentBody)
+}).strict();
+const addTaxItemToCartItemComponentTool = (options) => {
+  const handler = (args, extra) => (0, import_mcp_support.toToolResult)(
+    (0, import_sdk.addTaxItemToCartItemComponent)({
+      ...args,
+      client: options?.client,
+      signal: extra.signal,
+      throwOnError: false
+    })
+  );
+  return {
+    name: "cart_checkout_order_add_tax_item_to_cart_item_component",
+    config: {
+      title: "Add Tax Item to Bundle Component",
+      description: "Adds a tax item to one bundle component product inside a cart item. Use it only for bundle components; for a whole cart item, add the tax to the item. A component product can have up to 5 unique tax items.",
+      inputSchema: addTaxItemToCartItemComponentInput,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: true
+      },
+      _meta: {
+        "com.elasticpath/operation": {
+          id: "cart_checkout_order.addTaxItemToCartItemComponent",
+          method: "POST",
+          path: "/v2/carts/{cartID}/items/{cartitemID}/components/{productID}/taxes",
+          risk: "create"
+        }
+      }
+    },
+    handler
+  };
+};
+const deleteTaxItemFromCartItemComponentInput = z.object({
+  path: import_zod.zDeleteTaxItemFromCartItemComponentPath.strict()
+}).strict();
+const deleteTaxItemFromCartItemComponentTool = (options) => {
+  const handler = (args, extra) => (0, import_mcp_support.toToolResult)(
+    (0, import_sdk.deleteTaxItemFromCartItemComponent)({
+      ...args,
+      client: options?.client,
+      signal: extra.signal,
+      throwOnError: false
+    })
+  );
+  return {
+    name: "cart_checkout_order_delete_tax_item_from_cart_item_component",
+    config: {
+      title: "Delete Tax Item from Bundle Component",
+      description: "Deletes a tax item from one bundle component product inside a cart item. For a tax item on the cart item itself, delete that instead.",
+      inputSchema: deleteTaxItemFromCartItemComponentInput,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: true,
+        openWorldHint: true
+      },
+      _meta: {
+        "com.elasticpath/operation": {
+          id: "cart_checkout_order.deleteTaxItemFromCartItemComponent",
+          method: "DELETE",
+          path: "/v2/carts/{cartID}/items/{cartitemID}/components/{productID}/taxes/{taxitemID}",
+          risk: "delete"
+        }
+      }
+    },
+    handler
+  };
+};
+const updateTaxItemFromCartItemComponentInput = z.object({
+  path: import_zod.zUpdateTaxItemFromCartItemComponentPath.strict(),
+  body: (0, import_mcp_support.loose)(import_zod.zUpdateTaxItemFromCartItemComponentBody).optional()
+}).strict();
+const updateTaxItemFromCartItemComponentTool = (options) => {
+  const handler = (args, extra) => (0, import_mcp_support.toToolResult)(
+    (0, import_sdk.updateTaxItemFromCartItemComponent)({
+      ...args,
+      client: options?.client,
+      signal: extra.signal,
+      throwOnError: false
+    })
+  );
+  return {
+    name: "cart_checkout_order_update_tax_item_from_cart_item_component",
+    config: {
+      title: "Update Tax Item on Bundle Component",
+      description: "Updates a tax item on one bundle component product inside a cart item. To switch between rate and amount, set the current one to null and then set the other. For a tax item on the cart item itself, update that instead.",
+      inputSchema: updateTaxItemFromCartItemComponentInput,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: true,
+        openWorldHint: true
+      },
+      _meta: {
+        "com.elasticpath/operation": {
+          id: "cart_checkout_order.updateTaxItemFromCartItemComponent",
+          method: "PUT",
+          path: "/v2/carts/{cartID}/items/{cartitemID}/components/{productID}/taxes/{taxitemID}",
+          risk: "update"
+        }
+      }
+    },
+    handler
+  };
+};
+const bulkDeleteTaxItemsFromCartInput = z.object({
+  path: import_zod.zBulkDeleteTaxItemsFromCartPath.strict()
+}).strict();
+const bulkDeleteTaxItemsFromCartTool = (options) => {
+  const handler = (args, extra) => (0, import_mcp_support.toToolResult)(
+    (0, import_sdk.bulkDeleteTaxItemsFromCart)({
+      ...args,
+      client: options?.client,
+      signal: extra.signal,
+      throwOnError: false
+    })
+  );
+  return {
+    name: "cart_checkout_order_bulk_delete_tax_items_from_cart",
+    config: {
+      title: "Bulk Delete Tax Items from Cart",
+      description: "Deletes every tax item in a cart, from all cart items and all bundle component products. Returns 404 if the cart has no tax items. To remove a single tax item, delete it on its item or component.",
+      inputSchema: bulkDeleteTaxItemsFromCartInput,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: true,
+        openWorldHint: true
+      },
+      _meta: {
+        "com.elasticpath/operation": {
+          id: "cart_checkout_order.bulkDeleteTaxItemsFromCart",
+          method: "DELETE",
+          path: "/v2/carts/{cartID}/taxes",
+          risk: "delete"
+        }
+      }
+    },
+    handler
+  };
+};
+const bulkAddTaxItemsToCartInput = z.object({
+  path: import_zod.zBulkAddTaxItemsToCartPath.strict(),
+  body: (0, import_mcp_support.loose)(import_zod.zBulkAddTaxItemsToCartBody).optional()
+}).strict();
+const bulkAddTaxItemsToCartTool = (options) => {
+  const handler = (args, extra) => (0, import_mcp_support.toToolResult)(
+    (0, import_sdk.bulkAddTaxItemsToCart)({
+      ...args,
+      client: options?.client,
+      signal: extra.signal,
+      throwOnError: false
+    })
+  );
+  return {
+    name: "cart_checkout_order_bulk_add_tax_items_to_cart",
+    config: {
+      title: "Bulk Add Tax Items to Cart",
+      description: "Adds tax items to many cart items and bundle component products in one request; a tax item with meta.component_product_id targets a bundle component. Each cart item and each component product can have at most 5 tax items. With add_all_or_nothing set, one failure stops the whole request.",
+      inputSchema: bulkAddTaxItemsToCartInput,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: true
+      },
+      _meta: {
+        "com.elasticpath/operation": {
+          id: "cart_checkout_order.bulkAddTaxItemsToCart",
+          method: "POST",
+          path: "/v2/carts/{cartID}/taxes",
+          risk: "create"
+        }
+      }
+    },
+    handler
+  };
+};
+const deleteATaxItemInput = z.object({
+  path: import_zod.zDeleteATaxItemPath.strict()
+}).strict();
+const deleteATaxItemTool = (options) => {
+  const handler = (args, extra) => (0, import_mcp_support.toToolResult)(
+    (0, import_sdk.deleteATaxItem)({
+      ...args,
+      client: options?.client,
+      signal: extra.signal,
+      throwOnError: false
+    })
+  );
+  return {
+    name: "cart_checkout_order_delete_a_tax_item",
+    config: {
+      title: "Delete Tax Item from Cart Item",
+      description: "Deletes one tax item from a cart item, by tax item ID. For a tax item on a bundle component, delete the component's tax item instead; to remove every tax item in the cart, delete them in bulk.",
+      inputSchema: deleteATaxItemInput,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: true,
+        openWorldHint: true
+      },
+      _meta: {
+        "com.elasticpath/operation": {
+          id: "cart_checkout_order.deleteATaxItem",
+          method: "DELETE",
+          path: "/v2/carts/{cartID}/items/{cartitemID}/taxes/{taxitemID}",
+          risk: "delete"
+        }
+      }
+    },
+    handler
+  };
+};
+const updateATaxItemInput = z.object({
+  path: import_zod.zUpdateATaxItemPath.strict(),
+  body: (0, import_mcp_support.loose)(import_zod.zUpdateATaxItemBody).optional()
+}).strict();
+const updateATaxItemTool = (options) => {
+  const handler = (args, extra) => (0, import_mcp_support.toToolResult)(
+    (0, import_sdk.updateATaxItem)({
+      ...args,
+      client: options?.client,
+      signal: extra.signal,
+      throwOnError: false
+    })
+  );
+  return {
+    name: "cart_checkout_order_update_a_tax_item",
+    config: {
+      title: "Update Tax Item on Cart Item",
+      description: "Updates a tax item on a cart item. To switch between rate and amount, set the current one to null and then set the other. For a tax item on a bundle component, update the component's tax item instead.",
+      inputSchema: updateATaxItemInput,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: true,
+        openWorldHint: true
+      },
+      _meta: {
+        "com.elasticpath/operation": {
+          id: "cart_checkout_order.updateATaxItem",
+          method: "PUT",
+          path: "/v2/carts/{cartID}/items/{cartitemID}/taxes/{taxitemID}",
+          risk: "update"
+        }
+      }
+    },
+    handler
+  };
+};
+const bulkDeleteCustomDiscountsFromCartInput = z.object({
+  path: import_zod.zBulkDeleteCustomDiscountsFromCartPath.strict()
+}).strict();
+const bulkDeleteCustomDiscountsFromCartTool = (options) => {
+  const handler = (args, extra) => (0, import_mcp_support.toToolResult)(
+    (0, import_sdk.bulkDeleteCustomDiscountsFromCart)({
+      ...args,
+      client: options?.client,
+      signal: extra.signal,
+      throwOnError: false
+    })
+  );
+  return {
+    name: "cart_checkout_order_bulk_delete_custom_discounts_from_cart",
+    config: {
+      title: "Bulk Delete Custom Discounts From Cart",
+      description: "Deletes the custom discounts on a cart in one request. To delete a single custom discount, delete it by ID on the cart or the cart item.",
+      inputSchema: bulkDeleteCustomDiscountsFromCartInput,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: true,
+        openWorldHint: true
+      },
+      _meta: {
+        "com.elasticpath/operation": {
+          id: "cart_checkout_order.bulkDeleteCustomDiscountsFromCart",
+          method: "DELETE",
+          path: "/v2/carts/{cartID}/custom-discounts",
+          risk: "delete"
+        }
+      }
+    },
+    handler
+  };
+};
+const bulkAddCustomDiscountsToCartInput = z.object({
+  path: import_zod.zBulkAddCustomDiscountsToCartPath.strict(),
+  body: (0, import_mcp_support.loose)(import_zod.zBulkAddCustomDiscountsToCartBody).optional()
+}).strict();
+const bulkAddCustomDiscountsToCartTool = (options) => {
+  const handler = (args, extra) => (0, import_mcp_support.toToolResult)(
+    (0, import_sdk.bulkAddCustomDiscountsToCart)({
+      ...args,
+      client: options?.client,
+      signal: extra.signal,
+      throwOnError: false
+    })
+  );
+  return {
+    name: "cart_checkout_order_bulk_add_custom_discounts_to_cart",
+    config: {
+      title: "Bulk Add Custom Discounts to Cart",
+      description: "Adds several custom discounts to a cart in one request. Custom discounts cannot be combined with Elastic Path promotions in the same cart. Unless the store sets another limit, the cart and each cart item can hold at most 5 custom discounts.",
+      inputSchema: bulkAddCustomDiscountsToCartInput,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: true
+      },
+      _meta: {
+        "com.elasticpath/operation": {
+          id: "cart_checkout_order.bulkAddCustomDiscountsToCart",
+          method: "POST",
+          path: "/v2/carts/{cartID}/custom-discounts",
+          risk: "create"
+        }
+      }
+    },
+    handler
+  };
+};
+const deleteCustomDiscountFromCartInput = z.object({
+  path: import_zod.zDeleteCustomDiscountFromCartPath.strict()
+}).strict();
+const deleteCustomDiscountFromCartTool = (options) => {
+  const handler = (args, extra) => (0, import_mcp_support.toToolResult)(
+    (0, import_sdk.deleteCustomDiscountFromCart)({
+      ...args,
+      client: options?.client,
+      signal: extra.signal,
+      throwOnError: false
+    })
+  );
+  return {
+    name: "cart_checkout_order_delete_custom_discount_from_cart",
+    config: {
+      title: "Delete Custom Discount From Cart",
+      description: "Deletes one custom discount that applies to the whole cart, by custom discount ID. For a discount on a single cart item, delete the cart item's discount instead.",
+      inputSchema: deleteCustomDiscountFromCartInput,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: true,
+        openWorldHint: true
+      },
+      _meta: {
+        "com.elasticpath/operation": {
+          id: "cart_checkout_order.deleteCustomDiscountFromCart",
+          method: "DELETE",
+          path: "/v2/carts/{cartID}/custom-discounts/{customdiscountID}",
+          risk: "delete"
+        }
+      }
+    },
+    handler
+  };
+};
+const updateCustomDiscountForCartInput = z.object({
+  path: import_zod.zUpdateCustomDiscountForCartPath.strict(),
+  body: (0, import_mcp_support.loose)(import_zod.zUpdateCustomDiscountForCartBody).optional()
+}).strict();
+const updateCustomDiscountForCartTool = (options) => {
+  const handler = (args, extra) => (0, import_mcp_support.toToolResult)(
+    (0, import_sdk.updateCustomDiscountForCart)({
+      ...args,
+      client: options?.client,
+      signal: extra.signal,
+      throwOnError: false
+    })
+  );
+  return {
+    name: "cart_checkout_order_update_custom_discount_for_cart",
+    config: {
+      title: "Update Custom Discount For Cart",
+      description: "Updates one custom discount that applies to the whole cart, by custom discount ID. For a discount on a single cart item, update the cart item's discount instead.",
+      inputSchema: updateCustomDiscountForCartInput,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: true,
+        openWorldHint: true
+      },
+      _meta: {
+        "com.elasticpath/operation": {
+          id: "cart_checkout_order.updateCustomDiscountForCart",
+          method: "PUT",
+          path: "/v2/carts/{cartID}/custom-discounts/{customdiscountID}",
+          risk: "update"
+        }
+      }
+    },
+    handler
+  };
+};
+const addCustomDiscountToCartItemInput = z.object({
+  path: import_zod.zAddCustomDiscountToCartItemPath.strict(),
+  body: (0, import_mcp_support.loose)(import_zod.zAddCustomDiscountToCartItemBody).optional()
+}).strict();
+const addCustomDiscountToCartItemTool = (options) => {
+  const handler = (args, extra) => (0, import_mcp_support.toToolResult)(
+    (0, import_sdk.addCustomDiscountToCartItem)({
+      ...args,
+      client: options?.client,
+      signal: extra.signal,
+      throwOnError: false
+    })
+  );
+  return {
+    name: "cart_checkout_order_add_custom_discount_to_cart_item",
+    config: {
+      title: "Add Custom Discount To Cart Item",
+      description: "Adds a custom discount to one cart item. Custom discounts cannot be combined with Elastic Path promotions, so remove any promotions from the cart first. To add several discounts at once, add them to the cart in bulk.",
+      inputSchema: addCustomDiscountToCartItemInput,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: true
+      },
+      _meta: {
+        "com.elasticpath/operation": {
+          id: "cart_checkout_order.addCustomDiscountToCartItem",
+          method: "POST",
+          path: "/v2/carts/{cartID}/items/{cartitemID}/custom-discounts",
+          risk: "create"
+        }
+      }
+    },
+    handler
+  };
+};
+const deleteCustomDiscountFromCartItemInput = z.object({
+  path: import_zod.zDeleteCustomDiscountFromCartItemPath.strict()
+}).strict();
+const deleteCustomDiscountFromCartItemTool = (options) => {
+  const handler = (args, extra) => (0, import_mcp_support.toToolResult)(
+    (0, import_sdk.deleteCustomDiscountFromCartItem)({
+      ...args,
+      client: options?.client,
+      signal: extra.signal,
+      throwOnError: false
+    })
+  );
+  return {
+    name: "cart_checkout_order_delete_custom_discount_from_cart_item",
+    config: {
+      title: "Delete Custom Discount From Cart Item",
+      description: "Deletes one custom discount from a cart item, by custom discount ID. For a discount that applies to the whole cart, delete the cart's discount instead.",
+      inputSchema: deleteCustomDiscountFromCartItemInput,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: true,
+        openWorldHint: true
+      },
+      _meta: {
+        "com.elasticpath/operation": {
+          id: "cart_checkout_order.deleteCustomDiscountFromCartItem",
+          method: "DELETE",
+          path: "/v2/carts/{cartID}/items/{cartitemID}/custom-discounts/{customdiscountID}",
+          risk: "delete"
+        }
+      }
+    },
+    handler
+  };
+};
+const updateCustomDiscountForCartItemInput = z.object({
+  path: import_zod.zUpdateCustomDiscountForCartItemPath.strict(),
+  body: (0, import_mcp_support.loose)(import_zod.zUpdateCustomDiscountForCartItemBody).optional()
+}).strict();
+const updateCustomDiscountForCartItemTool = (options) => {
+  const handler = (args, extra) => (0, import_mcp_support.toToolResult)(
+    (0, import_sdk.updateCustomDiscountForCartItem)({
+      ...args,
+      client: options?.client,
+      signal: extra.signal,
+      throwOnError: false
+    })
+  );
+  return {
+    name: "cart_checkout_order_update_custom_discount_for_cart_item",
+    config: {
+      title: "Update Custom Discount For Cart Item",
+      description: "Updates one custom discount on a cart item, by custom discount ID. For a discount that applies to the whole cart, update the cart's discount instead.",
+      inputSchema: updateCustomDiscountForCartItemInput,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: true,
+        openWorldHint: true
+      },
+      _meta: {
+        "com.elasticpath/operation": {
+          id: "cart_checkout_order.updateCustomDiscountForCartItem",
+          method: "PUT",
+          path: "/v2/carts/{cartID}/items/{cartitemID}/custom-discounts/{customdiscountID}",
+          risk: "update"
+        }
+      }
+    },
+    handler
+  };
+};
+const getShippingGroupsInput = z.object({
+  path: import_zod.zGetShippingGroupsPath.strict()
+}).strict();
+const getShippingGroupsTool = (options) => {
+  const handler = (args, extra) => (0, import_mcp_support.toToolResult)(
+    (0, import_sdk.getShippingGroups)({
+      ...args,
+      client: options?.client,
+      signal: extra.signal,
+      throwOnError: false
+    })
+  );
+  return {
+    name: "cart_checkout_order_get_shipping_groups",
+    config: {
+      title: "Retrieve all shipping groups for a cart",
+      description: "Lists the shipping groups on a cart. This is for carts before checkout; an order's shipping groups are read from the order.",
+      inputSchema: getShippingGroupsInput,
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true
+      },
+      _meta: {
+        "com.elasticpath/operation": {
+          id: "cart_checkout_order.getShippingGroups",
+          method: "GET",
+          path: "/v2/carts/{cartID}/shipping-groups",
+          risk: "read"
+        }
+      }
+    },
+    handler
+  };
+};
+const createShippingGroupInput = z.object({
+  path: import_zod.zCreateShippingGroupPath.strict(),
+  body: (0, import_mcp_support.loose)(import_zod.zCreateShippingGroupBody)
+}).strict();
+const createShippingGroupTool = (options) => {
+  const handler = (args, extra) => (0, import_mcp_support.toToolResult)(
+    (0, import_sdk.createShippingGroup)({
+      ...args,
+      client: options?.client,
+      signal: extra.signal,
+      throwOnError: false
+    })
+  );
+  return {
+    name: "cart_checkout_order_create_shipping_group",
+    config: {
+      title: "Create a new shipping group for a cart",
+      description: "Creates a shipping group on a cart, which cart items can then be assigned to. This is for carts before checkout; an order has its own shipping groups.",
+      inputSchema: createShippingGroupInput,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: true
+      },
+      _meta: {
+        "com.elasticpath/operation": {
+          id: "cart_checkout_order.createShippingGroup",
+          method: "POST",
+          path: "/v2/carts/{cartID}/shipping-groups",
+          risk: "create"
+        }
+      }
+    },
+    handler
+  };
+};
+const deleteCartShippingGroupInput = z.object({
+  path: import_zod.zDeleteCartShippingGroupPath.strict()
+}).strict();
+const deleteCartShippingGroupTool = (options) => {
+  const handler = (args, extra) => (0, import_mcp_support.toToolResult)(
+    (0, import_sdk.deleteCartShippingGroup)({
+      ...args,
+      client: options?.client,
+      signal: extra.signal,
+      throwOnError: false
+    })
+  );
+  return {
+    name: "cart_checkout_order_delete_cart_shipping_group",
+    config: {
+      title: "Delete Cart Shipping Group",
+      description: "Deletes a shipping group from a cart. It fails while any cart item is attached to the group, so remove the group from those items first. This is for carts only, not orders.",
+      inputSchema: deleteCartShippingGroupInput,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: true,
+        openWorldHint: true
+      },
+      _meta: {
+        "com.elasticpath/operation": {
+          id: "cart_checkout_order.deleteCartShippingGroup",
+          method: "DELETE",
+          path: "/v2/carts/{cartId}/shipping-groups/{shippingGroupId}",
+          risk: "delete"
+        }
+      }
+    },
+    handler
+  };
+};
+const getShippingGroupByIdInput = z.object({
+  path: import_zod.zGetShippingGroupByIdPath.strict()
+}).strict();
+const getShippingGroupByIdTool = (options) => {
+  const handler = (args, extra) => (0, import_mcp_support.toToolResult)(
+    (0, import_sdk.getShippingGroupById)({
+      ...args,
+      client: options?.client,
+      signal: extra.signal,
+      throwOnError: false
+    })
+  );
+  return {
+    name: "cart_checkout_order_get_shipping_group_by_id",
+    config: {
+      title: "Retrieve a specific shipping group for a cart",
+      description: "Gets one shipping group on a cart by its ID. This is for carts before checkout; an order's shipping groups are read from the order.",
+      inputSchema: getShippingGroupByIdInput,
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true
+      },
+      _meta: {
+        "com.elasticpath/operation": {
+          id: "cart_checkout_order.getShippingGroupById",
+          method: "GET",
+          path: "/v2/carts/{cartId}/shipping-groups/{shippingGroupId}",
+          risk: "read"
+        }
+      }
+    },
+    handler
+  };
+};
+const updateShippingGroupInput = z.object({
+  path: import_zod.zUpdateShippingGroupPath.strict(),
+  body: (0, import_mcp_support.loose)(import_zod.zUpdateShippingGroupBody)
+}).strict();
+const updateShippingGroupTool = (options) => {
+  const handler = (args, extra) => (0, import_mcp_support.toToolResult)(
+    (0, import_sdk.updateShippingGroup)({
+      ...args,
+      client: options?.client,
+      signal: extra.signal,
+      throwOnError: false
+    })
+  );
+  return {
+    name: "cart_checkout_order_update_shipping_group",
+    config: {
+      title: "Update a shipping group for a cart",
+      description: "Updates one shipping group on a cart. This is for carts before checkout; after checkout, update the shipping group on the order.",
+      inputSchema: updateShippingGroupInput,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: true,
+        openWorldHint: true
+      },
+      _meta: {
+        "com.elasticpath/operation": {
+          id: "cart_checkout_order.updateShippingGroup",
+          method: "PUT",
+          path: "/v2/carts/{cartId}/shipping-groups/{shippingGroupId}",
+          risk: "update"
+        }
+      }
+    },
+    handler
+  };
+};
+const createCartPaymentIntentInput = z.object({
+  path: import_zod.zCreateCartPaymentIntentPath.strict(),
+  body: (0, import_mcp_support.loose)(import_zod.zCreateCartPaymentIntentBody).optional()
+}).strict();
+const createCartPaymentIntentTool = (options) => {
+  const handler = (args, extra) => (0, import_mcp_support.toToolResult)(
+    (0, import_sdk.createCartPaymentIntent)({
+      ...args,
+      client: options?.client,
+      signal: extra.signal,
+      throwOnError: false
+    })
+  );
+  return {
+    name: "cart_checkout_order_create_cart_payment_intent",
+    config: {
+      title: "Create Stripe Payment Intent for a Cart",
+      description: "Creates a Stripe Payment Intent for a cart, linked to the cart and, at checkout, to the order. Use it before checkout when paying through Stripe Payment Intents; after checkout, confirm the order to sync the payment into a transaction. To change an existing intent, update it instead.",
+      inputSchema: createCartPaymentIntentInput,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: true
+      },
+      _meta: {
+        "com.elasticpath/operation": {
+          id: "cart_checkout_order.createCartPaymentIntent",
+          method: "POST",
+          path: "/v2/carts/{cartID}/payments",
+          risk: "create"
+        }
+      }
+    },
+    handler
+  };
+};
+const updateCartPaymentIntentInput = z.object({
+  path: import_zod.zUpdateCartPaymentIntentPath.strict(),
+  body: (0, import_mcp_support.loose)(import_zod.zUpdateCartPaymentIntentBody)
+}).strict();
+const updateCartPaymentIntentTool = (options) => {
+  const handler = (args, extra) => (0, import_mcp_support.toToolResult)(
+    (0, import_sdk.updateCartPaymentIntent)({
+      ...args,
+      client: options?.client,
+      signal: extra.signal,
+      throwOnError: false
+    })
+  );
+  return {
+    name: "cart_checkout_order_update_cart_payment_intent",
+    config: {
+      title: "Update a Payment Intent on a Cart",
+      description: "Updates the Stripe Payment Intent on a cart so it matches the final cart details. Call it once when ready to take payment, not after every cart change.",
+      inputSchema: updateCartPaymentIntentInput,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: true,
+        openWorldHint: true
+      },
+      _meta: {
+        "com.elasticpath/operation": {
+          id: "cart_checkout_order.updateCartPaymentIntent",
+          method: "PUT",
+          path: "/v2/carts/{cartID}/payments/{paymentIntentID}",
+          risk: "update"
+        }
+      }
+    },
+    handler
+  };
+};
+const checkoutApiInput = z.object({
+  path: import_zod.zCheckoutApiPath.strict(),
+  headers: import_zod.zCheckoutApiHeaders.strict().optional(),
+  body: (0, import_mcp_support.loose)(import_zod.zCheckoutApiBody).optional()
+}).strict();
+const checkoutApiTool = (options) => {
+  const handler = (args, extra) => (0, import_mcp_support.toToolResult)(
+    (0, import_sdk.checkoutApi)({
+      ...args,
+      client: options?.client,
+      signal: extra.signal,
+      throwOnError: false
+    })
+  );
+  return {
+    name: "cart_checkout_order_checkout_api",
+    config: {
+      title: "Check Out a Cart",
+      description: "Converts a cart to an unpaid order and returns the order. Check out with a customer ID, a guest customer's name and email, or an account; billing and shipping addresses are optional. The cart remains and can be checked out again. Pay for the order afterwards.",
+      inputSchema: checkoutApiInput,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: true
+      },
+      _meta: {
+        "com.elasticpath/operation": {
+          id: "cart_checkout_order.checkoutApi",
+          method: "POST",
+          path: "/v2/carts/{cartID}/checkout",
+          risk: "create"
+        }
+      }
+    },
+    handler
+  };
+};
+const getCustomerOrdersInput = z.object({
+  query: import_zod.zGetCustomerOrdersQuery.strict().optional(),
+  headers: import_zod.zGetCustomerOrdersHeaders.strict().optional()
+}).strict();
+const getCustomerOrdersTool = (options) => {
+  const handler = (args, extra) => (0, import_mcp_support.toToolResult)(
+    (0, import_sdk.getCustomerOrders)({
+      ...args,
+      client: options?.client,
+      signal: extra.signal,
+      throwOnError: false
+    })
+  );
+  return {
+    name: "cart_checkout_order_get_customer_orders",
+    config: {
+      title: "Get all Orders",
+      description: "Lists orders, with optional filters. Paging reaches at most 10,000 orders, so filter to reach orders beyond that. A customer or account token header limits the results to that customer's or account's orders.",
+      inputSchema: getCustomerOrdersInput,
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true
+      },
+      _meta: {
+        "com.elasticpath/operation": {
+          id: "cart_checkout_order.getCustomerOrders",
+          method: "GET",
+          path: "/v2/orders",
+          risk: "read"
+        }
+      }
+    },
+    handler
+  };
+};
+const getAnOrderInput = z.object({
+  path: import_zod.zGetAnOrderPath.strict(),
+  query: import_zod.zGetAnOrderQuery.strict().optional()
+}).strict();
+const getAnOrderTool = (options) => {
+  const handler = (args, extra) => (0, import_mcp_support.toToolResult)(
+    (0, import_sdk.getAnOrder)({
+      ...args,
+      client: options?.client,
+      signal: extra.signal,
+      throwOnError: false
+    })
+  );
+  return {
+    name: "cart_checkout_order_get_an_order",
+    config: {
+      title: "Get an Order",
+      description: "Gets one order by ID, optionally including its items, tax items, custom discounts or promotions. To list only the order's items, get the order items.",
+      inputSchema: getAnOrderInput,
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true
+      },
+      _meta: {
+        "com.elasticpath/operation": {
+          id: "cart_checkout_order.getAnOrder",
+          method: "GET",
+          path: "/v2/orders/{orderID}",
+          risk: "read"
+        }
+      }
+    },
+    handler
+  };
+};
+const updateAnOrderInput = z.object({
+  path: import_zod.zUpdateAnOrderPath.strict(),
+  body: (0, import_mcp_support.loose)(import_zod.zUpdateAnOrderBody).optional()
+}).strict();
+const updateAnOrderTool = (options) => {
+  const handler = (args, extra) => (0, import_mcp_support.toToolResult)(
+    (0, import_sdk.updateAnOrder)({
+      ...args,
+      client: options?.client,
+      signal: extra.signal,
+      throwOnError: false
+    })
+  );
+  return {
+    name: "cart_checkout_order_update_an_order",
+    config: {
+      title: "Update an Order",
+      description: "Updates an order's custom data, shipping, shipping address, status, order number or external reference; everything else on an order is immutable. It can cancel an order that is not fulfilled, or fulfill a paid one. Canceling does not refund.",
+      inputSchema: updateAnOrderInput,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: true,
+        openWorldHint: true
+      },
+      _meta: {
+        "com.elasticpath/operation": {
+          id: "cart_checkout_order.updateAnOrder",
+          method: "PUT",
+          path: "/v2/orders/{orderID}",
+          risk: "update"
+        }
+      }
+    },
+    handler
+  };
+};
+const getOrderItemsInput = z.object({
+  path: import_zod.zGetOrderItemsPath.strict(),
+  query: import_zod.zGetOrderItemsQuery.strict().optional()
+}).strict();
+const getOrderItemsTool = (options) => {
+  const handler = (args, extra) => (0, import_mcp_support.toToolResult)(
+    (0, import_sdk.getOrderItems)({
+      ...args,
+      client: options?.client,
+      signal: extra.signal,
+      throwOnError: false
+    })
+  );
+  return {
+    name: "cart_checkout_order_get_order_items",
+    config: {
+      title: "Get Order Items",
+      description: "Lists the items of one order, optionally including their tax items, custom discounts or promotions. Use it for an order's items; a cart's items are read from the cart.",
+      inputSchema: getOrderItemsInput,
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true
+      },
+      _meta: {
+        "com.elasticpath/operation": {
+          id: "cart_checkout_order.getOrderItems",
+          method: "GET",
+          path: "/v2/orders/{orderID}/items",
+          risk: "read"
+        }
+      }
+    },
+    handler
+  };
+};
+const anonymizeOrdersInput = z.object({
+  body: (0, import_mcp_support.loose)(import_zod.zAnonymizeOrdersBody).optional()
+}).strict();
+const anonymizeOrdersTool = (options) => {
+  const handler = (args, extra) => (0, import_mcp_support.toToolResult)(
+    (0, import_sdk.anonymizeOrders)({
+      ...args,
+      client: options?.client,
+      signal: extra.signal,
+      throwOnError: false
+    })
+  );
+  return {
+    name: "cart_checkout_order_anonymize_orders",
+    config: {
+      title: "Anonymize Orders",
+      description: "Anonymizes orders that are fulfilled, canceled or fully refunded, replacing the customer details and the shipping and billing addresses with *. Orders in other states cannot be anonymized.",
+      inputSchema: anonymizeOrdersInput,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: false,
+        openWorldHint: true
+      },
+      _meta: {
+        "com.elasticpath/operation": {
+          id: "cart_checkout_order.anonymizeOrders",
+          method: "POST",
+          path: "/v2/orders/anonymize",
+          risk: "update"
+        }
+      }
+    },
+    handler
+  };
+};
+const confirmOrderInput = z.object({
+  path: import_zod.zConfirmOrderPath.strict()
+}).strict();
+const confirmOrderTool = (options) => {
+  const handler = (args, extra) => (0, import_mcp_support.toToolResult)(
+    (0, import_sdk.confirmOrder)({
+      ...args,
+      client: options?.client,
+      signal: extra.signal,
+      throwOnError: false
+    })
+  );
+  return {
+    name: "cart_checkout_order_confirm_order",
+    config: {
+      title: "Confirm Order",
+      description: "Confirms an order, finalizing it and making it ready for processing. For an order paid through a cart's Stripe Payment Intent, confirming after checkout syncs the intent into a transaction and updates the order's statuses.",
+      inputSchema: confirmOrderInput,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: true
+      },
+      _meta: {
+        "com.elasticpath/operation": {
+          id: "cart_checkout_order.confirmOrder",
+          method: "POST",
+          path: "/v2/orders/{orderID}/confirm",
+          risk: "create"
+        }
+      }
+    },
+    handler
+  };
+};
+const paymentSetupInput = z.object({
+  path: import_zod.zPaymentSetupPath.strict(),
+  body: (0, import_mcp_support.loose)(import_zod.zPaymentSetupBody).optional()
+}).strict();
+const paymentSetupTool = (options) => {
+  const handler = (args, extra) => (0, import_mcp_support.toToolResult)(
+    (0, import_sdk.paymentSetup)({
+      ...args,
+      client: options?.client,
+      signal: extra.signal,
+      throwOnError: false
+    })
+  );
+  return {
+    name: "cart_checkout_order_payment_setup",
+    config: {
+      title: "Pay for an Order",
+      description: "Starts a payment on an order through a payment gateway. The transaction type depends on the gateway: purchase charges now, authorize holds funds for a later capture, and purchase_setup or authorize_setup only verify the payment method. Split payments are supported.",
+      inputSchema: paymentSetupInput,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: true
+      },
+      _meta: {
+        "com.elasticpath/operation": {
+          id: "cart_checkout_order.paymentSetup",
+          method: "POST",
+          path: "/v2/orders/{orderID}/payments",
+          risk: "create"
+        }
+      }
+    },
+    handler
+  };
+};
+const confirmPaymentInput = z.object({
+  path: import_zod.zConfirmPaymentPath.strict(),
+  body: (0, import_mcp_support.loose)(import_zod.zConfirmPaymentBody).optional()
+}).strict();
+const confirmPaymentTool = (options) => {
+  const handler = (args, extra) => (0, import_mcp_support.toToolResult)(
+    (0, import_sdk.confirmPayment)({
+      ...args,
+      client: options?.client,
+      signal: extra.signal,
+      throwOnError: false
+    })
+  );
+  return {
+    name: "cart_checkout_order_confirm_payment",
+    config: {
+      title: "Confirm a Transaction",
+      description: "Confirms a transaction on an order by syncing its details from the third-party payment provider, so Elastic Path reflects the provider's values. For Stripe 3D Secure, call it after the shopper's client-side authentication succeeds.",
+      inputSchema: confirmPaymentInput,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: true
+      },
+      _meta: {
+        "com.elasticpath/operation": {
+          id: "cart_checkout_order.confirmPayment",
+          method: "POST",
+          path: "/v2/orders/{orderID}/transactions/{transactionID}/confirm",
+          risk: "create"
+        }
+      }
+    },
+    handler
+  };
+};
+const captureATransactionInput = z.object({
+  path: import_zod.zCaptureATransactionPath.strict(),
+  body: (0, import_mcp_support.loose)(import_zod.zCaptureATransactionBody).optional()
+}).strict();
+const captureATransactionTool = (options) => {
+  const handler = (args, extra) => (0, import_mcp_support.toToolResult)(
+    (0, import_sdk.captureATransaction)({
+      ...args,
+      client: options?.client,
+      signal: extra.signal,
+      throwOnError: false
+    })
+  );
+  return {
+    name: "cart_checkout_order_capture_a_transaction",
+    config: {
+      title: "Capture a Transaction",
+      description: "Captures a payment that was previously authorized on an order transaction. Optionally pass a custom reference, such as the gateway's payment reference. Use it after an authorize payment.",
+      inputSchema: captureATransactionInput,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: true
+      },
+      _meta: {
+        "com.elasticpath/operation": {
+          id: "cart_checkout_order.captureATransaction",
+          method: "POST",
+          path: "/v2/orders/{orderID}/transactions/{transactionID}/capture",
+          risk: "create"
+        }
+      }
+    },
+    handler
+  };
+};
+const refundATransactionInput = z.object({
+  path: import_zod.zRefundATransactionPath.strict(),
+  body: (0, import_mcp_support.loose)(import_zod.zRefundATransactionBody).optional()
+}).strict();
+const refundATransactionTool = (options) => {
+  const handler = (args, extra) => (0, import_mcp_support.toToolResult)(
+    (0, import_sdk.refundATransaction)({
+      ...args,
+      client: options?.client,
+      signal: extra.signal,
+      throwOnError: false
+    })
+  );
+  return {
+    name: "cart_checkout_order_refund_a_transaction",
+    config: {
+      title: "Refund a Transaction",
+      description: "Refunds an order transaction. Either mark it refunded after refunding through your own payment provider, which is a full refund, or send a full or partial refund amount to a supported gateway.",
+      inputSchema: refundATransactionInput,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: true
+      },
+      _meta: {
+        "com.elasticpath/operation": {
+          id: "cart_checkout_order.refundATransaction",
+          method: "POST",
+          path: "/v2/orders/{orderID}/transactions/{transactionID}/refund",
+          risk: "create"
+        }
+      }
+    },
+    handler
+  };
+};
+const getOrderTransactionsInput = z.object({
+  path: import_zod.zGetOrderTransactionsPath.strict()
+}).strict();
+const getOrderTransactionsTool = (options) => {
+  const handler = (args, extra) => (0, import_mcp_support.toToolResult)(
+    (0, import_sdk.getOrderTransactions)({
+      ...args,
+      client: options?.client,
+      signal: extra.signal,
+      throwOnError: false
+    })
+  );
+  return {
+    name: "cart_checkout_order_get_order_transactions",
+    config: {
+      title: "Get Order Transactions",
+      description: "Lists all payment transactions on one order. Use it to find a transaction ID before confirming, capturing, refunding or canceling it.",
+      inputSchema: getOrderTransactionsInput,
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true
+      },
+      _meta: {
+        "com.elasticpath/operation": {
+          id: "cart_checkout_order.getOrderTransactions",
+          method: "GET",
+          path: "/v2/orders/{orderID}/transactions",
+          risk: "read"
+        }
+      }
+    },
+    handler
+  };
+};
+const getATransactionInput = z.object({
+  path: import_zod.zGetATransactionPath.strict()
+}).strict();
+const getATransactionTool = (options) => {
+  const handler = (args, extra) => (0, import_mcp_support.toToolResult)(
+    (0, import_sdk.getATransaction)({
+      ...args,
+      client: options?.client,
+      signal: extra.signal,
+      throwOnError: false
+    })
+  );
+  return {
+    name: "cart_checkout_order_get_a_transaction",
+    config: {
+      title: "Get a Transaction",
+      description: "Gets one transaction on an order by its transaction ID. Use it to check a single transaction's status.",
+      inputSchema: getATransactionInput,
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true
+      },
+      _meta: {
+        "com.elasticpath/operation": {
+          id: "cart_checkout_order.getATransaction",
+          method: "GET",
+          path: "/v2/orders/{orderID}/transactions/{transactionID}",
+          risk: "read"
+        }
+      }
+    },
+    handler
+  };
+};
+const cancelATransactionInput = z.object({
+  path: import_zod.zCancelATransactionPath.strict(),
+  body: (0, import_mcp_support.loose)(import_zod.zCancelATransactionBody).optional()
+}).strict();
+const cancelATransactionTool = (options) => {
+  const handler = (args, extra) => (0, import_mcp_support.toToolResult)(
+    (0, import_sdk.cancelATransaction)({
+      ...args,
+      client: options?.client,
+      signal: extra.signal,
+      throwOnError: false
+    })
+  );
+  return {
+    name: "cart_checkout_order_cancel_a_transaction",
+    config: {
+      title: "Cancel a Transaction",
+      description: "Cancels or voids a pending or authorized transaction on an order. Works only with the Stripe and PayPal gateways, not the manual gateway. To return funds already taken, refund the transaction instead.",
+      inputSchema: cancelATransactionInput,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: true
+      },
+      _meta: {
+        "com.elasticpath/operation": {
+          id: "cart_checkout_order.cancelATransaction",
+          method: "POST",
+          path: "/v2/orders/{orderID}/transactions/{transactionID}/cancel",
+          risk: "create"
+        }
+      }
+    },
+    handler
+  };
+};
+const getOrderShippingGroupsInput = z.object({
+  path: import_zod.zGetOrderShippingGroupsPath.strict()
+}).strict();
+const getOrderShippingGroupsTool = (options) => {
+  const handler = (args, extra) => (0, import_mcp_support.toToolResult)(
+    (0, import_sdk.getOrderShippingGroups)({
+      ...args,
+      client: options?.client,
+      signal: extra.signal,
+      throwOnError: false
+    })
+  );
+  return {
+    name: "cart_checkout_order_get_order_shipping_groups",
+    config: {
+      title: "Retrieve all shipping groups for an order",
+      description: "Lists the shipping groups on an order. This is for orders after checkout; a cart's shipping groups are read from the cart.",
+      inputSchema: getOrderShippingGroupsInput,
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true
+      },
+      _meta: {
+        "com.elasticpath/operation": {
+          id: "cart_checkout_order.getOrderShippingGroups",
+          method: "GET",
+          path: "/v2/orders/{orderID}/shipping-groups",
+          risk: "read"
+        }
+      }
+    },
+    handler
+  };
+};
+const createOrderShippingGroupInput = z.object({
+  path: import_zod.zCreateOrderShippingGroupPath.strict(),
+  body: (0, import_mcp_support.loose)(import_zod.zCreateOrderShippingGroupBody).optional()
+}).strict();
+const createOrderShippingGroupTool = (options) => {
+  const handler = (args, extra) => (0, import_mcp_support.toToolResult)(
+    (0, import_sdk.createOrderShippingGroup)({
+      ...args,
+      client: options?.client,
+      signal: extra.signal,
+      throwOnError: false
+    })
+  );
+  return {
+    name: "cart_checkout_order_create_order_shipping_group",
+    config: {
+      title: "Create a shipping group for an order",
+      description: "Creates a shipping group on an order. This is for orders after checkout; before checkout, create the shipping group on the cart.",
+      inputSchema: createOrderShippingGroupInput,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: true
+      },
+      _meta: {
+        "com.elasticpath/operation": {
+          id: "cart_checkout_order.createOrderShippingGroup",
+          method: "POST",
+          path: "/v2/orders/{orderID}/shipping-groups",
+          risk: "create"
+        }
+      }
+    },
+    handler
+  };
+};
+const getShippingGroupsByIdInput = z.object({
+  path: import_zod.zGetShippingGroupsByIdPath.strict(),
+  query: import_zod.zGetShippingGroupsByIdQuery.strict().optional()
+}).strict();
+const getShippingGroupsByIdTool = (options) => {
+  const handler = (args, extra) => (0, import_mcp_support.toToolResult)(
+    (0, import_sdk.getShippingGroupsById)({
+      ...args,
+      client: options?.client,
+      signal: extra.signal,
+      throwOnError: false
+    })
+  );
+  return {
+    name: "cart_checkout_order_get_shipping_groups_by_id",
+    config: {
+      title: "Retrieve a specific shipping group for an order",
+      description: "Gets one shipping group on an order by its ID. This is for orders after checkout; a cart's shipping groups are read from the cart.",
+      inputSchema: getShippingGroupsByIdInput,
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true
+      },
+      _meta: {
+        "com.elasticpath/operation": {
+          id: "cart_checkout_order.getShippingGroupsById",
+          method: "GET",
+          path: "/v2/orders/{orderID}/shipping-groups/{shippingGroupID}",
+          risk: "read"
+        }
+      }
+    },
+    handler
+  };
+};
+const putShippingGroupByIdInput = z.object({
+  path: import_zod.zPutShippingGroupByIdPath.strict(),
+  body: (0, import_mcp_support.loose)(import_zod.zPutShippingGroupByIdBody)
+}).strict();
+const putShippingGroupByIdTool = (options) => {
+  const handler = (args, extra) => (0, import_mcp_support.toToolResult)(
+    (0, import_sdk.putShippingGroupById)({
+      ...args,
+      client: options?.client,
+      signal: extra.signal,
+      throwOnError: false
+    })
+  );
+  return {
+    name: "cart_checkout_order_put_shipping_group_by_id",
+    config: {
+      title: "Update a shipping group for an order",
+      description: "Updates one shipping group on an order. This is for orders after checkout; before checkout, update the shipping group on the cart.",
+      inputSchema: putShippingGroupByIdInput,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: true,
+        openWorldHint: true
+      },
+      _meta: {
+        "com.elasticpath/operation": {
+          id: "cart_checkout_order.putShippingGroupById",
+          method: "PUT",
+          path: "/v2/orders/{orderID}/shipping-groups/{shippingGroupID}",
+          risk: "update"
+        }
+      }
+    },
+    handler
+  };
+};
+const getV2SettingsCartInput = z.object({}).strict();
+const getV2SettingsCartTool = (options) => {
+  const handler = (args, extra) => (0, import_mcp_support.toToolResult)(
+    (0, import_sdk.getV2SettingsCart)({
+      ...args,
+      client: options?.client,
+      signal: extra.signal,
+      throwOnError: false
+    })
+  );
+  return {
+    name: "cart_checkout_order_get_v2_settings_cart",
+    config: {
+      title: "Get Cart Settings",
+      description: "Gets the store's cart settings, such as cart expiry, custom discounts, deferred inventory checks and show_all_carts. Read them before changing a setting.",
+      inputSchema: getV2SettingsCartInput,
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true
+      },
+      _meta: {
+        "com.elasticpath/operation": {
+          id: "cart_checkout_order.getV2SettingsCart",
+          method: "GET",
+          path: "/v2/settings/cart",
+          risk: "read"
+        }
+      }
+    },
+    handler
+  };
+};
+const putV2SettingsCartInput = z.object({
+  body: (0, import_mcp_support.loose)(import_zod.zPutV2SettingsCartBody).optional()
+}).strict();
+const putV2SettingsCartTool = (options) => {
+  const handler = (args, extra) => (0, import_mcp_support.toToolResult)(
+    (0, import_sdk.putV2SettingsCart)({
+      ...args,
+      client: options?.client,
+      signal: extra.signal,
+      throwOnError: false
+    })
+  );
+  return {
+    name: "cart_checkout_order_put_v2_settings_cart",
+    config: {
+      title: "Update Cart Settings",
+      description: "Updates the store's cart settings: cart expiry in days (up to 365), custom discounts, rule promotions, deferred inventory checks, show_all_carts and separating items by location. The settings are the defaults for every cart in the store; one cart's custom discount and inventory check settings can be changed on that cart instead.",
+      inputSchema: putV2SettingsCartInput,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: true,
+        openWorldHint: true
+      },
+      _meta: {
+        "com.elasticpath/operation": {
+          id: "cart_checkout_order.putV2SettingsCart",
+          method: "PUT",
+          path: "/v2/settings/cart",
+          risk: "update"
+        }
+      }
+    },
+    handler
+  };
+};
+const getV2SettingsCartStoreIdInput = z.object({
+  path: import_zod.zGetV2SettingsCartStoreIdPath.strict()
+}).strict();
+const getV2SettingsCartStoreIdTool = (options) => {
+  const handler = (args, extra) => (0, import_mcp_support.toToolResult)(
+    (0, import_sdk.getV2SettingsCartStoreId)({
+      ...args,
+      client: options?.client,
+      signal: extra.signal,
+      throwOnError: false
+    })
+  );
+  return {
+    name: "cart_checkout_order_get_v2_settings_cart_store_id",
+    config: {
+      title: "Get Cart Settings by Store ID",
+      description: "Gets the cart settings of the store with the given store ID, such as cart expiry, custom discounts, deferred inventory checks and show_all_carts. Read them before changing a setting.",
+      inputSchema: getV2SettingsCartStoreIdInput,
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true
+      },
+      _meta: {
+        "com.elasticpath/operation": {
+          id: "cart_checkout_order.getV2SettingsCartStoreId",
+          method: "GET",
+          path: "/v2/settings/cart/{storeID}",
+          risk: "read"
+        }
+      }
+    },
+    handler
+  };
+};
+const putV2SettingsCartStoreIdInput = z.object({
+  path: import_zod.zPutV2SettingsCartStoreIdPath.strict(),
+  body: (0, import_mcp_support.loose)(import_zod.zPutV2SettingsCartStoreIdBody).optional()
+}).strict();
+const putV2SettingsCartStoreIdTool = (options) => {
+  const handler = (args, extra) => (0, import_mcp_support.toToolResult)(
+    (0, import_sdk.putV2SettingsCartStoreId)({
+      ...args,
+      client: options?.client,
+      signal: extra.signal,
+      throwOnError: false
+    })
+  );
+  return {
+    name: "cart_checkout_order_put_v2_settings_cart_store_id",
+    config: {
+      title: "Update Cart Settings by Store ID",
+      description: "Updates the cart settings of the store with the given store ID: cart expiry in days (up to 365), custom discounts, rule promotions, deferred inventory checks, show_all_carts and separating items by location. The settings are the defaults for every cart in that store; one cart's custom discount and inventory check settings can be changed on that cart instead.",
+      inputSchema: putV2SettingsCartStoreIdInput,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: true,
+        openWorldHint: true
+      },
+      _meta: {
+        "com.elasticpath/operation": {
+          id: "cart_checkout_order.putV2SettingsCartStoreId",
+          method: "PUT",
+          path: "/v2/settings/cart/{storeID}",
+          risk: "update"
+        }
+      }
+    },
+    handler
+  };
+};
+const tools = (options) => [
+  getCartsTool(options),
+  createACartTool(options),
+  deleteACartTool(options),
+  getACartTool(options),
+  updateACartTool(options),
+  deleteAllCartItemsTool(options),
+  getCartItemsTool(options),
+  manageCartsTool(options),
+  bulkUpdateItemsInCartTool(options),
+  deleteACartItemTool(options),
+  updateACartItemTool(options),
+  deleteAccountCartAssociationTool(options),
+  createAccountCartAssociationTool(options),
+  deleteCustomerCartAssociationTool(options),
+  createCustomerCartAssociationTool(options),
+  deleteAPromotionViaPromotionCodeTool(options),
+  addTaxItemToCartTool(options),
+  addTaxItemToCartItemComponentTool(options),
+  deleteTaxItemFromCartItemComponentTool(options),
+  updateTaxItemFromCartItemComponentTool(options),
+  bulkDeleteTaxItemsFromCartTool(options),
+  bulkAddTaxItemsToCartTool(options),
+  deleteATaxItemTool(options),
+  updateATaxItemTool(options),
+  bulkDeleteCustomDiscountsFromCartTool(options),
+  bulkAddCustomDiscountsToCartTool(options),
+  deleteCustomDiscountFromCartTool(options),
+  updateCustomDiscountForCartTool(options),
+  addCustomDiscountToCartItemTool(options),
+  deleteCustomDiscountFromCartItemTool(options),
+  updateCustomDiscountForCartItemTool(options),
+  getShippingGroupsTool(options),
+  createShippingGroupTool(options),
+  deleteCartShippingGroupTool(options),
+  getShippingGroupByIdTool(options),
+  updateShippingGroupTool(options),
+  createCartPaymentIntentTool(options),
+  updateCartPaymentIntentTool(options),
+  checkoutApiTool(options),
+  getCustomerOrdersTool(options),
+  getAnOrderTool(options),
+  updateAnOrderTool(options),
+  getOrderItemsTool(options),
+  anonymizeOrdersTool(options),
+  confirmOrderTool(options),
+  paymentSetupTool(options),
+  confirmPaymentTool(options),
+  captureATransactionTool(options),
+  refundATransactionTool(options),
+  getOrderTransactionsTool(options),
+  getATransactionTool(options),
+  cancelATransactionTool(options),
+  getOrderShippingGroupsTool(options),
+  createOrderShippingGroupTool(options),
+  getShippingGroupsByIdTool(options),
+  putShippingGroupByIdTool(options),
+  getV2SettingsCartTool(options),
+  putV2SettingsCartTool(options),
+  getV2SettingsCartStoreIdTool(options),
+  putV2SettingsCartStoreIdTool(options)
+];
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addCustomDiscountToCartItemTool,
+  addTaxItemToCartItemComponentTool,
+  addTaxItemToCartTool,
+  anonymizeOrdersTool,
+  bulkAddCustomDiscountsToCartTool,
+  bulkAddTaxItemsToCartTool,
+  bulkDeleteCustomDiscountsFromCartTool,
+  bulkDeleteTaxItemsFromCartTool,
+  bulkUpdateItemsInCartTool,
+  cancelATransactionTool,
+  captureATransactionTool,
+  checkoutApiTool,
+  confirmOrderTool,
+  confirmPaymentTool,
+  createACartTool,
+  createAccountCartAssociationTool,
+  createCartPaymentIntentTool,
+  createCustomerCartAssociationTool,
+  createOrderShippingGroupTool,
+  createShippingGroupTool,
+  deleteACartItemTool,
+  deleteACartTool,
+  deleteAPromotionViaPromotionCodeTool,
+  deleteATaxItemTool,
+  deleteAccountCartAssociationTool,
+  deleteAllCartItemsTool,
+  deleteCartShippingGroupTool,
+  deleteCustomDiscountFromCartItemTool,
+  deleteCustomDiscountFromCartTool,
+  deleteCustomerCartAssociationTool,
+  deleteTaxItemFromCartItemComponentTool,
+  getACartTool,
+  getATransactionTool,
+  getAnOrderTool,
+  getCartItemsTool,
+  getCartsTool,
+  getCustomerOrdersTool,
+  getOrderItemsTool,
+  getOrderShippingGroupsTool,
+  getOrderTransactionsTool,
+  getShippingGroupByIdTool,
+  getShippingGroupsByIdTool,
+  getShippingGroupsTool,
+  getV2SettingsCartStoreIdTool,
+  getV2SettingsCartTool,
+  manageCartsTool,
+  paymentSetupTool,
+  putShippingGroupByIdTool,
+  putV2SettingsCartStoreIdTool,
+  putV2SettingsCartTool,
+  refundATransactionTool,
+  tools,
+  updateACartItemTool,
+  updateACartTool,
+  updateATaxItemTool,
+  updateAnOrderTool,
+  updateCartPaymentIntentTool,
+  updateCustomDiscountForCartItemTool,
+  updateCustomDiscountForCartTool,
+  updateShippingGroupTool,
+  updateTaxItemFromCartItemComponentTool
+});
+//# sourceMappingURL=mcp.gen.cjs.map