@adaas/a-utils 0.1.18 → 0.1.20

package/dist/index.d.mts

@@ -1,4 +1,52 @@
-import { A_Fragment, A_Error, A_Component, A_TYPES__Error_Serialized, A_TYPES__Entity_Serialized, A_Entity, A_Scope, A_TYPES__ConceptENVVariables, A_TYPES__Fragment_Constructor, A_Container, A_Feature, A_TYPES__Component_Constructor, A_TYPES__Entity_Constructor, A_TYPES__Container_Constructor } from '@adaas/a-concept';
+import { A_Error, A_TYPES__Error_Serialized, A_Fragment, A_Component, A_TYPES__Entity_Serialized, A_TYPES__ConceptENVVariables, A_TYPES__Fragment_Constructor, A_Scope, A_Entity, A_Container, A_Feature, A_TYPES__Component_Constructor, A_TYPES__Entity_Constructor, A_TYPES__Container_Constructor, A_TYPES__Fragment_Serialized } from '@adaas/a-concept';
+
+type A_Operation_Storage<_Result_type extends any = any, _ParamsType extends Record<string, any> = Record<string, any>> = {
+    /**
+     * The name of the operation
+     */
+    name: string;
+    /**
+     * The parameters for the operation
+     */
+    params: _ParamsType;
+    /**
+     * The result of the operation
+     */
+    result: _Result_type;
+    /**
+     * Any error that occurred during the operation
+     */
+    error?: A_Error;
+};
+type A_Operation_Serialized<_Result_type extends any = any, _ParamsType extends Record<string, any> = Record<string, any>> = {
+    /**
+     * The name of the operation
+     */
+    name: string;
+    /**
+     * The parameters for the operation
+     */
+    params: _ParamsType;
+    /**
+     * The result of the operation
+     */
+    result: _Result_type;
+    /**
+     * Any error that occurred during the operation
+     */
+    error?: A_TYPES__Error_Serialized;
+};
+
+declare class A_OperationContext<_AllowedOperations extends string = string, _ParamsType extends Record<string, any> = Record<string, any>, _ResultType = any, _StorageType extends A_Operation_Storage<_ResultType, _ParamsType> = A_Operation_Storage<_ResultType, _ParamsType>> extends A_Fragment<_StorageType, A_Operation_Serialized<_ResultType, _ParamsType>> {
+    constructor(operation: _AllowedOperations, params?: _ParamsType);
+    get name(): _AllowedOperations;
+    get result(): _ResultType | undefined;
+    get error(): A_Error | undefined;
+    get params(): _ParamsType;
+    fail(error: A_Error): void;
+    succeed(result: _ResultType): void;
+    toJSON(): A_Operation_Serialized<_ResultType, _ParamsType>;
+}
 
 declare enum A_ChannelFeatures {
     /**
@@ -67,54 +115,14 @@ declare enum A_ChannelRequestStatuses {
     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
-     */
+declare class A_ChannelRequest<_ParamsType extends Record<string, any> = Record<string, any>, _ResultType extends Record<string, any> = Record<string, any>> extends A_OperationContext<'request', _ParamsType, {
+    data?: _ResultType;
+    status?: A_ChannelRequestStatuses;
+}> {
+    constructor(params?: _ParamsType);
+    get status(): A_ChannelRequestStatuses | undefined;
     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>;
 }
 
 /**
@@ -471,12 +479,12 @@ declare class A_Channel extends A_Component {
      * 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>>;
+    consume<T extends Record<string, any> = Record<string, any>>(): Promise<A_OperationContext<any, T>>;
 }
 
 declare class A_ChannelError extends A_Error {
     static readonly MethodNotImplemented = "A-Channel Method Not Implemented";
-    protected _context?: A_ChannelRequest;
+    protected _context?: A_OperationContext;
     /**
      * Channel Error allows to keep track of errors within a channel if something goes wrong
      *
@@ -484,390 +492,494 @@ declare class A_ChannelError extends A_Error {
      * @param originalError
      * @param context
      */
-    constructor(originalError: string | A_Error | Error | any, context?: A_ChannelRequest | string);
+    constructor(originalError: string | A_Error | Error | any, context?: A_OperationContext | string);
     /***
      * Returns Context of the error
      */
-    get context(): A_ChannelRequest | undefined;
+    get context(): A_OperationContext | undefined;
 }
 
 /**
- * A-Command Statuses
+ * A-Command Status Enumeration
+ *
+ * Defines all possible states a command can be in during its lifecycle.
+ * Commands progress through these states in a specific order:
+ * CREATED → INITIALIZED → COMPILED → EXECUTING → COMPLETED/FAILED
  */
-declare enum A_CONSTANTS__A_Command_Status {
+declare enum A_Command_Status {
     /**
-     * Command has been created but not yet initialized
+     * Initial state when command is instantiated but not yet ready for execution
      */
     CREATED = "CREATED",
     /**
-     * Command is initializing
-     */
-    INITIALIZATION = "INITIALIZATION",
-    /**
-     * Command has been initialized
+     * Command has been initialized with execution scope and dependencies
      */
     INITIALIZED = "INITIALIZED",
     /**
-     * Command is compiling
-     */
-    COMPILATION = "COMPILATION",
-    /**
-     * Command is compiled
+     * Command has been compiled and is ready for execution
      */
     COMPILED = "COMPILED",
     /**
-     * Command is executing
+     * Command is currently being executed
      */
-    IN_PROGRESS = "IN_PROGRESS",
+    EXECUTING = "EXECUTING",
     /**
      * Command has completed successfully
      */
     COMPLETED = "COMPLETED",
     /**
-     * Command has failed
+     * Command execution has failed with errors
      */
     FAILED = "FAILED"
 }
+/**
+ * A-Command State Transitions
+ *
+ * Defines valid state transitions for command lifecycle management.
+ * These transitions are used by the StateMachine to enforce proper command flow.
+ */
+declare enum A_CommandTransitions {
+    /** Transition from CREATED to INITIALIZED state */
+    CREATED_TO_INITIALIZED = "created_initialized",
+    /** Transition from INITIALIZED to EXECUTING state */
+    INITIALIZED_TO_EXECUTING = "initialized_executing",
+    /** Transition from EXECUTING to COMPLETED state (success path) */
+    EXECUTING_TO_COMPLETED = "executing_completed",
+    /** Transition from EXECUTING to FAILED state (error path) */
+    EXECUTING_TO_FAILED = "executing_failed"
+}
 /**
  * A-Command Lifecycle Features
+ *
+ * Defines feature extension points that components can implement to customize
+ * command behavior at different stages of the lifecycle.
+ *
+ * Components can use @A_Feature.Extend() decorator with these feature names
+ * to inject custom logic into command execution.
  */
 declare enum A_CommandFeatures {
     /**
-     * Allows to extend initialization logic and behavior
+     * Triggered during command initialization phase
+     * Use to set up execution environment, validate parameters, or prepare resources
      */
     onInit = "onInit",
     /**
-     * Allows to extend compilation logic and behavior
+     * Triggered before command execution starts
+     * Use for pre-execution validation, logging, or setup tasks
      */
-    onCompile = "onCompile",
+    onBeforeExecute = "onBeforeExecute",
     /**
-     * Allows to extend execution logic and behavior
+     * Main command execution logic
+     * Core business logic should be implemented here
      */
     onExecute = "onExecute",
     /**
-     * Allows to extend completion logic and behavior
+     * Triggered after command execution completes (success or failure)
+     * Use for cleanup, logging, or post-processing tasks
+     */
+    onAfterExecute = "onAfterExecute",
+    /**
+     * Triggered when command completes successfully
+     * Use for success-specific operations like notifications or result processing
      */
     onComplete = "onComplete",
     /**
-     *
+     * Triggered when command execution fails
+     * Use for error handling, cleanup, or failure notifications
      */
-    onFail = "onFail"
+    onFail = "onFail",
+    /**
+     * Triggered when an error occurs during execution
+     * Use for error logging, transformation, or recovery attempts
+     */
+    onError = "onError"
 }
-type A_CONSTANTS__A_Command_Event = keyof typeof A_CommandFeatures;
+/**
+ * Type alias for command lifecycle event names
+ * Represents all available events that can be listened to on a command instance
+ */
+type A_Command_Event = keyof typeof A_CommandFeatures;
 
 /**
- * Command constructor type
- * Uses the generic type T to specify the type of the entity
+ * Command Constructor Type
+ *
+ * Generic constructor type for creating command instances.
+ * Used for dependency injection and factory patterns.
+ *
+ * @template T - The command class type extending A_Command
  */
 type A_TYPES__Command_Constructor<T = A_Command> = new (...args: any[]) => T;
 /**
- * Command initialization type
+ * Command Initialization Parameters
+ *
+ * Base type for command parameters. Commands should extend this with
+ * specific parameter types for their use case.
+ *
+ * @example
+ * ```typescript
+ * interface UserCommandParams extends A_TYPES__Command_Init {
+ *   userId: string;
+ *   action: 'create' | 'update' | 'delete';
+ * }
+ * ```
  */
 type A_TYPES__Command_Init = Record<string, any>;
 /**
- * Command serialized type
+ * Command Serialized Format
+ *
+ * Complete serialized representation of a command including all state,
+ * timing information, results, and errors. Used for persistence,
+ * transmission between services, and state restoration.
+ *
+ * @template ParamsType - Type of command parameters
+ * @template ResultType - Type of command execution result
+ *
+ * @example
+ * ```typescript
+ * const serialized: A_TYPES__Command_Serialized<
+ *   { userId: string },
+ *   { success: boolean }
+ * > = command.toJSON();
+ * ```
  */
 type A_TYPES__Command_Serialized<ParamsType extends Record<string, any> = Record<string, any>, ResultType extends Record<string, any> = Record<string, any>> = {
     /**
-     * Unique code of the command
+     * Unique identifier for the command type (derived from class name)
      */
     code: string;
     /**
-     * Current status of the command
+     * Current execution status of the command
      */
-    status: A_CONSTANTS__A_Command_Status;
+    status: A_Command_Status;
     /**
-     * Parameters used to invoke the command
+     * Parameters used to initialize the command
      */
     params: ParamsType;
     /**
-     * The time when the command was created
+     * ISO timestamp when the command was created
+     */
+    createdAt: string;
+    /**
+     * ISO timestamp when command execution started (if started)
      */
     startedAt?: string;
     /**
-     * The time when the command execution ended
+     * ISO timestamp when command execution ended (if completed/failed)
      */
     endedAt?: string;
     /**
-     * Duration of the command execution in milliseconds
+     * Total execution duration in milliseconds (if completed/failed)
      */
     duration?: number;
     /**
-     * Result of the command execution
+     * Time between creation and execution start in milliseconds
+     */
+    idleTime?: number;
+    /**
+     * Result data produced by successful command execution
      */
     result?: ResultType;
     /**
-     * List of errors occurred during the command execution
+     * Array of serialized errors that occurred during execution
      */
-    errors?: Array<A_TYPES__Error_Serialized>;
+    error?: A_TYPES__Error_Serialized;
 } & A_TYPES__Entity_Serialized;
 /**
- * Command listener type
+ * Command Event Listener Function
+ *
+ * Type definition for event listener functions that can be registered
+ * to respond to command lifecycle events.
+ *
+ * @template InvokeType - Type of command initialization parameters
+ * @template ResultType - Type of command execution result
+ * @template LifecycleEvents - Union type of custom lifecycle event names
+ *
+ * @param command - The command instance that triggered the event
+ *
+ * @example
+ * ```typescript
+ * const listener: A_TYPES__Command_Listener<UserParams, UserResult> = (command) => {
+ *   console.log(`Command ${command?.code} triggered event`);
+ * };
+ *
+ * command.on('onExecute', listener);
+ * ```
  */
-type A_TYPES__Command_Listener<InvokeType extends A_TYPES__Command_Init = A_TYPES__Command_Init, ResultType extends Record<string, any> = Record<string, any>, LifecycleEvents extends string = A_CONSTANTS__A_Command_Event> = (command?: A_Command<InvokeType, ResultType, LifecycleEvents>) => void;
+type A_TYPES__Command_Listener<InvokeType extends A_TYPES__Command_Init = A_TYPES__Command_Init, ResultType extends Record<string, any> = Record<string, any>, LifecycleEvents extends string = A_Command_Event> = (command?: A_Command<InvokeType, ResultType, LifecycleEvents>) => void;
 
-declare class A_Command<InvokeType extends A_TYPES__Command_Init = A_TYPES__Command_Init, ResultType extends Record<string, any> = Record<string, any>, LifecycleEvents extends string | A_CONSTANTS__A_Command_Event = A_CONSTANTS__A_Command_Event> extends A_Entity<InvokeType, A_TYPES__Command_Serialized<InvokeType, ResultType>> {
-    /**
-     * Command Identifier that corresponds to the class name
-     */
-    static get code(): string;
-    protected _result?: ResultType;
-    protected _executionScope: A_Scope;
-    protected _errors?: Set<A_Error>;
-    protected _params: InvokeType;
-    protected _status: A_CONSTANTS__A_Command_Status;
-    protected _listeners: Map<LifecycleEvents | A_CONSTANTS__A_Command_Event, Set<A_TYPES__Command_Listener<InvokeType, ResultType, LifecycleEvents>>>;
-    protected _startTime?: Date;
-    protected _endTime?: Date;
-    /**
-     * Execution Duration in milliseconds
-     */
-    get duration(): number | undefined;
+declare enum A_StateMachineFeatures {
     /**
-     * A shared scope between all features of the command during its execution
+     * Allows to extend error handling logic and behavior
      */
-    get scope(): A_Scope;
+    onError = "onError",
     /**
-     * Unique code identifying the command type
-     * Example: 'user.create', 'task.complete', etc.
-     *
+     * Allows to extend initialization logic and behavior
      */
-    get code(): string;
+    onInitialize = "onInitialize",
     /**
-     * Current status of the command
+     * Allows to extend transition validation logic and behavior
      */
-    get status(): A_CONSTANTS__A_Command_Status;
+    onBeforeTransition = "onBeforeTransition",
     /**
-     * Start time of the command execution
+     * Allows to extend post-transition logic and behavior
      */
-    get startedAt(): Date | undefined;
+    onAfterTransition = "onAfterTransition"
+}
+
+/**
+ * A_StateMachine is a powerful state machine implementation that allows you to define and manage
+ * complex state transitions with validation, hooks, and error handling.
+ *
+ * @template T - A record type defining the state transitions and their associated data types.
+ *               Each key represents a state name, and the value represents the data type for that state.
+ *
+ * @example
+ * ```typescript
+ * interface OrderStates {
+ *   pending: { orderId: string };
+ *   processing: { orderId: string; processedBy: string };
+ *   completed: { orderId: string; completedAt: Date };
+ *   cancelled: { orderId: string; reason: string };
+ * }
+ *
+ * class OrderStateMachine extends A_StateMachine<OrderStates> {
+ *   // Define custom transition logic
+ *   async pending_processing(scope: A_Scope) {
+ *     const operation = scope.resolve(A_StateMachineTransition)!;
+ *     const { orderId } = operation.props;
+ *     // Custom validation and business logic
+ *   }
+ * }
+ * ```
+ */
+declare class A_StateMachine<T extends Record<string, any> = Record<string, any>> extends A_Component {
     /**
-     * End time of the command execution
+     * Internal promise that tracks the initialization state of the state machine.
+     * Used to ensure the state machine is properly initialized before allowing transitions.
      */
-    get endedAt(): Date | undefined;
+    protected _initialized?: Promise<void>;
     /**
-     * Result of the command execution stored in the context
+     * Gets a promise that resolves when the state machine is fully initialized and ready for transitions.
+     * This ensures that all initialization hooks have been executed before allowing state transitions.
+     *
+     * @returns Promise<void> that resolves when initialization is complete
+     *
+     * @example
+     * ```typescript
+     * const stateMachine = new MyStateMachine();
+     * await stateMachine.ready; // Wait for initialization
+     * await stateMachine.transition('idle', 'running');
+     * ```
      */
-    get result(): ResultType | undefined;
+    get ready(): Promise<void>;
     /**
-     * Errors encountered during the command execution stored in the context
+     * Initialization hook that runs when the state machine is first created.
+     * This method can be extended to add custom initialization logic.
+     *
+     * @param args - Variable arguments passed during initialization
+     * @returns Promise<void>
+     *
+     * @example
+     * ```typescript
+     * class MyStateMachine extends A_StateMachine {
+     *   @A_Feature.Extend()
+     *   async [A_StateMachineFeatures.onInitialize]() {
+     *     // Custom initialization logic
+     *     console.log('State machine initialized');
+     *   }
+     * }
+     * ```
      */
-    get errors(): Set<A_Error> | undefined;
+    [A_StateMachineFeatures.onInitialize](...args: any[]): Promise<void>;
     /**
-     * Parameters used to invoke the command
+     * Hook that runs before any state transition occurs.
+     * Use this to add validation, logging, or preparation logic that should run for all transitions.
+     *
+     * @param args - Variable arguments, typically includes the transition scope
+     * @returns Promise<void>
+     *
+     * @example
+     * ```typescript
+     * class MyStateMachine extends A_StateMachine {
+     *   @A_Feature.Extend()
+     *   async [A_StateMachineFeatures.onBeforeTransition](scope: A_Scope) {
+     *     const operation = scope.resolve(A_StateMachineTransition)!;
+     *     console.log(`Transitioning from ${operation.props.from} to ${operation.props.to}`);
+     *   }
+     * }
+     * ```
      */
-    get params(): InvokeType;
+    [A_StateMachineFeatures.onBeforeTransition](...args: any[]): Promise<void>;
     /**
-     * Indicates if the command has failed
+     * Hook that runs after a successful state transition.
+     * Use this to add cleanup, logging, or post-transition logic that should run for all transitions.
+     *
+     * @param args - Variable arguments, typically includes the transition scope
+     * @returns Promise<void>
+     *
+     * @example
+     * ```typescript
+     * class MyStateMachine extends A_StateMachine {
+     *   @A_Feature.Extend()
+     *   async [A_StateMachineFeatures.onAfterTransition](scope: A_Scope) {
+     *     const operation = scope.resolve(A_StateMachineTransition)!;
+     *     console.log(`Successfully transitioned to ${operation.props.to}`);
+     *   }
+     * }
+     * ```
      */
-    get isFailed(): boolean;
+    [A_StateMachineFeatures.onAfterTransition](...args: any[]): Promise<void>;
     /**
-     * Indicates if the command has completed successfully
+     * Error handling hook that runs when a transition fails.
+     * Use this to add custom error handling, logging, or recovery logic.
+     *
+     * @param args - Variable arguments, typically includes the error scope
+     * @returns Promise<void>
+     *
+     * @example
+     * ```typescript
+     * class MyStateMachine extends A_StateMachine {
+     *   @A_Feature.Extend()
+     *   async [A_StateMachineFeatures.onError](scope: A_Scope) {
+     *     const error = scope.resolve(A_StateMachineError);
+     *     console.error('Transition failed:', error?.message);
+     *   }
+     * }
+     * ```
      */
-    get isCompleted(): boolean;
+    [A_StateMachineFeatures.onError](...args: any[]): Promise<void>;
     /**
+     * Executes a state transition from one state to another.
+     * This is the core method of the state machine that handles the complete transition lifecycle.
      *
-     * A-Command represents an executable command with a specific code and parameters.
-     * It can be executed within a given scope and stores execution results and errors.
+     * @param from - The state to transition from (must be a key of T)
+     * @param to - The state to transition to (must be a key of T)
+     * @param props - Optional properties to pass to the transition context (should match T[keyof T])
+     * @returns Promise<void> that resolves when the transition is complete
      *
+     * @throws {A_StateMachineError} When the transition fails for any reason
      *
-     * A-Command should be context independent and execution logic should be based on attached components
+     * @example
+     * ```typescript
+     * interface OrderStates {
+     *   pending: { orderId: string };
+     *   processing: { orderId: string; processedBy: string };
+     * }
      *
-     * @param code
-     * @param params
+     * const orderMachine = new A_StateMachine<OrderStates>();
+     *
+     * // Transition with props
+     * await orderMachine.transition('pending', 'processing', {
+     *   orderId: '12345',
+     *   processedBy: 'user-456'
+     * });
+     * ```
+     *
+     * The transition process follows this lifecycle:
+     * 1. Wait for state machine initialization (ready)
+     * 2. Create transition name in camelCase format (e.g., "pending_processing")
+     * 3. Create operation context with transition data
+     * 4. Create isolated scope for the transition
+     * 5. Call onBeforeTransition hook
+     * 6. Execute the specific transition method (if defined)
+     * 7. Call onAfterTransition hook
+     * 8. Clean up scope and return result
+     *
+     * If any step fails, the onError hook is called and a wrapped error is thrown.
      */
-    constructor(
+    transition(
     /**
-     * Command invocation parameters
+     * The state to transition from
      */
-    params: InvokeType | A_TYPES__Command_Serialized<InvokeType, ResultType> | string);
-    init(): Promise<void>;
-    compile(): Promise<void>;
+    from: keyof T, 
     /**
-     * Processes the command execution
-     *
-     * @returns
+     * The state to transition to
      */
-    process(): Promise<void>;
+    to: keyof T, 
     /**
-     * Executes the command logic.
+     * Optional properties to pass to the transition context
      */
-    execute(): Promise<any>;
+    props?: T[keyof T]): Promise<void>;
+}
+
+declare enum A_TYPES__ConfigFeature {
+}
+type A_TYPES__ConfigContainerConstructor<T extends Array<string | A_TYPES__ConceptENVVariables[number]>> = {
     /**
-     * Marks the command as completed
+     * If set to true, the SDK will throw an error if the variable is not defined OR not presented in the defaults
      */
-    complete(): Promise<void>;
+    strict: boolean;
     /**
-     * Marks the command as failed
+     * Allows to define the names of variable to be loaded
      */
-    fail(): Promise<void>;
+    variables: T;
     /**
-     * Registers an event listener for a specific event
-     *
-     * @param event
-     * @param listener
+     * Allows to set the default values for the variables
      */
-    on(event: LifecycleEvents | A_CONSTANTS__A_Command_Event, listener: A_TYPES__Command_Listener<InvokeType, ResultType, LifecycleEvents>): void;
+    defaults: {
+        [key in T[number]]?: any;
+    };
+} & A_TYPES__Fragment_Constructor;
+
+declare class A_Config<T extends Array<string | A_TYPES__ConceptENVVariables[number]> = any[]> extends A_Fragment<{
+    [key in T[number]]: any;
+}> {
+    config: A_TYPES__ConfigContainerConstructor<T>;
+    private VARIABLES;
+    CONFIG_PROPERTIES: T;
+    protected DEFAULT_ALLOWED_TO_READ_PROPERTIES: ("A_CONCEPT_NAME" | "A_CONCEPT_ROOT_SCOPE" | "A_CONCEPT_ENVIRONMENT" | "A_CONCEPT_ROOT_FOLDER" | "A_ERROR_DEFAULT_DESCRIPTION")[];
+    constructor(config: Partial<A_TYPES__ConfigContainerConstructor<T>>);
     /**
-     * Removes an event listener for a specific event
+     * This method is used to get the configuration property by name
      *
-     * @param event
-     * @param listener
+     * @param property
+     * @returns
      */
-    off(event: LifecycleEvents | A_CONSTANTS__A_Command_Event, listener: A_TYPES__Command_Listener<InvokeType, ResultType, LifecycleEvents>): void;
+    get<K extends T[number]>(property: K | typeof this.DEFAULT_ALLOWED_TO_READ_PROPERTIES[number]): {
+        [key in T[number]]: any;
+    }[K] | undefined;
     /**
-     * Emits an event to all registered listeners
      *
-     * @param event
+     * This method is used to set the configuration property by name
+     * OR set multiple properties at once by passing an array of objects
+     *
+     * @param variables
      */
-    emit(event: LifecycleEvents | A_CONSTANTS__A_Command_Event): void;
+    set(variables: Array<{
+        property: T[number] | A_TYPES__ConceptENVVariables[number];
+        value: any;
+    }>): any;
+    set(variables: Partial<Record<T[number] | A_TYPES__ConceptENVVariables[number], any>>): any;
+    set(property: T[number] | A_TYPES__ConceptENVVariables[number], value: any): any;
+}
+
+declare const A_LoggerEnvVariables: {
     /**
-     * Allows to create a Command instance from new data
+     * Sets the log level for the logger
      *
-     * @param newEntity
+     * @example 'debug', 'info', 'warn', 'error'
      */
-    fromNew(newEntity: InvokeType): void;
+    readonly A_LOGGER_LEVEL: "A_LOGGER_LEVEL";
     /**
-     * Allows to convert serialized data to Command instance
+     * Sets the default scope length for log messages
      *
-     * [!] By default it omits params as they are not stored in the serialized data
+     * @example 'A_LOGGER_DEFAULT_SCOPE_LENGTH'
+     */
+    readonly A_LOGGER_DEFAULT_SCOPE_LENGTH: "A_LOGGER_DEFAULT_SCOPE_LENGTH";
+    /**
+     * Sets the default color for scope display in log messages
      *
-     * @param serialized
+     * @example 'green', 'blue', 'red', 'yellow', 'gray', 'magenta', 'cyan', 'white', 'pink'
      */
-    fromJSON(serialized: A_TYPES__Command_Serialized<InvokeType, ResultType>): void;
+    readonly A_LOGGER_DEFAULT_SCOPE_COLOR: "A_LOGGER_DEFAULT_SCOPE_COLOR";
     /**
-     * Converts the Command instance to a plain object
+     * Sets the default color for log message content
      *
-     * @returns
+     * @example 'green', 'blue', 'red', 'yellow', 'gray', 'magenta', 'cyan', 'white', 'pink'
      */
-    toJSON(): A_TYPES__Command_Serialized<InvokeType, ResultType>;
-    protected checkScopeInheritance(): void;
-}
-
-declare class A_CommandError extends A_Error {
-    static readonly CommandScopeBindingError = "A-Command Scope Binding Error";
-}
-
-interface Ifspolyfill {
-    readFileSync: (path: string, encoding: string) => string;
-    existsSync: (path: string) => boolean;
-    createReadStream: (path: string, options?: BufferEncoding) => any;
-}
-interface IcryptoInterface {
-    createTextHash(text: string, algorithm: string): Promise<string>;
-    createFileHash(filePath: string, algorithm: string): Promise<string>;
-}
-interface IhttpInterface {
-    request: (options: any, callback?: (res: any) => void) => any;
-    get: (url: string | any, callback?: (res: any) => void) => any;
-    createServer: (requestListener?: (req: any, res: any) => void) => any;
-}
-interface IhttpsInterface {
-    request: (options: any, callback?: (res: any) => void) => any;
-    get: (url: string | any, callback?: (res: any) => void) => any;
-    createServer: (options: any, requestListener?: (req: any, res: any) => void) => any;
-}
-interface IpathInterface {
-    join: (...paths: string[]) => string;
-    resolve: (...paths: string[]) => string;
-    dirname: (path: string) => string;
-    basename: (path: string, ext?: string) => string;
-    extname: (path: string) => string;
-    relative: (from: string, to: string) => string;
-    normalize: (path: string) => string;
-    isAbsolute: (path: string) => boolean;
-    parse: (path: string) => any;
-    format: (pathObject: any) => string;
-    sep: string;
-    delimiter: string;
-}
-interface IurlInterface {
-    parse: (urlString: string) => any;
-    format: (urlObject: any) => string;
-    resolve: (from: string, to: string) => string;
-    URL: typeof URL;
-    URLSearchParams: typeof URLSearchParams;
-}
-interface IbufferInterface {
-    from: (data: any, encoding?: string) => any;
-    alloc: (size: number, fill?: any) => any;
-    allocUnsafe: (size: number) => any;
-    isBuffer: (obj: any) => boolean;
-    concat: (list: any[], totalLength?: number) => any;
-}
-interface IprocessInterface {
-    env: Record<string, string | undefined>;
-    argv: string[];
-    platform: string;
-    version: string;
-    versions: Record<string, string>;
-    cwd: () => string;
-    exit: (code?: number) => never;
-    nextTick: (callback: Function, ...args: any[]) => void;
-}
-
-declare enum A_TYPES__ConfigFeature {
-}
-type A_TYPES__ConfigContainerConstructor<T extends Array<string | A_TYPES__ConceptENVVariables[number]>> = {
-    /**
-     * If set to true, the SDK will throw an error if the variable is not defined OR not presented in the defaults
-     */
-    strict: boolean;
-    /**
-     * Allows to define the names of variable to be loaded
-     */
-    variables: T;
-    /**
-     * Allows to set the default values for the variables
-     */
-    defaults: {
-        [key in T[number]]?: any;
-    };
-} & A_TYPES__Fragment_Constructor;
-
-declare class A_Config<T extends Array<string | A_TYPES__ConceptENVVariables[number]> = any[]> extends A_Fragment {
-    config: A_TYPES__ConfigContainerConstructor<T>;
-    private VARIABLES;
-    CONFIG_PROPERTIES: T;
-    protected DEFAULT_ALLOWED_TO_READ_PROPERTIES: ("A_CONCEPT_NAME" | "A_CONCEPT_ROOT_SCOPE" | "A_CONCEPT_ENVIRONMENT" | "A_CONCEPT_ROOT_FOLDER" | "A_ERROR_DEFAULT_DESCRIPTION")[];
-    constructor(config: Partial<A_TYPES__ConfigContainerConstructor<T>>);
-    /**
-     * This method is used to get the configuration property by name
-     *
-     * @param property
-     * @returns
-     */
-    get<_OutType = any>(property: T[number] | typeof this.DEFAULT_ALLOWED_TO_READ_PROPERTIES[number]): _OutType;
-    /**
-     *
-     * This method is used to set the configuration property by name
-     * OR set multiple properties at once by passing an array of objects
-     *
-     * @param variables
-     */
-    set(variables: Array<{
-        property: T[number] | A_TYPES__ConceptENVVariables[number];
-        value: any;
-    }>): any;
-    set(variables: Partial<Record<T[number] | A_TYPES__ConceptENVVariables[number], any>>): any;
-    set(property: T[number] | A_TYPES__ConceptENVVariables[number], value: any): any;
-}
-
-declare const A_LoggerEnvVariables: {
-    /**
-     * Sets the log level for the logger
-     *
-     * @example 'debug', 'info', 'warn', 'error'
-     */
-    readonly A_LOGGER_LEVEL: "A_LOGGER_LEVEL";
-    /**
-     * Sets the default scope length for log messages
-     *
-     * @example 'A_LOGGER_DEFAULT_SCOPE_LENGTH'
-     */
-    readonly A_LOGGER_DEFAULT_SCOPE_LENGTH: "A_LOGGER_DEFAULT_SCOPE_LENGTH";
-};
-type A_LoggerEnvVariablesType = (typeof A_LoggerEnvVariables)[keyof typeof A_LoggerEnvVariables][];
+    readonly A_LOGGER_DEFAULT_LOG_COLOR: "A_LOGGER_DEFAULT_LOG_COLOR";
+};
+type A_LoggerEnvVariablesType = (typeof A_LoggerEnvVariables)[keyof typeof A_LoggerEnvVariables][];
 
 /**
  * A_Logger - Advanced Logging Component with Scope-based Output Formatting
@@ -890,21 +1002,33 @@ type A_LoggerEnvVariablesType = (typeof A_LoggerEnvVariables)[keyof typeof A_Log
  *
  * @example
  * ```typescript
- * // Basic usage with dependency injection
+ * // Basic usage with dependency injection (uses deterministic colors based on scope name)
  * class MyService {
  *   constructor(@A_Inject(A_Logger) private logger: A_Logger) {}
  *
  *   doSomething() {
- *     this.logger.log('Processing started');
- *     this.logger.log('blue', 'Custom color message');
+ *     this.logger.info('Processing started'); // Uses scope-name-based colors, always shows
+ *     this.logger.debug('Debug information'); // Only shows when debug level enabled
+ *     this.logger.info('green', 'Custom message color'); // Green message, scope stays default
  *     this.logger.warning('Something might be wrong');
  *     this.logger.error(new Error('Something failed'));
  *   }
  * }
  *
- * // Advanced usage with objects
- * logger.log('green', 'User data:', { id: 1, name: 'John' });
- * logger.error(new A_Error('VALIDATION_FAILED', 'Invalid input data'));
+ * // Same scope names will always get the same colors automatically
+ * const logger1 = new A_Logger(new A_Scope({name: 'UserService'})); // Gets consistent colors
+ * const logger2 = new A_Logger(new A_Scope({name: 'UserService'})); // Gets same colors as logger1
+ *
+ * // Configuration via environment variables or A_Config (overrides automatic selection)
+ * process.env.A_LOGGER_DEFAULT_SCOPE_COLOR = 'magenta';
+ * process.env.A_LOGGER_DEFAULT_LOG_COLOR = 'green';
+ *
+ * // Or through A_Config instance
+ * const config = new A_Config({
+ *   A_LOGGER_DEFAULT_SCOPE_COLOR: 'red',
+ *   A_LOGGER_DEFAULT_LOG_COLOR: 'white'
+ * });
+ * const logger = new A_Logger(scope, config);
  * ```
  */
 declare class A_Logger extends A_Component {
@@ -920,13 +1044,49 @@ declare class A_Logger extends A_Component {
      * This ensures all log messages align properly regardless of scope name length
      */
     private readonly STANDARD_SCOPE_LENGTH;
+    /**
+     * Default color for the scope portion of log messages
+     * This color is used for the scope brackets and content, and remains consistent
+     * for this logger instance regardless of message color overrides
+     */
+    private readonly DEFAULT_SCOPE_COLOR;
+    /**
+     * Default color for log message content when no explicit color is provided
+     * This color is used for the message body when logging without specifying a color
+     */
+    private readonly DEFAULT_LOG_COLOR;
     /**
      * Initialize A_Logger with dependency injection
+     * Colors are configured through A_Config or generated randomly if not provided
      *
      * @param scope - The current scope context for message prefixing
-     * @param config - Optional configuration for log level filtering
+     * @param config - Optional configuration for log level filtering and color settings
      */
     constructor(scope: A_Scope, config?: A_Config<A_LoggerEnvVariablesType> | undefined);
+    /**
+     * Generate a simple hash from a string
+     * Used to create deterministic color selection based on scope name
+     *
+     * @param str - The string to hash
+     * @returns A numeric hash value
+     */
+    private simpleHash;
+    /**
+     * Generate a deterministic color based on scope name
+     * Same scope names will always get the same color, but uses safe color palette
+     *
+     * @param scopeName - The scope name to generate color for
+     * @returns A color key from the safe colors palette
+     */
+    private generateColorFromScopeName;
+    /**
+     * Generate a pair of complementary colors based on scope name
+     * Ensures visual harmony between scope and message colors while being deterministic
+     *
+     * @param scopeName - The scope name to base colors on
+     * @returns Object with scopeColor and logColor that work well together
+     */
+    private generateComplementaryColorsFromScope;
     /**
      * Get the formatted scope length for consistent message alignment
      * Uses a standard length to ensure all messages align properly regardless of scope name
@@ -935,26 +1095,26 @@ declare class A_Logger extends A_Component {
      */
     get scopeLength(): number;
     /**
-     * Get the formatted scope name with proper padding
-     * Ensures consistent width for all scope names in log output
+     * Get the formatted scope name with proper padding, centered within the container
+     * Ensures consistent width for all scope names in log output with centered alignment
      *
-     * @returns Padded scope name for consistent formatting
+     * @returns Centered and padded scope name for consistent formatting
      */
     get formattedScope(): string;
     /**
      * Compile log arguments into formatted console output with colors and proper alignment
      *
      * This method handles the core formatting logic for all log messages:
-     * - Applies terminal color codes for visual distinction
+     * - Applies separate colors for scope and message content
      * - Formats scope names with consistent padding
      * - Handles different data types appropriately
      * - Maintains proper indentation for multi-line content
      *
-     * @param color - The color key to apply to the message
+     * @param messageColor - The color key to apply to the message content
      * @param args - Variable arguments to format and display
      * @returns Array of formatted strings ready for console output
      */
-    compile(color: keyof typeof this.COLORS, ...args: any[]): Array<string>;
+    compile(messageColor: keyof typeof this.COLORS, ...args: any[]): Array<string>;
     /**
      * Format an object for display with proper JSON indentation
      *
@@ -977,7 +1137,7 @@ declare class A_Logger extends A_Component {
      * Determine if a log message should be output based on configured log level
      *
      * Log level hierarchy:
-     * - debug: Shows all messages
+     * - debug: Shows all messages (debug, info, warning, error)
      * - info: Shows info, warning, and error messages
      * - warn: Shows warning and error messages only
      * - error: Shows error messages only
@@ -986,24 +1146,60 @@ declare class A_Logger extends A_Component {
      * @param logMethod - The type of log method being called
      * @returns True if the message should be logged, false otherwise
      */
-    protected shouldLog(logMethod: 'log' | 'warning' | 'error'): boolean;
+    protected shouldLog(logMethod: 'debug' | 'info' | 'warning' | 'error'): boolean;
+    /**
+     * Debug logging method with optional color specification
+     * Only logs when debug level is enabled
+     *
+     * Supports two usage patterns:
+     * 1. debug(message, ...args) - Uses instance's default log color
+     * 2. debug(color, message, ...args) - Uses specified color for message content only
+     *
+     * Note: The scope color always remains the instance's default scope color,
+     * only the message content color changes when explicitly specified.
+     *
+     * @param color - Optional color key or the first message argument
+     * @param args - Additional arguments to log
+     *
+     * @example
+     * ```typescript
+     * logger.debug('Debug information'); // Uses instance default colors
+     * logger.debug('gray', 'Debug message'); // Gray message, scope stays instance color
+     * logger.debug('Processing user:', { id: 1, name: 'John' });
+     * ```
+     */
+    debug(color: keyof typeof this.COLORS, ...args: any[]): void;
+    debug(...args: any[]): void;
     /**
-     * General purpose logging method with optional color specification
+     * Info logging method with optional color specification
+     * Logs without any restrictions (always shows regardless of log level)
      *
      * Supports two usage patterns:
-     * 1. log(message, ...args) - Uses default blue color
-     * 2. log(color, message, ...args) - Uses specified color
+     * 1. info(message, ...args) - Uses instance's default log color
+     * 2. info(color, message, ...args) - Uses specified color for message content only
+     *
+     * Note: The scope color always remains the instance's default scope color,
+     * only the message content color changes when explicitly specified.
      *
      * @param color - Optional color key or the first message argument
      * @param args - Additional arguments to log
      *
      * @example
      * ```typescript
-     * logger.log('Hello World');
-     * logger.log('green', 'Success message');
-     * logger.log('Processing user:', { id: 1, name: 'John' });
+     * logger.info('Hello World'); // Uses instance default colors
+     * logger.info('green', 'Success message'); // Green message, scope stays instance color
+     * logger.info('Processing user:', { id: 1, name: 'John' });
      * ```
      */
+    info(color: keyof typeof this.COLORS, ...args: any[]): void;
+    info(...args: any[]): void;
+    /**
+     * Legacy log method (kept for backward compatibility)
+     * @deprecated Use info() method instead
+     *
+     * @param color - Optional color key or the first message argument
+     * @param args - Additional arguments to log
+     */
     log(color: keyof typeof this.COLORS, ...args: any[]): void;
     log(...args: any[]): void;
     /**
@@ -1081,6 +1277,365 @@ declare class A_Logger extends A_Component {
     protected getTime(): string;
 }
 
+type A_StateMachineTransitionParams<T = any> = {
+    from: string;
+    to: string;
+    props?: T;
+};
+type A_StateMachineTransitionStorage<_ResultType extends any = any, _ParamsType extends any = any> = {
+    from: string;
+    to: string;
+} & A_Operation_Storage<_ResultType, A_StateMachineTransitionParams<_ParamsType>>;
+
+declare class A_StateMachineTransition<_ParamsType = any, _ResultType = any> extends A_OperationContext<'a-state-machine-transition', A_StateMachineTransitionParams<_ParamsType>, _ResultType, A_StateMachineTransitionStorage<_ResultType, _ParamsType>> {
+    constructor(params: A_StateMachineTransitionParams<_ParamsType>);
+    get from(): string;
+    get to(): string;
+}
+
+/**
+ * A_Command - Advanced Command Pattern Implementation
+ *
+ * A comprehensive command pattern implementation that encapsulates business logic
+ * as executable commands with full lifecycle management, event handling, and
+ * state persistence capabilities.
+ *
+ * ## Key Features
+ * - **Structured Lifecycle**: Automatic progression through init → compile → execute → complete/fail
+ * - **Event-Driven**: Subscribe to lifecycle events and emit custom events
+ * - **State Persistence**: Full serialization/deserialization for cross-service communication
+ * - **Type Safety**: Generic types for parameters, results, and custom events
+ * - **Dependency Injection**: Integrated with A-Concept's DI system
+ * - **Error Management**: Comprehensive error capture and handling
+ * - **Execution Tracking**: Built-in timing and performance metrics
+ *
+ * ## Lifecycle Phases
+ * 1. **CREATED** - Command instantiated but not initialized
+ * 2. **INITIALIZED** - Execution scope and dependencies set up
+ * 3. **COMPILED** - Ready for execution with all resources prepared
+ * 4. **EXECUTING** - Currently running business logic
+ * 5. **COMPLETED** - Successfully finished execution
+ * 6. **FAILED** - Execution failed with errors captured
+ *
+ * @template InvokeType - Type definition for command parameters
+ * @template ResultType - Type definition for command execution result
+ * @template LifecycleEvents - Union type of custom lifecycle event names
+ *
+ * @example
+ * ```typescript
+ * // Define parameter and result types
+ * interface UserCreateParams {
+ *   name: string;
+ *   email: string;
+ *   role: 'admin' | 'user';
+ * }
+ *
+ * interface UserCreateResult {
+ *   userId: string;
+ *   success: boolean;
+ * }
+ *
+ * // Create custom command
+ * class CreateUserCommand extends A_Command<UserCreateParams, UserCreateResult> {}
+ *
+ * // Execute command
+ * const command = new CreateUserCommand({
+ *   name: 'John Doe',
+ *   email: 'john@example.com',
+ *   role: 'user'
+ * });
+ *
+ * scope.register(command);
+ * await command.execute();
+ *
+ * console.log('Result:', command.result);
+ * console.log('Status:', command.status);
+ * ```
+ */
+declare class A_Command<InvokeType extends A_TYPES__Command_Init = A_TYPES__Command_Init, ResultType extends Record<string, any> = Record<string, any>, LifecycleEvents extends string | A_Command_Event = A_Command_Event> extends A_Entity<InvokeType, A_TYPES__Command_Serialized<InvokeType, ResultType>> {
+    /**
+     * Static command identifier derived from the class name
+     * Used for command registration and serialization
+     */
+    static get code(): string;
+    /** The origin of the command, used to know has it been created from serialization or invoked */
+    protected _origin: 'invoked' | 'serialized';
+    /** Command execution scope for dependency injection and feature resolution */
+    protected _executionScope: A_Scope;
+    /** Result data produced by successful command execution */
+    protected _result?: ResultType;
+    /** Set of errors that occurred during command execution */
+    protected _error: A_Error;
+    /** Command initialization parameters */
+    protected _params: InvokeType;
+    /** Current lifecycle status of the command */
+    protected _status: A_Command_Status;
+    /** Map of event listeners organized by event name */
+    protected _listeners: Map<LifecycleEvents | A_Command_Event, Set<A_TYPES__Command_Listener<InvokeType, ResultType, LifecycleEvents>>>;
+    /** Timestamp when command execution started */
+    protected _startTime?: Date;
+    /** Timestamp when command execution ended */
+    protected _endTime?: Date;
+    /** Timestamp when command was created */
+    protected _createdAt: Date;
+    /**
+     * Total execution duration in milliseconds
+     *
+     * - If completed/failed: Returns total time from start to end
+     * - If currently executing: Returns elapsed time since start
+     * - If not started: Returns undefined
+     */
+    get duration(): number | undefined;
+    /**
+     * Idle time before execution started in milliseconds
+     *
+     * Time between command creation and execution start.
+     * Useful for monitoring command queue performance.
+     */
+    get idleTime(): number | undefined;
+    /**
+     * Command execution scope for dependency injection
+     *
+     * Provides access to components, services, and shared resources
+     * during command execution. Inherits from the scope where the
+     * command was registered.
+     */
+    get scope(): A_Scope;
+    /**
+     * Unique command type identifier
+     *
+     * Derived from the class name and used for:
+     * - Command registration and resolution
+     * - Serialization and deserialization
+     * - Logging and debugging
+     *
+     * @example 'create-user-command', 'process-order-command'
+     */
+    get code(): string;
+    /**
+     * Current lifecycle status of the command
+     *
+     * Indicates the current phase in the command execution lifecycle.
+     * Used to track progress and determine available operations.
+     */
+    get status(): A_Command_Status;
+    /**
+     * Timestamp when the command was created
+     *
+     * Marks the initial instantiation time, useful for tracking
+     * command age and queue performance metrics.
+     */
+    get createdAt(): Date;
+    /**
+     * Timestamp when command execution started
+     *
+     * Undefined until execution begins. Used for calculating
+     * execution duration and idle time.
+     */
+    get startedAt(): Date | undefined;
+    /**
+     * Timestamp when command execution ended
+     *
+     * Set when command reaches COMPLETED or FAILED status.
+     * Used for calculating total execution duration.
+     */
+    get endedAt(): Date | undefined;
+    /**
+     * Result data produced by command execution
+     *
+     * Contains the output data from successful command execution.
+     * Undefined until command completes successfully.
+     */
+    get result(): ResultType | undefined;
+    /**
+     * Array of errors that occurred during execution
+     *
+     * Automatically wraps native errors in A_Error instances
+     * for consistent error handling. Empty array if no errors occurred.
+     */
+    get error(): A_Error | undefined;
+    /**
+     * Command initialization parameters
+     *
+     * Contains the input data used to create and configure the command.
+     * These parameters are immutable during command execution.
+                    return new A_Error(err);
+                }
+            });
+    }
+
+    /**
+     * Command initialization parameters
+     *
+     * Contains the input data used to create and configure the command.
+     * These parameters are immutable during command execution.
+     */
+    get params(): InvokeType;
+    /**
+     * Indicates if the command has been processed (completed or failed)
+     *
+     * Returns true if the command has completed or failed, false otherwise.
+     */
+    get isProcessed(): boolean;
+    /**
+     *
+     * A-Command represents an executable command with a specific code and parameters.
+     * It can be executed within a given scope and stores execution results and errors.
+     *
+     *
+     * A-Command should be context independent and execution logic should be based on attached components
+     *
+     * @param code
+     * @param params
+     */
+    constructor(
+    /**
+     * Command invocation parameters
+     */
+    params: InvokeType | A_TYPES__Command_Serialized<InvokeType, ResultType> | string);
+    protected [A_StateMachineFeatures.onBeforeTransition](transition: A_StateMachineTransition, logger?: A_Logger, ...args: any[]): Promise<void>;
+    protected [A_CommandTransitions.CREATED_TO_INITIALIZED](transition: A_StateMachineTransition, ...args: any[]): Promise<void>;
+    protected [A_CommandTransitions.INITIALIZED_TO_EXECUTING](transition: A_StateMachineTransition, ...args: any[]): Promise<void>;
+    protected [A_CommandTransitions.EXECUTING_TO_COMPLETED](transition: A_StateMachineTransition, ...args: any[]): Promise<void>;
+    protected [A_CommandTransitions.EXECUTING_TO_FAILED](transition: A_StateMachineTransition, error: A_Error, ...args: any[]): Promise<void>;
+    protected [A_CommandFeatures.onInit](stateMachine: A_StateMachine, ...args: any[]): Promise<void>;
+    protected [A_CommandFeatures.onBeforeExecute](stateMachine: A_StateMachine, ...args: any[]): Promise<void>;
+    protected [A_CommandFeatures.onExecute](...args: any[]): Promise<void>;
+    protected [A_CommandFeatures.onAfterExecute](...args: any[]): Promise<void>;
+    protected [A_CommandFeatures.onComplete](stateMachine: A_StateMachine, ...args: any[]): Promise<void>;
+    protected [A_CommandFeatures.onFail](stateMachine: A_StateMachine, operation: A_OperationContext, ...args: any[]): Promise<void>;
+    /**
+     * Initializes the command before execution.
+     */
+    init(): Promise<void>;
+    /**
+     * Executes the command logic.
+     */
+    execute(): Promise<any>;
+    /**
+     * Marks the command as completed
+     */
+    complete(result?: ResultType): Promise<void>;
+    /**
+     * Marks the command as failed
+     */
+    fail(error?: A_Error): Promise<void>;
+    /**
+     * Registers an event listener for a specific event
+     *
+     * @param event
+     * @param listener
+     */
+    on(event: LifecycleEvents | A_Command_Event, listener: A_TYPES__Command_Listener<InvokeType, ResultType, LifecycleEvents>): void;
+    /**
+     * Removes an event listener for a specific event
+     *
+     * @param event
+     * @param listener
+     */
+    off(event: LifecycleEvents | A_Command_Event, listener: A_TYPES__Command_Listener<InvokeType, ResultType, LifecycleEvents>): void;
+    /**
+     * Emits an event to all registered listeners
+     *
+     * @param event
+     */
+    emit(event: LifecycleEvents | A_Command_Event): void;
+    /**
+     * Allows to create a Command instance from new data
+     *
+     * @param newEntity
+     */
+    fromNew(newEntity: InvokeType): void;
+    /**
+     * Allows to convert serialized data to Command instance
+     *
+     * [!] By default it omits params as they are not stored in the serialized data
+     *
+     * @param serialized
+     */
+    fromJSON(serialized: A_TYPES__Command_Serialized<InvokeType, ResultType>): void;
+    /**
+     * Converts the Command instance to a plain object
+     *
+     * @returns
+     */
+    toJSON(): A_TYPES__Command_Serialized<InvokeType, ResultType>;
+    /**
+     * Ensures that the command's execution scope inherits from the context scope
+     *
+     * Throws an error if the command is not bound to any context scope
+     */
+    protected checkScopeInheritance(): void;
+}
+
+declare class A_CommandError extends A_Error {
+    static readonly CommandScopeBindingError = "A-Command Scope Binding Error";
+    static readonly ExecutionError = "A-Command Execution Error";
+    static readonly ResultProcessingError = "A-Command Result Processing Error";
+    /**
+     * Error indicating that the command was interrupted during execution
+     */
+    static readonly CommandInterruptedError = "A-Command Interrupted Error";
+}
+
+interface Ifspolyfill {
+    readFileSync: (path: string, encoding: string) => string;
+    existsSync: (path: string) => boolean;
+    createReadStream: (path: string, options?: BufferEncoding) => any;
+}
+interface IcryptoInterface {
+    createTextHash(text: string, algorithm: string): Promise<string>;
+    createFileHash(filePath: string, algorithm: string): Promise<string>;
+}
+interface IhttpInterface {
+    request: (options: any, callback?: (res: any) => void) => any;
+    get: (url: string | any, callback?: (res: any) => void) => any;
+    createServer: (requestListener?: (req: any, res: any) => void) => any;
+}
+interface IhttpsInterface {
+    request: (options: any, callback?: (res: any) => void) => any;
+    get: (url: string | any, callback?: (res: any) => void) => any;
+    createServer: (options: any, requestListener?: (req: any, res: any) => void) => any;
+}
+interface IpathInterface {
+    join: (...paths: string[]) => string;
+    resolve: (...paths: string[]) => string;
+    dirname: (path: string) => string;
+    basename: (path: string, ext?: string) => string;
+    extname: (path: string) => string;
+    relative: (from: string, to: string) => string;
+    normalize: (path: string) => string;
+    isAbsolute: (path: string) => boolean;
+    parse: (path: string) => any;
+    format: (pathObject: any) => string;
+    sep: string;
+    delimiter: string;
+}
+interface IurlInterface {
+    parse: (urlString: string) => any;
+    format: (urlObject: any) => string;
+    resolve: (from: string, to: string) => string;
+    URL: typeof URL;
+    URLSearchParams: typeof URLSearchParams;
+}
+interface IbufferInterface {
+    from: (data: any, encoding?: string) => any;
+    alloc: (size: number, fill?: any) => any;
+    allocUnsafe: (size: number) => any;
+    isBuffer: (obj: any) => boolean;
+    concat: (list: any[], totalLength?: number) => any;
+}
+interface IprocessInterface {
+    env: Record<string, string | undefined>;
+    argv: string[];
+    platform: string;
+    version: string;
+    versions: Record<string, string>;
+    cwd: () => string;
+    exit: (code?: number) => never;
+    nextTick: (callback: Function, ...args: any[]) => void;
+}
+
 declare class A_FSPolyfillClass {
     protected logger: A_Logger;
     private _fs;
@@ -1276,7 +1831,7 @@ declare class A_ConfigError extends A_Error {
 declare class ConfigReader extends A_Component {
     protected polyfill: A_Polyfill;
     constructor(polyfill: A_Polyfill);
-    attachContext(container: A_Container, feature: A_Feature, config?: A_Config): Promise<void>;
+    attachContext(container: A_Container, feature: A_Feature, config?: A_Config<any>): Promise<void>;
     initialize(config: A_Config): Promise<void>;
     /**
      * Get the configuration property by Name
@@ -1432,53 +1987,110 @@ declare class A_ManifestError extends A_Error {
     static readonly ManifestInitializationError = "A-Manifest Initialization Error";
 }
 
-declare class A_Memory<_MemoryType extends Record<string, any> = Record<string, any>, _SerializedType extends Record<string, any> = Record<string, any>> extends A_Fragment {
+declare enum A_MemoryFeatures {
     /**
-     * Internal storage of all intermediate values
+     * Allows to extend initialization logic and behavior
      */
-    protected _memory: Map<keyof _MemoryType, _MemoryType[keyof _MemoryType]>;
+    onInit = "onInit",
     /**
-     * Errors encountered during the execution
+     * Allows to extend destruction logic and behavior
      */
-    protected _errors: Set<A_Error>;
+    onDestroy = "onDestroy",
     /**
-     * Memory object that allows to store intermediate values and errors
-     *
-     * @param initialValues
+     * Allows to extend expiration logic and behavior
      */
-    constructor(initialValues?: _MemoryType);
-    get Errors(): Set<A_Error> | undefined;
+    onExpire = "onExpire",
     /**
-     * Verifies that all required keys are present in the proxy values
-     *
-     * @param requiredKeys
-     * @returns
+     * Allows to extend error handling logic and behavior
+     */
+    onError = "onError",
+    /**
+     * Allows to extend serialization logic and behavior
      */
-    prerequisites(requiredKeys: Array<keyof _MemoryType>): Promise<boolean>;
+    onSerialize = "onSerialize",
     /**
-     * Adds an error to the context
-     *
-     * @param error
+     * Allows to extend set operation logic and behavior
      */
-    error(error: A_Error): Promise<void>;
+    onSet = "onSet",
     /**
-     * Retrieves a value from the context memory
+     * Allows to extend get operation logic and behavior
+     */
+    onGet = "onGet",
+    /**
+     * Allows to extend drop operation logic and behavior
+     */
+    onDrop = "onDrop",
+    /**
+     * Allows to extend clear operation logic and behavior
+     */
+    onClear = "onClear",
+    /**
+     * Allows to extend has operation logic and behavior
+     */
+    onHas = "onHas"
+}
+
+declare class A_MemoryContext<_MemoryType extends Record<string, any> = Record<string, any>, _SerializedType extends A_TYPES__Fragment_Serialized = A_TYPES__Fragment_Serialized> extends A_Fragment<_MemoryType, _MemoryType & _SerializedType> {
+    set<K extends keyof _MemoryType>(param: 'error', value: A_Error): void;
+    set<K extends keyof _MemoryType>(param: K, value: _MemoryType[K]): void;
+    get<K extends keyof A_Error>(param: 'error'): A_Error | undefined;
+    get<K extends keyof _MemoryType>(param: K): _MemoryType[K] | undefined;
+}
+
+type A_MemoryOperations = 'get' | 'set' | 'drop' | 'clear' | 'has' | 'serialize';
+type A_MemoryOperationContext<T extends any = any> = A_OperationContext<A_MemoryOperations, {
+    key: string;
+    value?: any;
+}, T>;
+
+declare class A_Memory<_StorageType extends Record<string, any> = Record<string, any>, _SerializedType extends Record<string, any> = Record<string, any>> extends A_Component {
+    protected _ready?: Promise<void>;
+    get ready(): Promise<void>;
+    [A_MemoryFeatures.onError](...args: any[]): Promise<void>;
+    [A_MemoryFeatures.onExpire](...args: any[]): Promise<void>;
+    [A_MemoryFeatures.onInit](context: A_MemoryContext<_StorageType>, ...args: any[]): Promise<void>;
+    [A_MemoryFeatures.onDestroy](context: A_MemoryContext<_StorageType>, ...args: any[]): Promise<void>;
+    [A_MemoryFeatures.onGet](operation: A_MemoryOperationContext, context: A_MemoryContext<_StorageType>, ...args: any[]): Promise<void>;
+    [A_MemoryFeatures.onHas](operation: A_MemoryOperationContext<boolean>, context: A_MemoryContext<_StorageType>, ...args: any[]): Promise<void>;
+    [A_MemoryFeatures.onSet](operation: A_MemoryOperationContext, context: A_MemoryContext<_StorageType>, ...args: any[]): Promise<void>;
+    [A_MemoryFeatures.onDrop](operation: A_MemoryOperationContext, context: A_MemoryContext<_StorageType>, ...args: any[]): Promise<void>;
+    [A_MemoryFeatures.onClear](operation: A_MemoryOperationContext, context: A_MemoryContext<_StorageType>, ...args: any[]): Promise<void>;
+    /**
+     * Initializes the memory context
+     */
+    init(): Promise<void>;
+    /**
+     * Destroys the memory context
      *
-     * @param key
-     * @returns
+     * This method is responsible for cleaning up any resources
+     * used by the memory context and resetting its state.
      */
-    get<K extends keyof _MemoryType>(
+    destroy(): Promise<void>;
+    /**
+      * Retrieves a value from the context memory
+      *
+      * @param key - memory key to retrieve
+      * @returns - value associated with the key or undefined if not found
+      */
+    get<K extends keyof _StorageType>(
     /**
      * Key to retrieve the value for
      */
-    key: K): _MemoryType[K] | undefined;
+    key: K): Promise<_StorageType[K] | undefined>;
+    /**
+     * Checks if a value exists in the context memory
+     *
+     * @param key - memory key to check
+     * @returns - true if key exists, false otherwise
+     */
+    has(key: keyof _StorageType): Promise<boolean>;
     /**
      * Saves a value in the context memory
      *
      * @param key
      * @param value
      */
-    set<K extends keyof _MemoryType>(
+    set<K extends keyof _StorageType>(
     /**
      * Key to save the value under
      */
@@ -1486,25 +2098,23 @@ declare class A_Memory<_MemoryType extends Record<string, any> = Record<string,
     /**
      * Value to save
      */
-    value: _MemoryType[K]): Promise<void>;
+    value: _StorageType[K]): Promise<void>;
     /**
      * Removes a value from the context memory by key
      *
      * @param key
      */
-    drop(key: keyof _MemoryType): Promise<void>;
+    drop(key: keyof _StorageType): Promise<void>;
     /**
      * Clears all stored values in the context memory
      */
     clear(): Promise<void>;
     /**
-     * Converts all stored values to a plain object
-     *
-     * [!] By default uses all saved in memory values
+     * Serializes the memory context to a JSON object
      *
-     * @returns
+     * @returns - serialized memory object
      */
-    toJSON(): _SerializedType;
+    toJSON(): Promise<_SerializedType>;
 }
 
 type A_UTILS_TYPES__ScheduleObjectConfig = {
@@ -1615,4 +2225,4 @@ declare class A_Deferred<T> {
     reject(reason?: any): void;
 }
 
-export { 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_CommandFeatures, 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__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__CONFIG_ENV_VARIABLES, A_CONSTANTS__CONFIG_ENV_VARIABLES_ARRAY, A_Channel, A_ChannelError, A_ChannelFeatures, A_ChannelRequestStatuses, A_Command, A_CommandError, A_CommandFeatures, A_CommandTransitions, type A_Command_Event, A_Command_Status, 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__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 };