@adaas/a-utils 0.1.13 → 0.1.15

package/README.md

@@ -2,13 +2,36 @@
 
 # A-Utils SDK 
 
+![TypeScript](https://img.shields.io/badge/TypeScript-007ACC?style=for-the-badge&logo=typescript&logoColor=white)
+![Node.js](https://img.shields.io/badge/Node.js-43853D?style=for-the-badge&logo=node.js&logoColor=white)
+![Jest](https://img.shields.io/badge/Jest-323330?style=for-the-badge&logo=Jest&logoColor=white)
+![npm](https://img.shields.io/badge/npm-CB3837?style=for-the-badge&logo=npm&logoColor=white)
+
+![License](https://img.shields.io/badge/license-ISC-blue.svg)
+![Version](https://img.shields.io/npm/v/@adaas/a-utils)
+![Downloads](https://img.shields.io/npm/dm/@adaas/a-utils)
+![Build Status](https://img.shields.io/badge/build-passing-brightgreen)
+
 This package is a set of common utilities that can be used across projects related or not related to ADAAS Ecosystem. 
 In this package it is possible to find useful features to work with structures, objects, types, commands, configuration management, logging, scheduling, and more.  
 
 
 | LTS | Latest | npm               |
 |---------------|----------|---------------------------|
-| v0.1.7      |   v0.1.7    |     [@adaas/a-utils](https://npm.com)    |
+| v0.1.14      |   v0.1.14    |     [@adaas/a-utils](https://www.npmjs.com/package/@adaas/a-utils)    |
+
+
+## ✨ Key Features
+
+🚀 **Communication Channels** - Structured messaging with lifecycle management  
+⚡ **Command Pattern** - Event-driven command execution with serialization  
+🔧 **Configuration Management** - Multi-source config with type safety  
+📝 **Smart Logging** - Scope-aware logging with color support  
+🛡️ **Access Control** - Regex-based permission management  
+💾 **Memory Management** - Type-safe intermediate value storage  
+📅 **Task Scheduling** - Promise-based scheduling with cancellation  
+🔌 **Polyfills** - Cross-environment compatibility  
+🏗️ **Component Architecture** - Extensible dependency injection system
 
 
 <!-- TABLE OF CONTENTS -->
@@ -16,6 +39,7 @@ In this package it is possible to find useful features to work with structures,
 
 - [About the Project](#overview)
 - [Installation](#installation)
+- [Key Features](#-key-features)
 - [Components](#components)
   - [A-Channel](#a-channel)
   - [A-Command](#a-command)
@@ -40,20 +64,59 @@ npm i @adaas/a-utils
 
 ### A-Channel
 
-A communication channel component that provides messaging capabilities within the ADAAS ecosystem.
+A powerful, extensible communication channel component that provides structured messaging patterns with lifecycle management, error handling, and type safety.
 
-**Basic Usage:**
+> 📚 **[Complete A-Channel Documentation](./src/lib/A-Channel/README.md)** - Comprehensive guide with examples, API reference, and advanced usage patterns.
+
+**Quick Start:**
 ```typescript
 import { A_Channel } from '@adaas/a-utils';
+import { A_Context } from '@adaas/a-concept';
 
+// Create and initialize a channel
 const channel = new A_Channel();
-// Channel is ready for use
+A_Context.root.register(channel);
+
+// Request/Response pattern
+const response = await channel.request({ action: 'getData', id: 123 });
+console.log('Response:', response.data);
+
+// Fire-and-forget pattern
+await channel.send({ type: 'notification', message: 'Hello World' });
 ```
 
-**Features:**
-- Inter-component communication
-- Message routing and handling
-- Integration with A-Context
+**Advanced Example:**
+```typescript
+// Custom HTTP channel
+class HttpChannel extends A_Channel {}
+
+class HttpProcessor extends A_Component {
+    @A_Feature.Extend({ scope: [HttpChannel] })
+    async [A_ChannelFeatures.onRequest](
+        @A_Inject(A_ChannelRequest) context: A_ChannelRequest
+    ) {
+        const response = await fetch(context.params.url);
+        (context as any)._result = await response.json();
+    }
+}
+
+A_Context.root.register(HttpProcessor);
+
+const httpChannel = new HttpChannel();
+A_Context.root.register(httpChannel);
+
+const apiResponse = await httpChannel.request({
+    url: 'https://api.example.com/users'
+});
+```
+
+**Key Features:**
+- ✅ **Lifecycle Management** - Complete connection and processing lifecycle with hooks
+- ✅ **Multiple Patterns** - Request/Response and Fire-and-Forget messaging
+- ✅ **Error Handling** - Comprehensive error capture and management
+- ✅ **Type Safety** - Full TypeScript support with generic types
+- ✅ **Extensible** - Component-based architecture for custom behavior
+- ✅ **Concurrent Processing** - Handle multiple requests simultaneously
 
 ---
 

package/dist/index.d.mts

@@ -1,30 +1,495 @@
-import { A_Component, A_Error, A_TYPES__Error_Serialized, A_TYPES__Entity_Serialized, A_Meta, A_TYPES__FeatureExtendDecoratorMeta, A_TYPES__FeatureDefineDecoratorMeta, A_Entity, A_Scope, A_TYPES__ConceptENVVariables, A_TYPES__Fragment_Constructor, A_Fragment, A_Container, A_Feature, A_TYPES__Component_Constructor, A_TYPES__Entity_Constructor } from '@adaas/a-concept';
+import { A_Fragment, A_Error, A_Component, A_TYPES__Error_Serialized, A_TYPES__Entity_Serialized, A_Meta, A_TYPES__FeatureExtendDecoratorMeta, A_TYPES__FeatureDefineDecoratorMeta, A_Entity, A_Scope, A_TYPES__ConceptENVVariables, A_TYPES__Fragment_Constructor, A_Container, A_Feature, A_TYPES__Component_Constructor, A_TYPES__Entity_Constructor } from '@adaas/a-concept';
 import { A_TYPES__Container_Constructor } from '@adaas/a-concept/dist/src/global/A-Container/A-Container.types';
 
+declare enum A_ChannelFeatures {
+    /**
+     * Allows to extend timeout logic and behavior
+     */
+    onTimeout = "onTimeout",
+    /**
+     * Allows to extend retry logic and behavior
+     */
+    onRetry = "onRetry",
+    /**
+     * Allows to extend circuit breaker logic and behavior
+     */
+    onCircuitBreakerOpen = "onCircuitBreakerOpen",
+    /**
+     * Allows to extend cache logic and behavior
+     */
+    onCache = "onCache",
+    /**
+     * Allows to extend connection logic and behavior
+     */
+    onConnect = "onConnect",
+    /**
+     * Allows to extend disconnection logic and behavior
+     */
+    onDisconnect = "onDisconnect",
+    /**
+     * Allows to extend request preparation logic and behavior
+     */
+    onBeforeRequest = "onBeforeRequest",
+    /**
+     * Allows to extend request sending logic and behavior
+     */
+    onRequest = "onRequest",
+    /**
+     * Allows to extend request post-processing logic and behavior
+     */
+    onAfterRequest = "onAfterRequest",
+    /**
+     * Allows to extend error handling logic and behavior
+     *
+     * [!] The same approach uses for ALL errors within the channel
+     */
+    onError = "onError",
+    /**
+     * Allows to extend send logic and behavior
+     */
+    onSend = "onSend",
+    /**
+     * Allows to extend consume logic and behavior
+     */
+    onConsume = "onConsume"
+}
+declare enum A_ChannelRequestStatuses {
+    /**
+     * Request is pending
+     */
+    PENDING = "PENDING",
+    /***
+     * Request was successful
+     */
+    SUCCESS = "SUCCESS",
+    /**
+     * Request failed
+     */
+    FAILED = "FAILED"
+}
+
+type A_ChannelRequestContext_Serialized<_ParamsType extends Record<string, any> = Record<string, any>, _ResultType extends Record<string, any> = Record<string, any>> = {
+    params: _ParamsType;
+    result?: _ResultType;
+    status: string;
+    errors?: string[];
+};
+
+declare class A_ChannelRequest<_ParamsType extends Record<string, any> = Record<string, any>, _ResultType extends Record<string, any> = Record<string, any>> extends A_Fragment {
+    protected _params: _ParamsType;
+    protected _result?: _ResultType;
+    protected _errors: Set<Error>;
+    protected _status: A_ChannelRequestStatuses;
+    constructor(params?: Partial<_ParamsType>);
+    /**
+     * Returns the status of the request
+     */
+    get status(): A_ChannelRequestStatuses;
+    /**
+     * Returns the parameters of the request
+     */
+    get failed(): boolean;
+    /**
+     * Returns the Params of the Request
+     */
+    get params(): _ParamsType;
+    /**
+     * Returns the Result of the Request
+     */
+    get data(): _ResultType | undefined;
+    get errors(): Set<Error> | undefined;
+    /**
+     * Adds an error to the context
+     *
+     * @param error
+     */
+    fail(error: A_Error): void;
+    /**
+     * Sets the result of the request
+     *
+     * @param result
+     */
+    succeed(result: _ResultType): void;
+    /**
+     * Serializes the context to a JSON object
+     *
+     * @returns
+     */
+    toJSON(): A_ChannelRequestContext_Serialized<_ParamsType, _ResultType>;
+}
+
+/**
+ * A-Channel - A powerful, extensible communication channel component
+ *
+ * A-Channel provides a structured approach to implementing various communication patterns
+ * such as HTTP clients, WebSocket connections, message queues, and other messaging systems.
+ * It offers a complete lifecycle management system with extensible hooks for custom behavior.
+ *
+ * ## Key Features:
+ * - 🔄 **Lifecycle Management** - Complete connection and processing lifecycle with hooks
+ * - 📡 **Multiple Communication Patterns** - Request/Response and Fire-and-Forget messaging
+ * - 🛡️ **Error Handling** - Comprehensive error capture and management
+ * - 🎯 **Type Safety** - Full TypeScript support with generic types
+ * - 🔧 **Extensible** - Component-based architecture for custom behavior
+ * - ⚡ **Concurrent Processing** - Handle multiple requests simultaneously
+ *
+ * ## Basic Usage:
+ * ```typescript
+ * const channel = new A_Channel();
+ * A_Context.root.register(channel);
+ *
+ * // Request/Response pattern
+ * const response = await channel.request({ action: 'getData', id: 123 });
+ *
+ * // Fire-and-forget pattern
+ * await channel.send({ type: 'notification', message: 'Hello World' });
+ * ```
+ *
+ * ## Custom Implementation:
+ * ```typescript
+ * class HttpChannel extends A_Channel {}
+ *
+ * class HttpProcessor extends A_Component {
+ *     @A_Feature.Extend({ scope: [HttpChannel] })
+ *     async [A_ChannelFeatures.onRequest](
+ *         @A_Inject(A_ChannelRequest) context: A_ChannelRequest
+ *     ) {
+ *         const response = await fetch(context.params.url);
+ *         (context as any)._result = await response.json();
+ *     }
+ * }
+ * ```
+ *
+ * @see {@link ./README.md} For complete documentation and examples
+ */
 declare class A_Channel extends A_Component {
     /**
-     * Indicates whether the channel is processing requests
+     * Indicates whether the channel is currently processing requests.
+     * This flag is managed automatically during request/send operations.
+     *
+     * @readonly
      */
     protected _processing: boolean;
     /**
-     * Indicates whether the channel is connected
+     * Promise that resolves when the channel initialization is complete.
+     * Ensures that onConnect lifecycle hook has been executed before
+     * any communication operations.
+     *
+     * @private
      */
     protected _initialized?: Promise<void>;
     /**
-      * Indicates whether the channel is processing requests
-      */
+     * Internal cache storage for channel-specific data.
+     * Can be used by custom implementations for caching responses,
+     * connection pools, or other channel-specific state.
+     *
+     * @protected
+     */
+    protected _cache: Map<string, any>;
+    /**
+     * Creates a new A_Channel instance.
+     *
+     * The channel must be registered with A_Context before use:
+     * ```typescript
+     * const channel = new A_Channel();
+     * A_Context.root.register(channel);
+     * ```
+     */
+    constructor();
+    /**
+     * Indicates whether the channel is currently processing requests.
+     *
+     * @returns {boolean} True if channel is processing, false otherwise
+     */
     get processing(): boolean;
     /**
-     * Indicates whether the channel is connected
+     * Promise that resolves when the channel is fully initialized.
+     *
+     * Automatically calls the onConnect lifecycle hook if not already called.
+     * This ensures the channel is ready for communication operations.
+     *
+     * @returns {Promise<void>} Promise that resolves when initialization is complete
      */
     get initialize(): Promise<void>;
+    /**
+     * Connection lifecycle hook - called during channel initialization.
+     *
+     * Override this method in custom components to implement connection logic:
+     * - Initialize network connections
+     * - Load configuration
+     * - Validate environment
+     * - Set up connection pools
+     *
+     * @example
+     * ```typescript
+     * class DatabaseChannel extends A_Channel {}
+     *
+     * class DatabaseConnector extends A_Component {
+     *     @A_Feature.Extend({ scope: [DatabaseChannel] })
+     *     async [A_ChannelFeatures.onConnect]() {
+     *         await this.initializeDatabase();
+     *         console.log('Database channel connected');
+     *     }
+     * }
+     * ```
+     */
+    onConnect(...args: any[]): Promise<void>;
+    /**
+     * Disconnection lifecycle hook - called during channel cleanup.
+     *
+     * Override this method in custom components to implement cleanup logic:
+     * - Close network connections
+     * - Save state
+     * - Release resources
+     * - Clear caches
+     *
+     * @example
+     * ```typescript
+     * @A_Feature.Extend({ scope: [DatabaseChannel] })
+     * async [A_ChannelFeatures.onDisconnect]() {
+     *     await this.closeConnections();
+     *     console.log('Database channel disconnected');
+     * }
+     * ```
+     */
+    onDisconnect(...args: any[]): Promise<void>;
+    /**
+     * Pre-request processing hook - called before main request processing.
+     *
+     * Use this hook for:
+     * - Request validation
+     * - Authentication
+     * - Rate limiting
+     * - Logging
+     * - Request transformation
+     *
+     * @example
+     * ```typescript
+     * @A_Feature.Extend({ scope: [HttpChannel] })
+     * async [A_ChannelFeatures.onBeforeRequest](
+     *     @A_Inject(A_ChannelRequest) context: A_ChannelRequest
+     * ) {
+     *     // Validate required parameters
+     *     if (!context.params.url) {
+     *         throw new Error('URL is required');
+     *     }
+     * }
+     * ```
+     */
+    onBeforeRequest(...args: any[]): Promise<void>;
+    /**
+     * Main request processing hook - core business logic goes here.
+     *
+     * This is where the main communication logic should be implemented:
+     * - Make HTTP requests
+     * - Send messages to queues
+     * - Execute database queries
+     * - Process business logic
+     *
+     * Set the result in the context: `(context as any)._result = yourResult;`
+     *
+     * @example
+     * ```typescript
+     * @A_Feature.Extend({ scope: [HttpChannel] })
+     * async [A_ChannelFeatures.onRequest](
+     *     @A_Inject(A_ChannelRequest) context: A_ChannelRequest
+     * ) {
+     *     const response = await fetch(context.params.url);
+     *     (context as any)._result = await response.json();
+     * }
+     * ```
+     */
+    onRequest(...args: any[]): Promise<void>;
+    /**
+     * Post-request processing hook - called after successful request processing.
+     *
+     * Use this hook for:
+     * - Response transformation
+     * - Logging
+     * - Analytics
+     * - Caching results
+     * - Cleanup
+     *
+     * @example
+     * ```typescript
+     * @A_Feature.Extend({ scope: [HttpChannel] })
+     * async [A_ChannelFeatures.onAfterRequest](
+     *     @A_Inject(A_ChannelRequest) context: A_ChannelRequest
+     * ) {
+     *     console.log(`Request completed in ${Date.now() - context.startTime}ms`);
+     *     await this.cacheResponse(context.params, context.data);
+     * }
+     * ```
+     */
+    onAfterRequest(...args: any[]): Promise<void>;
+    /**
+     * Error handling hook - called when any operation fails.
+     *
+     * Use this hook for:
+     * - Error logging
+     * - Error transformation
+     * - Alerting
+     * - Retry logic
+     * - Fallback mechanisms
+     *
+     * @example
+     * ```typescript
+     * @A_Feature.Extend({ scope: [HttpChannel] })
+     * async [A_ChannelFeatures.onError](
+     *     @A_Inject(A_ChannelRequest) context: A_ChannelRequest
+     * ) {
+     *     console.error('Request failed:', context.params, context.failed);
+     *     await this.logError(context);
+     *     await this.sendAlert(context);
+     * }
+     * ```
+     */
+    onError(...args: any[]): Promise<void>;
+    /**
+     * Send operation hook - called for fire-and-forget messaging.
+     *
+     * Use this hook for:
+     * - Message broadcasting
+     * - Event publishing
+     * - Notification sending
+     * - Queue operations
+     *
+     * @example
+     * ```typescript
+     * @A_Feature.Extend({ scope: [EventChannel] })
+     * async [A_ChannelFeatures.onSend](
+     *     @A_Inject(A_ChannelRequest) context: A_ChannelRequest
+     * ) {
+     *     const { eventType, payload } = context.params;
+     *     await this.publishEvent(eventType, payload);
+     * }
+     * ```
+     */
+    onSend(...args: any[]): Promise<void>;
+    /**
+     * Initializes the channel by calling the onConnect lifecycle hook.
+     *
+     * This method is called automatically when accessing the `initialize` property.
+     * You can also call it manually if needed.
+     *
+     * @returns {Promise<void>} Promise that resolves when connection is established
+     */
     connect(): Promise<void>;
-    request(params: any): Promise<any>;
-    send(message: any): Promise<void>;
+    /**
+     * Disconnects the channel by calling the onDisconnect lifecycle hook.
+     *
+     * Use this method to properly cleanup resources when the channel is no longer needed.
+     *
+     * @returns {Promise<void>} Promise that resolves when cleanup is complete
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Sends a request and waits for a response (Request/Response pattern).
+     *
+     * This method follows the complete request lifecycle:
+     * 1. Ensures channel is initialized
+     * 2. Creates request scope and context
+     * 3. Calls onBeforeRequest hook
+     * 4. Calls onRequest hook (main processing)
+     * 5. Calls onAfterRequest hook
+     * 6. Returns the response context
+     *
+     * If any step fails, the onError hook is called and the error is captured
+     * in the returned context.
+     *
+     * @template _ParamsType The type of request parameters
+     * @template _ResultType The type of response data
+     * @param params The request parameters
+     * @returns {Promise<A_ChannelRequest<_ParamsType, _ResultType>>} Request context with response
+     *
+     * @example
+     * ```typescript
+     * // Basic usage
+     * const response = await channel.request({ action: 'getData', id: 123 });
+     *
+     * // Typed usage
+     * interface UserRequest { userId: string; }
+     * interface UserResponse { name: string; email: string; }
+     *
+     * const userResponse = await channel.request<UserRequest, UserResponse>({
+     *     userId: 'user-123'
+     * });
+     *
+     * if (!userResponse.failed) {
+     *     console.log('User:', userResponse.data.name);
+     * }
+     * ```
+     */
+    request<_ParamsType extends Record<string, any> = Record<string, any>, _ResultType extends Record<string, any> = Record<string, any>>(params: _ParamsType): Promise<A_ChannelRequest<_ParamsType, _ResultType>>;
+    /**
+     * Sends a fire-and-forget message (Send pattern).
+     *
+     * This method is used for one-way communication where no response is expected:
+     * - Event broadcasting
+     * - Notification sending
+     * - Message queuing
+     * - Logging operations
+     *
+     * The method follows this lifecycle:
+     * 1. Ensures channel is initialized
+     * 2. Creates send scope and context
+     * 3. Calls onSend hook
+     * 4. Completes without returning data
+     *
+     * If the operation fails, the onError hook is called but no error is thrown
+     * to the caller (fire-and-forget semantics).
+     *
+     * @template _ParamsType The type of message parameters
+     * @param message The message to send
+     * @returns {Promise<void>} Promise that resolves when send is complete
+     *
+     * @example
+     * ```typescript
+     * // Send notification
+     * await channel.send({
+     *     type: 'user.login',
+     *     userId: 'user-123',
+     *     timestamp: new Date().toISOString()
+     * });
+     *
+     * // Send to message queue
+     * await channel.send({
+     *     queue: 'email-queue',
+     *     payload: {
+     *         to: 'user@example.com',
+     *         subject: 'Welcome!',
+     *         body: 'Welcome to our service!'
+     *     }
+     * });
+     * ```
+     */
+    send<_ParamsType extends Record<string, any> = Record<string, any>>(message: _ParamsType): Promise<void>;
+    /**
+     * @deprecated This method is deprecated and will be removed in future versions.
+     * Use request() or send() methods instead depending on your communication pattern.
+     *
+     * For request/response pattern: Use request()
+     * For fire-and-forget pattern: Use send()
+     * For consumer patterns: Implement custom consumer logic using request() in a loop
+     */
+    consume<T extends Record<string, any> = Record<string, any>>(): Promise<A_ChannelRequest<any, T>>;
 }
 
 declare class A_ChannelError extends A_Error {
     static readonly MethodNotImplemented = "A-Channel Method Not Implemented";
+    protected _context?: A_ChannelRequest;
+    /**
+     * Channel Error allows to keep track of errors within a channel if something goes wrong
+     *
+     *
+     * @param originalError
+     * @param context
+     */
+    constructor(originalError: string | A_Error | Error | any, context?: A_ChannelRequest | string);
+    /***
+     * Returns Context of the error
+     */
+    get context(): A_ChannelRequest | undefined;
 }
 
 declare enum A_TYPES__CommandMetaKey {
@@ -938,4 +1403,4 @@ declare class A_Deferred<T> {
     reject(reason?: any): void;
 }
 
-export { A_CONSTANTS_A_Command_Features, type A_CONSTANTS__A_Command_Event, A_CONSTANTS__A_Command_Status, A_CONSTANTS__CONFIG_ENV_VARIABLES, A_CONSTANTS__CONFIG_ENV_VARIABLES_ARRAY, A_Channel, A_ChannelError, A_Command, A_CommandError, A_Config, A_ConfigError, A_ConfigLoader, A_Deferred, A_Logger, A_Manifest, A_ManifestChecker, A_ManifestError, A_Memory, A_Polyfill, A_Schedule, A_ScheduleObject, type A_TYPES__CommandMeta, A_TYPES__CommandMetaKey, type A_TYPES__Command_Constructor, type A_TYPES__Command_Init, type A_TYPES__Command_Listener, type A_TYPES__Command_Serialized, type A_TYPES__ConfigContainerConstructor, type A_TYPES__ConfigENVVariables, A_TYPES__ConfigFeature, type A_UTILS_TYPES__ManifestQuery, type A_UTILS_TYPES__ManifestRule, type A_UTILS_TYPES__Manifest_AllowedComponents, type A_UTILS_TYPES__Manifest_ComponentLevelConfig, type A_UTILS_TYPES__Manifest_Init, type A_UTILS_TYPES__Manifest_MethodLevelConfig, type A_UTILS_TYPES__Manifest_Rules, type A_UTILS_TYPES__ScheduleObjectCallback, type A_UTILS_TYPES__ScheduleObjectConfig, ConfigReader, ENVConfigReader, FileConfigReader, type IbufferInterface, type IcryptoInterface, type Ifspolyfill, type IhttpInterface, type IhttpsInterface, type IpathInterface, type IprocessInterface, type IurlInterface };
+export { A_CONSTANTS_A_Command_Features, type A_CONSTANTS__A_Command_Event, A_CONSTANTS__A_Command_Status, A_CONSTANTS__CONFIG_ENV_VARIABLES, A_CONSTANTS__CONFIG_ENV_VARIABLES_ARRAY, A_Channel, A_ChannelError, A_ChannelFeatures, A_ChannelRequest, type A_ChannelRequestContext_Serialized, A_ChannelRequestStatuses, A_Command, A_CommandError, A_Config, A_ConfigError, A_ConfigLoader, A_Deferred, A_Logger, A_Manifest, A_ManifestChecker, A_ManifestError, A_Memory, A_Polyfill, A_Schedule, A_ScheduleObject, type A_TYPES__CommandMeta, A_TYPES__CommandMetaKey, type A_TYPES__Command_Constructor, type A_TYPES__Command_Init, type A_TYPES__Command_Listener, type A_TYPES__Command_Serialized, type A_TYPES__ConfigContainerConstructor, type A_TYPES__ConfigENVVariables, A_TYPES__ConfigFeature, type A_UTILS_TYPES__ManifestQuery, type A_UTILS_TYPES__ManifestRule, type A_UTILS_TYPES__Manifest_AllowedComponents, type A_UTILS_TYPES__Manifest_ComponentLevelConfig, type A_UTILS_TYPES__Manifest_Init, type A_UTILS_TYPES__Manifest_MethodLevelConfig, type A_UTILS_TYPES__Manifest_Rules, type A_UTILS_TYPES__ScheduleObjectCallback, type A_UTILS_TYPES__ScheduleObjectConfig, ConfigReader, ENVConfigReader, FileConfigReader, type IbufferInterface, type IcryptoInterface, type Ifspolyfill, type IhttpInterface, type IhttpsInterface, type IpathInterface, type IprocessInterface, type IurlInterface };