@adobe-commerce/aio-toolkit 1.0.3 → 1.0.5

package/dist/index.mjs

@@ -396,15 +396,34 @@ var _FileRepository = class _FileRepository {
   async list() {
     const filesLib = await this.getFiles();
     const results = [];
-    const existingFiles = await filesLib.list(`${this.filepath}/`);
+    const existingFiles = await this.metadata();
     if (existingFiles.length) {
-      for (const { name } of existingFiles) {
-        const buffer = await filesLib.read(`${name}`);
-        results.push(JSON.parse(buffer.toString()));
+      for (const file of existingFiles) {
+        const buffer = await filesLib.read(`${file.name}`);
+        const data = JSON.parse(buffer.toString());
+        results.push({
+          ...data,
+          createdAt: file.creationTime.toISOString(),
+          updatedAt: file.lastModified.toISOString()
+        });
       }
     }
     return results;
   }
+  /**
+   * Lists file metadata without reading file contents
+   * Provides a lightweight alternative to list() for performance-critical operations
+   * @param id - Optional ID of a specific file to get metadata for
+   * @returns Promise<FileMetadata | FileMetadata[]> Single file metadata if id provided, array of all files otherwise
+   */
+  async metadata(id) {
+    const filesLib = await this.getFiles();
+    if (id) {
+      const filepath = `${this.filepath}/${id}.json`;
+      return await filesLib.getProperties(filepath);
+    }
+    return await filesLib.list(`${this.filepath}/`);
+  }
   /**
    * Loads a specific file by ID
    * @param id - The ID of the file to load
@@ -416,7 +435,13 @@ var _FileRepository = class _FileRepository {
     const existingFile = await filesLib.list(filepath);
     if (existingFile.length) {
       const buffer = await filesLib.read(filepath);
-      return JSON.parse(buffer.toString());
+      const data = JSON.parse(buffer.toString());
+      const fileProps = await filesLib.getProperties(filepath);
+      return {
+        ...data,
+        createdAt: fileProps.creationTime.toISOString(),
+        updatedAt: fileProps.lastModified.toISOString()
+      };
     }
     return {};
   }
@@ -424,9 +449,12 @@ var _FileRepository = class _FileRepository {
    * Saves a file record to the repository
    * @param payload - The data to save
    * @param id - Optional ID for the file (sanitized to alphanumeric + underscore, takes precedence over payload.id)
+   * @param overwrite - Optional flag to control file write behavior:
+   *                    - true: Replace file entirely with payload (no merge)
+   *                    - false (default): Merge payload with existing file content
    * @returns Promise<string | null> The filename on success, null on failure
    */
-  async save(payload = {}, id) {
+  async save(payload = {}, id, overwrite = false) {
     try {
       const filesLib = await this.getFiles();
       let fileId;
@@ -440,23 +468,26 @@ var _FileRepository = class _FileRepository {
       const filepath = `${this.filepath}/${fileId}.json`;
       const existingFile = await filesLib.list(filepath);
       if (existingFile.length) {
-        const buffer = await filesLib.read(filepath);
-        const existingData = JSON.parse(buffer.toString());
-        payload = {
-          ...payload,
-          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-        };
-        payload = { ...existingData, ...payload };
+        if (overwrite) {
+          console.log(`Overwriting existing file: ${filepath}`);
+          payload = {
+            id: fileId,
+            ...payload
+          };
+        } else {
+          const buffer = await filesLib.read(filepath);
+          const existingData = JSON.parse(buffer.toString());
+          payload = { ...existingData, ...payload };
+        }
         await filesLib.delete(filepath);
       } else {
         payload = {
-          ...payload,
           id: fileId,
-          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+          ...payload
         };
       }
-      await filesLib.write(filepath, JSON.stringify(payload));
+      const { createdAt, updatedAt, ...payloadWithoutTimestamps } = payload;
+      await filesLib.write(filepath, JSON.stringify(payloadWithoutTimestamps));
       return fileId;
     } catch (error) {
       console.error("Error saving file:", error);
@@ -521,28 +552,31 @@ var _CustomLogger = class _CustomLogger {
   /**
    * Log debug message if logger is available
    * @param message - Debug message to log
+   * @param args - Additional arguments to pass to logger
    */
-  debug(message) {
+  debug(message, ...args) {
     if (this.logger && typeof this.logger.debug === "function") {
-      this.logger.debug(message);
+      this.logger.debug(message, ...args);
     }
   }
   /**
    * Log info message if logger is available
    * @param message - Info message to log
+   * @param args - Additional arguments to pass to logger
    */
-  info(message) {
+  info(message, ...args) {
     if (this.logger && typeof this.logger.info === "function") {
-      this.logger.info(message);
+      this.logger.info(message, ...args);
     }
   }
   /**
    * Log error message if logger is available
    * @param message - Error message to log
+   * @param args - Additional arguments to pass to logger
    */
-  error(message) {
+  error(message, ...args) {
     if (this.logger && typeof this.logger.error === "function") {
-      this.logger.error(message);
+      this.logger.error(message, ...args);
     }
   }
   /**
@@ -642,6 +676,281 @@ __name(_PublishEvent, "PublishEvent");
 var PublishEvent = _PublishEvent;
 var publish_event_default = PublishEvent;
 
+// src/framework/webhook-action/response/types.ts
+var WebhookActionOperation = /* @__PURE__ */ ((WebhookActionOperation2) => {
+  WebhookActionOperation2["SUCCESS"] = "success";
+  WebhookActionOperation2["EXCEPTION"] = "exception";
+  WebhookActionOperation2["ADD"] = "add";
+  WebhookActionOperation2["REPLACE"] = "replace";
+  WebhookActionOperation2["REMOVE"] = "remove";
+  return WebhookActionOperation2;
+})(WebhookActionOperation || {});
+
+// src/framework/webhook-action/response/index.ts
+var _WebhookActionResponse = class _WebhookActionResponse {
+  /**
+   * Creates a success response indicating the webhook was processed successfully.
+   *
+   * Use this method when the webhook has been processed without errors and
+   * no modifications to the payload are needed.
+   *
+   * @returns A success response object
+   *
+   * @example
+   * ```typescript
+   * const handler = WebhookAction.execute('process-order', [], [], async (params) => {
+   *   // Process the order...
+   *   await processOrder(params.order);
+   *
+   *   // Return success
+   *   return {
+   *     statusCode: 200,
+   *     body: WebhookActionResponse.success()
+   *   };
+   * });
+   * ```
+   */
+  static success() {
+    return {
+      op: "success" /* SUCCESS */
+    };
+  }
+  /**
+   * Creates an exception response to report an error during webhook processing.
+   *
+   * Use this method to notify Adobe Commerce that an error occurred while
+   * processing the webhook. This helps with debugging and error tracking.
+   *
+   * @param message - Optional error message describing what went wrong
+   * @param exceptionClass - Optional exception class name for categorization (e.g., 'Magento\\Framework\\Exception\\LocalizedException')
+   * @returns An exception response object
+   *
+   * @example
+   * ```typescript
+   * const handler = WebhookAction.execute('validate-product', [], [], async (params) => {
+   *   const product = await findProduct(params.sku);
+   *
+   *   if (!product) {
+   *     return {
+   *       statusCode: 404,
+   *       body: WebhookActionResponse.exception(
+   *         `Product with SKU ${params.sku} not found`,
+   *         'Magento\\Framework\\Exception\\NoSuchEntityException'
+   *       )
+   *     };
+   *   }
+   *
+   *   return { statusCode: 200, body: WebhookActionResponse.success() };
+   * });
+   * ```
+   */
+  static exception(message, exceptionClass) {
+    const response = {
+      op: "exception" /* EXCEPTION */
+    };
+    if (message !== void 0) {
+      response.message = message;
+    }
+    if (exceptionClass !== void 0) {
+      response.class = exceptionClass;
+    }
+    return response;
+  }
+  /**
+   * Creates a response to add new data to the webhook payload.
+   *
+   * Use this method to inject additional data into the webhook payload that
+   * will be processed by Adobe Commerce. The data is added at the specified
+   * path using dot notation.
+   *
+   * @param path - Dot-notation path where the value should be added (e.g., 'order.items', 'customer.addresses')
+   * @param value - The value to add at the specified path
+   * @param instance - Optional instance identifier for tracking or reference purposes
+   * @returns An add response object
+   *
+   * @example
+   * ```typescript
+   * const handler = WebhookAction.execute('enrich-order', [], [], async (params) => {
+   *   // Add loyalty points to the order
+   *   return {
+   *     statusCode: 200,
+   *     body: WebhookActionResponse.add(
+   *       'order.loyalty',
+   *       { points: 150, tier: 'gold' },
+   *       params.order.id
+   *     )
+   *   };
+   * });
+   * ```
+   */
+  static add(path, value, instance) {
+    const response = {
+      op: "add" /* ADD */,
+      path,
+      value
+    };
+    if (instance !== void 0) {
+      response.instance = instance;
+    }
+    return response;
+  }
+  /**
+   * Creates a response to replace existing data in the webhook payload.
+   *
+   * Use this method to modify existing fields in the webhook payload.
+   * The existing value at the specified path will be replaced with the new value.
+   *
+   * @param path - Dot-notation path to the field that should be replaced (e.g., 'product.price', 'order.status')
+   * @param value - The new value to replace the existing value
+   * @param instance - Optional instance identifier for tracking or reference purposes
+   * @returns A replace response object
+   *
+   * @example
+   * ```typescript
+   * const handler = WebhookAction.execute('adjust-price', [], [], async (params) => {
+   *   // Apply dynamic pricing
+   *   const newPrice = await calculateDiscountedPrice(params.product.price);
+   *
+   *   return {
+   *     statusCode: 200,
+   *     body: WebhookActionResponse.replace(
+   *       'product.price',
+   *       newPrice,
+   *       params.product.id
+   *     )
+   *   };
+   * });
+   * ```
+   */
+  static replace(path, value, instance) {
+    const response = {
+      op: "replace" /* REPLACE */,
+      path,
+      value
+    };
+    if (instance !== void 0) {
+      response.instance = instance;
+    }
+    return response;
+  }
+  /**
+   * Creates a response to remove data from the webhook payload.
+   *
+   * Use this method to remove fields from the webhook payload before it's
+   * processed by Adobe Commerce. This is useful for filtering sensitive data
+   * or removing unnecessary information.
+   *
+   * @param path - Dot-notation path to the field that should be removed (e.g., 'items.0', 'customer.internal_notes')
+   * @returns A remove response object
+   *
+   * @example
+   * ```typescript
+   * const handler = WebhookAction.execute('sanitize-customer', [], [], async (params) => {
+   *   // Remove internal notes before processing
+   *   return {
+   *     statusCode: 200,
+   *     body: WebhookActionResponse.remove('customer.internal_notes')
+   *   };
+   * });
+   * ```
+   *
+   * @example
+   * ```typescript
+   * // Remove an item from an array
+   * return {
+   *   statusCode: 200,
+   *   body: WebhookActionResponse.remove('order.items.2')
+   * };
+   * ```
+   */
+  static remove(path) {
+    return {
+      op: "remove" /* REMOVE */,
+      path
+    };
+  }
+};
+__name(_WebhookActionResponse, "WebhookActionResponse");
+var WebhookActionResponse = _WebhookActionResponse;
+var response_default2 = WebhookActionResponse;
+
+// src/framework/webhook-action/types.ts
+var SignatureVerification = /* @__PURE__ */ ((SignatureVerification2) => {
+  SignatureVerification2["ENABLED"] = "enabled";
+  SignatureVerification2["DISABLED"] = "disabled";
+  return SignatureVerification2;
+})(SignatureVerification || {});
+
+// src/framework/webhook-action/index.ts
+import crypto from "crypto";
+var _WebhookAction = class _WebhookAction {
+  /**
+   * Execute a webhook action with validation and response handling.
+   *
+   * @param name - Name of the webhook action
+   * @param requiredParams - Required parameters in the webhook payload
+   * @param requiredHeaders - Required headers (e.g., signature headers)
+   * @param signatureVerification - Enable/disable signature verification
+   * @param action - Webhook action function returning WebhookActionResponse
+   * @returns Function that handles the webhook HTTP request
+   */
+  static execute(name = "webhook", requiredParams = [], requiredHeaders = [], signatureVerification = "disabled" /* DISABLED */, action = async () => response_default2.success()) {
+    const httpMethods = ["POST" /* POST */];
+    const verifySignature = /* @__PURE__ */ __name(async (params) => {
+      const signature = params.__ow_headers["x-adobe-commerce-webhook-signature"] || "";
+      if (!signature) {
+        return "Header `x-adobe-commerce-webhook-signature` not found. Make sure Webhooks signature is enabled in the Commerce instance.";
+      }
+      const body = params.__ow_body;
+      if (!body) {
+        return "Request body not found. Make sure the action is configured with `raw-http: true`.";
+      }
+      let publicKey = params.PUBLIC_KEY;
+      if (!publicKey && params.PUBLIC_KEY_BASE64) {
+        publicKey = atob(params.PUBLIC_KEY_BASE64);
+      }
+      if (!publicKey) {
+        return "Public key not found. Make sure the action is configured with the input `PUBLIC_KEY` or `PUBLIC_KEY_BASE64` and it is defined in .env file.";
+      }
+      try {
+        const verifier = crypto.createVerify("SHA256");
+        verifier.update(body);
+        const isSignatureValid = verifier.verify(publicKey, signature, "base64");
+        if (!isSignatureValid) {
+          return "The signature is invalid.";
+        }
+      } catch (error) {
+        return "The signature is invalid.";
+      }
+      return null;
+    }, "verifySignature");
+    const callback = /* @__PURE__ */ __name(async (params, ctx) => {
+      if (signatureVerification === "enabled" /* ENABLED */) {
+        const verificationErrorMessage = await verifySignature(params);
+        if (verificationErrorMessage) {
+          const verificationErrorResponse = response_default2.exception(verificationErrorMessage);
+          return response_default.success(JSON.stringify(verificationErrorResponse));
+        }
+        params = {
+          ...params,
+          ...JSON.parse(atob(params.__ow_body))
+        };
+      }
+      const errorMessage = validator_default.checkMissingRequestInputs(params, requiredParams, requiredHeaders) ?? "";
+      if (errorMessage) {
+        const errorMessageResponse = response_default2.exception(errorMessage);
+        return response_default.success(JSON.stringify(errorMessageResponse));
+      }
+      const response = await action(params, ctx);
+      return response_default.success(JSON.stringify(response));
+    }, "callback");
+    return runtime_action_default.execute(name, httpMethods, [], [], callback);
+  }
+};
+__name(_WebhookAction, "WebhookAction");
+var WebhookAction = _WebhookAction;
+var webhook_action_default = WebhookAction;
+
 // src/integration/bearer-token/index.ts
 var _BearerToken = class _BearerToken {
   /**
@@ -4471,7 +4780,7 @@ var onboard_events_default = OnboardEvents;
 
 // src/integration/infinite-loop-breaker/index.ts
 import { Core as Core5, State } from "@adobe/aio-sdk";
-import crypto from "crypto";
+import crypto2 from "crypto";
 var _InfiniteLoopBreaker = class _InfiniteLoopBreaker {
   // seconds
   /**
@@ -4551,7 +4860,7 @@ var _InfiniteLoopBreaker = class _InfiniteLoopBreaker {
    * @returns The fingerprint
    */
   static fingerPrint(data) {
-    const hash = crypto.createHash(_InfiniteLoopBreaker.FINGERPRINT_ALGORITHM);
+    const hash = crypto2.createHash(_InfiniteLoopBreaker.FINGERPRINT_ALGORITHM);
     hash.update(JSON.stringify(data));
     return hash.digest(_InfiniteLoopBreaker.FINGERPRINT_ENCODING);
   }
@@ -4610,26 +4919,22 @@ var AdobeAuth = _AdobeAuth;
 var adobe_auth_default = AdobeAuth;
 
 // src/commerce/adobe-commerce-client/index.ts
-import { Core as Core6 } from "@adobe/aio-sdk";
 import got from "got";
 var _AdobeCommerceClient = class _AdobeCommerceClient {
   /**
    * @param baseUrl
    * @param connection
    * @param logger
+   * @param httpsOptions
    */
-  constructor(baseUrl, connection, logger = null) {
+  constructor(baseUrl, connection, logger = null, httpsOptions) {
     if (!baseUrl) {
       throw new Error("Commerce URL must be provided");
     }
     this.baseUrl = baseUrl;
     this.connection = connection;
-    if (logger === null) {
-      logger = Core6.Logger("adobe-commerce-client", {
-        level: "debug"
-      });
-    }
-    this.logger = logger;
+    this.httpsOptions = httpsOptions;
+    this.logger = new custom_logger_default(logger);
   }
   /**
    * @param endpoint
@@ -4716,6 +5021,7 @@ var _AdobeCommerceClient = class _AdobeCommerceClient {
       headers: {
         "Content-Type": "application/json"
       },
+      ...this.httpsOptions && { https: this.httpsOptions },
       hooks: {
         beforeRequest: [
           (options) => this.logger.debug(`Request [${options.method}] ${options.url}`)
@@ -4751,11 +5057,8 @@ __name(_AdobeCommerceClient, "AdobeCommerceClient");
 var AdobeCommerceClient = _AdobeCommerceClient;
 var adobe_commerce_client_default = AdobeCommerceClient;
 
-// src/commerce/adobe-commerce-client/basic-auth-connection/index.ts
-import { Core as Core8 } from "@adobe/aio-sdk";
-
 // src/commerce/adobe-commerce-client/basic-auth-connection/generate-basic-auth-token/index.ts
-import { State as State2, Core as Core7 } from "@adobe/aio-sdk";
+import { State as State2 } from "@adobe/aio-sdk";
 var _GenerateBasicAuthToken = class _GenerateBasicAuthToken {
   /**
    * @param baseUrl
@@ -4768,12 +5071,7 @@ var _GenerateBasicAuthToken = class _GenerateBasicAuthToken {
     this.username = username;
     this.password = password;
     this.key = "adobe_commerce_basic_auth_token";
-    if (logger === null) {
-      logger = Core7.Logger("adobe-commerce-client", {
-        level: "debug"
-      });
-    }
-    this.logger = logger;
+    this.logger = new custom_logger_default(logger);
   }
   /**
    * @return string | null
@@ -4935,12 +5233,7 @@ var _BasicAuthConnection = class _BasicAuthConnection {
     this.baseUrl = baseUrl;
     this.username = username;
     this.password = password;
-    if (logger === null) {
-      logger = Core8.Logger("adobe-commerce-client", {
-        level: "debug"
-      });
-    }
-    this.logger = logger;
+    this.logger = new custom_logger_default(logger);
   }
   /**
    * @param commerceGot
@@ -4951,7 +5244,7 @@ var _BasicAuthConnection = class _BasicAuthConnection {
       this.baseUrl,
       this.username,
       this.password,
-      this.logger
+      this.logger.getLogger()
     );
     const token = await generateToken.execute();
     return commerceGot.extend({
@@ -4966,9 +5259,8 @@ var BasicAuthConnection = _BasicAuthConnection;
 var basic_auth_connection_default = BasicAuthConnection;
 
 // src/commerce/adobe-commerce-client/oauth1a-connection/index.ts
-import { Core as Core9 } from "@adobe/aio-sdk";
 import Oauth1a from "oauth-1.0a";
-import * as crypto2 from "crypto";
+import * as crypto3 from "crypto";
 var _Oauth1aConnection = class _Oauth1aConnection {
   /**
    * @param consumerKey
@@ -4982,12 +5274,7 @@ var _Oauth1aConnection = class _Oauth1aConnection {
     this.consumerSecret = consumerSecret;
     this.accessToken = accessToken;
     this.accessTokenSecret = accessTokenSecret;
-    if (logger === null) {
-      logger = Core9.Logger("adobe-commerce-client", {
-        level: "debug"
-      });
-    }
-    this.logger = logger;
+    this.logger = new custom_logger_default(logger);
   }
   /**
    * @param commerceGot
@@ -5017,7 +5304,7 @@ var _Oauth1aConnection = class _Oauth1aConnection {
         secret: this.consumerSecret
       },
       signature_method: "HMAC-SHA256",
-      hash_function: /* @__PURE__ */ __name((baseString, key) => crypto2.createHmac("sha256", key).update(baseString).digest("base64"), "hash_function")
+      hash_function: /* @__PURE__ */ __name((baseString, key) => crypto3.createHmac("sha256", key).update(baseString).digest("base64"), "hash_function")
     });
     const oauthToken = {
       key: this.accessToken,
@@ -5234,6 +5521,390 @@ __name(_ImsConnection, "ImsConnection");
 var ImsConnection = _ImsConnection;
 var ims_connection_default = ImsConnection;
 
+// src/commerce/shipping-carrier/method/index.ts
+var _ShippingCarrierMethod = class _ShippingCarrierMethod {
+  constructor(carrierCode, method) {
+    this.methodData = { carrier_code: carrierCode, method, additional_data: [] };
+  }
+  /**
+   * Sets the display name for the shipping method
+   *
+   * @param methodTitle - Display name for the shipping method
+   * @returns The rate builder instance for method chaining
+   */
+  setMethodTitle(methodTitle) {
+    this.methodData.method_title = methodTitle;
+    return this;
+  }
+  /**
+   * Sets the price charged to the customer
+   *
+   * @param price - Price charged to the customer
+   * @returns The rate builder instance for method chaining
+   */
+  setPrice(price) {
+    this.methodData.price = price;
+    return this;
+  }
+  /**
+   * Sets the cost to the merchant
+   *
+   * @param cost - Cost to the merchant
+   * @returns The rate builder instance for method chaining
+   */
+  setCost(cost) {
+    this.methodData.cost = cost;
+    return this;
+  }
+  /**
+   * Adds additional data to the shipping method
+   *
+   * @param key - Key for the additional data
+   * @param value - Value for the additional data
+   * @returns The rate builder instance for method chaining
+   *
+   * @example
+   * ```typescript
+   * rate.addAdditionalData('delivery_time', '3-5 business days')
+   *     .addAdditionalData('tracking_available', true);
+   * ```
+   */
+  addAdditionalData(key, value) {
+    const additionalDataItem = { key, value };
+    this.methodData.additional_data?.push(additionalDataItem);
+    return this;
+  }
+  /**
+   * Gets and returns the shipping carrier method data
+   *
+   * @returns The shipping carrier method data
+   */
+  getData() {
+    return this.methodData;
+  }
+};
+__name(_ShippingCarrierMethod, "ShippingCarrierMethod");
+var ShippingCarrierMethod = _ShippingCarrierMethod;
+var method_default = ShippingCarrierMethod;
+
+// src/commerce/shipping-carrier/index.ts
+var _ShippingCarrier = class _ShippingCarrier {
+  constructor(code, callback) {
+    this.addedMethods = [];
+    this.removedMethods = [];
+    this.validateCarrierCode(code);
+    this.carrierData = {
+      code,
+      active: true,
+      tracking_available: true,
+      shipping_labels_available: true
+    };
+    this.addedMethods = [];
+    this.removedMethods = [];
+    if (callback) {
+      callback(this);
+    }
+  }
+  /**
+   * Validates that the carrier code contains only alphanumeric characters and underscores
+   *
+   * @param code - Carrier code to validate
+   * @throws Error if code is invalid
+   */
+  validateCarrierCode(code) {
+    if (!code || code.trim() === "") {
+      throw new Error("Carrier code cannot be empty");
+    }
+    const validPattern = /^[a-zA-Z0-9_]+$/;
+    if (!validPattern.test(code)) {
+      throw new Error("Carrier code must contain only alphanumeric characters and underscores");
+    }
+  }
+  /**
+   * Validates that the method code contains only alphanumeric characters and underscores
+   *
+   * @param method - Method code to validate
+   * @throws Error if method code is invalid
+   */
+  validateMethodCode(method) {
+    if (!method || method.trim() === "") {
+      throw new Error("Method code cannot be empty");
+    }
+    const validPattern = /^[a-zA-Z0-9_]+$/;
+    if (!validPattern.test(method)) {
+      throw new Error("Method code must contain only alphanumeric characters and underscores");
+    }
+  }
+  /**
+   * Sets the title for the shipping carrier
+   *
+   * @param title - Display title for the carrier
+   * @returns The builder instance for method chaining
+   *
+   * @example
+   * ```typescript
+   * carrier.setTitle('FedEx Express');
+   * ```
+   */
+  setTitle(title) {
+    this.carrierData.title = title;
+    return this;
+  }
+  /**
+   * Sets the stores for the shipping carrier
+   *
+   * @param stores - Array of store codes
+   * @returns The builder instance for method chaining
+   *
+   * @example
+   * ```typescript
+   * carrier.setStores(['default', 'store1', 'store2']);
+   * ```
+   */
+  setStores(stores) {
+    this.carrierData.stores = stores;
+    return this;
+  }
+  /**
+   * Sets the countries for the shipping carrier
+   *
+   * @param countries - Array of country codes
+   * @returns The builder instance for method chaining
+   *
+   * @example
+   * ```typescript
+   * carrier.setCountries(['US', 'CA', 'MX']);
+   * ```
+   */
+  setCountries(countries) {
+    this.carrierData.countries = countries;
+    return this;
+  }
+  /**
+   * Sets the sort order for the shipping carrier
+   *
+   * @param sortOrder - Sort order number
+   * @returns The builder instance for method chaining
+   *
+   * @example
+   * ```typescript
+   * carrier.setSortOrder(10);
+   * ```
+   */
+  setSortOrder(sortOrder) {
+    this.carrierData.sort_order = sortOrder;
+    return this;
+  }
+  /**
+   * Sets the active status for the shipping carrier
+   *
+   * @param active - Active status
+   * @returns The builder instance for method chaining
+   *
+   * @example
+   * ```typescript
+   * carrier.setActive(true);
+   * carrier.setActive(false);
+   * ```
+   */
+  setActive(active) {
+    this.carrierData.active = active;
+    return this;
+  }
+  /**
+   * Sets the tracking availability for the shipping carrier
+   *
+   * @param trackingAvailable - Tracking availability status
+   * @returns The builder instance for method chaining
+   *
+   * @example
+   * ```typescript
+   * carrier.setTrackingAvailable(true);
+   * carrier.setTrackingAvailable(false);
+   * ```
+   */
+  setTrackingAvailable(trackingAvailable) {
+    this.carrierData.tracking_available = trackingAvailable;
+    return this;
+  }
+  /**
+   * Sets the shipping labels availability for the shipping carrier
+   *
+   * @param shippingLabelsAvailable - Shipping labels availability status
+   * @returns The builder instance for method chaining
+   *
+   * @example
+   * ```typescript
+   * carrier.setShippingLabelsAvailable(true);
+   * carrier.setShippingLabelsAvailable(false);
+   * ```
+   */
+  setShippingLabelsAvailable(shippingLabelsAvailable) {
+    this.carrierData.shipping_labels_available = shippingLabelsAvailable;
+    return this;
+  }
+  /**
+   * Sets the carrier data from a ShippingCarrierData object
+   * Note: The code property cannot be changed once set in the constructor
+   *
+   * @param carrierData - Carrier data object
+   * @returns The builder instance for method chaining
+   *
+   * @example
+   * ```typescript
+   * carrier.setData({
+   *   code: 'fedex',
+   *   title: 'FedEx Express',
+   *   stores: ['default'],
+   *   countries: ['US', 'CA'],
+   *   sort_order: 10,
+   *   active: true,
+   *   tracking_available: true,
+   *   shipping_labels_available: true
+   * });
+   * ```
+   */
+  setData(carrierData) {
+    const originalCode = this.carrierData.code;
+    if (carrierData.code !== void 0) {
+      this.validateCarrierCode(carrierData.code);
+    }
+    this.carrierData = { ...carrierData, code: originalCode };
+    return this;
+  }
+  /**
+   * Adds a shipping method to the carrier using a callback pattern
+   *
+   * @param method - Unique method for the shipping rate
+   * @param callback - Optional callback function to configure the method
+   * @returns The builder instance for method chaining
+   *
+   * @example
+   * ```typescript
+   * builder.addMethod('standard', (method) => {
+   *   method.setMethodTitle('Standard Shipping')
+   *       .setPrice(9.99)
+   *       .setCost(5.00)
+   *       .addAdditionalData('delivery_time', '3-5 business days');
+   * });
+   * ```
+   */
+  addMethod(method, callback) {
+    this.validateMethodCode(method);
+    const methodBuilder = new method_default(this.carrierData.code, method);
+    if (callback) {
+      callback(methodBuilder);
+    }
+    this.addedMethods.push(methodBuilder.getData());
+    return this;
+  }
+  /**
+   * Removes a shipping method from the carrier
+   *
+   * @param method - Method code to remove
+   * @returns The builder instance for method chaining
+   *
+   * @example
+   * ```typescript
+   * builder.removeMethod('express');
+   * ```
+   */
+  removeMethod(method) {
+    this.validateMethodCode(method);
+    this.removedMethods.push(method);
+    return this;
+  }
+  /**
+   * Gets and returns the shipping carrier data as a JSON object
+   *
+   * @returns The shipping carrier data
+   *
+   * @example
+   * ```typescript
+   * const carrierData = carrier.getData();
+   * // Returns:
+   * // {
+   * //   code: 'DPS',
+   * //   title: 'Demo Postal Service',
+   * //   stores: ['default'],
+   * //   countries: ['US', 'CA'],
+   * //   sort_order: 10,
+   * //   active: true,
+   * //   tracking_available: true,
+   * //   shipping_labels_available: true
+   * // }
+   * ```
+   */
+  getData() {
+    return this.carrierData;
+  }
+  /**
+   * Gets the list of methods that have been added to the carrier
+   *
+   * @returns Array of added shipping carrier methods
+   *
+   * @example
+   * ```typescript
+   * const addedMethods = carrier.getAddedMethods();
+   * // Returns: [{ carrier_code: 'fedex', method: 'standard', ... }, ...]
+   * ```
+   */
+  getAddedMethods() {
+    return this.addedMethods;
+  }
+  /**
+   * Gets the list of method codes that have been marked for removal
+   *
+   * @returns Array of method codes to be removed
+   *
+   * @example
+   * ```typescript
+   * const removedMethods = carrier.getRemovedMethods();
+   * // Returns: ['overnight', 'express']
+   * ```
+   */
+  getRemovedMethods() {
+    return this.removedMethods;
+  }
+};
+__name(_ShippingCarrier, "ShippingCarrier");
+var ShippingCarrier = _ShippingCarrier;
+var shipping_carrier_default = ShippingCarrier;
+
+// src/commerce/shipping-carrier/response/index.ts
+var _ShippingCarrierResponse = class _ShippingCarrierResponse {
+  constructor(carrier) {
+    this.carrier = carrier;
+  }
+  /**
+   * Generates and returns an array of WebhookActionResponse operations
+   *
+   * @returns Array of WebhookActionResponse operations
+   *
+   * @example
+   * ```typescript
+   * const carrier = new ShippingCarrier('fedex');
+   * const response = new ShippingCarrierResponse(carrier);
+   * const operations = response.generate();
+   * ```
+   */
+  generate() {
+    const operations = [];
+    const addedMethods = this.carrier["addedMethods"];
+    for (const method of addedMethods) {
+      operations.push(response_default2.add("result", method));
+    }
+    const removedMethods = this.carrier["removedMethods"];
+    for (const method of removedMethods) {
+      operations.push(response_default2.add("result", { method, remove: true }));
+    }
+    return operations;
+  }
+};
+__name(_ShippingCarrierResponse, "ShippingCarrierResponse");
+var ShippingCarrierResponse = _ShippingCarrierResponse;
+var response_default3 = ShippingCarrierResponse;
+
 // src/experience/admin-ui-sdk/index.ts
 var _AdminUiSdk = class _AdminUiSdk {
   /**
@@ -5423,6 +6094,13 @@ export {
   rest_client_default as RestClient,
   runtime_action_default as RuntimeAction,
   response_default as RuntimeActionResponse,
-  validator_default as Validator
+  shipping_carrier_default as ShippingCarrier,
+  method_default as ShippingCarrierMethod,
+  response_default3 as ShippingCarrierResponse,
+  SignatureVerification,
+  validator_default as Validator,
+  webhook_action_default as WebhookAction,
+  WebhookActionOperation,
+  response_default2 as WebhookActionResponse
 };
 //# sourceMappingURL=index.mjs.map