@adobe-commerce/aio-toolkit 1.0.2 → 1.0.4

package/dist/index.js

@@ -31,6 +31,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  AdminUiSdk: () => AdminUiSdk,
   AdobeAuth: () => adobe_auth_default,
   AdobeCommerceClient: () => adobe_commerce_client_default,
   BasicAuthConnection: () => basic_auth_connection_default,
@@ -54,11 +55,19 @@ __export(index_exports, {
   OpenwhiskAction: () => openwhisk_action_default,
   Parameters: () => parameters_default,
   ProviderManager: () => provider_default,
+  PublishEvent: () => publish_event_default,
   RegistrationManager: () => registration_default,
   RestClient: () => rest_client_default,
   RuntimeAction: () => runtime_action_default,
   RuntimeActionResponse: () => response_default,
-  Validator: () => validator_default
+  ShippingCarrier: () => shipping_carrier_default,
+  ShippingCarrierMethod: () => method_default,
+  ShippingCarrierResponse: () => response_default3,
+  SignatureVerification: () => SignatureVerification,
+  Validator: () => validator_default,
+  WebhookAction: () => webhook_action_default,
+  WebhookActionOperation: () => WebhookActionOperation,
+  WebhookActionResponse: () => response_default2
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -457,15 +466,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
@@ -477,7 +505,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 {};
   }
@@ -485,9 +519,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;
@@ -501,23 +538,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);
@@ -566,6 +606,418 @@ __name(_FileRepository, "FileRepository");
 var FileRepository = _FileRepository;
 var file_repository_default = FileRepository;
 
+// src/framework/publish-event/index.ts
+var import_aio_sdk5 = require("@adobe/aio-sdk");
+var import_cloudevents = require("cloudevents");
+var import_uuid = require("uuid");
+
+// src/framework/custom-logger/index.ts
+var _CustomLogger = class _CustomLogger {
+  /**
+   * @param logger - External logger instance (can be null)
+   */
+  constructor(logger = null) {
+    this.logger = logger;
+  }
+  /**
+   * Log debug message if logger is available
+   * @param message - Debug message to log
+   */
+  debug(message) {
+    if (this.logger && typeof this.logger.debug === "function") {
+      this.logger.debug(message);
+    }
+  }
+  /**
+   * Log info message if logger is available
+   * @param message - Info message to log
+   */
+  info(message) {
+    if (this.logger && typeof this.logger.info === "function") {
+      this.logger.info(message);
+    }
+  }
+  /**
+   * Log error message if logger is available
+   * @param message - Error message to log
+   */
+  error(message) {
+    if (this.logger && typeof this.logger.error === "function") {
+      this.logger.error(message);
+    }
+  }
+  /**
+   * Get the underlying logger instance
+   * @returns the logger instance or null
+   */
+  getLogger() {
+    return this.logger;
+  }
+};
+__name(_CustomLogger, "CustomLogger");
+var CustomLogger = _CustomLogger;
+var custom_logger_default = CustomLogger;
+
+// src/framework/publish-event/index.ts
+var _PublishEvent = class _PublishEvent {
+  /**
+   * Creates a new PublishEvent instance
+   *
+   * @param imsOrgId - Adobe IMS Organization ID
+   * @param apiKey - Adobe API Key (Client ID)
+   * @param accessToken - Adobe Access Token
+   * @param logger - Optional logger instance
+   */
+  constructor(imsOrgId, apiKey, accessToken, logger = null) {
+    if (!imsOrgId?.trim()) {
+      throw new Error("imsOrgId is required and cannot be empty");
+    }
+    if (!apiKey?.trim()) {
+      throw new Error("apiKey is required and cannot be empty");
+    }
+    if (!accessToken?.trim()) {
+      throw new Error("accessToken is required and cannot be empty");
+    }
+    this.imsOrgId = imsOrgId;
+    this.apiKey = apiKey;
+    this.accessToken = accessToken;
+    this.customLogger = new custom_logger_default(logger);
+    this.customLogger.debug("PublishEvent initialized with valid configuration");
+  }
+  /**
+   * Publishes a CloudEvent to Adobe I/O Events
+   *
+   * @param providerId - The Adobe I/O Events provider ID
+   * @param eventCode - The event type identifier (e.g., 'commerce.order.created')
+   * @param payload - The event payload data
+   * @param subject - Optional subject for the event
+   * @returns Promise<PublishEventResult> - The publish result
+   *
+   * @throws Error when providerId or eventCode is invalid or publishing fails
+   */
+  async execute(providerId, eventCode, payload, subject) {
+    try {
+      if (!providerId?.trim()) {
+        throw new Error("providerId is required and cannot be empty");
+      }
+      if (!eventCode?.trim()) {
+        throw new Error("eventCode is required and cannot be empty");
+      }
+      if (payload === null || payload === void 0) {
+        throw new Error("payload is required");
+      }
+      this.customLogger.info(`Publishing event to provider: ${providerId}`);
+      const eventId = (0, import_uuid.v4)();
+      const cloudEvent = new import_cloudevents.CloudEvent({
+        id: eventId,
+        source: `urn:uuid:${providerId}`,
+        datacontenttype: "application/json",
+        type: eventCode,
+        data: payload,
+        ...subject && { subject }
+      });
+      this.customLogger.debug(`Constructed CloudEvent with ID: ${eventId}`);
+      const eventsClient = await import_aio_sdk5.Events.init(this.imsOrgId, this.apiKey, this.accessToken);
+      this.customLogger.debug("Adobe I/O Events client initialized successfully");
+      await eventsClient.publishEvent(cloudEvent);
+      const publishedAt = (/* @__PURE__ */ new Date()).toISOString();
+      this.customLogger.info(`Event published successfully with ID: ${eventId}`);
+      return {
+        eventId,
+        status: "published",
+        publishedAt
+      };
+    } catch (error) {
+      this.customLogger.error(`Failed to publish event: ${error.message}`);
+      return {
+        eventId: (0, import_uuid.v4)(),
+        // Generate ID for tracking even failed events
+        status: "failed",
+        publishedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        error: error.message
+      };
+    }
+  }
+};
+__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
+var import_crypto = __toESM(require("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 = import_crypto.default.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 {
   /**
@@ -883,7 +1335,7 @@ var RestClient = _RestClient;
 var rest_client_default = RestClient;
 
 // src/integration/onboard-events/index.ts
-var import_aio_sdk5 = require("@adobe/aio-sdk");
+var import_aio_sdk6 = require("@adobe/aio-sdk");
 
 // src/io-events/types.ts
 var IoEventsGlobals = {
@@ -3393,7 +3845,7 @@ var RegistrationManager = _RegistrationManager;
 var registration_default = RegistrationManager;
 
 // src/integration/onboard-events/create-providers/index.ts
-var import_crypto = require("crypto");
+var import_crypto2 = require("crypto");
 var _CreateProviders = class _CreateProviders {
   /**
    * Creates a new CreateProviders instance
@@ -3589,7 +4041,7 @@ var _CreateProviders = class _CreateProviders {
     }
     if (this.isCommerceProvider(providerData)) {
       input.provider_metadata = "dx_commerce_events";
-      input.instance_id = (0, import_crypto.randomUUID)();
+      input.instance_id = (0, import_crypto2.randomUUID)();
     }
     return input;
   }
@@ -4198,7 +4650,7 @@ var _OnboardEvents = class _OnboardEvents {
       throw new Error("Access token is required");
     }
     const loggerName = projectName.toLowerCase().replace(/[^a-z0-9\s-_]/g, "").replace(/\s+/g, "-").replace(/_{2,}/g, "_").replace(/-{2,}/g, "-").trim().concat("-onboard-events");
-    this.logger = import_aio_sdk5.Core.Logger(loggerName, { level: "debug" });
+    this.logger = import_aio_sdk6.Core.Logger(loggerName, { level: "debug" });
     this.createProviders = new create_providers_default(
       consumerId,
       projectId,
@@ -4394,8 +4846,8 @@ var OnboardEvents = _OnboardEvents;
 var onboard_events_default = OnboardEvents;
 
 // src/integration/infinite-loop-breaker/index.ts
-var import_aio_sdk6 = require("@adobe/aio-sdk");
-var import_crypto2 = __toESM(require("crypto"));
+var import_aio_sdk7 = require("@adobe/aio-sdk");
+var import_crypto3 = __toESM(require("crypto"));
 var _InfiniteLoopBreaker = class _InfiniteLoopBreaker {
   // seconds
   /**
@@ -4412,7 +4864,7 @@ var _InfiniteLoopBreaker = class _InfiniteLoopBreaker {
     event
   }) {
     const logLevel = process.env.LOG_LEVEL || "info";
-    const logger = import_aio_sdk6.Core.Logger("infiniteLoopBreaker", { level: logLevel });
+    const logger = import_aio_sdk7.Core.Logger("infiniteLoopBreaker", { level: logLevel });
     logger.debug(`Checking for potential infinite loop for event: ${event}`);
     if (!eventTypes.includes(event)) {
       logger.debug(`Event type ${event} is not in the infinite loop event types list`);
@@ -4420,7 +4872,7 @@ var _InfiniteLoopBreaker = class _InfiniteLoopBreaker {
     }
     const key = typeof keyFn === "function" ? keyFn() : keyFn;
     const data = typeof fingerprintFn === "function" ? fingerprintFn() : fingerprintFn;
-    const state = await import_aio_sdk6.State.init();
+    const state = await import_aio_sdk7.State.init();
     const persistedFingerPrint = await state.get(key);
     if (!persistedFingerPrint) {
       logger.debug(`No persisted fingerprint found for key ${key}`);
@@ -4441,7 +4893,7 @@ var _InfiniteLoopBreaker = class _InfiniteLoopBreaker {
   static async storeFingerPrint(keyFn, fingerprintFn, ttl) {
     const key = typeof keyFn === "function" ? keyFn() : keyFn;
     const data = typeof fingerprintFn === "function" ? fingerprintFn() : fingerprintFn;
-    const state = await import_aio_sdk6.State.init();
+    const state = await import_aio_sdk7.State.init();
     await state.put(key, _InfiniteLoopBreaker.fingerPrint(data), {
       ttl: ttl !== void 0 ? ttl : _InfiniteLoopBreaker.DEFAULT_INFINITE_LOOP_BREAKER_TTL
     });
@@ -4475,7 +4927,7 @@ var _InfiniteLoopBreaker = class _InfiniteLoopBreaker {
    * @returns The fingerprint
    */
   static fingerPrint(data) {
-    const hash = import_crypto2.default.createHash(_InfiniteLoopBreaker.FINGERPRINT_ALGORITHM);
+    const hash = import_crypto3.default.createHash(_InfiniteLoopBreaker.FINGERPRINT_ALGORITHM);
     hash.update(JSON.stringify(data));
     return hash.digest(_InfiniteLoopBreaker.FINGERPRINT_ENCODING);
   }
@@ -4534,7 +4986,7 @@ var AdobeAuth = _AdobeAuth;
 var adobe_auth_default = AdobeAuth;
 
 // src/commerce/adobe-commerce-client/index.ts
-var import_aio_sdk7 = require("@adobe/aio-sdk");
+var import_aio_sdk8 = require("@adobe/aio-sdk");
 var import_got = __toESM(require("got"));
 var _AdobeCommerceClient = class _AdobeCommerceClient {
   /**
@@ -4549,7 +5001,7 @@ var _AdobeCommerceClient = class _AdobeCommerceClient {
     this.baseUrl = baseUrl;
     this.connection = connection;
     if (logger === null) {
-      logger = import_aio_sdk7.Core.Logger("adobe-commerce-client", {
+      logger = import_aio_sdk8.Core.Logger("adobe-commerce-client", {
         level: "debug"
       });
     }
@@ -4676,10 +5128,10 @@ var AdobeCommerceClient = _AdobeCommerceClient;
 var adobe_commerce_client_default = AdobeCommerceClient;
 
 // src/commerce/adobe-commerce-client/basic-auth-connection/index.ts
-var import_aio_sdk9 = require("@adobe/aio-sdk");
+var import_aio_sdk10 = require("@adobe/aio-sdk");
 
 // src/commerce/adobe-commerce-client/basic-auth-connection/generate-basic-auth-token/index.ts
-var import_aio_sdk8 = require("@adobe/aio-sdk");
+var import_aio_sdk9 = require("@adobe/aio-sdk");
 var _GenerateBasicAuthToken = class _GenerateBasicAuthToken {
   /**
    * @param baseUrl
@@ -4693,7 +5145,7 @@ var _GenerateBasicAuthToken = class _GenerateBasicAuthToken {
     this.password = password;
     this.key = "adobe_commerce_basic_auth_token";
     if (logger === null) {
-      logger = import_aio_sdk8.Core.Logger("adobe-commerce-client", {
+      logger = import_aio_sdk9.Core.Logger("adobe-commerce-client", {
         level: "debug"
       });
     }
@@ -4725,7 +5177,7 @@ var _GenerateBasicAuthToken = class _GenerateBasicAuthToken {
    * @return TokenResult | null
    */
   async getCommerceToken() {
-    const endpoint = this.createEndpoint("rest/V1/integration/admin/token");
+    const endpoint = this.createTokenEndpoint();
     this.logger.debug(`Endpoint: ${endpoint}`);
     try {
       const restClient = new rest_client_default();
@@ -4771,6 +5223,19 @@ var _GenerateBasicAuthToken = class _GenerateBasicAuthToken {
       return null;
     }
   }
+  /**
+   * Create the Adobe Commerce integration admin token endpoint.
+   * Handles cases where baseUrl may or may not already include /rest.
+   * @return string
+   */
+  createTokenEndpoint() {
+    const normalizedBaseUrl = this.baseUrl.replace(/\/+$/, "");
+    if (normalizedBaseUrl.endsWith("/rest")) {
+      return `${normalizedBaseUrl}/V1/integration/admin/token`;
+    } else {
+      return `${normalizedBaseUrl}/rest/V1/integration/admin/token`;
+    }
+  }
   /**
    * @param endpoint
    * @return string
@@ -4821,7 +5286,7 @@ var _GenerateBasicAuthToken = class _GenerateBasicAuthToken {
   async getState() {
     if (this.state === void 0) {
       try {
-        this.state = await import_aio_sdk8.State.init();
+        this.state = await import_aio_sdk9.State.init();
       } catch (error) {
         this.logger.debug("State API initialization failed, running without caching");
         this.state = null;
@@ -4847,7 +5312,7 @@ var _BasicAuthConnection = class _BasicAuthConnection {
     this.username = username;
     this.password = password;
     if (logger === null) {
-      logger = import_aio_sdk9.Core.Logger("adobe-commerce-client", {
+      logger = import_aio_sdk10.Core.Logger("adobe-commerce-client", {
         level: "debug"
       });
     }
@@ -4877,9 +5342,9 @@ var BasicAuthConnection = _BasicAuthConnection;
 var basic_auth_connection_default = BasicAuthConnection;
 
 // src/commerce/adobe-commerce-client/oauth1a-connection/index.ts
-var import_aio_sdk10 = require("@adobe/aio-sdk");
+var import_aio_sdk11 = require("@adobe/aio-sdk");
 var import_oauth_1 = __toESM(require("oauth-1.0a"));
-var crypto2 = __toESM(require("crypto"));
+var crypto3 = __toESM(require("crypto"));
 var _Oauth1aConnection = class _Oauth1aConnection {
   /**
    * @param consumerKey
@@ -4894,7 +5359,7 @@ var _Oauth1aConnection = class _Oauth1aConnection {
     this.accessToken = accessToken;
     this.accessTokenSecret = accessTokenSecret;
     if (logger === null) {
-      logger = import_aio_sdk10.Core.Logger("adobe-commerce-client", {
+      logger = import_aio_sdk11.Core.Logger("adobe-commerce-client", {
         level: "debug"
       });
     }
@@ -4928,7 +5393,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,
@@ -4941,8 +5406,161 @@ __name(_Oauth1aConnection, "Oauth1aConnection");
 var Oauth1aConnection = _Oauth1aConnection;
 var oauth1a_connection_default = Oauth1aConnection;
 
+// src/commerce/adobe-commerce-client/ims-connection/generate-ims-token/index.ts
+var import_aio_sdk12 = require("@adobe/aio-sdk");
+var _GenerateImsToken = class _GenerateImsToken {
+  /**
+   * @param clientId
+   * @param clientSecret
+   * @param technicalAccountId
+   * @param technicalAccountEmail
+   * @param imsOrgId
+   * @param scopes
+   * @param logger
+   */
+  constructor(clientId, clientSecret, technicalAccountId, technicalAccountEmail, imsOrgId, scopes, logger = null) {
+    this.key = "adobe_ims_auth_token";
+    this.tokenContext = "adobe-commerce-client";
+    this.clientId = clientId;
+    this.clientSecret = clientSecret;
+    this.technicalAccountId = technicalAccountId;
+    this.technicalAccountEmail = technicalAccountEmail;
+    this.imsOrgId = imsOrgId;
+    this.scopes = scopes;
+    this.customLogger = new custom_logger_default(logger);
+  }
+  /**
+   * @return string | null
+   */
+  async execute() {
+    try {
+      this.customLogger.info("Starting IMS token generation/retrieval process");
+      const currentValue = await this.getValue();
+      if (currentValue !== null) {
+        this.customLogger.info("Found cached IMS token, returning cached value");
+        return currentValue;
+      }
+      this.customLogger.info("No cached token found, generating new IMS token");
+      let result = {
+        token: null,
+        expire_in: 86399
+        // Default fallback, will be overridden by actual token expiry
+      };
+      const response = await this.getImsToken();
+      if (response !== null) {
+        result = response;
+      }
+      if (result.token !== null) {
+        this.customLogger.info(`Generated new IMS token, caching for ${result.expire_in} seconds`);
+        await this.setValue(result);
+      }
+      return result.token;
+    } catch (error) {
+      this.customLogger.error(`Failed to execute IMS token generation: ${error.message}`);
+      return null;
+    }
+  }
+  /**
+   * @return ImsTokenResult | null
+   */
+  async getImsToken() {
+    try {
+      this.customLogger.debug(`Calling AdobeAuth.getToken with context: ${this.tokenContext}`);
+      const token = await adobe_auth_default.getToken(
+        this.clientId,
+        this.clientSecret,
+        this.technicalAccountId,
+        this.technicalAccountEmail,
+        this.imsOrgId,
+        this.scopes,
+        this.tokenContext
+      );
+      if (token !== null && token !== void 0) {
+        this.customLogger.debug("Received token from AdobeAuth, parsing with BearerToken.info");
+        const tokenInfo = bearer_token_default.info(token);
+        if (!tokenInfo.isValid) {
+          this.customLogger.error("Received invalid or expired token from IMS");
+          return null;
+        }
+        const expireInSeconds = tokenInfo.timeUntilExpiry ? Math.floor(tokenInfo.timeUntilExpiry / 1e3) : 86399;
+        this.customLogger.debug(`Token expires in ${expireInSeconds} seconds`);
+        return {
+          token,
+          expire_in: expireInSeconds
+        };
+      }
+      this.customLogger.error("Received null or undefined token from IMS");
+      return null;
+    } catch (error) {
+      this.customLogger.error(`Failed to get IMS token: ${error.message}`);
+      return null;
+    }
+  }
+  /**
+   * @param result
+   * @return boolean
+   */
+  async setValue(result) {
+    try {
+      const state = await this.getState();
+      if (state === null) {
+        this.customLogger.info("State API not available, skipping token caching");
+        return true;
+      }
+      const ttlWithBuffer = Math.max(result.expire_in - 300, 60);
+      this.customLogger.debug(
+        `Caching IMS token with TTL: ${ttlWithBuffer} seconds (original: ${result.expire_in})`
+      );
+      await state.put(this.key, result.token, { ttl: ttlWithBuffer });
+      return true;
+    } catch (error) {
+      this.customLogger.error(`Failed to cache IMS token: ${error.message}`);
+      return true;
+    }
+  }
+  /**
+   * @return string | null
+   */
+  async getValue() {
+    try {
+      this.customLogger.debug("Checking for cached IMS token");
+      const state = await this.getState();
+      if (state === null) {
+        this.customLogger.debug("State API not available, cannot retrieve cached token");
+        return null;
+      }
+      const value = await state.get(this.key);
+      if (value !== void 0 && value.value) {
+        this.customLogger.debug("Found cached IMS token");
+        return value.value;
+      }
+      this.customLogger.debug("No cached IMS token found");
+    } catch (error) {
+      this.customLogger.error(`Failed to retrieve cached IMS token: ${error.message}`);
+    }
+    return null;
+  }
+  /**
+   * @return any
+   */
+  async getState() {
+    if (this.state === void 0) {
+      try {
+        this.customLogger.debug("Initializing State API for token caching");
+        this.state = await import_aio_sdk12.State.init();
+      } catch (error) {
+        this.customLogger.error(`Failed to initialize State API: ${error.message}`);
+        this.state = null;
+      }
+    }
+    return this.state;
+  }
+};
+__name(_GenerateImsToken, "GenerateImsToken");
+var GenerateImsToken = _GenerateImsToken;
+var generate_ims_token_default = GenerateImsToken;
+
 // src/commerce/adobe-commerce-client/ims-connection/index.ts
-var import_aio_sdk11 = require("@adobe/aio-sdk");
 var _ImsConnection = class _ImsConnection {
   /**
    * @param clientId
@@ -4952,38 +5570,35 @@ var _ImsConnection = class _ImsConnection {
    * @param imsOrgId
    * @param scopes
    * @param logger
-   * @param currentContext
    */
-  constructor(clientId, clientSecret, technicalAccountId, technicalAccountEmail, imsOrgId, scopes, logger = null, currentContext = "adobe-commerce-client") {
+  constructor(clientId, clientSecret, technicalAccountId, technicalAccountEmail, imsOrgId, scopes, logger = null) {
     this.clientId = clientId;
     this.clientSecret = clientSecret;
     this.technicalAccountId = technicalAccountId;
     this.technicalAccountEmail = technicalAccountEmail;
     this.imsOrgId = imsOrgId;
     this.scopes = scopes;
-    this.currentContext = currentContext;
-    if (logger === null) {
-      logger = import_aio_sdk11.Core.Logger(currentContext, {
-        level: "debug"
-      });
-    }
-    this.logger = logger;
+    this.customLogger = new custom_logger_default(logger);
   }
   /**
    * @param commerceGot
    */
   async extend(commerceGot) {
-    this.logger.debug("Using Commerce client with IMS authentication");
-    const token = await adobe_auth_default.getToken(
+    this.customLogger.info("Using Commerce client with IMS authentication");
+    const tokenGenerator = new generate_ims_token_default(
       this.clientId,
       this.clientSecret,
       this.technicalAccountId,
       this.technicalAccountEmail,
       this.imsOrgId,
       this.scopes,
-      this.currentContext
+      this.customLogger.getLogger()
     );
-    this.logger.debug(`IMS token being extended to header: ${token}`);
+    const token = await tokenGenerator.execute();
+    if (token === null) {
+      throw new Error("Failed to generate or retrieve IMS token");
+    }
+    this.customLogger.info(`IMS token being extended to header: ${token.substring(0, 10)}...`);
     return commerceGot.extend({
       headers: {
         Authorization: `Bearer ${token}`
@@ -4994,8 +5609,552 @@ var _ImsConnection = class _ImsConnection {
 __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
+   *
+   * @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) {
+    this.validateCarrierCode(carrierData.code);
+    this.carrierData = { ...carrierData };
+    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;
+  }
+  /**
+   * Resets the carrier and re-initializes it with new code and optional callback
+   *
+   * @param code - Carrier code
+   * @param callback - Optional callback function to configure the carrier
+   * @returns The builder instance for method chaining
+   *
+   * @example
+   * ```typescript
+   * carrier.reset('ups', (carrier) => {
+   *   carrier.addMethod('ground', (method) => {
+   *     method.setMethodTitle('UPS Ground').setPrice(12.99).setCost(8.00);
+   *   });
+   * });
+   * ```
+   */
+  reset(code, callback) {
+    this.validateCarrierCode(code);
+    this.carrierData = {
+      code,
+      active: true,
+      tracking_available: true,
+      shipping_labels_available: true
+    };
+    this.addedMethods = [];
+    this.removedMethods = [];
+    if (callback) {
+      callback(this);
+    }
+    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;
+  }
+};
+__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 {
+  /**
+   * Creates a new AdminUiSdk instance
+   * @param extensionId - Unique identifier for the extension
+   * @throws {Error} If extensionId is empty or invalid
+   */
+  constructor(extensionId) {
+    this.menuItems = [];
+    if (!extensionId?.trim()) {
+      throw new Error("Extension ID is required and cannot be empty");
+    }
+    const trimmedId = extensionId.trim();
+    if (!this.isValidExtensionId(trimmedId)) {
+      throw new Error(
+        "Extension ID must be alphanumeric with underscores only (no spaces, hyphens, or special characters)"
+      );
+    }
+    this.extensionId = trimmedId;
+  }
+  /**
+   * Validates that an extension ID contains only alphanumeric characters and underscores
+   * @param id - The extension ID to validate
+   * @returns true if valid, false otherwise
+   */
+  isValidExtensionId(id) {
+    return /^[a-zA-Z0-9_]+$/.test(id);
+  }
+  /**
+   * Validates that a menu ID is valid (can contain :: separator for namespacing)
+   * @param id - The menu ID to validate
+   * @returns true if valid, false otherwise
+   */
+  isValidMenuId(id) {
+    return /^[a-zA-Z0-9_:]+$/.test(id);
+  }
+  /**
+   * Adds a menu item to the extension
+   * @param id - Full identifier for the menu item (e.g., 'extensionId::menuItem')
+   * @param title - Display title for the menu item
+   * @param sortOrder - Sort order for menu positioning
+   * @param parent - Parent menu identifier (optional, full ID like 'extensionId::parent')
+   * @throws {Error} If parameters are invalid or ID already exists
+   */
+  addMenuItem(id, title, sortOrder, parent) {
+    if (!id?.trim()) {
+      throw new Error("Menu item ID is required and cannot be empty");
+    }
+    if (!this.isValidMenuId(id.trim())) {
+      throw new Error(
+        "Menu item ID must be alphanumeric with underscores and colons only (no spaces, hyphens, or other special characters)"
+      );
+    }
+    if (!title?.trim()) {
+      throw new Error("Menu item title is required and cannot be empty");
+    }
+    if (parent !== void 0 && !parent?.trim()) {
+      throw new Error("Menu item parent cannot be empty if provided");
+    }
+    if (parent !== void 0 && !this.isValidMenuId(parent.trim())) {
+      throw new Error(
+        "Menu item parent must be alphanumeric with underscores and colons only (no spaces, hyphens, or other special characters)"
+      );
+    }
+    if (typeof sortOrder !== "number" || sortOrder < 0) {
+      throw new Error("Menu item sortOrder must be a non-negative number");
+    }
+    const trimmedId = id.trim();
+    if (this.menuItems.some((item) => item.id === trimmedId)) {
+      throw new Error(`Menu item with ID '${trimmedId}' already exists`);
+    }
+    const menuItem = {
+      id: trimmedId,
+      title: title.trim(),
+      sortOrder
+    };
+    if (parent?.trim()) {
+      menuItem.parent = parent.trim();
+    }
+    this.menuItems.push(menuItem);
+  }
+  /**
+   * Adds a menu section to the extension
+   * @param id - Full identifier for the menu section (e.g., 'extensionId::section')
+   * @param title - Display title for the menu section
+   * @param sortOrder - Sort order for section positioning
+   * @param parent - Parent menu identifier (optional, full ID like 'Magento_Backend::system')
+   * @throws {Error} If parameters are invalid or ID already exists
+   */
+  addMenuSection(id, title, sortOrder, parent) {
+    if (!id?.trim()) {
+      throw new Error("Menu section ID is required and cannot be empty");
+    }
+    if (!this.isValidMenuId(id.trim())) {
+      throw new Error(
+        "Menu section ID must be alphanumeric with underscores and colons only (no spaces, hyphens, or other special characters)"
+      );
+    }
+    if (!title?.trim()) {
+      throw new Error("Menu section title is required and cannot be empty");
+    }
+    if (parent !== void 0 && !parent?.trim()) {
+      throw new Error("Menu section parent cannot be empty if provided");
+    }
+    if (parent !== void 0 && !this.isValidMenuId(parent.trim())) {
+      throw new Error(
+        "Menu section parent must be alphanumeric with underscores and colons only (no spaces, hyphens, or other special characters)"
+      );
+    }
+    if (typeof sortOrder !== "number" || sortOrder < 0) {
+      throw new Error("Menu section sortOrder must be a non-negative number");
+    }
+    const trimmedId = id.trim();
+    if (this.menuItems.some((item) => item.id === trimmedId)) {
+      throw new Error(`Menu item with ID '${trimmedId}' already exists`);
+    }
+    const menuSection = {
+      id: trimmedId,
+      title: title.trim(),
+      sortOrder,
+      isSection: true
+    };
+    if (parent?.trim()) {
+      menuSection.parent = parent.trim();
+    }
+    this.menuItems.push(menuSection);
+  }
+  /**
+   * Sets the page title for the extension
+   * @param title - The page title
+   * @throws {Error} If title is empty or invalid
+   */
+  addPage(title) {
+    if (!title?.trim()) {
+      throw new Error("Page title is required and cannot be empty");
+    }
+    this.pageTitle = title.trim();
+  }
+  /**
+   * Gets the complete registration object for the extension
+   * @returns The registration object with optional menu items and page configuration
+   */
+  getRegistration() {
+    const registration = {};
+    if (this.menuItems.length > 0) {
+      registration.menuItems = [...this.menuItems];
+    }
+    if (this.pageTitle) {
+      registration.page = {
+        title: this.pageTitle
+      };
+    }
+    return {
+      registration
+    };
+  }
+};
+__name(_AdminUiSdk, "AdminUiSdk");
+var AdminUiSdk = _AdminUiSdk;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AdminUiSdk,
   AdobeAuth,
   AdobeCommerceClient,
   BasicAuthConnection,
@@ -5019,10 +6178,18 @@ var ims_connection_default = ImsConnection;
   OpenwhiskAction,
   Parameters,
   ProviderManager,
+  PublishEvent,
   RegistrationManager,
   RestClient,
   RuntimeAction,
   RuntimeActionResponse,
-  Validator
+  ShippingCarrier,
+  ShippingCarrierMethod,
+  ShippingCarrierResponse,
+  SignatureVerification,
+  Validator,
+  WebhookAction,
+  WebhookActionOperation,
+  WebhookActionResponse
 });
 //# sourceMappingURL=index.js.map