@adobe-commerce/aio-toolkit 1.0.8 → 1.0.10

package/CHANGELOG.md

@@ -5,6 +5,177 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.0.10] - 2026-01-01
+
+### 🐛 Bug Fixes
+
+- **Telemetry** - Fixed `ERR_PACKAGE_PATH_NOT_EXPORTED` error when requiring the package
+  - Root cause: `@adobe/aio-lib-telemetry@1.1.2` has broken CommonJS exports in its package.json
+  - Solution: Implemented lazy-loading proxy pattern for OpenTelemetry logger
+  - `getLogger` is now dynamically imported only when `ENABLE_TELEMETRY=true`
+  - Maintains synchronous API with immediate logger availability
+  - Graceful fallback to `Core.Logger` if telemetry loading fails
+  - **Impact:** Zero breaking changes - existing client code works without modification
+  - **Benefits:** 
+    - Full OpenTelemetry integration preserved when telemetry is enabled
+    - Package size reduced by 92% (3.83 MB → 288 KB)
+    - No more import errors from broken dependency exports
+
+### 🔧 Technical Changes
+
+- **src/framework/telemetry/index.ts** - Implemented lazy-loading proxy pattern for `getLogger`
+- **src/framework/telemetry/types.ts** - Added local `EntrypointInstrumentationConfig` type definition
+- **src/commerce/adobe-auth/index.ts** - Changed to namespace import for ESM/CommonJS compatibility
+- **tsconfig.json** - Added `"module": "ES2020"` to support dynamic imports
+- **tsup.config.ts** - Configured to keep all dependencies external (not bundled)
+
+### ✅ Quality Assurance
+
+- Added 8 comprehensive test cases for lazy-loading telemetry behavior
+- Maintained 100% test coverage (1902 tests passing)
+- All validation checks passing (linting, formatting, type safety)
+
+## [1.0.9] - 2025-12-23
+
+### ⚠️ Deprecations
+
+- **ImsToken** `[Deprecated]` - Class deprecated due to built-in caching mechanism issues
+  - Internal caching relies on Adobe I/O Runtime State API which has reliability issues
+  - State API may not be available in all runtime environments
+  - Hard-coded TTL buffers (10-minute) and minimum TTL (60-minute) are inflexible
+  - Limited control over caching strategy and error handling
+  - Complex testing requirements due to State API dependencies
+  - **Migration:** Use `AdobeAuth.getToken()` directly and implement application-level caching (Redis, Memcached, in-memory, etc.)
+  - **Token Validation:** Use `BearerToken.info()` for token validation and expiry checking
+  - All existing functionality remains working but shows deprecation warnings
+
+### 💥 Breaking Changes
+
+- **RuntimeApiGatewayService** `[Breaking]` - Simplified to accept bearer tokens directly
+  - Constructor changed from 8 parameters (IMS credentials) to 4 parameters: `(namespace, imsOrgId, token, logger)`
+  - No longer generates tokens internally - accepts pre-generated token string
+  - `getAuthenticatedHeaders()` changed from async to synchronous method
+  - **Migration Example:**
+    ```typescript
+    // OLD - Built-in token generation (no longer supported)
+    const service = new RuntimeApiGatewayService(
+      clientId, clientSecret, techAccountId, techEmail, 
+      imsOrgId, scopes, namespace, logger
+    );
+    
+    // NEW - Accept token directly
+    const token = await AdobeAuth.getToken(
+      clientId, clientSecret, techAccountId, 
+      techEmail, imsOrgId, scopes
+    );
+    const service = new RuntimeApiGatewayService(
+      namespace, imsOrgId, token, logger
+    );
+    ```
+
+- **ImsConnection** `[Breaking]` - Simplified to accept bearer tokens directly
+  - Constructor changed from 7 parameters (IMS credentials) to 2 parameters: `(token, logger)`
+  - No longer generates tokens internally using deprecated `ImsToken` class
+  - Accepts pre-generated token string from `AdobeAuth`
+  - Token caching must be implemented at application level (Redis, Memcached, in-memory, etc.)
+  - **Migration Example:**
+    ```typescript
+    // OLD - Built-in token generation (no longer supported)
+    const connection = new ImsConnection(
+      clientId, clientSecret, techAccountId, 
+      techEmail, imsOrgId, scopes, logger
+    );
+    
+    // NEW - Accept token directly
+    const token = await AdobeAuth.getToken(
+      clientId, clientSecret, techAccountId, 
+      techEmail, imsOrgId, scopes
+    );
+    const connection = new ImsConnection(token, logger);
+    ```
+
+### 🚀 Major New Features
+
+#### 📊 OpenTelemetry Integration with New Relic Support
+
+This release introduces comprehensive OpenTelemetry instrumentation for enterprise-grade observability, enabling distributed tracing, metrics collection, and structured logging with automatic request correlation.
+
+- **Telemetry** `[New Feature]` - OpenTelemetry integration with multi-provider support
+  - Added `Telemetry` class for initializing OpenTelemetry instrumentation
+  - Integrated New Relic as the first telemetry provider with full OTLP support
+  - Multi-provider chain architecture with graceful fallback mechanism
+  - Automatic instrumentation for traces, metrics, and logs via OTLP exporters
+  - Configuration via environment variables for easy deployment
+  - Backwards compatible - telemetry is completely opt-in via feature flags
+  - Zero impact when disabled - no performance overhead for existing deployments
+
+#### 🔍 Automatic Request ID Tracking
+
+- **Logger Wrapper** `[New Feature]` - Automatic request correlation across all log messages
+  - Extracts `x-adobe-commerce-request-id` from webhook headers automatically
+  - Injects request ID into all log messages without manual intervention
+  - Enables distributed tracing and request correlation in New Relic
+  - Works seamlessly with `RuntimeAction`, `EventConsumerAction`, `WebhookAction`, and `OpenwhiskAction`
+  - Supports both object-based and string log messages
+  - Request ID automatically appears in New Relic log queries for filtering
+
+#### 🏷️ Action Type Metadata
+
+- **Action Classification** `[New Feature]` - Automatic action type identification in logs
+  - Adds `action.type` field to all log messages for better filtering
+  - Supported types: `runtime-action`, `webhook-action`, `event-consumer-action`, `openwhisk-action`
+  - Extracted from `params.action_type` with automatic fallbacks
+  - Enables filtering and grouping by action type in observability platforms
+  - Helps identify performance patterns and issues by action category
+
+#### 🔄 Updated Action Classes with Telemetry Support
+
+- **RuntimeAction** `[Enhanced]` - Full telemetry integration
+  - Structured logging for action lifecycle (start, parameters, completion, errors)
+  - Automatic request ID and action type injection
+  - OpenTelemetry span creation for distributed tracing
+  - Comprehensive error logging with stack traces
+  - JSDoc documentation for all telemetry features
+
+- **EventConsumerAction** `[Enhanced]` - Telemetry support added
+  - Structured logging matching RuntimeAction patterns
+  - Automatic request ID tracking from event parameters
+  - OpenTelemetry instrumentation for event processing
+  - Action type always set to `event-consumer-action`
+
+- **WebhookAction** `[Enhanced]` - Correct action type handling
+  - Sets action type to `webhook-action` via `RuntimeAction.setActionType()`
+  - Ensures proper action type appears in all log messages
+  - Maintains webhook-specific context in telemetry data
+
+- **OpenwhiskAction** `[Enhanced]` - Complete telemetry integration
+  - Full structured logging implementation
+  - Automatic request ID and action type tracking
+  - OpenTelemetry instrumentation for OpenWhisk invocations
+  - Action type always set to `openwhisk-action`
+  - Comprehensive JSDoc documentation
+
+### 📦 Dependencies
+
+- **Added** `@adobe/aio-lib-telemetry@^1.1.2` - Official Adobe OpenTelemetry library
+
+### 📊 Statistics
+
+- **New Classes**: 5 (Telemetry, TelemetryInputError, SuccessChecker, ResourceFactory, JsonMessageProcessor)
+- **New Files**: 14 source files, 9 test files
+- **Test Coverage**: 100% maintained (1897 tests passing, +218 new tests)
+- **Lines Added**: 7,172 insertions across 32 files
+- **Dependencies**: +1 (`@adobe/aio-lib-telemetry`)
+
+### 🔮 Future Enhancements
+
+- Additional telemetry provider support (Grafana, Datadog, etc.)
+- Custom metric collection APIs
+- Advanced trace sampling strategies
+- Performance monitoring dashboards
+
+---
+
 ## [1.0.8] - 2025-11-18
 
 ### 🔒 Security Fixes

package/README.md

@@ -282,22 +282,137 @@ const helloWorldAction = OpenwhiskAction.execute('hello-world', async (params, c
 exports.main = helloWorldAction;
 ```
 
+#### `Telemetry`
+OpenTelemetry integration for enterprise-grade observability with distributed tracing, metrics collection, and structured logging.
+
+**Features:**
+- Automatic telemetry instrumentation for all framework action classes
+- Request ID correlation across all log messages (`x-adobe-commerce-request-id`)
+- Action type identification for better filtering (`action.type`)
+- Multi-provider support (New Relic implemented, Grafana ready)
+- Graceful fallback when telemetry is not configured
+- Zero performance impact when disabled (opt-in via feature flags)
+
+**Configuration:**
+
+Configure telemetry in your `app.config.yaml`:
+
+```yaml
+runtime-action:
+  function: actions/runtime-action/index.js
+  web: 'yes'
+  runtime: nodejs:22
+  inputs:
+    LOG_LEVEL: debug
+    ENVIRONMENT: $ENVIRONMENT
+    ENABLE_TELEMETRY: true
+    NEW_RELIC_TELEMETRY: true
+    NEW_RELIC_SERVICE_NAME: $NEW_RELIC_SERVICE_NAME
+    NEW_RELIC_LICENSE_KEY: $NEW_RELIC_LICENSE_KEY
+  annotations:
+    require-adobe-auth: true
+    final: true
+```
+
+Set environment variables in your `.env` file:
+
+```bash
+# Telemetry configuration
+ENVIRONMENT=production
+NEW_RELIC_SERVICE_NAME=my-app-builder-app
+NEW_RELIC_LICENSE_KEY=your-license-key-here
+NEW_RELIC_URL=https://otlp.nr-data.net:4318  # Optional
+```
+
+**Usage Example:**
+
+Telemetry is automatically initialized when you use framework action classes:
+
+```javascript
+/*
+ * <license header>
+ */
+
+const { RuntimeAction, RuntimeActionResponse, HttpMethod } = require("@adobe-commerce/aio-toolkit");
+const name = 'runtime-action';
+
+exports.main = RuntimeAction.execute(
+  name,
+  [HttpMethod.POST],
+  [],
+  ['Authorization'],
+  async (params, ctx) => {
+    const { logger } = ctx;
+
+    // Logger automatically includes x-adobe-commerce-request-id and action.type
+    logger.info({
+      message: `${name}-log`,
+      params: JSON.stringify(params),
+    });
+
+    return RuntimeActionResponse.success("Hello World");
+  }
+);
+```
+
+**What Gets Logged Automatically:**
+
+All log messages automatically include:
+- `x-adobe-commerce-request-id` - Extracted from webhook headers for request correlation
+- `action.type` - Identifies the action type (runtime-action, webhook-action, event-consumer-action, openwhisk-action)
+- Action lifecycle events (start, parameters, completion, errors)
+- Full stack traces for errors
+
+**Viewing in New Relic:**
+
+Once configured, you can query your logs in New Relic using these attributes:
+
+```sql
+-- Filter by request ID
+SELECT * FROM Log WHERE `x-adobe-commerce-request-id` = 'request-123'
+
+-- Filter by action type
+SELECT * FROM Log WHERE `action.type` = 'webhook-action'
+
+-- Find errors for a specific request
+SELECT * FROM Log WHERE `x-adobe-commerce-request-id` = 'request-123' AND level = 'error'
+
+-- Group by action type
+SELECT count(*) FROM Log FACET `action.type` SINCE 1 hour ago
+```
+
+**Supported Action Classes:**
+
+Telemetry is automatically integrated with all framework action classes:
+- `RuntimeAction` - HTTP request handling with telemetry
+- `WebhookAction` - Webhook processing with telemetry
+- `EventConsumerAction` - Event-driven processing with telemetry
+- `OpenwhiskAction` - OpenWhisk action handling with telemetry
+
+All action classes provide structured logging with automatic request ID and action type tracking.
+
 #### `RuntimeApiGatewayService`
-Flexible Adobe I/O Runtime API Gateway client with automatic IMS token management and authentication.
+Flexible Adobe I/O Runtime API Gateway client that accepts bearer tokens for authenticated requests.
 
 ```typescript
-const { RuntimeApiGatewayService } = require('@adobe-commerce/aio-toolkit');
+const { RuntimeApiGatewayService, AdobeAuth } = require('@adobe-commerce/aio-toolkit');
 
-// Initialize the service
-const apiGatewayService = new RuntimeApiGatewayService(
+// Step 1: Generate token using AdobeAuth (implement caching in your application)
+const token = await AdobeAuth.getToken(
   'your-client-id',
   'your-client-secret',
   'your-technical-account-id',
   'your-technical-account-email@example.com',
   'your-ims-org-id@AdobeOrg',
-  ['openid', 'AdobeID', 'adobeio_api'],
-  'your-namespace-12345',
-  logger // Optional custom logger
+  ['openid', 'AdobeID', 'adobeio_api']
+);
+
+// Step 2: Initialize the service with the token
+const apiGatewayService = new RuntimeApiGatewayService(
+  'your-namespace-12345',          // Runtime namespace
+  'your-ims-org-id@AdobeOrg',      // IMS Org ID
+  token,                            // Bearer token
+  logger                            // Optional custom logger
 );
 
 // GET request
@@ -321,14 +436,15 @@ const deleteResult = await apiGatewayService.delete('v1/web/my-package/remove/12
 ```
 
 **Key Features:**
-- Automatic IMS token generation and caching
 - Built-in authentication headers
 - Support for GET, POST, PUT, DELETE methods
 - Flexible endpoint configuration
 - Comprehensive error handling
-- Integration with ImsToken for token management
+- Accepts pre-generated bearer tokens (implement your own caching strategy)
 - CustomLogger integration
 
+**💡 Best Practice:** Implement token caching at the application level (Redis, Memcached, in-memory) and validate tokens with `BearerToken.info()` before use to avoid unnecessary token generation calls.
+
 #### `FileRepository`
 File-based storage with CRUD operations for Adobe I/O Runtime applications.
 
@@ -579,40 +695,109 @@ const newProduct = await client.post('V1/products', {}, productData);
 
 **IMS (Identity Management System) Authentication**
 ```typescript
-const { AdobeCommerceClient, ImsConnection } = require('@adobe-commerce/aio-toolkit');
+const { AdobeCommerceClient, ImsConnection, AdobeAuth, BearerToken } = require('@adobe-commerce/aio-toolkit');
+
+// Step 1: Generate token using AdobeAuth (implement caching in your application)
+// Check your application cache first
+let token = await yourAppCache.get('commerce_ims_token');
+
+if (!token || !BearerToken.info(token).isValid) {
+  // Generate new token
+  token = await AdobeAuth.getToken(
+    'client-id',
+    'client-secret',
+    'technical-account-id',
+    'technical-account-email',
+    'ims-org-id@AdobeOrg',
+    ['AdobeID', 'openid', 'adobeio_api']
+  );
+
+  // Store in your application cache with appropriate TTL
+  const tokenInfo = BearerToken.info(token);
+  if (tokenInfo.isValid && tokenInfo.timeUntilExpiry) {
+    const ttl = Math.floor(tokenInfo.timeUntilExpiry / 1000) - 600; // 10-min buffer
+    await yourAppCache.set('commerce_ims_token', token, ttl);
+  }
+}
 
-const connection = new ImsConnection(
-  'client-id',
-  'client-secret', 
-  'technical-account-id',
-  'technical-account-email',
-  'ims-org-id',
-  ['AdobeID', 'openid', 'adobeio_api'], // Scopes array
-  logger // Optional custom logger
-);
+// Step 2: Create connection with token
+const connection = new ImsConnection(token, logger); // Optional logger
 
-// Create client with IMS authentication
+// Step 3: Create client with IMS authentication
 const client = new AdobeCommerceClient('https://your-commerce-store.com', connection);
 
-// Make API calls - tokens are automatically cached and refreshed
+// Make API calls
 const products = await client.get('V1/products');
 const newProduct = await client.post('V1/products', {}, productData);
 ```
 
-**Enhanced IMS Token Caching**
+> **💡 Best Practice:** Implement token caching at the application level (Redis, Memcached, in-memory) to avoid unnecessary token generation calls.
+
+**⚠️ DEPRECATED: ImsToken Class**
+
+> **This class is deprecated due to built-in caching mechanism issues:**
+> - Relies on Adobe I/O Runtime State API which has reliability issues
+> - State API may not be available in all runtime environments
+> - Hard-coded TTL buffers and minimum TTL are inflexible
+> - Limited control over caching strategy
+> 
+> **Migration Required:** Use `AdobeAuth` directly and implement caching at the application level.
 
 ```typescript
-const { GenerateImsToken } = require('@adobe-commerce/aio-toolkit');
+// ❌ OLD (Deprecated) - ImsToken with built-in caching
+const { ImsToken } = require('@adobe-commerce/aio-toolkit');
 
-const tokenGenerator = new GenerateImsToken(
-  'client-id', 'client-secret', 'technical-account-id',
-  'technical-account-email', 'ims-org-id',
-  ['AdobeID', 'openid', 'adobeio_api'], logger
+const imsToken = new ImsToken(
+  'client-id',
+  'client-secret',
+  'technical-account-id',
+  'technical-account-email',
+  'ims-org-id@AdobeOrg',
+  ['AdobeID', 'openid', 'adobeio_api'],
+  logger // optional
 );
 
-const token = await tokenGenerator.execute();
+const token = await imsToken.execute();
 ```
 
+```typescript
+// ✅ NEW (Recommended) - AdobeAuth with application-level caching
+const { AdobeAuth, BearerToken } = require('@adobe-commerce/aio-toolkit');
+
+// Check your application cache first (Redis, Memcached, in-memory, etc.)
+let token = await yourAppCache.get('ims_token');
+
+// Validate cached token
+if (!token || !BearerToken.info(token).isValid) {
+  // Generate new token using AdobeAuth
+  token = await AdobeAuth.getToken(
+    'client-id',
+    'client-secret',
+    'technical-account-id',
+    'technical-account-email',
+    'ims-org-id@AdobeOrg',
+    ['AdobeID', 'openid', 'adobeio_api']
+  );
+
+  // Store in your application cache with appropriate TTL
+  const tokenInfo = BearerToken.info(token);
+  if (tokenInfo.isValid && tokenInfo.timeUntilExpiry) {
+    const ttl = Math.floor(tokenInfo.timeUntilExpiry / 1000) - 600; // 10-min buffer
+    await yourAppCache.set('ims_token', token, ttl);
+  }
+}
+
+// Use the token
+console.log('Token:', token);
+```
+
+**Why Migrate?**
+- ✅ Full control over caching strategy (Redis, Memcached, in-memory, etc.)
+- ✅ Better error handling and retry logic
+- ✅ Works in any environment (not just Adobe I/O Runtime)
+- ✅ Easier to test and mock
+- ✅ Flexible TTL management based on your needs
+
 **Basic Authentication**
 ```typescript
 const { AdobeCommerceClient, BasicAuthConnection } = require('@adobe-commerce/aio-toolkit');
@@ -727,16 +912,18 @@ const {
 } = require('@adobe-commerce/aio-toolkit');
 const Core = require('@adobe/aio-sdk').Core;
 
-// Initialize Adobe Commerce client
-const connection = new ImsConnection(
+// Generate token using AdobeAuth (implement caching in your application)
+const token = await AdobeAuth.getToken(
   'client-id',
   'client-secret',
   'technical-account-id',
   'technical-account-email',
-  'ims-org-id',
-  ['AdobeID', 'openid', 'adobeio_api'],
-  logger
+  'ims-org-id@AdobeOrg',
+  ['AdobeID', 'openid', 'adobeio_api']
 );
+
+// Initialize Adobe Commerce client
+const connection = new ImsConnection(token, logger);
 const adobeCommerceClient = new AdobeCommerceClient(
   'https://your-commerce-store.com',
   connection

package/dist/index.d.mts

@@ -1,4 +1,6 @@
 import openwhisk, { Dict, Activation } from 'openwhisk';
+import { LogRecordProcessor } from '@opentelemetry/sdk-logs';
+import { SdkLogRecord } from '@adobe/aio-lib-telemetry/otel';
 import { Response } from 'node-fetch';
 import { Logger } from '@adobe/aio-sdk';
 import { Got, RequestError } from 'got';
@@ -39,6 +41,9 @@ interface ErrorResponse {
 type RuntimeActionResponseType = SuccessResponse | ErrorResponse;
 
 declare class RuntimeAction {
+    private static actionType;
+    static setActionType(type: string): void;
+    static getActionType(): string;
     static execute(name?: string, httpMethods?: HttpMethod[], requiredParams?: string[], requiredHeaders?: string[], action?: (params: {
         [key: string]: any;
     }, ctx: {
@@ -262,7 +267,7 @@ declare class RuntimeApiGatewayService {
     private readonly imsToken;
     private readonly restClient;
     private readonly customLogger;
-    constructor(clientId: string, clientSecret: string, technicalAccountId: string, technicalAccountEmail: string, imsOrgId: string, scopes: Array<string>, namespace: string, logger?: any);
+    constructor(namespace: string, imsOrgId: string, imsToken: string, logger?: any);
     private buildEndpoint;
     private getAuthenticatedHeaders;
     get(endpoint: string, additionalHeaders?: Record<string, string>): Promise<any>;
@@ -271,6 +276,43 @@ declare class RuntimeApiGatewayService {
     delete(endpoint: string, additionalHeaders?: Record<string, string>): Promise<any>;
 }
 
+type EntrypointInstrumentationConfig = any;
+interface BaseTelemetryValidator {
+    isConfigured(params: Record<string, unknown>): boolean;
+    validateConfiguration(params: Record<string, unknown>): void;
+}
+interface BaseTelemetry {
+    canInitialize(params: Record<string, unknown>): boolean;
+    getConfig(): EntrypointInstrumentationConfig;
+    initialize(action: (params: Record<string, unknown>) => any): (params: Record<string, unknown>) => any;
+}
+
+declare class Telemetry {
+    static createLogger(name: string, params: Record<string, unknown>): any;
+    private static wrapLogger;
+    static formatError(error: unknown): Record<string, unknown>;
+    static initialize(action: (params: Record<string, unknown>) => any): (params: Record<string, unknown>) => any;
+}
+
+declare class TelemetryInputError extends Error {
+    constructor(message: string);
+}
+
+declare class SuccessChecker {
+    execute(result: unknown): boolean;
+}
+
+declare class JsonMessageProcessor implements LogRecordProcessor {
+    private readonly wrappedProcessor;
+    constructor(wrappedProcessor: LogRecordProcessor);
+    private parseJavaScriptObjectNotation;
+    private flattenObject;
+    onEmit(logRecord: SdkLogRecord): void;
+    private mapSeverityNumberToLevel;
+    forceFlush(): Promise<void>;
+    shutdown(): Promise<void>;
+}
+
 interface BearerTokenInfo {
     token: string | null;
     tokenLength: number;
@@ -644,14 +686,9 @@ declare class Oauth1aConnection implements Connection {
 }
 
 declare class ImsConnection implements Connection {
-    private clientId;
-    private clientSecret;
-    private technicalAccountId;
-    private technicalAccountEmail;
-    private imsOrgId;
-    private scopes;
-    private customLogger;
-    constructor(clientId: string, clientSecret: string, technicalAccountId: string, technicalAccountEmail: string, imsOrgId: string, scopes: Array<string>, logger?: any);
+    private readonly imsToken;
+    private readonly customLogger;
+    constructor(imsToken: string, logger?: any);
     extend(commerceGot: any): Promise<any>;
 }
 
@@ -919,4 +956,4 @@ declare class AdminUiSdk {
     getRegistration(): AdminUiSdkRegistration;
 }
 
-export { AdminUiSdk, type AdminUiSdkRegistration, AdobeAuth, AdobeCommerceClient, type AdobeIMSConfig, BasicAuthConnection, BearerToken, type BearerTokenInfo, type CommerceEvent, type CommerceEventConfig, type CommerceEventField, type Connection, type CreateEventResult, CreateEvents, type CreateProviderParams, type CreateProviderResult, type CreateRegistrationResult, CreateRegistrations, type ErrorResponse, EventConsumerAction, type EventData, type EventMetadata, type EventMetadataInputModel, type EventMetadataListResponse, EventMetadataManager, type ExtendedRequestError, type FileMetadata, type FileRecord, FileRepository, GenerateBasicAuthToken, type GetProviderQueryParams, type GetRegistrationQueryParams, GraphQlAction, type HALLink, type Headers, HttpMethod, HttpStatus, IOEventsApiError, type IOEventsError, ImsConnection, ImsToken, type ImsTokenResult, InfiniteLoopBreaker, type InfiniteLoopData, IoEventsGlobals, type ListProvidersQueryParams, type ListRegistrationQueryParams, type MenuItem, Oauth1aConnection, OnboardCommerce, type OnboardCommerceConfig, type OnboardCommerceResult, OnboardEvents, type OnboardEventsInput, type OnboardEventsResponse, OnboardEvents as OnboardIOEvents, Openwhisk, OpenwhiskAction, type Page, Parameters, type Provider, type ProviderInputModel, ProviderManager, PublishEvent, type PublishEventResult, type Registration, type RegistrationCreateModel, type RegistrationListResponse, RegistrationManager, RestClient, RuntimeAction, RuntimeActionResponse, type RuntimeActionResponseType, RuntimeApiGatewayService, ShippingCarrier, type ShippingCarrierData, ShippingCarrierMethod, type ShippingCarrierMethodAdditionalData, type ShippingCarrierMethodData, ShippingCarrierResponse, SignatureVerification, type SuccessResponse, type TokenResult, Validator, WebhookAction, type WebhookActionAddResponse, type WebhookActionExceptionResponse, WebhookActionOperation, type WebhookActionRemoveResponse, type WebhookActionReplaceResponse, WebhookActionResponse, type WebhookActionResponseType, type WebhookActionSuccessResponse, type WorkspaceConfig };
+export { AdminUiSdk, type AdminUiSdkRegistration, AdobeAuth, AdobeCommerceClient, type AdobeIMSConfig, type BaseTelemetry, type BaseTelemetryValidator, BasicAuthConnection, BearerToken, type BearerTokenInfo, type CommerceEvent, type CommerceEventConfig, type CommerceEventField, type Connection, type CreateEventResult, CreateEvents, type CreateProviderParams, type CreateProviderResult, type CreateRegistrationResult, CreateRegistrations, type EntrypointInstrumentationConfig, type ErrorResponse, EventConsumerAction, type EventData, type EventMetadata, type EventMetadataInputModel, type EventMetadataListResponse, EventMetadataManager, type ExtendedRequestError, type FileMetadata, type FileRecord, FileRepository, GenerateBasicAuthToken, type GetProviderQueryParams, type GetRegistrationQueryParams, GraphQlAction, type HALLink, type Headers, HttpMethod, HttpStatus, IOEventsApiError, type IOEventsError, ImsConnection, ImsToken, type ImsTokenResult, InfiniteLoopBreaker, type InfiniteLoopData, IoEventsGlobals, JsonMessageProcessor, type ListProvidersQueryParams, type ListRegistrationQueryParams, type MenuItem, Oauth1aConnection, OnboardCommerce, type OnboardCommerceConfig, type OnboardCommerceResult, OnboardEvents, type OnboardEventsInput, type OnboardEventsResponse, OnboardEvents as OnboardIOEvents, Openwhisk, OpenwhiskAction, type Page, Parameters, type Provider, type ProviderInputModel, ProviderManager, PublishEvent, type PublishEventResult, type Registration, type RegistrationCreateModel, type RegistrationListResponse, RegistrationManager, RestClient, RuntimeAction, RuntimeActionResponse, type RuntimeActionResponseType, RuntimeApiGatewayService, ShippingCarrier, type ShippingCarrierData, ShippingCarrierMethod, type ShippingCarrierMethodAdditionalData, type ShippingCarrierMethodData, ShippingCarrierResponse, SignatureVerification, SuccessChecker, type SuccessResponse, Telemetry, TelemetryInputError, type TokenResult, Validator, WebhookAction, type WebhookActionAddResponse, type WebhookActionExceptionResponse, WebhookActionOperation, type WebhookActionRemoveResponse, type WebhookActionReplaceResponse, WebhookActionResponse, type WebhookActionResponseType, type WebhookActionSuccessResponse, type WorkspaceConfig };