@adaas/a-concept 0.1.61 → 0.2.2

package/dist/index.d.ts

@@ -33,6 +33,7 @@ type A_TYPES__ConceptENVVariables = (typeof A_CONSTANTS__DEFAULT_ENV_VARIABLES)[
 declare const A_CONSTANTS__DEFAULT_ENV_VARIABLES_ARRAY: readonly ["A_CONCEPT_NAME", "A_CONCEPT_ROOT_SCOPE", "A_CONCEPT_ENVIRONMENT", "A_CONCEPT_ROOT_FOLDER", "A_ERROR_DEFAULT_DESCRIPTION"];
 
 type Decrement = [never, 0, 1, 2, 3, 4, 5];
+type A_TYPES__Ctor<T> = new (...args: any[]) => T;
 type A_TYPES__DeepPartial<T, D extends number = 5> = {
     [P in keyof Required<T>]?: [
         D
@@ -68,6 +69,177 @@ type A_TYPES__ExtractProperties<T, P extends A_TYPES__Paths<T>[]> = A_TYPES__Uni
     [K in keyof P]: P[K] extends string ? A_TYPES__ExtractNested<T, P[K]> : never;
 }[number]>;
 
+/**
+ * Fragment constructor type
+ * Uses the generic type T to specify the type of the fragment
+ */
+type A_TYPES__Fragment_Constructor<T = A_Fragment> = A_TYPES__Ctor<T>;
+/**
+ * Fragment initialization type
+ */
+type A_TYPES__Fragment_Init = {
+    name: string;
+};
+/**
+ * Fragment serialized type
+ */
+type A_TYPES__Fragment_Serialized = {
+    /**
+     * The Name of the fragment
+     */
+    name: string;
+};
+
+/**
+ * A_Fragment is a core architectural component that represents a singleton execution context
+ * within the A-Concept framework. It serves as a shared memory container that can be passed
+ * between Components, Entities, and Commands throughout the application pipeline.
+ *
+ * Key Features:
+ * - Singleton pattern: Only one instance per fragment type per scope
+ * - Meta storage: Built-in key-value storage for pipeline data
+ * - Type-safe: Full TypeScript generics support for meta items and serialization
+ * - Serializable: Can be converted to JSON for persistence or transmission
+ *
+ * @template _MetaItems - Type definition for the meta storage structure
+ * @template _SerializedType - Type definition for the serialized output format
+ *
+ * @example
+ * ```typescript
+ * // Basic usage with typed meta
+ * class UserFragment extends A_Fragment<{ userId: string; role: string }> {
+ *   constructor() {
+ *     super({ name: 'UserFragment' });
+ *   }
+ * }
+ *
+ * // Custom serialization
+ * class SessionFragment extends A_Fragment<
+ *   { sessionId: string; timestamp: number },
+ *   { name: string; sessionData: string }
+ * > {
+ *   toJSON() {
+ *     return {
+ *       name: this.name,
+ *       sessionData: `${this.get('sessionId')}-${this.get('timestamp')}`
+ *     };
+ *   }
+ * }
+ * ```
+ */
+declare class A_Fragment<_SerializedType extends A_TYPES__Fragment_Serialized = A_TYPES__Fragment_Serialized> {
+    /**
+     * The unique identifier/name for this fragment instance.
+     * Used for identification and debugging purposes.
+     */
+    protected _name: string;
+    /**
+     * Creates a new A_Fragment instance.
+     *
+     * A_Fragment implements the singleton pattern for execution contexts, allowing
+     * shared state management across different parts of the application pipeline.
+     * Each fragment serves as a memory container that can store typed data and be
+     * serialized for persistence or transmission.
+     *
+     * Key Benefits:
+     * - Centralized state management for related operations
+     * - Type-safe meta operations with full IntelliSense support
+     * - Serialization support for data persistence
+     * - Singleton pattern ensures consistent state within scope
+     *
+     * @param params - Initialization parameters
+     * @param params.name - Optional custom name for the fragment (defaults to class name)
+     *
+     * @example
+     * ```typescript
+     * const fragment = new A_Fragment<{ userId: string }>({
+     *   name: 'UserSessionFragment'
+     * });
+     * fragment.set('userId', '12345');
+     * ```
+     */
+    constructor(params?: Partial<A_TYPES__Fragment_Init>);
+    /**
+     * Gets the fragment's unique name/identifier.
+     *
+     * @returns The fragment name
+     */
+    get name(): string;
+    /**
+     * Serializes the fragment to a JSON-compatible object.
+     *
+     * This method combines the fragment's name with all meta data to create
+     * a serializable representation. The return type is determined by the
+     * _SerializedType generic parameter, allowing for custom serialization formats.
+     *
+     * @returns A serialized representation of the fragment
+     *
+     * @example
+     * ```typescript
+     * const fragment = new A_Fragment<{ userId: string, role: string }>({
+     *   name: 'UserFragment'
+     * });
+     * fragment.set('userId', '12345');
+     * fragment.set('role', 'admin');
+     *
+     * const json = fragment.toJSON();
+     * // Result: { name: 'UserFragment', userId: '12345', role: 'admin' }
+     * ```
+     */
+    toJSON(): _SerializedType;
+}
+
+declare class A_Container {
+    /**
+     * Configuration of the container that will be used to run it.
+     */
+    protected readonly config: Partial<A_TYPES__Container_Init>;
+    /**
+     * Name of the container
+     */
+    get name(): string;
+    /**
+     * Returns the scope where the container is registered
+     */
+    get scope(): A_Scope;
+    /**
+     * This class should combine Components to achieve the goal withing Concept
+     *
+     * Container is a direct container that should be "run" to make Concept work.
+     * So because of that Container can be:
+     * - HTTP Server
+     * - BASH Script
+     * - Database Connection
+     * - Microservice
+     * - etc.
+     *
+     * @param config - Configuration of the container that will be used to run it.
+     */
+    constructor(
+    /**
+     * Configuration of the container that will be used to run it.
+     */
+    config?: Partial<A_TYPES__Container_Init>);
+    /**
+     * Calls the feature with the given name in the given scope
+     *
+     * [!] Note: This method creates a new instance of the feature every time it is called
+     *
+     * @param feature - the name of the feature to call
+     * @param scope  - the scope in which to call the feature
+     * @returns  - void
+     */
+    call(
+    /**
+     * Name of the feature to call
+     */
+    feature: string, 
+    /**
+     * scope in which the feature will be executed
+     */
+    scope?: A_Scope): Promise<void>;
+}
+
 declare enum A_TYPES__ConceptAbstractions {
     /**
      * Run the concept.
@@ -102,104 +274,129 @@ declare enum A_TYPES__ConceptMetaKey {
     LIFECYCLE = "a-component-extensions"
 }
 
-declare enum A_TYPES__A_Stage_Status {
-    /**
-     * The stage is currently being processed
-     */
-    PROCESSING = "PROCESSING",
+/**
+ * This is a common class that uses to return an entity that initiates a feature call
+ *
+ * It can be used then in @A_Inject(A_Caller) to get the entity that initiated the feature call
+ *
+ * [!] the class itself may be retrieved, but may require additional processing inside the feature
+ *
+ */
+declare class A_Caller<T extends A_TYPES__FeatureAvailableComponents = A_TYPES__FeatureAvailableComponents> {
     /**
-     * The stage has been completed
+     * The component that initiated the feature call
      */
-    COMPLETED = "COMPLETED",
+    protected _component: T;
     /**
-     * The stage has failed
+     * A_Caller allows to get the component that initiated the feature call
+     *
+     * It can be used then in @A_Inject(A_Caller) to get the entity that initiated the feature call
+     *
+     * [!] If Scope is not provided, a new empty scope will be created and inherited from the global scope
+     *
+     * @param component
+     * @param scope
      */
-    FAILED = "FAILED",
+    constructor(component: T);
+    get component(): T;
     /**
-     * The stage has been skipped
+     * Validates the provided parameters and Ensures that the component is of an allowed type
+     *
+     * @param component
      */
-    SKIPPED = "SKIPPED",
+    protected validateParams(component: T): void;
+}
+
+/**
+ * Entity constructor type
+ * Uses the generic type T to specify the type of the entity
+ */
+type A_TYPES__Error_Constructor<T = A_Error> = A_TYPES__Ctor<T>;
+/**
+ * Error initialization type
+ */
+type A_TYPES__Error_Init = {
     /**
-     * The stage has been paused
+     * Error title
+     *
+     * A short description of the error
      */
+    title: string;
     /**
-     * The stage has been stopped
+     * Error code representing the type of error
+     *
+     * Should be unique within the application or service
+     *
+     * Example: 'validation-error', 'not-found', 'user-not-found', 'unauthorized' etc.
+     *
+     * [!] Note: It is recommended to use kebab-case for error codes
+     * [!] Note: If not provided would be used a kebab-case message of the error
      */
+    code?: string;
     /**
-     * The stage has been started
+     * Possible Scope if needed to identify the error by it's execution environment
+     *
+     * For example, error of type 'validation' could happen in different scopes
+     * like 'user', 'admin', 'system' etc. This will help to identify the error context better
+     *
+     * Could be string or A_Scope instance
+     *
+     * [!] Note: If not provided, the default scope of the A_Error will be used (A_Context.root.name)
      */
+    scope?: string | A_Scope;
     /**
-     * The stage has been initialized
+     * Detailed description of the error
      */
-    INITIALIZED = "INITIALIZED",
+    description?: string;
     /**
-     * The stage has been aborted
+     * Link to the documentation or support page for the error
      */
-    ABORTED = "ABORTED"
-}
-type A_TYPES_StageExecutionBehavior = 'async' | 'sync';
-type A_TYPES__A_StageStep = {
+    link?: string;
     /**
-     * The component to be called
+     * Original Error if any
      */
-    component: A_TYPES__Component_Constructor | A_Container | string;
-    /**
-     * The method to be called on the component
+    originalError?: Error | unknown;
+};
+/**
+ * Error serialized type
+ */
+type A_TYPES__Error_Serialized = {
+    /**
+     * ASEID of the error
      */
-    handler: string;
+    aseid: string;
     /**
-     * Original Feature Extension name
-     *
-     * [!] could be string or regex
-     *
+     * A brief title of the error
      */
-    name: string;
+    title: string;
     /**
-     * In case its async it will be executed independently from the main thread.
-     *
-     * [!] However, in case of sync, it will be executed in the main thread.in the order of the declaration.
-     *
+     * Error message
      */
-    behavior: A_TYPES_StageExecutionBehavior;
+    message: string;
     /**
-     * Allows to define the order of the execution of the method.
-     *
-     * [!] In case the method has circular dependencies it will Throw an error.
-     *
+     * Type of the error
      */
-    before: string;
+    type: string;
     /**
-     * Allows to define the order of the execution of the method.
-     *
-     * [!] In case the method has circular dependencies it will Throw an error.
-     *
+     * Error code
      */
-    after: string;
+    code: string;
     /**
-     * Indicates whether to throw an error if the step fails.
-     *
-     * [!] By default is true
+     * Error description
      */
-    throwOnError: boolean;
+    description: string;
     /**
-     *
+     * Link to documentation or support page
      */
-    override: string;
-};
-type A_TYPES__Stage_Serialized = {
+    link?: string;
     /**
-     * The name of the stage
+     * Scope of the error
      */
-    name: string;
+    scope: string;
     /**
-     *  The status of the stage
-     *
+     * Original error message if any
      */
-    status: A_TYPES__A_Stage_Status;
-};
-type A_TYPES__A_StageStepProcessingExtraParams = {
-    steps: A_TYPES__A_StageStep[];
-    filter: (step: A_TYPES__A_StageStep) => boolean;
+    originalError?: string;
 };
 
 interface A_TYPES__ASEID_Constructor {
@@ -280,6 +477,7 @@ declare class ASEID {
      * @returns
      */
     static isASEID(identity: string): boolean;
+    static compare(aseid1: ASEID | string | undefined, aseid2: ASEID | string | undefined): boolean;
     /**
      * Concept for the ASEID
      * Generally it is the application name or code, should correspond to the concept where the entity is used
@@ -402,300 +600,243 @@ declare class ASEID {
     protected verifyInput(param1: string | A_TYPES__Required<Partial<A_TYPES__ASEID_Constructor>, ['id', 'entity']>): void;
 }
 
-declare enum A_TYPES__EntityMetaKey {
-    EXTENSIONS = "a-component-extensions",
-    FEATURES = "a-component-features",
-    ABSTRACTIONS = "a-component-abstractions",
-    INJECTIONS = "a-component-injections"
-}
-declare enum A_TYPES__EntityFeatures {
-    SAVE = "save",
-    DESTROY = "destroy",
-    LOAD = "load"
-}
-
-/**
- * Entity interface
- */
-interface A_TYPES__IEntity {
-    /**
-     * The ASEID of the entity
-     */
-    aseid: ASEID;
-}
-/**
- * Entity constructor type
- * Uses the generic type T to specify the type of the entity
- */
-type A_TYPES__Entity_Constructor<T = A_Entity> = new (...args: any[]) => T;
-/**
- * Entity initialization type
- */
-type A_TYPES__Entity_Init = any;
-/**
- * Entity serialized type
- */
-type A_TYPES__Entity_Serialized = {
-    /**
-     * The ASEID of the entity
-     */
-    aseid: string;
-};
-/**
- * Entity meta type
- */
-type A_TYPES__EntityMeta = {
-    [A_TYPES__EntityMetaKey.EXTENSIONS]: A_Meta<{
-        /**
-         * Where Key the regexp for what to apply the extension
-         * A set of container names or a wildcard, or a regexp
-         *
-         *
-         * Where value is the extension instructions
-         */
-        [Key: string]: A_TYPES__FeatureExtendDecoratorMeta[];
-    }>;
-    case: any;
-    [A_TYPES__EntityMetaKey.FEATURES]: A_Meta<{
-        /**
-         * Where Key is the name of the feature
-         *
-         * Where value is the list of features
-         */
-        [Key: string]: A_TYPES__FeatureDefineDecoratorMeta;
-    }>;
-    /**
-     * Injections defined on the component per handler
-     */
-    [A_TYPES__EntityMetaKey.INJECTIONS]: A_Meta<{
-        /**
-         * Where Key is the name of the injection
-         *
-         * Where value is the list of injections
-         */
-        [Key: string]: A_TYPES__A_InjectDecorator_Meta;
-    }>;
-};
-
-/**
- * A_Entity is another abstraction that describes all major participants in the system business logic.
- * Each Entity should have a clear definition and a clear set of responsibilities.
- * However, entity may hide some of its responsibilities behind the interface to prevent overload.
- *
- * Each entity should be connected to the ContextFragment (Scope) and should be able to communicate with other entities.
- */
-declare class A_Entity<_ConstructorType extends A_TYPES__Entity_Init = A_TYPES__Entity_Init, _SerializedType extends A_TYPES__Entity_Serialized = A_TYPES__Entity_Serialized> implements A_TYPES__IEntity {
+declare class A_Error<_ConstructorType extends A_TYPES__Error_Init = A_TYPES__Error_Init, _SerializedType extends A_TYPES__Error_Serialized = A_TYPES__Error_Serialized> extends Error {
     /**
-     * Entity Identifier that corresponds to the class name
+     * Error Identifier that corresponds to the class name
      */
     static get entity(): string;
     /**
-     * DEFAULT Concept Name (Application Name) of the entity from environment variable A_CONCEPT_NAME
+     * DEFAULT Namespace of the error from environment variable A_CONCEPT_NAMESPACE
+     *
      * [!] If environment variable is not set, it will default to 'a-concept'
      */
     static get concept(): string;
     /**
      * DEFAULT Scope of the entity from environment variable A_CONCEPT_DEFAULT_SCOPE
+     *
      * [!] If environment variable is not set, it will default to 'core'
      * [!] Scope is an application specific identifier that can be used to group entities together
      * [!] e.g. 'default', 'core', 'public', 'internal', etc
      */
     static get scope(): string;
     /**
-     * ASEID is an entity identifier that is unique across the system
-     * A - A_Concept or Application
-     * S - System or Scope
-     * E - Entity
-     * ID - Identifier
-     *
-     * [!] ASEID is immutable and should not be changed after the entity is created
-     *
-     * [!] ASEID is composed of the following parts:
-     * - concept: an application specific identifier from where the entity is coming from
-     * - scope: the scope of the entity from concept
-     * - entity: the name of the entity from concept
-     * - id: the unique identifier of the entity
-     *
-     * [!] For more information about ASEID, please refer to the ASEID class documentation]
+     * ASEID of the error instance
      */
-    aseid: ASEID;
+    protected _aseid: ASEID;
     /**
-     * Create a new A_entity instance from Aseid String
-     * e.g. project@scope:entity:0000000001
-     *
-     * @param aseid
+     * Title of the error
      */
-    constructor(
+    protected _title: string;
     /**
-     * ASEID string that represents the entity
+     * Possible Scope if needed to identify the error by it's execution environment
      */
-    aseid?: string);
+    protected _scope?: string;
     /**
-     * Create a new A_entity instance from Aseid instance
-     * e.g. new ASEID({concept: 'project', scope: 'default', entity: 'entity', id: '0000000001'})
-     *
-     * @param aseid
+     * Unique code representing the type of error
      */
-    constructor(
+    protected _code?: string;
     /**
-     * ASEID instance that represents the entity
+     * Detailed description of the error
      */
-    aseid: ASEID);
+    protected _description?: string;
     /**
-     * Create a new A_entity instance from serialized object
-     *
-     * @param serialized
+     * Original Error if any
      */
-    constructor(
+    protected _originalError?: Error | any;
     /**
-     * Serialized object that represents the entity
+     * Link to the documentation or support page for the error
      */
-    serialized: _SerializedType);
+    protected _link?: string;
     /**
-     * Create a new A_entity instance from constructor object
+     * A_Error is a custom error class for A_Concept framework.
+     * This error allows to have more structured error handling.
+     * Each error has a unique code, description and a link to the documentation.
      *
-     * @param newEntity
+     * Example of usage:
+     * ```typescript
+     *
+     * // 1) all parameters will be used as provided
+     * throw new A_Error({
+     *    message: 'User not found',
+     *    code: 'USER_NOT_FOUND',
+     *    description: 'The user with the given ID was not found.',
+     *    link: 'https://support.adaas.org/error/USER_NOT_FOUND'
+     * });
+     *
+     * // or
+     * // 2) only message is provided, other parameters will be set to default values:
+     * //     - code: 'user-not-found' (kebab-case of the message)
+     * //     - description: 'User not found' (same as message)
+     * //     - link: Empty
+     * throw new A_Error('User not found');
+     *
+     * // or
+     * // 3) Provided Message and Description, other parameters will be set to default values:
+     * //     - code: 'user-not-found' (kebab-case of the message)
+     * //     - description: 'The user with the given ID was not found.' (as provided)
+     * //     - link: Empty
+     * throw new A_Error('User not found', 'The user with the given ID was not found.');
+     *
+     *
+     * ```
+     * [!] Note: The behavior of A_Error is similar to the A_Entity however it cannot have own A_Features.
+     * [!] Note: This class can be inherited to create custom error classes.
+     *
+     * @param message
      */
     constructor(
     /**
-     * Constructor object that represents the entity
+     * A_Error Constructor params
      */
-    newEntity?: _ConstructorType);
+    params: _ConstructorType);
+    constructor(
     /**
-     * Extracts the ID from the ASEID
-     * ID is the unique identifier of the entity
+     * Error message
      */
-    get id(): string | number;
-    protected isStringASEID(x: unknown): x is string;
-    protected isASEIDInstance(x: unknown): x is ASEID;
+    message: string);
+    constructor(
     /**
-     * A "serialized" object is considered such if it is a non-null object
-     * and contains an "aseid" property (this mirrors your original check).
-     *
-     * @param x
-     * @returns
+     * Original JS Error
      */
-    protected isSerializedObject(x: unknown): x is _SerializedType;
+    error: Error);
+    constructor(
     /**
-     * Constructor-style props = a plain object which does NOT contain "aseid".
-     * This is the "create from provided fields" case.
-     *
-     * @param x
-     * @returns
+     * Original JS Error
      */
-    protected isConstructorProps(x: unknown): x is _ConstructorType;
+    error: unknown);
+    constructor(
     /**
-     * Determines the appropriate initializer method based on the type of `props`.
-     * The method checks if `props` is:
-     * 1) a string that matches ASEID format -> fromASEID
-     * 2) an ASEID instance -> fromASEID
-     * 3) a serialized object (has 'aseid') -> fromJSON
-     * 4) a plain object with no 'aseid' -> treat as constructor props -> fromNew
-     *
-     * [!] If `props` is undefined, it will call fromUndefined method
-     *
-     * If none of the above, it throws an error indicating incorrect constructor usage.
+     * Error message
+     */
+    title: string, 
+    /**
+     * Detailed description of the error
+     */
+    description: string);
+    /**
+     * Returns the ASEID of the error instance
+     */
+    get aseid(): ASEID;
+    /**
+     * Returns the title of the error
      *
+     * Example: 'User not found', 'Validation error', 'Unauthorized access', etc.
      *
-     * To get a custom initializer, override this method in the child class.
-     * Example:
-     * ```typescript
-     * protected getInitializer(
-     *   props?: string | ASEID | _SerializedType | _ConstructorType
-     * ): (props: any) => void | (() => void) {
-     *   if('customField' in props) {
-     *       return this.fromCustomField.bind(this);
-     *   }
-     *   return super.getInitializer(props);
-     * }
-     * ```
-     * @param props
-     * @returns The appropriate initializer method
+     * [!] Note: This title should be short and concise, less than 60 characters
+     * [!] Note: If title exceeds 60 characters, there would be an error thrown
+     * [!] Note: This title is intended to be human-readable and can be displayed in UI or logs
      */
-    protected getInitializer(props?: string | ASEID | _SerializedType | _ConstructorType): (props: any) => void | (() => void);
+    get title(): string;
     /**
-     * Generates a new ASEID for the entity.
-     * It uses class definitions for concept, scope, and entity,
-     * and allows overriding any of these values.
+     * Returns an Error message what is a brief title of the error
      *
-     * @param override
-     * @returns
      */
-    protected generateASEID(override?: Partial<A_TYPES__ASEID_Constructor>): ASEID;
+    get message(): string;
     /**
-     * Call a feature of the component with the provided scope
+     * Returns a unique code representing the type of error
      *
-     * [!] If the provided scope is not inherited from the entity scope, it will be inherited
+     * If code is not provided, it will generate a kebab-case of the message
      *
-     * @param lifecycleMethod
-     * @param args
+     * Example: 'validation-error', 'not-found', 'user-not-found', 'unauthorized' etc.
+     *
+     * [!] Note: It is recommended to use kebab-case for error codes
+     * [!] Note: If not provided would be used a kebab-case message of the error
      */
-    call(feature: string, scope?: A_Scope): any;
+    get code(): string;
     /**
-     * The default method that can be called and extended to load entity data.
+     * Returns the type of the error which corresponds to the static entity of the class
+     *
+     * Example: 'a-error', 'validation-error', 'not-found-error', 'user-error', etc.
+     *
+     * Defaults to the kebab-case of the class name
+     *
+     * [!] Note: naming ad separation are fully dependent on the architecture of the application
+     * [!] Note: It is recommended to use kebab-case for error types
+     * [!] Note: This type is intended to group similar errors together
      */
-    load(scope?: A_Scope): Promise<any>;
+    get type(): string;
     /**
-     * The default method that can be called and extended to destroy entity data.
+     * Returns a link with possible documentation or support page for the error
+     * If link is not provided, it will generate a link based on the ASEID of the error that points to the A-Concept support page
+     *
+     * Example: https://adaas.support/a-concept/errors/{ASEID}
+     *
+     * [!] Note: ASEID is generated based on the static properties of the class (concept, scope, entity) and the code of the error
      */
-    destroy(scope?: A_Scope): Promise<any>;
+    get link(): string;
     /**
-     * The default method that can be called and extended to save entity data.
+     * The scope name of the error instance
+     *
+     * If scope is not provided, it will use the static scope of the class
+     *
+     * [!] Note: Scope is an application specific identifier that can be used to group entities together
+     * [!] e.g. 'default', 'core', 'public', 'internal', etc
      */
-    save(scope?: A_Scope): Promise<any>;
+    get scope(): string;
     /**
-     * Create a new entity from ASEID string or instance
-     * [!] Executed when the constructor is called with a string or ASEID instance that represents the ASEID
-     * [!] Executes By Default with new A_Entity('aseid-string') or new A_Entity(new ASEID(...)) if getInitializer has not been overridden
+     * A detailed description of the error
+     * If description is not provided, it will use the environment variable A_ERROR_DEFAULT_DESCRIPTION or a generic message
      *
-     * @param aseid
+     * Example: 'The user with the given ID was not found.', 'The provided data is invalid.', 'You do not have permission to access this resource.', etc.
+     *
+     * [!] Note: This description is intended to provide more context about the error and can be used for debugging or logging purposes
      */
-    fromASEID(aseid: string | ASEID): void;
+    get description(): string;
     /**
-     * Handles the case when no props are provided to the constructor.
-     * This method can be overridden in child classes to set default values or perform specific initialization logic.
-     * By default, it does nothing.
+     * Returns the original error if any
      *
+     * This can be useful for debugging purposes to see the original stack trace or error message
      *
-     * @returns
+     * [!] Note: Original error is optional and may not be present in all cases
      */
-    fromUndefined(): void;
+    get originalError(): Error | any | undefined;
     /**
-     * Create a new entity from constructor object
-     * [!] Executed when the constructor is called with an object that does not contain "aseid" property
-     * [!] Executes By Default with new A_Entity({}) if getInitializer has not been overridden
+     * Determines which initializer method to use based on the type of the first parameter.
      *
-     * @param newEntity
+     * @param param1
      * @returns
      */
-    fromNew(newEntity: _ConstructorType): void;
+    protected getInitializer(param1: _ConstructorType | Error | string | any, param2?: string): (param1: any, param2: any) => void | (() => void);
     /**
-     * Creates a new entity from serialized object
+     * Initializes the A_Error instance from a standard Error object.
      *
-     * [!] Executed when the constructor is called with an object that contains "aseid" property
-     * [!] Executes By Default with new A_Entity({ aseid: '...' }) if getInitializer has not been overridden
+     * @param error
+     */
+    protected fromError(error: Error): void;
+    /**
+     * Initializes the A_Error instance from a message.
      *
+     * @param title
+     * @param description
+     */
+    protected fromMessage(message: string): void;
+    /**
+     * Initializes the A_Error instance from a serialized object.
      *
      * @param serialized
-     * @returns
      */
-    fromJSON(serialized: _SerializedType): void;
+    protected fromJSON(serialized: _SerializedType): void;
+    fromTitle(title: string, description: string): void;
     /**
-     * Converts the entity to a JSON object
-     * [!] This method should be extended in the child classes to include all properties of the entity
-     * [!] Includes aseid by default
+     * Initializes the A_Error instance from a constructor parameters object.
+     *
+     * @param params
+     */
+    protected fromConstructor(params: _ConstructorType): void;
+    /**
+     * Serializes the A_Error instance to a plain object.
      *
      *
      * @returns
      */
     toJSON(): _SerializedType;
     /**
-     * Returns the string representation of the entity
-     * what is basically the ASEID string
+     * Checks if the provided title exceeds 60 characters.
+     * If it does, throws a validation A_Error.
      *
-     * @returns
+     * @param title
      */
-    toString(): string;
+    protected validateTitle(title: string): void;
 }
 
 /**
@@ -759,752 +900,707 @@ config: Partial<A_TYPES__FeatureExtendDecoratorConfig>): any;
  */
 declare function A_Feature_Extend(): any;
 
-/**
- * Entity constructor type
- * Uses the generic type T to specify the type of the entity
- */
-type A_TYPES__Error_Constructor<T = A_Error> = new (...args: any[]) => T;
-/**
- * Error initialization type
- */
-type A_TYPES__Error_Init = {
+declare class A_Stage {
     /**
-     * Error title
-     *
-     * A short description of the error
+     * The feature that owns this stage
      */
-    title: string;
+    private readonly _feature;
     /**
-     * Error code representing the type of error
-     *
-     * Should be unique within the application or service
-     *
-     * Example: 'validation-error', 'not-found', 'user-not-found', 'unauthorized' etc.
-     *
-     * [!] Note: It is recommended to use kebab-case for error codes
-     * [!] Note: If not provided would be used a kebab-case message of the error
+     * Initial Instructions to process the stage
      */
-    code?: string;
+    private readonly _definition;
     /**
-     * Possible Scope if needed to identify the error by it's execution environment
-     *
-     * For example, error of type 'validation' could happen in different scopes
-     * like 'user', 'admin', 'system' etc. This will help to identify the error context better
-     *
-     * Could be string or A_Scope instance
-     *
-     * [!] Note: If not provided, the default scope of the A_Error will be used (A_Context.root.name)
+     * Possible errors during stage processing
      */
-    scope?: string | A_Scope;
+    private _error?;
     /**
-     * Detailed description of the error
+     * Indicates the current status of the stage
      */
-    description?: string;
+    private _status;
     /**
-     * Link to the documentation or support page for the error
+     * Promise that will be resolved when the stage is Processed
      */
-    link?: string;
+    private _processed;
     /**
-     * Original Error if any
+     * A_Stage is a callable A_Function within A_Feature that should be run with specific parameters.
+     * [!] Depending on the Stage Definition type sync/async function can be executed correspondingly.
+     *
+     * A-Stage is a common object that uses to simplify logic and re-use of A-Feature internals for better composition.
      */
-    originalError?: Error | unknown;
-};
-/**
- * Error serialized type
- */
-type A_TYPES__Error_Serialized = {
+    constructor(
     /**
-     * ASEID of the error
+     * The feature that owns this stage
      */
-    aseid: string;
+    feature: A_Feature, 
     /**
-     * A brief title of the error
+     * The step definitions of the stage
      */
-    title: string;
+    step: A_TYPES__A_StageStep);
     /**
-     * Error message
+     * Returns the name of the stage
      */
-    message: string;
+    get name(): string;
     /**
-     * Type of the error
+     * Returns the definition of the stage
      */
-    type: string;
+    get definition(): A_TYPES__A_StageStep;
     /**
-     * Error code
+     * Returns the current status of the stage
      */
-    code: string;
+    get status(): A_TYPES__A_Stage_Status;
     /**
-     * Error description
+     * Returns the feature that owns this stage
      */
-    description: string;
+    get feature(): A_Feature;
     /**
-     * Link to documentation or support page
+     * Returns true if the stage is processed (completed, failed, or skipped)
      */
-    link?: string;
+    get isProcessed(): boolean;
     /**
-     * Scope of the error
+     * Returns the error of the stage
      */
-    scope: string;
+    get error(): A_Error | undefined;
     /**
-     * Original error message if any
+     * Resolves the arguments of the step
+     *
+     * @param step
+     * @returns
      */
-    originalError?: string;
-};
-
-declare class A_Error<_ConstructorType extends A_TYPES__Error_Init = A_TYPES__Error_Init, _SerializedType extends A_TYPES__Error_Serialized = A_TYPES__Error_Serialized> extends Error {
+    protected getStepArgs(scope: A_Scope, step: A_TYPES__A_StageStep): Promise<(A_Container | A_Component | A_Entity<any, A_TYPES__Entity_Serialized> | A_Fragment<A_TYPES__Fragment_Serialized> | A_Feature<A_TYPES__FeatureAvailableComponents> | A_Caller<A_TYPES__FeatureAvailableComponents> | A_Error<A_TYPES__Error_Init, A_TYPES__Error_Serialized> | A_Scope<any, A_TYPES__Component_Constructor[], A_TYPES__Error_Constructor[], A_TYPES__Entity_Constructor[], A_Fragment<A_TYPES__Fragment_Serialized>[]> | A_TYPES__A_DependencyInjectable[] | undefined)[]>;
     /**
-     * Error Identifier that corresponds to the class name
+     * Resolves the component of the step
+     *
+     * @param step
+     * @returns
      */
-    static get entity(): string;
+    protected getStepComponent(scope: A_Scope, step: A_TYPES__A_StageStep): A_TYPES__A_DependencyInjectable;
     /**
-     * DEFAULT Namespace of the error from environment variable A_CONCEPT_NAMESPACE
+     * Calls the handler of the step
      *
-     * [!] If environment variable is not set, it will default to 'a-concept'
+     * @param step
+     * @returns
      */
-    static get concept(): string;
+    protected callStepHandler(step: A_TYPES__A_StageStep, scope: A_Scope): Promise<any>;
+    skip(): void;
     /**
-     * DEFAULT Scope of the entity from environment variable A_CONCEPT_DEFAULT_SCOPE
+     * This method processes the stage by executing all the steps
      *
-     * [!] If environment variable is not set, it will default to 'core'
-     * [!] Scope is an application specific identifier that can be used to group entities together
-     * [!] e.g. 'default', 'core', 'public', 'internal', etc
+     * @param scope - Scope to be used to resolve the steps dependencies
      */
-    static get scope(): string;
+    process(
     /**
-     * ASEID of the error instance
+     * Scope to be used to resolve the steps dependencies
      */
-    protected _aseid: ASEID;
+    scope?: A_Scope): Promise<void>;
+    protected completed(): void;
+    protected failed(error: Error | A_Error | any): void;
     /**
-     * Title of the error
+     * Serializes the stage to JSON
+     *
      */
-    protected _title: string;
+    toJSON(): A_TYPES__Stage_Serialized;
     /**
-     * Possible Scope if needed to identify the error by it's execution environment
+     * Returns a string representation of the stage
+     *
+     * @returns
      */
-    protected _scope?: string;
+    toString(): string;
+}
+
+declare class A_StepsManager {
+    entities: A_TYPES__A_StageStep[];
+    graph: Map<string, Set<string>>;
+    visited: Set<string>;
+    tempMark: Set<string>;
+    sortedEntities: string[];
+    private _isBuilt;
+    constructor(entities: Array<A_TYPES__FeatureDefineDecoratorTemplateItem>);
+    private prepareSteps;
+    private ID;
+    private buildGraph;
+    private matchEntities;
+    private visit;
+    toSortedArray(): Array<string>;
+    toStages(feature: A_Feature): Array<A_Stage>;
+}
+
+declare class A_StageError extends A_Error {
+    static readonly ArgumentsResolutionError = "A-Stage Arguments Resolution Error";
+    static get CompileError(): string;
+}
+
+declare class A_FeatureError extends A_Error<A_TYPES__FeatureError_Init> {
     /**
-     * Unique code representing the type of error
+     * Indicates that the Feature has been interrupted
      */
-    protected _code?: string;
+    static readonly Interruption = "Feature Interrupted";
     /**
-     * Detailed description of the error
+     * Indicates that there was an error initializing the Feature
+     *
+     * Failed during the A-Feature initialization process
      */
-    protected _description?: string;
+    static readonly FeatureInitializationError = "Unable to initialize A-Feature";
     /**
-     * Original Error if any
+     * Indicates that there was an error processing the Feature
+     *
+     * Failed during the A-Feature processing
      */
-    protected _originalError?: Error | any;
+    static readonly FeatureProcessingError = "Error occurred during A-Feature processing";
     /**
-     * Link to the documentation or support page for the error
+     * Indicates that there was an error defining the Feature
+     *
+     * Failed during the @A_Feature.Define() decorator execution
      */
-    protected _link?: string;
+    static readonly FeatureDefinitionError = "Unable to define A-Feature";
     /**
-     * A_Error is a custom error class for A_Concept framework.
-     * This error allows to have more structured error handling.
-     * Each error has a unique code, description and a link to the documentation.
-     *
-     * Example of usage:
-     * ```typescript
-     *
-     * // 1) all parameters will be used as provided
-     * throw new A_Error({
-     *    message: 'User not found',
-     *    code: 'USER_NOT_FOUND',
-     *    description: 'The user with the given ID was not found.',
-     *    link: 'https://support.adaas.org/error/USER_NOT_FOUND'
-     * });
-     *
-     * // or
-     * // 2) only message is provided, other parameters will be set to default values:
-     * //     - code: 'user-not-found' (kebab-case of the message)
-     * //     - description: 'User not found' (same as message)
-     * //     - link: Empty
-     * throw new A_Error('User not found');
-     *
-     * // or
-     * // 3) Provided Message and Description, other parameters will be set to default values:
-     * //     - code: 'user-not-found' (kebab-case of the message)
-     * //     - description: 'The user with the given ID was not found.' (as provided)
-     * //     - link: Empty
-     * throw new A_Error('User not found', 'The user with the given ID was not found.');
-     *
-     *
-     * ```
-     * [!] Note: The behavior of A_Error is similar to the A_Entity however it cannot have own A_Features.
-     * [!] Note: This class can be inherited to create custom error classes.
+     * Indicates that there was an error extending the Feature
      *
-     * @param message
+     * Failed during the @A_Feature.Extend() decorator execution
      */
-    constructor(
+    static readonly FeatureExtensionError = "Unable to extend A-Feature";
     /**
-     * A_Error Constructor params
+     * Stage where the error occurred
      */
-    params: _ConstructorType);
-    constructor(
+    stage?: A_Stage;
+    protected fromConstructor(params: A_TYPES__FeatureError_Init): void;
+}
+
+/**
+ * A_Feature is representing a feature that can be executed across multiple components
+ * This class stores the steps of the feature and executes them in order of appearance
+ *
+ * Using A_Feature.Define and A_Feature.Extend decorators to define and extend the feature methods
+ * across the different, distributed components
+ *
+ */
+declare class A_Feature<T extends A_TYPES__FeatureAvailableComponents = A_TYPES__FeatureAvailableComponents> {
     /**
-     * Error message
+     * Define a new A-Feature
      */
-    message: string);
-    constructor(
+    static get Define(): typeof A_Feature_Define;
     /**
-     * Original JS Error
+     * Extend an existing A-Feature
      */
-    error: Error);
-    constructor(
+    static get Extend(): typeof A_Feature_Extend;
     /**
-     * Original JS Error
+     * The name of the Feature
      */
-    error: unknown);
-    constructor(
+    protected _name: string;
     /**
-     * Error message
+     * List of stages that are part of this Feature
      */
-    title: string, 
+    protected _stages: Array<A_Stage>;
     /**
-     * Detailed description of the error
+     * The Stage currently being processed
      */
-    description: string);
+    protected _current?: A_Stage;
     /**
-     * Returns the ASEID of the error instance
+     * Actual Index of the current Stage being processed
      */
-    get aseid(): ASEID;
+    protected _index: number;
     /**
-     * Returns the title of the error
-     *
-     * Example: 'User not found', 'Validation error', 'Unauthorized access', etc.
-     *
-     * [!] Note: This title should be short and concise, less than 60 characters
-     * [!] Note: If title exceeds 60 characters, there would be an error thrown
-     * [!] Note: This title is intended to be human-readable and can be displayed in UI or logs
+     * Steps Manager to organize the steps into stages
      */
-    get title(): string;
+    protected _SM: A_StepsManager;
     /**
-     * Returns an Error message what is a brief title of the error
-     *
+     * The Caller that initiated the Feature call
      */
-    get message(): string;
+    protected _caller: A_Caller<T>;
     /**
-     * Returns a unique code representing the type of error
-     *
-     * If code is not provided, it will generate a kebab-case of the message
-     *
-     * Example: 'validation-error', 'not-found', 'user-not-found', 'unauthorized' etc.
-     *
-     * [!] Note: It is recommended to use kebab-case for error codes
-     * [!] Note: If not provided would be used a kebab-case message of the error
+     * The current state of the Feature
      */
-    get code(): string;
+    protected _state: A_TYPES__FeatureState;
     /**
-     * Returns the type of the error which corresponds to the static entity of the class
-     *
-     * Example: 'a-error', 'validation-error', 'not-found-error', 'user-error', etc.
-     *
-     * Defaults to the kebab-case of the class name
-     *
-     * [!] Note: naming ad separation are fully dependent on the architecture of the application
-     * [!] Note: It is recommended to use kebab-case for error types
-     * [!] Note: This type is intended to group similar errors together
+     * The error that caused the Feature to be interrupted
      */
-    get type(): string;
+    protected _error?: A_FeatureError;
     /**
-     * Returns a link with possible documentation or support page for the error
-     * If link is not provided, it will generate a link based on the ASEID of the error that points to the A-Concept support page
-     *
-     * Example: https://adaas.support/a-concept/errors/{ASEID}
+     * A-Feature is a pipeline distributed by multiple components that can be easily attached or detached from the scope.
+     * Feature itself does not have scope, but attached to the caller who dictates how feature should be processed.
      *
-     * [!] Note: ASEID is generated based on the static properties of the class (concept, scope, entity) and the code of the error
-     */
-    get link(): string;
-    /**
-     * The scope name of the error instance
+     * Comparing to A-Command Feature does not store any state except statuses for better analysis.
      *
-     * If scope is not provided, it will use the static scope of the class
+     * [!] Note: If A-Feature should have result use A-Fragment
      *
-     * [!] Note: Scope is an application specific identifier that can be used to group entities together
-     * [!] e.g. 'default', 'core', 'public', 'internal', etc
+     * @param params
      */
-    get scope(): string;
+    constructor(
     /**
-     * A detailed description of the error
-     * If description is not provided, it will use the environment variable A_ERROR_DEFAULT_DESCRIPTION or a generic message
-     *
-     * Example: 'The user with the given ID was not found.', 'The provided data is invalid.', 'You do not have permission to access this resource.', etc.
-     *
-     * [!] Note: This description is intended to provide more context about the error and can be used for debugging or logging purposes
+     * Feature Initialization parameters
      */
-    get description(): string;
+    params: A_TYPES__Feature_Init<T>);
     /**
-     * Returns the original error if any
-     *
-     * This can be useful for debugging purposes to see the original stack trace or error message
-     *
-     * [!] Note: Original error is optional and may not be present in all cases
+     * The name of the Feature
      */
-    get originalError(): Error | any | undefined;
+    get name(): string;
     /**
-     * Determines which initializer method to use based on the type of the first parameter.
-     *
-     * @param param1
-     * @returns
+     * The error that caused the Feature to be interrupted
      */
-    protected getInitializer(param1: _ConstructorType | Error | string | any, param2?: string): (param1: any, param2: any) => void | (() => void);
+    get error(): A_FeatureError | undefined;
     /**
-     * Initializes the A_Error instance from a standard Error object.
-     *
-     * @param error
+     * The current state of the Feature
      */
-    protected fromError(error: Error): void;
+    get state(): A_TYPES__FeatureState;
     /**
-     * Initializes the A_Error instance from a message.
-     *
-     * @param title
-     * @param description
+     * Sets the current state of the Feature
      */
-    protected fromMessage(message: string): void;
+    get index(): number;
     /**
-     * Initializes the A_Error instance from a serialized object.
-     *
-     * @param serialized
+     * Returns the current A-Feature Stage
      */
-    protected fromJSON(serialized: _SerializedType): void;
-    fromTitle(title: string, description: string): void;
+    get stage(): A_Stage | undefined;
     /**
-     * Initializes the A_Error instance from a constructor parameters object.
-     *
-     * @param params
+     * The Caller that initiated the Feature call
      */
-    protected fromConstructor(params: _ConstructorType): void;
+    get caller(): A_Caller<T>;
     /**
-     * Serializes the A_Error instance to a plain object.
-     *
-     *
-     * @returns
+     * The Scope allocated for the Feature Execution
      */
-    toJSON(): _SerializedType;
+    get scope(): A_Scope;
     /**
-     * Checks if the provided title exceeds 60 characters.
-     * If it does, throws a validation A_Error.
-     *
-     * @param title
+     * The number of stages in the feature
      */
-    protected validateTitle(title: string): void;
-}
-
-declare class A_Stage {
+    get size(): number;
     /**
-     * The feature that owns this stage
+     * This method checks if the A-Feature is done
+     *
+     * @returns
      */
-    private readonly _feature;
+    get isDone(): boolean;
     /**
-     * Initial Instructions to process the stage
+     * Indicates whether the feature has been processed (completed, failed, or interrupted)
      */
-    private readonly _definition;
+    get isProcessed(): boolean;
     /**
-     * Possible errors during stage processing
+     * Iterator to iterate over the steps of the feature
+     *
+     * @returns
      */
-    private _error?;
+    [Symbol.iterator](): Iterator<A_Stage, any>;
     /**
-     * Indicates the current status of the stage
+     * Validates the provided parameters for A-Feature initialization
+     *
+     * @param params
      */
-    private _status;
+    protected validateParams(params: A_TYPES__Feature_Init<T>): void;
     /**
-     * Promise that will be resolved when the stage is Processed
+     * Returns the appropriate initializer method based on the provided parameters
+     *
+     * @param params
+     * @returns
      */
-    private _processed;
+    protected getInitializer(params: A_TYPES__Feature_Init<T>): (param1: any) => void | (() => void);
     /**
-     * A_Stage is a callable A_Function within A_Feature that should be run with specific parameters.
-     * [!] Depending on the Stage Definition type sync/async function can be executed correspondingly.
+     * Initializes the A-Feature from the provided template
      *
-     * A-Stage is a common object that uses to simplify logic and re-use of A-Feature internals for better composition.
+     * @param params
      */
-    constructor(
+    protected fromTemplate(params: A_TYPES__Feature_InitWithTemplate<T>): void;
     /**
-     * The feature that owns this stage
+     * Initializes the A-Feature from the provided component
+     *
+     * @param params
      */
-    feature: A_Feature, 
+    protected fromComponent(params: A_TYPES__Feature_InitWithComponent<T>): void;
     /**
-     * The step definitions of the stage
+     * This method processes the feature by executing all the stages
+     *
      */
-    step: A_TYPES__A_StageStep);
+    process(
     /**
-     * Returns the name of the stage
+     * Optional scope to be used to resolve the steps dependencies
+     * If not provided, the scope of the caller component will be used
      */
-    get name(): string;
+    scope?: A_Scope): Promise<void>;
     /**
-     * Returns the definition of the stage
+     * This method moves the feature to the next stage
+     *
+     * @param stage
      */
-    get definition(): A_TYPES__A_StageStep;
+    next(stage: any): void;
     /**
-     * Returns the current status of the stage
+     * This method marks the feature as completed and returns the result
+     * Uses to interrupt or end the feature processing
+     *
+     * @param result
+     * @returns
      */
-    get status(): A_TYPES__A_Stage_Status;
+    completed(): Promise<void>;
     /**
-     * Returns the feature that owns this stage
+     * This method marks the feature as failed and throws an error
+     * Uses to mark the feature as failed
+     *
+     * @param error
      */
-    get feature(): A_Feature;
+    failed(error: A_FeatureError): Promise<void>;
     /**
-     * Returns true if the stage is processed (completed, failed, or skipped)
+     * This method marks the feature as failed and throws an error
+     * Uses to interrupt or end the feature processing
+     *
+     * @param error
      */
-    get isProcessed(): boolean;
+    interrupt(
     /**
-     * Returns the error of the stage
+     * The reason of feature interruption
      */
-    get error(): A_Error | undefined;
+    reason?: string | A_StageError | Error): Promise<void>;
     /**
-     * Resolves the arguments of the step
+     * Allows to chain the feature to another feature.
+     * In this case the parent feature scope (if new not provided), stages, caller will be used.
      *
-     * @param step
-     * @returns
-     */
-    protected getStepArgs(scope: A_Scope, step: A_TYPES__A_StageStep): Promise<any[]>;
-    /**
-     * Resolves the component of the step
+     * [!] Note: Chained feature will use the same caller as the parent feature.
      *
-     * @param step
-     * @returns
+     * @param feature
      */
-    protected getStepComponent(scope: A_Scope, step: A_TYPES__A_StageStep): A_TYPES__ScopeResolvableComponents;
+    chain(
     /**
-     * Calls the handler of the step
-     *
-     * @param step
-     * @returns
+     * A Feature to be chained
      */
-    protected callStepHandler(step: A_TYPES__A_StageStep, scope: A_Scope): Promise<any>;
-    skip(): void;
+    feature: A_Feature, 
     /**
-     * This method processes the stage by executing all the steps
-     *
-     * @param scope - Scope to be used to resolve the steps dependencies
+     * Optional scope to be used for the chained feature.
      */
-    process(
+    scope?: A_Scope): any;
+    chain<T extends A_TYPES__FeatureAvailableComponents = A_TYPES__FeatureAvailableComponents>(
     /**
-     * Scope to be used to resolve the steps dependencies
+     * Component whose feature should be chained
      */
-    scope?: A_Scope): Promise<void>;
-    protected completed(): void;
-    protected failed(error: Error | A_Error | any): void;
+    component: A_TYPES__FeatureAvailableComponents, 
     /**
-     * Serializes the stage to JSON
-     *
+     * A Feature Name to be chained
      */
-    toJSON(): A_TYPES__Stage_Serialized;
+    feature: string, 
     /**
-     * Returns a string representation of the stage
-     *
-     * @returns
+     * Optional scope to be used for the chained feature.
      */
+    scope?: A_Scope): any;
     toString(): string;
 }
 
-declare class A_StepsManager {
-    entities: A_TYPES__A_StageStep[];
-    graph: Map<string, Set<string>>;
-    visited: Set<string>;
-    tempMark: Set<string>;
-    sortedEntities: string[];
-    private _isBuilt;
-    constructor(entities: Array<A_TYPES__FeatureDefineDecoratorTemplateItem>);
-    private prepareSteps;
-    private ID;
-    private buildGraph;
-    private matchEntities;
-    private visit;
-    toSortedArray(): Array<string>;
-    toStages(feature: A_Feature): Array<A_Stage>;
-}
-
-declare class A_StageError extends A_Error {
-    static readonly ArgumentsResolutionError = "A-Stage Arguments Resolution Error";
-    static get CompileError(): string;
-}
-
-declare class A_FeatureError extends A_Error<A_TYPES__FeatureError_Init> {
+type A_TYPES__A_DependencyConstructor<T extends A_Dependency> = A_TYPES__Ctor<T>;
+type A_TYPES__A_DependencyInjectable = A_Entity | A_Container | A_Component | A_Fragment | A_Feature | A_Caller | A_Error | A_Scope;
+type A_TYPES__A_DependencyResolutionType<T> = T extends string ? string : T extends A_TYPES__Ctor<infer R> ? R : never;
+type A_TYPES__A_DependencyResolutionStrategy<T extends A_TYPES__A_DependencyInjectable = A_TYPES__A_DependencyInjectable> = {
     /**
-     * Indicates that the Feature has been interrupted
-     */
-    static readonly Interruption = "Feature Interrupted";
-    /**
-     * Indicates that there was an error initializing the Feature
-     *
-     * Failed during the A-Feature initialization process
+     * If tru will throw an error if the dependency is not found
      */
-    static readonly FeatureInitializationError = "Unable to initialize A-Feature";
+    require: boolean;
     /**
-     * Indicates that there was an error processing the Feature
-     *
-     * Failed during the A-Feature processing
+     * Indicates that dependency should be loaded from a specific path before resolution
      */
-    static readonly FeatureProcessingError = "Error occurred during A-Feature processing";
+    load: boolean;
     /**
-     * Indicates that there was an error defining the Feature
-     *
-     * Failed during the @A_Feature.Define() decorator execution
+     * Number of levels to go up in the parent chain when resolving the dependency
      */
-    static readonly FeatureDefinitionError = "Unable to define A-Feature";
+    parent: number;
     /**
-     * Indicates that there was an error extending the Feature
-     *
-     * Failed during the @A_Feature.Extend() decorator execution
+     * If true, will only resolve the dependency in the current scope without going up to parent scopes
      */
-    static readonly FeatureExtensionError = "Unable to extend A-Feature";
+    flat: boolean;
     /**
-     * Stage where the error occurred
+     * If has any value indicates that entity should be created with default parameters provided
      */
-    stage?: A_Stage;
-    protected fromConstructor(params: A_TYPES__FeatureError_Init): void;
-}
-
-/**
- * This is a common class that uses to return an entity that initiates a feature call
- *
- * It can be used then in @A_Inject(A_Caller) to get the entity that initiated the feature call
- *
- * [!] the class itself may be retrieved, but may require additional processing inside the feature
- *
- */
-declare class A_Caller<T extends A_TYPES__FeatureAvailableComponents = A_TYPES__FeatureAvailableComponents> {
+    create: boolean;
     /**
-     * The component that initiated the feature call
+     * Default constructor arguments to use when creating the dependency
      */
-    protected _component: T;
+    args: any[];
     /**
-     * A_Caller allows to get the component that initiated the feature call
-     *
-     * It can be used then in @A_Inject(A_Caller) to get the entity that initiated the feature call
-     *
-     * [!] If Scope is not provided, a new empty scope will be created and inherited from the global scope
-     *
-     * @param component
-     * @param scope
+     * Allows to query by specific entity properties e.g. ASEID, name, type, custom properties, etc.
      */
-    constructor(component: T);
-    get component(): T;
+    query: Partial<A_TYPES__A_Dependency_EntityInjectionQuery<T>>;
     /**
-     * Validates the provided parameters and Ensures that the component is of an allowed type
-     *
-     * @param component
+     * Pagination settings for the entity search
      */
-    protected validateParams(component: T): void;
-}
-
-/**
- * A_Feature is representing a feature that can be executed across multiple components
- * This class stores the steps of the feature and executes them in order of appearance
- *
- * Using A_Feature.Define and A_Feature.Extend decorators to define and extend the feature methods
- * across the different, distributed components
+    pagination: A_TYPES__A_Dependency_EntityInjectionPagination;
+};
+type A_TYPES__A_Dependency_Serialized<T extends A_TYPES__A_DependencyInjectable = A_TYPES__A_DependencyInjectable> = {
+    name: string;
+    all: boolean;
+    require: boolean;
+    load: boolean;
+    parent: number;
+    flat: boolean;
+    create: any;
+    args: any[];
+    query: Partial<A_TYPES__A_Dependency_EntityInjectionQuery<T>>;
+    pagination: A_TYPES__A_Dependency_EntityInjectionPagination;
+};
+type A_TYPES__A_Dependency_EntityResolutionConfig<T extends A_TYPES__A_DependencyInjectable = A_TYPES__A_DependencyInjectable> = {
+    query: Partial<A_TYPES__A_Dependency_EntityInjectionQuery<T>>;
+    pagination: Partial<A_TYPES__A_Dependency_EntityInjectionPagination>;
+};
+type A_TYPES__A_Dependency_EntityInjectionQuery<T extends A_TYPES__A_DependencyInjectable = A_TYPES__A_DependencyInjectable> = T extends A_Entity ? {
+    aseid: string;
+} & {
+    [key in keyof T]?: any;
+} : never;
+type A_TYPES__A_Dependency_EntityInjectionPagination = {
+    count: number;
+    from: 'start' | 'end';
+};
+/**
+ * A-Dependency require decorator return type
+ */
+type A_TYPES__A_Dependency_RequireDecoratorReturn<T = any> = (target: T, propertyKey: string | symbol | undefined, parameterIndex: number) => void;
+/**
+ * A-Dependency load decorator return type
+ */
+type A_TYPES__A_Dependency_LoadDecoratorReturn<T = any> = (target: T, propertyKey: string | symbol | undefined, parameterIndex: number) => void;
+/**
+ * A-Dependency default decorator return type
+ */
+type A_TYPES__A_Dependency_DefaultDecoratorReturn<T = any> = (target: T, propertyKey: string | symbol | undefined, parameterIndex: number) => void;
+/**
+ * A-Dependency parent decorator return type
+ */
+type A_TYPES__A_Dependency_ParentDecoratorReturn<T = any> = (target: T, propertyKey: string | symbol | undefined, parameterIndex: number) => void;
+/**
+ * A-Dependency flat decorator return type
+ */
+type A_TYPES__A_Dependency_FlatDecoratorReturn<T = any> = (target: T, propertyKey: string | symbol | undefined, parameterIndex: number) => void;
+/**
+ * A-Dependency All decorator return type
+ */
+type A_TYPES__A_Dependency_AllDecoratorReturn<T = any> = (target: T, propertyKey: string | symbol | undefined, parameterIndex: number) => void;
+
+/**
+ * Should indicate which Default is required
+ */
+declare function A_Dependency_Default(
+/**
+ * Constructor Parameters that will be used to create the default instance
+ */
+...args: any[]): A_TYPES__A_Dependency_DefaultDecoratorReturn;
+
+/**
+ * Should indicate which dependency is required
+ */
+declare function A_Dependency_Flat(): A_TYPES__A_Dependency_FlatDecoratorReturn;
+
+/**
+ * Should indicate which Load is required
+ */
+declare function A_Dependency_Load(): A_TYPES__A_Dependency_LoadDecoratorReturn;
+
+/**
+ * Should indicate which dependency is required
+ */
+declare function A_Dependency_Parent(
+/**
+ * Indicates how many layers up the parent dependency should be resolved from current dependency
  *
+ * Default: -1 (one layer up)
  */
-declare class A_Feature<T extends A_TYPES__FeatureAvailableComponents = A_TYPES__FeatureAvailableComponents> {
+layerOffset?: number): A_TYPES__A_Dependency_ParentDecoratorReturn;
+
+/**
+ * Should indicate which dependency is required
+ */
+declare function A_Dependency_Require(): A_TYPES__A_Dependency_RequireDecoratorReturn;
+
+declare class A_Dependency<T extends A_TYPES__A_DependencyInjectable = A_TYPES__A_DependencyInjectable> {
     /**
-     * Define a new A-Feature
+     * Allows to indicate which Injected parameter is required
+     *
+     * [!] If parameter marked as required is not provided, an error will be thrown
+     *
+     * @returns
      */
-    static get Define(): typeof A_Feature_Define;
+    static get Required(): typeof A_Dependency_Require;
     /**
-     * Extend an existing A-Feature
+     * Allows to indicate which dependency should be loaded from a specific path
+     *
+     * @returns
      */
-    static get Extend(): typeof A_Feature_Extend;
+    static get Loaded(): typeof A_Dependency_Load;
     /**
-     * The name of the Feature
+     * Allows to indicate which dependency default parameters should be used
+     *
+     * @returns
      */
-    protected _name: string;
+    static get Default(): typeof A_Dependency_Default;
     /**
-     * List of stages that are part of this Feature
+     * Allows to indicate which parent dependency should be resolved
+     * e.g. from which layer up the parent should be taken
+     *
+     * @returns
      */
-    protected _stages: Array<A_Stage>;
+    static get Parent(): typeof A_Dependency_Parent;
     /**
-     * The Stage currently being processed
+     * Allows to indicate that the dependency should be resolved in a flat manner
+     * Only in the same scope, without going up to parent scopes
+     *
+     * @returns
      */
-    protected _current?: A_Stage;
+    static get Flat(): typeof A_Dependency_Flat;
+    protected _name: string;
+    protected _target?: A_TYPES__Ctor<T>;
+    protected _resolutionStrategy: A_TYPES__A_DependencyResolutionStrategy;
+    protected _defaultPagination: A_TYPES__A_DependencyResolutionStrategy['pagination'];
+    protected _defaultResolutionStrategy: A_TYPES__A_DependencyResolutionStrategy;
+    get flat(): boolean;
+    get require(): boolean;
+    get load(): boolean;
     /**
-     * Actual Index of the current Stage being processed
+     * Indicates cases when it's necessary to search across all instances
      */
-    protected _index: number;
+    get all(): boolean;
+    get parent(): number;
+    get create(): any;
+    get args(): any[];
+    get query(): Partial<A_TYPES__A_Dependency_EntityInjectionQuery<T>>;
+    get pagination(): A_TYPES__A_Dependency_EntityInjectionPagination;
     /**
-     * Steps Manager to organize the steps into stages
+     * Class instances allows to identify dependencies by name and use them for better type checking
+     *
+     * @param name
      */
-    protected _SM: A_StepsManager;
+    constructor(name: string | A_TYPES__Ctor<T>, resolutionStrategy?: Partial<Omit<A_TYPES__A_DependencyResolutionStrategy<T>, 'pagination'> & {
+        pagination: Partial<A_TYPES__A_Dependency_EntityInjectionPagination>;
+    }>);
     /**
-     * The Caller that initiated the Feature call
+     * Gets the dependency name
+     *
+     * Can be identifier, url or any string value
+     *
+     * @returns
      */
-    protected _caller: A_Caller<T>;
+    get name(): string;
     /**
-     * The current state of the Feature
+     * Returns the original class of the dependency if provided
+     *
      */
-    protected _state: A_TYPES__FeatureState;
+    get target(): A_TYPES__Ctor<T> | undefined;
     /**
-     * The error that caused the Feature to be interrupted
+     * Gets the dependency resolution strategy
      */
-    protected _error?: A_FeatureError;
+    get resolutionStrategy(): A_TYPES__A_DependencyResolutionStrategy<T>;
     /**
-     * A-Feature is a pipeline distributed by multiple components that can be easily attached or detached from the scope.
-     * Feature itself does not have scope, but attached to the caller who dictates how feature should be processed.
-     *
-     * Comparing to A-Command Feature does not store any state except statuses for better analysis.
-     *
-     * [!] Note: If A-Feature should have result use A-Fragment
-     *
-     * @param params
+     * Sets the dependency resolution strategy
      */
-    constructor(
+    set resolutionStrategy(strategy: Partial<Omit<A_TYPES__A_DependencyResolutionStrategy<T>, 'pagination'> & {
+        pagination: Partial<A_TYPES__A_Dependency_EntityInjectionPagination>;
+    }>);
     /**
-     * Feature Initialization parameters
+     * Method for the parameters check and all input data before usage
+     *
+     * @returns
      */
-    params: A_TYPES__Feature_Init<T>);
+    private initCheck;
     /**
-     * The name of the Feature
+     * Serializes the dependency to a JSON object
+     *
+     * @returns
      */
-    get name(): string;
+    toJSON(): A_TYPES__A_Dependency_Serialized<T>;
+}
+
+declare enum A_TYPES__A_Stage_Status {
     /**
-     * The error that caused the Feature to be interrupted
+     * The stage is currently being processed
      */
-    get error(): A_FeatureError | undefined;
+    PROCESSING = "PROCESSING",
     /**
-     * The current state of the Feature
+     * The stage has been completed
      */
-    get state(): A_TYPES__FeatureState;
+    COMPLETED = "COMPLETED",
     /**
-     * Sets the current state of the Feature
+     * The stage has failed
      */
-    get index(): number;
+    FAILED = "FAILED",
     /**
-     * Returns the current A-Feature Stage
+     * The stage has been skipped
      */
-    get stage(): A_Stage | undefined;
+    SKIPPED = "SKIPPED",
     /**
-     * The Caller that initiated the Feature call
+     * The stage has been paused
      */
-    get caller(): A_Caller<T>;
     /**
-     * The Scope allocated for the Feature Execution
+     * The stage has been stopped
      */
-    get scope(): A_Scope;
     /**
-     * The number of stages in the feature
+     * The stage has been started
      */
-    get size(): number;
     /**
-     * This method checks if the A-Feature is done
-     *
-     * @returns
+     * The stage has been initialized
      */
-    get isDone(): boolean;
+    INITIALIZED = "INITIALIZED",
     /**
-     * Indicates whether the feature has been processed (completed, failed, or interrupted)
+     * The stage has been aborted
      */
-    get isProcessed(): boolean;
+    ABORTED = "ABORTED"
+}
+type A_TYPES_StageExecutionBehavior = 'async' | 'sync';
+type A_TYPES__A_StageStep = {
     /**
-     * Iterator to iterate over the steps of the feature
-     *
-     * @returns
+     * The component to be called
      */
-    [Symbol.iterator](): Iterator<A_Stage, any>;
+    dependency: A_Dependency;
     /**
-     * Validates the provided parameters for A-Feature initialization
-     *
-     * @param params
+     * The method to be called on the component
      */
-    protected validateParams(params: A_TYPES__Feature_Init<T>): void;
+    handler: string;
     /**
-     * Returns the appropriate initializer method based on the provided parameters
+     * Original Feature Extension name
      *
-     * @param params
-     * @returns
-     */
-    protected getInitializer(params: A_TYPES__Feature_Init<T>): (param1: any) => void | (() => void);
-    /**
-     * Initializes the A-Feature from the provided template
+     * [!] could be string or regex
      *
-     * @param params
      */
-    protected fromTemplate(params: A_TYPES__Feature_InitWithTemplate<T>): void;
+    name: string;
     /**
-     * Initializes the A-Feature from the provided component
+     * In case its async it will be executed independently from the main thread.
      *
-     * @param params
-     */
-    protected fromComponent(params: A_TYPES__Feature_InitWithComponent<T>): void;
-    /**
-     * This method processes the feature by executing all the stages
+     * [!] However, in case of sync, it will be executed in the main thread.in the order of the declaration.
      *
      */
-    process(
-    /**
-     * Optional scope to be used to resolve the steps dependencies
-     * If not provided, the scope of the caller component will be used
-     */
-    scope?: A_Scope): Promise<void>;
+    behavior: A_TYPES_StageExecutionBehavior;
     /**
-     * This method moves the feature to the next stage
+     * Allows to define the order of the execution of the method.
+     *
+     * [!] In case the method has circular dependencies it will Throw an error.
      *
-     * @param stage
      */
-    next(stage: any): void;
+    before: string;
     /**
-     * This method marks the feature as completed and returns the result
-     * Uses to interrupt or end the feature processing
+     * Allows to define the order of the execution of the method.
+     *
+     * [!] In case the method has circular dependencies it will Throw an error.
      *
-     * @param result
-     * @returns
      */
-    completed(): Promise<void>;
+    after: string;
     /**
-     * This method marks the feature as failed and throws an error
-     * Uses to mark the feature as failed
+     * Indicates whether to throw an error if the step fails.
      *
-     * @param error
+     * [!] By default is true
      */
-    failed(error: A_FeatureError): Promise<void>;
+    throwOnError: boolean;
     /**
-     * This method marks the feature as failed and throws an error
-     * Uses to interrupt or end the feature processing
      *
-     * @param error
      */
-    interrupt(
+    override: string;
+};
+type A_TYPES__Stage_Serialized = {
     /**
-     * The reason of feature interruption
+     * The name of the stage
      */
-    reason?: string | A_StageError | Error): Promise<void>;
+    name: string;
     /**
-     * Allows to chain the feature to another feature.
-     * In this case the parent feature scope (if new not provided), stages, caller will be used.
-     *
-     * [!] Note: Chained feature will use the same caller as the parent feature.
+     *  The status of the stage
      *
-     * @param feature
-     */
-    chain(
-    /**
-     * A Feature to be chained
-     */
-    feature: A_Feature, 
-    /**
-     * Optional scope to be used for the chained feature.
-     */
-    scope?: A_Scope): any;
-    chain<T extends A_TYPES__FeatureAvailableComponents = A_TYPES__FeatureAvailableComponents>(
-    /**
-     * Component whose feature should be chained
      */
-    component: A_TYPES__FeatureAvailableComponents, 
-    /**
-     * A Feature Name to be chained
-     */
-    feature: string, 
-    /**
-     * Optional scope to be used for the chained feature.
-     */
-    scope?: A_Scope): any;
-    toString(): string;
-}
+    status: A_TYPES__A_Stage_Status;
+};
+type A_TYPES__A_StageStepProcessingExtraParams = {
+    steps: A_TYPES__A_StageStep[];
+    filter: (step: A_TYPES__A_StageStep) => boolean;
+};
 
 /**
  * Feature constructor type
  * Uses the generic type T to specify the type of the feature
  */
-type A_TYPES__Feature_Constructor<T = A_Feature> = new (...args: any[]) => T;
+type A_TYPES__Feature_Constructor<T = A_Feature> = A_TYPES__Ctor<T>;
 /**
  * Feature initialization type
  */
@@ -1633,7 +1729,7 @@ type A_TYPES__FeatureDefineDecoratorConfig = {
 /**
  * Describes a single template item used in Feature Define decorator
  */
-type A_TYPES__FeatureDefineDecoratorTemplateItem = A_TYPES__Required<Partial<A_TYPES__A_StageStep>, ['name', 'handler', 'component']>;
+type A_TYPES__FeatureDefineDecoratorTemplateItem = A_TYPES__Required<Partial<A_TYPES__A_StageStep>, ['name', 'handler', 'dependency']>;
 /**
  * Describes a target where Feature Define decorator can be applied
  *
@@ -1929,7 +2025,7 @@ declare class A_Abstraction {
  * Abstraction constructor type
  * Uses the generic type T to specify the type of the abstraction
  */
-type A_TYPES__Abstraction_Constructor<T = A_Abstraction> = new (...args: any[]) => T;
+type A_TYPES__Abstraction_Constructor<T = A_Abstraction> = A_TYPES__Ctor<T>;
 /**
  * Abstraction initialization type
  */
@@ -2108,131 +2204,11 @@ declare class A_Concept<_Imports extends A_Container[] = A_Container[]> {
     container: _Imports[number]): Promise<void>;
 }
 
-/**
- * A_Fragment is a core architectural component that represents a singleton execution context
- * within the A-Concept framework. It serves as a shared memory container that can be passed
- * between Components, Entities, and Commands throughout the application pipeline.
- *
- * Key Features:
- * - Singleton pattern: Only one instance per fragment type per scope
- * - Meta storage: Built-in key-value storage for pipeline data
- * - Type-safe: Full TypeScript generics support for meta items and serialization
- * - Serializable: Can be converted to JSON for persistence or transmission
- *
- * @template _MetaItems - Type definition for the meta storage structure
- * @template _SerializedType - Type definition for the serialized output format
- *
- * @example
- * ```typescript
- * // Basic usage with typed meta
- * class UserFragment extends A_Fragment<{ userId: string; role: string }> {
- *   constructor() {
- *     super({ name: 'UserFragment' });
- *   }
- * }
- *
- * // Custom serialization
- * class SessionFragment extends A_Fragment<
- *   { sessionId: string; timestamp: number },
- *   { name: string; sessionData: string }
- * > {
- *   toJSON() {
- *     return {
- *       name: this.name,
- *       sessionData: `${this.get('sessionId')}-${this.get('timestamp')}`
- *     };
- *   }
- * }
- * ```
- */
-declare class A_Fragment<_SerializedType extends A_TYPES__Fragment_Serialized = A_TYPES__Fragment_Serialized> {
-    /**
-     * The unique identifier/name for this fragment instance.
-     * Used for identification and debugging purposes.
-     */
-    protected _name: string;
-    /**
-     * Creates a new A_Fragment instance.
-     *
-     * A_Fragment implements the singleton pattern for execution contexts, allowing
-     * shared state management across different parts of the application pipeline.
-     * Each fragment serves as a memory container that can store typed data and be
-     * serialized for persistence or transmission.
-     *
-     * Key Benefits:
-     * - Centralized state management for related operations
-     * - Type-safe meta operations with full IntelliSense support
-     * - Serialization support for data persistence
-     * - Singleton pattern ensures consistent state within scope
-     *
-     * @param params - Initialization parameters
-     * @param params.name - Optional custom name for the fragment (defaults to class name)
-     *
-     * @example
-     * ```typescript
-     * const fragment = new A_Fragment<{ userId: string }>({
-     *   name: 'UserSessionFragment'
-     * });
-     * fragment.set('userId', '12345');
-     * ```
-     */
-    constructor(params?: Partial<A_TYPES__Fragment_Init>);
-    /**
-     * Gets the fragment's unique name/identifier.
-     *
-     * @returns The fragment name
-     */
-    get name(): string;
-    /**
-     * Serializes the fragment to a JSON-compatible object.
-     *
-     * This method combines the fragment's name with all meta data to create
-     * a serializable representation. The return type is determined by the
-     * _SerializedType generic parameter, allowing for custom serialization formats.
-     *
-     * @returns A serialized representation of the fragment
-     *
-     * @example
-     * ```typescript
-     * const fragment = new A_Fragment<{ userId: string, role: string }>({
-     *   name: 'UserFragment'
-     * });
-     * fragment.set('userId', '12345');
-     * fragment.set('role', 'admin');
-     *
-     * const json = fragment.toJSON();
-     * // Result: { name: 'UserFragment', userId: '12345', role: 'admin' }
-     * ```
-     */
-    toJSON(): _SerializedType;
-}
-
-/**
- * Fragment constructor type
- * Uses the generic type T to specify the type of the fragment
- */
-type A_TYPES__Fragment_Constructor<T = A_Fragment> = new (...args: any[]) => T;
-/**
- * Fragment initialization type
- */
-type A_TYPES__Fragment_Init = {
-    name: string;
-};
-/**
- * Fragment serialized type
- */
-type A_TYPES__Fragment_Serialized = {
-    /**
-     * The Name of the fragment
-     */
-    name: string;
-};
-
 /**
  * Concept constructor type
  * Uses the generic type T to specify the type of the concept
  */
-type A_TYPES__Concept_Constructor<T = A_Concept> = new (...args: any[]) => T;
+type A_TYPES__Concept_Constructor<T = A_Concept> = A_TYPES__Ctor<T>;
 /**
  * Concept initialization type
  * Uses the generic type T to specify the type of containers that the concept will use
@@ -2279,53 +2255,355 @@ type A_TYPES__Concept_Serialized = {};
  */
 type A_TYPES__ConceptAbstractionMeta = {
     /**
-     * The arguments that will be passed to the handler
+     * The arguments that will be passed to the handler
+     */
+    args: A_TYPES__A_InjectDecorator_Meta;
+} & A_TYPES__FeatureExtendDecoratorMeta;
+/**
+ * Uses to define the extension that will be applied to the Concept
+ */
+type A_TYPES__ConceptAbstraction = A_TYPES__FeatureExtendDecoratorMeta;
+
+declare enum A_TYPES__ContainerMetaKey {
+    FEATURES = "a-container-features",
+    INJECTIONS = "a-container-injections",
+    ABSTRACTIONS = "a-container-abstractions",
+    EXTENSIONS = "a-container-extensions"
+}
+
+/**
+ * Container constructor type
+ * Uses the generic type T to specify the type of the container
+ */
+type A_TYPES__Container_Constructor<T = A_Container> = A_TYPES__Ctor<T>;
+/**
+ * Container initialization type
+ */
+type A_TYPES__Container_Init = {
+    /**
+     * The extra name for the container (optional)
+     */
+    name?: string;
+} & A_TYPES__Scope_Init;
+/**
+ * Container serialized type
+ */
+type A_TYPES__Container_Serialized = {
+    /**
+     * The ASEID of the container
+     */
+    aseid: string;
+};
+/**
+ * Meta information stored in each Container
+ */
+type A_TYPES__ContainerMeta = {
+    /**
+     * Extensions applied to the component per handler
+     */
+    [A_TYPES__ContainerMetaKey.EXTENSIONS]: A_Meta<{
+        /**
+         * Where Key the regexp for what to apply the extension
+         * A set of container names or a wildcard, or a regexp
+         *
+         *
+         * Where value is the extension instructions
+         */
+        [Key: string]: A_TYPES__FeatureExtendDecoratorMeta[];
+    }>;
+    [A_TYPES__ContainerMetaKey.FEATURES]: A_Meta<{
+        /**
+         * Where Key is the name of the feature
+         *
+         * Where value is the list of features
+         */
+        [Key: string]: A_TYPES__FeatureDefineDecoratorMeta;
+    }>;
+    [A_TYPES__ContainerMetaKey.ABSTRACTIONS]: A_Meta<{
+        /**
+         * Where Key the regexp for what to apply the extension
+         * A set of container names or a wildcard, or a regexp
+         *
+         *
+         * Where value is the extension instructions
+         */
+        [Key: string]: A_TYPES__ConceptAbstraction[];
+    }>;
+    [A_TYPES__ContainerMetaKey.INJECTIONS]: A_Meta<{
+        /**
+         * Where Key is the name of the injection
+         *
+         * Where value is the list of injections
+         */
+        [Key: string]: A_TYPES__A_InjectDecorator_Meta;
+    }>;
+};
+type A_TYPES__ContainerMetaExtension = A_TYPES__FeatureExtendDecoratorMeta;
+
+/**
+ * A-Inject decorator descriptor type
+ * Indicates the type of the decorator function
+ */
+type A_TYPES__A_InjectDecoratorDescriptor = TypedPropertyDescriptor<(...args: any[]) => Promise<void>>;
+/**
+ * A-Inject decorator return type
+ * Indicates what the decorator function returns
+ */
+type A_TYPES__A_InjectDecoratorReturn<T = any> = (target: T, propertyKey: string | symbol | undefined, parameterIndex: number) => void;
+type A_TYPES__A_InjectDecorator_Meta = Array<A_Dependency>;
+/**
+ * Targets that can be injected into Extended functions or constructors
+ */
+type A_TYPES__InjectableTargets = A_TYPES__Component_Constructor | InstanceType<A_TYPES__Component_Constructor> | InstanceType<A_TYPES__Container_Constructor>;
+
+declare enum A_TYPES__ComponentMetaKey {
+    EXTENSIONS = "a-component-extensions",
+    FEATURES = "a-component-features",
+    INJECTIONS = "a-component-injections",
+    ABSTRACTIONS = "a-component-abstractions"
+}
+
+/**
+ * Component constructor type
+ * Uses the generic type T to specify the type of the component
+ */
+type A_TYPES__Component_Constructor<T = A_Component> = A_TYPES__Ctor<T>;
+/**
+ * Component initialization type
+ */
+type A_TYPES__Component_Init = any;
+/**
+ * Component serialized type
+ */
+type A_TYPES__Component_Serialized = {
+    /**
+     * The ASEID of the component
+     */
+    aseid: string;
+};
+/**
+ * Component meta type
+ */
+type A_TYPES__ComponentMeta = {
+    /**
+     * Extensions applied to the component per handler
+     */
+    [A_TYPES__ComponentMetaKey.EXTENSIONS]: A_Meta<{
+        /**
+         * Where Key the regexp for what to apply the extension
+         * A set of container names or a wildcard, or a regexp
+         *
+         *
+         * Where value is the extension instructions
+         */
+        [Key: string]: A_TYPES__FeatureExtendDecoratorMeta[];
+    }>;
+    /**
+     * Features defined on the component per handler
+     */
+    [A_TYPES__ComponentMetaKey.FEATURES]: A_Meta<{
+        /**
+         * Where Key is the name of the feature
+         *
+         * Where value is the list of features
+         */
+        [Key: string]: A_TYPES__FeatureDefineDecoratorMeta;
+    }>;
+    /**
+     * Injections defined on the component per handler
+     */
+    [A_TYPES__ComponentMetaKey.INJECTIONS]: A_Meta<{
+        /**
+         * Where Key is the name of the injection
+         *
+         * Where value is the list of injections
+         */
+        [Key: string]: A_TYPES__A_InjectDecorator_Meta;
+    }>;
+    /**
+     *  Abstractions extended by the component per handler
+     */
+    [A_TYPES__ComponentMetaKey.ABSTRACTIONS]: A_Meta<{
+        /**
+         * Where Key is the name of the stage
+         *
+         * Where value is the list of injections
+         */
+        [Key: string]: A_TYPES__ConceptAbstraction[];
+    }>;
+};
+type A_TYPES__ComponentMetaExtension = A_TYPES__FeatureExtendDecoratorMeta;
+
+/**
+ * Meta constructor type
+ */
+type A_TYPES__Meta_Constructor<T = A_Meta> = A_TYPES__Ctor<T>;
+/**
+ * Components that can have Meta associated with them
+ */
+type A_TYPES__MetaLinkedComponents = A_Container | A_Component | A_Entity | A_Fragment;
+/**
+ * Constructors of components that can have Meta associated with them
+ */
+type A_TYPES__MetaLinkedComponentConstructors = new (...args: any[]) => any | A_TYPES__Container_Constructor | A_TYPES__Component_Constructor | A_TYPES__Entity_Constructor | A_TYPES__Fragment_Constructor;
+
+/**
+ * A Meta is an entity that stores all the metadata for the specific entity like container, component, feature, etc.
+ *
+ * [!] Meta can be different depending on the type of input data
+ */
+declare class A_Meta<_StorageItems extends Record<any, any> = any, _SerializedType extends Record<string, any> = Record<string, any>> implements Iterable<[keyof _StorageItems, _StorageItems[keyof _StorageItems]]> {
+    /**
+     * Allows to set a custom meta class for the Component or Container or Entity, or anything else.
+     *
+     * @param target
+     * @returns
+     */
+    static Define<T extends A_Meta>(target: A_TYPES__Meta_Constructor<T>): <TTarget extends A_TYPES__MetaLinkedComponentConstructors>(target: TTarget) => TTarget;
+    protected meta: Map<keyof _StorageItems, _StorageItems[keyof _StorageItems]>;
+    /**
+     * Method to get the iterator for the meta object
+     *
+     * @returns
+     */
+    [Symbol.iterator](): Iterator<[keyof _StorageItems, _StorageItems[keyof _StorageItems]]>;
+    /**
+     * Allows to replicate received meta object by replacing internal meta to the received one
+     *
+     * @param meta
+     * @returns
+     */
+    from(meta: A_Meta<_StorageItems>): A_Meta<_StorageItems>;
+    /**
+     * Method to set values in the map
+     *
+     * @param key
+     * @param value
+     */
+    set<K extends keyof _StorageItems>(key: K, value: _StorageItems[K]): void;
+    /**
+     * Method to get values from the map
+     *
+     * @param key
+     * @returns
+     */
+    get<K extends keyof _StorageItems>(key: K): _StorageItems[K] | undefined;
+    /**
+     * Method to delete values from the map
+     *
+     * @param key
+     * @returns
+     */
+    delete(key: keyof _StorageItems): boolean;
+    /**
+     * Method to get the size of the map
+     *
+     * @returns
+     */
+    size(): number;
+    /**
+     * This method is needed to convert the key to a regular expression and cover cases like:
+     *
+     * simple * e.g. "a*" instead of "a.*"
+     *
+     * simple ? e.g. "a?" instead of "a."
+     *
+     * etc.
+     *
+     * @param key
+     * @returns
+     */
+    private convertToRegExp;
+    /**
+     * Method to find values in the map by name.
+     *
+     * Converts the Key in Map to a regular expression and then compares to the name
+     *
+     * @param name
+     * @returns
+     */
+    find(name: string): [keyof _StorageItems, _StorageItems[keyof _StorageItems]][];
+    /**
+     * Method to find values in the map by regular expression
+     *
+     * Compares Map Key to the input regular expression
+     *
+     * @param regex
+     * @returns
+     */
+    findByRegex(regex: RegExp): Array<[keyof _StorageItems, _StorageItems[keyof _StorageItems]]>;
+    /**
+     * Method to check if the map has a specific key
+     *
+     * @param key
+     * @returns
+     */
+    has(key: keyof _StorageItems): boolean;
+    /**
+     * Method to get the size of the map
+     *
+     * @returns
+     */
+    entries(): IterableIterator<[keyof _StorageItems, _StorageItems[keyof _StorageItems]]>;
+    /**
+     * Method to clear the map
+     */
+    clear(): void;
+    toArray(): Array<[keyof _StorageItems, _StorageItems[keyof _StorageItems]]>;
+    protected recursiveToJSON(value: any): any;
+    /**
+     * Serializes the meta to a JSON object
+     * Uses internal storage to convert to JSON
+     *
+     * @returns
      */
-    args: A_TYPES__A_InjectDecorator_Meta;
-} & A_TYPES__FeatureExtendDecoratorMeta;
-/**
- * Uses to define the extension that will be applied to the Concept
- */
-type A_TYPES__ConceptAbstraction = A_TYPES__FeatureExtendDecoratorMeta;
+    toJSON(): _SerializedType;
+}
 
-declare enum A_TYPES__ContainerMetaKey {
-    FEATURES = "a-container-features",
-    INJECTIONS = "a-container-injections",
-    ABSTRACTIONS = "a-container-abstractions",
-    EXTENSIONS = "a-container-extensions"
+declare enum A_TYPES__EntityMetaKey {
+    EXTENSIONS = "a-component-extensions",
+    FEATURES = "a-component-features",
+    ABSTRACTIONS = "a-component-abstractions",
+    INJECTIONS = "a-component-injections"
+}
+declare enum A_TYPES__EntityFeatures {
+    SAVE = "save",
+    DESTROY = "destroy",
+    LOAD = "load"
 }
 
 /**
- * Container constructor type
- * Uses the generic type T to specify the type of the container
- */
-type A_TYPES__Container_Constructor<T = A_Container> = new (...args: any[]) => T;
-/**
- * Container initialization type
+ * Entity interface
  */
-type A_TYPES__Container_Init = {
+interface A_TYPES__IEntity {
     /**
-     * The extra name for the container (optional)
+     * The ASEID of the entity
      */
-    name?: string;
-} & A_TYPES__Scope_Init;
+    aseid: ASEID;
+}
 /**
- * Container serialized type
+ * Entity constructor type
+ * Uses the generic type T to specify the type of the entity
  */
-type A_TYPES__Container_Serialized = {
+type A_TYPES__Entity_Constructor<T = A_Entity> = A_TYPES__Ctor<T>;
+/**
+ * Entity initialization type
+ */
+type A_TYPES__Entity_Init = any;
+/**
+ * Entity serialized type
+ */
+type A_TYPES__Entity_Serialized = {
     /**
-     * The ASEID of the container
+     * The ASEID of the entity
      */
     aseid: string;
 };
 /**
- * Meta information stored in each Container
+ * Entity meta type
  */
-type A_TYPES__ContainerMeta = {
-    /**
-     * Extensions applied to the component per handler
-     */
-    [A_TYPES__ContainerMetaKey.EXTENSIONS]: A_Meta<{
+type A_TYPES__EntityMeta = {
+    [A_TYPES__EntityMetaKey.EXTENSIONS]: A_Meta<{
         /**
          * Where Key the regexp for what to apply the extension
          * A set of container names or a wildcard, or a regexp
@@ -2335,7 +2613,8 @@ type A_TYPES__ContainerMeta = {
          */
         [Key: string]: A_TYPES__FeatureExtendDecoratorMeta[];
     }>;
-    [A_TYPES__ContainerMetaKey.FEATURES]: A_Meta<{
+    case: any;
+    [A_TYPES__EntityMetaKey.FEATURES]: A_Meta<{
         /**
          * Where Key is the name of the feature
          *
@@ -2343,17 +2622,10 @@ type A_TYPES__ContainerMeta = {
          */
         [Key: string]: A_TYPES__FeatureDefineDecoratorMeta;
     }>;
-    [A_TYPES__ContainerMetaKey.ABSTRACTIONS]: A_Meta<{
-        /**
-         * Where Key the regexp for what to apply the extension
-         * A set of container names or a wildcard, or a regexp
-         *
-         *
-         * Where value is the extension instructions
-         */
-        [Key: string]: A_TYPES__ConceptAbstraction[];
-    }>;
-    [A_TYPES__ContainerMetaKey.INJECTIONS]: A_Meta<{
+    /**
+     * Injections defined on the component per handler
+     */
+    [A_TYPES__EntityMetaKey.INJECTIONS]: A_Meta<{
         /**
          * Where Key is the name of the injection
          *
@@ -2362,320 +2634,228 @@ type A_TYPES__ContainerMeta = {
         [Key: string]: A_TYPES__A_InjectDecorator_Meta;
     }>;
 };
-type A_TYPES__ContainerMetaExtension = A_TYPES__FeatureExtendDecoratorMeta;
 
-declare class A_Container {
+/**
+ * A_Entity is another abstraction that describes all major participants in the system business logic.
+ * Each Entity should have a clear definition and a clear set of responsibilities.
+ * However, entity may hide some of its responsibilities behind the interface to prevent overload.
+ *
+ * Each entity should be connected to the ContextFragment (Scope) and should be able to communicate with other entities.
+ */
+declare class A_Entity<_ConstructorType extends A_TYPES__Entity_Init = A_TYPES__Entity_Init, _SerializedType extends A_TYPES__Entity_Serialized = A_TYPES__Entity_Serialized> implements A_TYPES__IEntity {
     /**
-     * Configuration of the container that will be used to run it.
+     * Entity Identifier that corresponds to the class name
      */
-    protected readonly config: Partial<A_TYPES__Container_Init>;
+    static get entity(): string;
     /**
-     * Name of the container
+     * DEFAULT Concept Name (Application Name) of the entity from environment variable A_CONCEPT_NAME
+     * [!] If environment variable is not set, it will default to 'a-concept'
      */
-    get name(): string;
+    static get concept(): string;
     /**
-     * Returns the scope where the container is registered
+     * DEFAULT Scope of the entity from environment variable A_CONCEPT_DEFAULT_SCOPE
+     * [!] If environment variable is not set, it will default to 'core'
+     * [!] Scope is an application specific identifier that can be used to group entities together
+     * [!] e.g. 'default', 'core', 'public', 'internal', etc
      */
-    get scope(): A_Scope;
+    static get scope(): string;
     /**
-     * This class should combine Components to achieve the goal withing Concept
+     * ASEID is an entity identifier that is unique across the system
+     * A - A_Concept or Application
+     * S - System or Scope
+     * E - Entity
+     * ID - Identifier
      *
-     * Container is a direct container that should be "run" to make Concept work.
-     * So because of that Container can be:
-     * - HTTP Server
-     * - BASH Script
-     * - Database Connection
-     * - Microservice
-     * - etc.
+     * [!] ASEID is immutable and should not be changed after the entity is created
      *
-     * @param config - Configuration of the container that will be used to run it.
+     * [!] ASEID is composed of the following parts:
+     * - concept: an application specific identifier from where the entity is coming from
+     * - scope: the scope of the entity from concept
+     * - entity: the name of the entity from concept
+     * - id: the unique identifier of the entity
+     *
+     * [!] For more information about ASEID, please refer to the ASEID class documentation]
+     */
+    aseid: ASEID;
+    /**
+     * Create a new A_entity instance from Aseid String
+     * e.g. project@scope:entity:0000000001
+     *
+     * @param aseid
      */
     constructor(
     /**
-     * Configuration of the container that will be used to run it.
+     * ASEID string that represents the entity
      */
-    config?: Partial<A_TYPES__Container_Init>);
+    aseid?: string);
     /**
-     * Calls the feature with the given name in the given scope
+     * Create a new A_entity instance from Aseid instance
+     * e.g. new ASEID({concept: 'project', scope: 'default', entity: 'entity', id: '0000000001'})
      *
-     * [!] Note: This method creates a new instance of the feature every time it is called
+     * @param aseid
+     */
+    constructor(
+    /**
+     * ASEID instance that represents the entity
+     */
+    aseid: ASEID);
+    /**
+     * Create a new A_entity instance from serialized object
      *
-     * @param feature - the name of the feature to call
-     * @param scope  - the scope in which to call the feature
-     * @returns  - void
+     * @param serialized
      */
-    call(
+    constructor(
     /**
-     * Name of the feature to call
+     * Serialized object that represents the entity
      */
-    feature: string, 
+    serialized: _SerializedType);
     /**
-     * scope in which the feature will be executed
+     * Create a new A_entity instance from constructor object
+     *
+     * @param newEntity
      */
-    scope?: A_Scope): Promise<void>;
-}
-
-/**
- * Meta constructor type
- */
-type A_TYPES__Meta_Constructor<T = A_Meta> = new (...args: any[]) => T;
-/**
- * Components that can have Meta associated with them
- */
-type A_TYPES__MetaLinkedComponents = A_Container | A_Component | A_Entity | A_Fragment;
-/**
- * Constructors of components that can have Meta associated with them
- */
-type A_TYPES__MetaLinkedComponentConstructors = new (...args: any[]) => any | A_TYPES__Container_Constructor | A_TYPES__Component_Constructor | A_TYPES__Entity_Constructor | A_TYPES__Fragment_Constructor;
-
-/**
- * A Meta is an entity that stores all the metadata for the specific entity like container, component, feature, etc.
- *
- * [!] Meta can be different depending on the type of input data
- */
-declare class A_Meta<_StorageItems extends Record<any, any> = any, _SerializedType extends Record<string, any> = Record<string, any>> implements Iterable<[keyof _StorageItems, _StorageItems[keyof _StorageItems]]> {
+    constructor(
     /**
-     * Allows to set a custom meta class for the Component or Container or Entity, or anything else.
+     * Constructor object that represents the entity
+     */
+    newEntity?: _ConstructorType);
+    /**
+     * Extracts the ID from the ASEID
+     * ID is the unique identifier of the entity
+     */
+    get id(): string | number;
+    protected isStringASEID(x: unknown): x is string;
+    protected isASEIDInstance(x: unknown): x is ASEID;
+    /**
+     * A "serialized" object is considered such if it is a non-null object
+     * and contains an "aseid" property (this mirrors your original check).
      *
-     * @param target
+     * @param x
      * @returns
      */
-    static Define<T extends A_Meta>(target: A_TYPES__Meta_Constructor<T>): <TTarget extends A_TYPES__MetaLinkedComponentConstructors>(target: TTarget) => TTarget;
-    protected meta: Map<keyof _StorageItems, _StorageItems[keyof _StorageItems]>;
+    protected isSerializedObject(x: unknown): x is _SerializedType;
     /**
-     * Method to get the iterator for the meta object
+     * Constructor-style props = a plain object which does NOT contain "aseid".
+     * This is the "create from provided fields" case.
      *
+     * @param x
      * @returns
      */
-    [Symbol.iterator](): Iterator<[keyof _StorageItems, _StorageItems[keyof _StorageItems]]>;
+    protected isConstructorProps(x: unknown): x is _ConstructorType;
     /**
-     * Allows to replicate received meta object by replacing internal meta to the received one
+     * Determines the appropriate initializer method based on the type of `props`.
+     * The method checks if `props` is:
+     * 1) a string that matches ASEID format -> fromASEID
+     * 2) an ASEID instance -> fromASEID
+     * 3) a serialized object (has 'aseid') -> fromJSON
+     * 4) a plain object with no 'aseid' -> treat as constructor props -> fromNew
+     *
+     * [!] If `props` is undefined, it will call fromUndefined method
+     *
+     * If none of the above, it throws an error indicating incorrect constructor usage.
+     *
+     *
+     * To get a custom initializer, override this method in the child class.
+     * Example:
+     * ```typescript
+     * protected getInitializer(
+     *   props?: string | ASEID | _SerializedType | _ConstructorType
+     * ): (props: any) => void | (() => void) {
+     *   if('customField' in props) {
+     *       return this.fromCustomField.bind(this);
+     *   }
+     *   return super.getInitializer(props);
+     * }
+     * ```
+     * @param props
+     * @returns The appropriate initializer method
+     */
+    protected getInitializer(props?: string | ASEID | _SerializedType | _ConstructorType): (props: any) => void | (() => void);
+    /**
+     * Generates a new ASEID for the entity.
+     * It uses class definitions for concept, scope, and entity,
+     * and allows overriding any of these values.
+     *
+     * @param override
+     * @returns
+     */
+    protected generateASEID(override?: Partial<A_TYPES__ASEID_Constructor>): ASEID;
+    /**
+     * Call a feature of the component with the provided scope
      *
-     * @param meta
-     * @returns
+     * [!] If the provided scope is not inherited from the entity scope, it will be inherited
+     *
+     * @param lifecycleMethod
+     * @param args
      */
-    from(meta: A_Meta<_StorageItems>): A_Meta<_StorageItems>;
+    call(feature: string, scope?: A_Scope): any;
     /**
-     * Method to set values in the map
-     *
-     * @param key
-     * @param value
+     * The default method that can be called and extended to load entity data.
      */
-    set<K extends keyof _StorageItems>(key: K, value: _StorageItems[K]): void;
+    load(scope?: A_Scope): Promise<any>;
     /**
-     * Method to get values from the map
-     *
-     * @param key
-     * @returns
+     * The default method that can be called and extended to destroy entity data.
      */
-    get<K extends keyof _StorageItems>(key: K): _StorageItems[K] | undefined;
+    destroy(scope?: A_Scope): Promise<any>;
     /**
-     * Method to delete values from the map
-     *
-     * @param key
-     * @returns
+     * The default method that can be called and extended to save entity data.
      */
-    delete(key: keyof _StorageItems): boolean;
+    save(scope?: A_Scope): Promise<any>;
     /**
-     * Method to get the size of the map
+     * Create a new entity from ASEID string or instance
+     * [!] Executed when the constructor is called with a string or ASEID instance that represents the ASEID
+     * [!] Executes By Default with new A_Entity('aseid-string') or new A_Entity(new ASEID(...)) if getInitializer has not been overridden
      *
-     * @returns
+     * @param aseid
      */
-    size(): number;
+    fromASEID(aseid: string | ASEID): void;
     /**
-     * This method is needed to convert the key to a regular expression and cover cases like:
-     *
-     * simple * e.g. "a*" instead of "a.*"
-     *
-     * simple ? e.g. "a?" instead of "a."
+     * Handles the case when no props are provided to the constructor.
+     * This method can be overridden in child classes to set default values or perform specific initialization logic.
+     * By default, it does nothing.
      *
-     * etc.
      *
-     * @param key
      * @returns
      */
-    private convertToRegExp;
+    fromUndefined(): void;
     /**
-     * Method to find values in the map by name.
-     *
-     * Converts the Key in Map to a regular expression and then compares to the name
+     * Create a new entity from constructor object
+     * [!] Executed when the constructor is called with an object that does not contain "aseid" property
+     * [!] Executes By Default with new A_Entity({}) if getInitializer has not been overridden
      *
-     * @param name
+     * @param newEntity
      * @returns
      */
-    find(name: string): [keyof _StorageItems, _StorageItems[keyof _StorageItems]][];
+    fromNew(newEntity: _ConstructorType): void;
     /**
-     * Method to find values in the map by regular expression
+     * Creates a new entity from serialized object
      *
-     * Compares Map Key to the input regular expression
+     * [!] Executed when the constructor is called with an object that contains "aseid" property
+     * [!] Executes By Default with new A_Entity({ aseid: '...' }) if getInitializer has not been overridden
      *
-     * @param regex
-     * @returns
-     */
-    findByRegex(regex: RegExp): Array<[keyof _StorageItems, _StorageItems[keyof _StorageItems]]>;
-    /**
-     * Method to check if the map has a specific key
      *
-     * @param key
+     * @param serialized
      * @returns
      */
-    has(key: keyof _StorageItems): boolean;
+    fromJSON(serialized: _SerializedType): void;
     /**
-     * Method to get the size of the map
+     * Converts the entity to a JSON object
+     * [!] This method should be extended in the child classes to include all properties of the entity
+     * [!] Includes aseid by default
+     *
      *
      * @returns
      */
-    entries(): IterableIterator<[keyof _StorageItems, _StorageItems[keyof _StorageItems]]>;
-    /**
-     * Method to clear the map
-     */
-    clear(): void;
-    toArray(): Array<[keyof _StorageItems, _StorageItems[keyof _StorageItems]]>;
-    protected recursiveToJSON(value: any): any;
+    toJSON(): _SerializedType;
     /**
-     * Serializes the meta to a JSON object
-     * Uses internal storage to convert to JSON
+     * Returns the string representation of the entity
+     * what is basically the ASEID string
      *
      * @returns
      */
-    toJSON(): _SerializedType;
-}
-
-declare enum A_TYPES__ComponentMetaKey {
-    EXTENSIONS = "a-component-extensions",
-    FEATURES = "a-component-features",
-    INJECTIONS = "a-component-injections",
-    ABSTRACTIONS = "a-component-abstractions"
+    toString(): string;
 }
 
-/**
- * Component constructor type
- * Uses the generic type T to specify the type of the component
- */
-type A_TYPES__Component_Constructor<T = A_Component> = new (...args: any[]) => T;
-/**
- * Component initialization type
- */
-type A_TYPES__Component_Init = any;
-/**
- * Component serialized type
- */
-type A_TYPES__Component_Serialized = {
-    /**
-     * The ASEID of the component
-     */
-    aseid: string;
-};
-/**
- * Component meta type
- */
-type A_TYPES__ComponentMeta = {
-    /**
-     * Extensions applied to the component per handler
-     */
-    [A_TYPES__ComponentMetaKey.EXTENSIONS]: A_Meta<{
-        /**
-         * Where Key the regexp for what to apply the extension
-         * A set of container names or a wildcard, or a regexp
-         *
-         *
-         * Where value is the extension instructions
-         */
-        [Key: string]: A_TYPES__FeatureExtendDecoratorMeta[];
-    }>;
-    /**
-     * Features defined on the component per handler
-     */
-    [A_TYPES__ComponentMetaKey.FEATURES]: A_Meta<{
-        /**
-         * Where Key is the name of the feature
-         *
-         * Where value is the list of features
-         */
-        [Key: string]: A_TYPES__FeatureDefineDecoratorMeta;
-    }>;
-    /**
-     * Injections defined on the component per handler
-     */
-    [A_TYPES__ComponentMetaKey.INJECTIONS]: A_Meta<{
-        /**
-         * Where Key is the name of the injection
-         *
-         * Where value is the list of injections
-         */
-        [Key: string]: A_TYPES__A_InjectDecorator_Meta;
-    }>;
-    /**
-     *  Abstractions extended by the component per handler
-     */
-    [A_TYPES__ComponentMetaKey.ABSTRACTIONS]: A_Meta<{
-        /**
-         * Where Key is the name of the stage
-         *
-         * Where value is the list of injections
-         */
-        [Key: string]: A_TYPES__ConceptAbstraction[];
-    }>;
-};
-type A_TYPES__ComponentMetaExtension = A_TYPES__FeatureExtendDecoratorMeta;
-
-type A_TYPES__CallerComponent = A_Container | A_Component | A_Entity;
-/**
- * Caller constructor type
- * Uses the generic type T to specify the type of the caller component
- */
-type A_TYPES__Caller_Constructor<T = A_Caller> = new (...args: any[]) => T;
-/**
- * Caller initialization type
- */
-type A_TYPES__Caller_Init = {};
-/**
- * Caller serialized type
- */
-type A_TYPES__Caller_Serialized = {};
-
-/**
- * A-Inject decorator descriptor type
- * Indicates the type of the decorator function
- */
-type A_TYPES__A_InjectDecoratorDescriptor = TypedPropertyDescriptor<(...args: any[]) => Promise<void>>;
-/**
- * A-Inject decorator return type
- * Indicates what the decorator function returns
- */
-type A_TYPES__A_InjectDecoratorReturn<T = any> = (target: T, propertyKey: string | symbol | undefined, parameterIndex: number) => void;
-type A_TYPES__A_InjectDecorator_Meta = Array<{
-    target: A_TYPES__InjectableConstructors;
-    require?: boolean;
-    load?: string;
-    defaultArgs?: any;
-    parent?: {
-        layerOffset?: number;
-    };
-    flat?: boolean;
-    create?: boolean;
-    instructions?: Partial<A_TYPES__A_InjectDecorator_EntityInjectionInstructions>;
-}>;
-/**
- * Targets that can be injected into Extended functions or constructors
- *
- */
-type A_TYPES__InjectableTargets = A_TYPES__Component_Constructor | InstanceType<A_TYPES__Component_Constructor> | InstanceType<A_TYPES__Container_Constructor>;
-type A_TYPES__InjectableConstructors = A_TYPES__Component_Constructor | A_TYPES__Container_Constructor | A_TYPES__Entity_Constructor | A_TYPES__Feature_Constructor | A_TYPES__Caller_Constructor | A_TYPES__Fragment_Constructor | A_TYPES__Error_Constructor | string;
-type A_TYPES__A_InjectDecorator_EntityInjectionInstructions<T extends A_Entity = A_Entity> = {
-    query: Partial<A_TYPES__A_InjectDecorator_EntityInjectionQuery<T>>;
-    pagination: Partial<A_TYPES__A_InjectDecorator_EntityInjectionPagination>;
-};
-type A_TYPES__A_InjectDecorator_EntityInjectionQuery<T extends A_Entity = A_Entity> = {
-    aseid: string;
-} & {
-    [key in keyof T]?: any;
-};
-type A_TYPES__A_InjectDecorator_EntityInjectionPagination = {
-    count: number;
-    from: 'start' | 'end';
-};
-
 declare class A_Scope<_MetaItems extends Record<string, any> = any, _ComponentType extends A_TYPES__Component_Constructor[] = A_TYPES__Component_Constructor[], _ErrorType extends A_TYPES__Error_Constructor[] = A_TYPES__Error_Constructor[], _EntityType extends A_TYPES__Entity_Constructor[] = A_TYPES__Entity_Constructor[], _FragmentType extends A_Fragment[] = A_Fragment[]> {
     /**
      * Scope Name uses for identification and logging purposes
@@ -2724,6 +2904,10 @@ declare class A_Scope<_MetaItems extends Record<string, any> = any, _ComponentTy
      * Storage for the fragments, should be weak as fragments are singletons per scope
      */
     protected _fragments: Map<A_TYPES__Fragment_Constructor<_FragmentType[number]>, _FragmentType[number]>;
+    /**
+     * Storage for imported scopes
+     */
+    protected _imports: Set<A_Scope>;
     /**
      * Returns the name of the scope
      */
@@ -2772,6 +2956,11 @@ declare class A_Scope<_MetaItems extends Record<string, any> = any, _ComponentTy
      * [!] One error per code
      */
     get errors(): Array<InstanceType<_ErrorType[number]>>;
+    /**
+     * Returns an Array of imported scopes
+     * [!] Imported scopes are scopes that have been imported into the current scope using the import() method
+     */
+    get imports(): Array<A_Scope>;
     /**
      * Returns the parent scope of the current scope
      *
@@ -2817,16 +3006,16 @@ declare class A_Scope<_MetaItems extends Record<string, any> = any, _ComponentTy
      * @param level
      * @returns
      */
-    parentOffset(
+    parentOffset<T extends A_Scope>(
     /**
      * Level of the parent scope to retrieve
      *
      * Examples:
-     * - level 0 - immediate parent
-     * - level -1 - grandparent
-     * - level -2 - great-grandparent
+     * - level 0 - this scope
+     * - level -1 - parent
+     * - level -2 - grandparent
      */
-    layerOffset: number): A_Scope | undefined;
+    layerOffset: number): T | undefined;
     /**
      * Determines which initializer method to use based on the type of the first parameter.
      *
@@ -2935,6 +3124,24 @@ declare class A_Scope<_MetaItems extends Record<string, any> = any, _ComponentTy
      * @returns
      */
     inherit(parent: A_Scope): A_Scope;
+    /**
+     * This method allows to import other scopes, to make their dependencies available in the current scope
+     *
+     * [!] Import doesn't create a parent-child relationship between scopes, it just copies the dependencies from the imported scopes
+     * [!] It doesn't change the entities ownership, so entities remain unique to their original scopes
+     *
+     * @param scopes
+     * @returns
+     */
+    import(...scopes: A_Scope[]): A_Scope;
+    /**
+     * This method allows to deimport other scopes, to remove their dependencies from the current scope
+     *
+     *
+     * @param scopes
+     * @returns
+     */
+    deimport(...scopes: A_Scope[]): A_Scope;
     /**
      * This method is used to check if the component is available in the scope
      *
@@ -2970,6 +3177,7 @@ declare class A_Scope<_MetaItems extends Record<string, any> = any, _ComponentTy
      * Provide a string to check if a component, entity or fragment with the provided name is available in the scope
      */
     constructor: string): boolean;
+    has<T extends A_TYPES__A_DependencyInjectable>(ctor: A_TYPES__Ctor<T> | string): boolean;
     /**
      * This method is used to check if the component is available in the scope
      *
@@ -3006,16 +3214,12 @@ declare class A_Scope<_MetaItems extends Record<string, any> = any, _ComponentTy
      */
     constructor: string): boolean;
     /**
-     * Merges two scopes into a new one
-     *
-     * [!] Notes:
-     *  - this method does NOT modify the existing scopes
-     *  - parent of the new scope will be the parent of the current scope or the parent of anotherScope (if exists)
+     * Allows to resolve a specific dependency
      *
-     * @param anotherScope
+     * @param dependency
      * @returns
      */
-    merge(anotherScope: A_Scope): A_Scope;
+    resolveDependency<T extends A_TYPES__A_DependencyInjectable>(dependency: A_Dependency<T>): T | Array<T> | undefined;
     /**
      * Allows to retrieve the constructor of the component or entity by its name
      *
@@ -3041,6 +3245,7 @@ declare class A_Scope<_MetaItems extends Record<string, any> = any, _ComponentTy
      * Provide the fragment name in PascalCase to retrieve its constructor
      */
     name: string): A_TYPES__Fragment_Constructor<T>;
+    resolveConstructor<T extends A_TYPES__A_DependencyInjectable>(name: string): A_TYPES__Entity_Constructor<T> | A_TYPES__Component_Constructor<T> | A_TYPES__Fragment_Constructor<T> | undefined;
     /**
      * This method should resolve all instances of the components, or entities within the scope, by provided parent class
      * So in case of providing a base class it should return all instances that extends this base class
@@ -3064,7 +3269,16 @@ declare class A_Scope<_MetaItems extends Record<string, any> = any, _ComponentTy
      * Provide an entity constructor to resolve its instance or an array of instances from the scope
      */
     entity: A_TYPES__Entity_Constructor<T>): Array<T>;
-    resolveAll<T extends A_TYPES__ScopeResolvableComponents>(constructorName: string): Array<T>;
+    resolveAll<T extends A_TYPES__A_DependencyInjectable>(
+    /**
+     * Provide a component, fragment or entity constructor to resolve its instance(s) from the scope
+     */
+    constructorName: string): Array<T>;
+    resolveAll<T extends A_TYPES__A_DependencyInjectable>(
+    /**
+     * Provide a component, fragment or entity constructor or an array of constructors to resolve its instance(s) from the scope
+     */
+    ctor: A_TYPES__Ctor<A_TYPES__A_DependencyInjectable> | string): Array<T>;
     /**
      * This method should resolve all instances of the components, or entities within the scope, by provided parent class
      * So in case of providing a base class it should return all instances that extends this base class
@@ -3073,22 +3287,58 @@ declare class A_Scope<_MetaItems extends Record<string, any> = any, _ComponentTy
      *
      * @param component
      */
-    resolveFlatAll<T extends A_Component>(
+    resolveFlatAll<T extends A_Component>(
+    /**
+     * Provide a component constructor to resolve its instance from the scope
+     */
+    component: A_TYPES__Component_Constructor<T>): Array<T>;
+    resolveFlatAll<T extends A_Fragment>(
+    /**
+     * Provide a fragment constructor to resolve its instance from the scope
+     */
+    fragment: A_TYPES__Fragment_Constructor<T>): Array<T>;
+    resolveFlatAll<T extends A_Entity>(
+    /**
+     * Provide an entity constructor to resolve its instance or an array of instances from the scope
+     */
+    entity: A_TYPES__Entity_Constructor<T>): Array<T>;
+    resolveFlatAll<T extends A_TYPES__A_DependencyInjectable>(
+    /**
+     * Provide a component, fragment or entity constructor to resolve its instance(s) from the scope
+     */
+    constructorName: string): Array<T>;
+    resolveFlatAll<T extends A_TYPES__A_DependencyInjectable>(
+    /**
+     * Provide a component, fragment or entity constructor or an array of constructors to resolve its instance(s) from the scope
+     */
+    ctor: A_TYPES__Ctor<A_TYPES__A_DependencyInjectable> | string): Array<T>;
+    /**
+     * This method allows to resolve/inject a component, fragment or entity from the scope
+     * Depending on the provided parameters it can resolve:
+     * - A single component/fragment/entity by its constructor or name
+     * - An array of components/fragments/entities by providing an array of constructors
+     * - An entity or an array of entities by providing the entity constructor and query instructions
+     *
+     * @param component
+     * @returns
+     */
+    resolve<T extends A_TYPES__A_DependencyInjectable>(
     /**
      * Provide a component constructor to resolve its instance from the scope
      */
-    component: A_TYPES__Component_Constructor<T>): Array<T>;
-    resolveFlatAll<T extends A_Fragment>(
+    component: A_TYPES__Ctor<T>): T | undefined;
+    resolve<T extends A_TYPES__A_DependencyInjectable>(
     /**
-     * Provide a fragment constructor to resolve its instance from the scope
+     * Provide a target dependency to resolve its instance from the scope
+     *
+     * [!] In this case its possible to provide a custom resolution strategy via A_Dependency options
      */
-    fragment: A_TYPES__Fragment_Constructor<T>): Array<T>;
-    resolveFlatAll<T extends A_Entity>(
+    dependency: A_Dependency<T>): T | Array<T> | undefined;
+    resolve<T extends A_TYPES__A_DependencyInjectable>(
     /**
-     * Provide an entity constructor to resolve its instance or an array of instances from the scope
+     * Provide a component constructor to resolve its instance from the scope
      */
-    entity: A_TYPES__Entity_Constructor<T>): Array<T>;
-    resolveFlatAll<T extends A_TYPES__ScopeResolvableComponents>(constructorName: string): Array<T>;
+    component: string): T | Array<T> | undefined;
     /**
      * This method allows to resolve/inject a component, fragment or entity from the scope
      * Depending on the provided parameters it can resolve:
@@ -3099,78 +3349,45 @@ declare class A_Scope<_MetaItems extends Record<string, any> = any, _ComponentTy
      * @param component
      * @returns
      */
-    resolve<T extends A_Component>(
+    resolveOnce<T extends A_Component>(
     /**
      * Provide a component constructor to resolve its instance from the scope
      */
     component: A_TYPES__Component_Constructor<T>): T | undefined;
-    resolve<T extends A_TYPES__Component_Constructor[]>(
-    /**
-     * Provide an array of component constructors to resolve their instances from the scope
-     */
-    components: [...T]): Array<InstanceType<T[number]>> | undefined;
-    resolve<T extends A_Fragment>(
+    resolveOnce<T extends A_Fragment>(
     /**
      * Provide a fragment constructor to resolve its instance from the scope
      */
     fragment: A_TYPES__Fragment_Constructor<T>): T | undefined;
-    resolve<T extends A_TYPES__Fragment_Constructor[]>(
-    /**
-     * Provide an array of fragment constructors to resolve their instances from the scope
-     */
-    fragments: [...T]): Array<InstanceType<T[number]>> | undefined;
-    resolve<T extends A_Entity>(
+    resolveOnce<T extends A_Entity>(
     /**
      * Provide an entity constructor to resolve its instance or an array of instances from the scope
      */
     entity: A_TYPES__Entity_Constructor<T>): T | undefined;
-    resolve<T extends A_Entity>(
-    /**
-     * Provide an entity constructor to resolve its instance or an array of instances from the scope
-     */
-    entity: A_TYPES__Entity_Constructor<T>, 
-    /**
-     * Only Aseid Provided, in this case one entity will be returned
-     */
-    instructions: {
-        query: {
-            aseid: string | ASEID;
-        };
-    }): T | undefined;
-    resolve<T extends A_Entity>(
-    /**
-     * Provide an entity constructor to resolve its instance or an array of instances from the scope
-     */
-    entity: A_TYPES__Entity_Constructor<T>, 
-    /**
-     * Provide optional instructions to find a specific entity or a set of entities
-     */
-    instructions: Partial<A_TYPES__A_InjectDecorator_EntityInjectionInstructions<T>>): Array<T>;
-    resolve<T extends A_Scope>(
+    resolveOnce<T extends A_Scope>(
     /**
      * Uses only in case of resolving a single entity
      *
      * Provide an entity constructor to resolve its instance from the scope
      */
     scope: A_TYPES__Scope_Constructor<T>): T | undefined;
-    resolve<T extends A_Error>(
+    resolveOnce<T extends A_Error>(
     /**
      * Uses only in case of resolving a single entity
      *
      * Provide an entity constructor to resolve its instance from the scope
      */
-    scope: A_TYPES__Error_Constructor<T>): T | undefined;
-    resolve<T extends A_TYPES__ScopeResolvableComponents>(constructorName: string): T | undefined;
-    resolve<T extends A_TYPES__ScopeResolvableComponents>(
+    error: A_TYPES__Error_Constructor<T>): T | undefined;
+    resolveOnce<T extends A_TYPES__A_DependencyInjectable>(
     /**
-     * Provide a component, fragment or entity constructor or an array of constructors to resolve its instance(s) from the scope
+     * Provide a component, fragment or entity constructor to resolve its instance(s) from the scope
      */
-    param1: A_TYPES__InjectableConstructors): T | Array<T> | undefined;
-    resolve<T extends A_TYPES__ScopeLinkedConstructors>(
+    constructorName: string): T | undefined;
+    resolveOnce<T extends A_TYPES__A_DependencyInjectable>(
     /**
      * Provide a component, fragment or entity constructor or an array of constructors to resolve its instance(s) from the scope
      */
-    param1: InstanceType<T>): T | Array<T> | undefined;
+    ctor: A_TYPES__Ctor<A_TYPES__A_DependencyInjectable> | string): T | undefined;
     /**
      * This polymorphic method allows to resolve/inject a component, fragment or entity from the scope
      * Depending on the provided parameters it can resolve:
@@ -3187,48 +3404,16 @@ declare class A_Scope<_MetaItems extends Record<string, any> = any, _ComponentTy
      * Provide a component constructor to resolve its instance from the scope
      */
     component: A_TYPES__Component_Constructor<T>): T | undefined;
-    resolveFlat<T extends A_TYPES__Component_Constructor[]>(
-    /**
-     * Provide an array of component constructors to resolve their instances from the scope
-     */
-    components: [...T]): Array<InstanceType<T[number]>> | undefined;
     resolveFlat<T extends A_Fragment>(
     /**
      * Provide a fragment constructor to resolve its instance from the scope
      */
     fragment: A_TYPES__Fragment_Constructor<T>): T | undefined;
-    resolveFlat<T extends A_TYPES__Fragment_Constructor[]>(
-    /**
-     * Provide an array of fragment constructors to resolve their instances from the scope
-     */
-    fragments: [...T]): Array<InstanceType<T[number]>> | undefined;
     resolveFlat<T extends A_Entity>(
     /**
      * Provide an entity constructor to resolve its instance or an array of instances from the scope
      */
     entity: A_TYPES__Entity_Constructor<T>): T | undefined;
-    resolveFlat<T extends A_Entity>(
-    /**
-     * Provide an entity constructor to resolve its instance or an array of instances from the scope
-     */
-    entity: A_TYPES__Entity_Constructor<T>, 
-    /**
-     * Only Aseid Provided, in this case one entity will be returned
-     */
-    instructions: {
-        query: {
-            aseid: string | ASEID;
-        };
-    }): T | undefined;
-    resolveFlat<T extends A_Entity>(
-    /**
-     * Provide an entity constructor to resolve its instance or an array of instances from the scope
-     */
-    entity: A_TYPES__Entity_Constructor<T>, 
-    /**
-     * Provide optional instructions to find a specific entity or a set of entities
-     */
-    instructions: Partial<A_TYPES__A_InjectDecorator_EntityInjectionInstructions<T>>): Array<T>;
     resolveFlat<T extends A_Scope>(
     /**
      * Uses only in case of resolving a single entity
@@ -3242,43 +3427,34 @@ declare class A_Scope<_MetaItems extends Record<string, any> = any, _ComponentTy
      *
      * Provide an entity constructor to resolve its instance from the scope
      */
-    scope: A_TYPES__Error_Constructor<T>): T | undefined;
-    resolveFlat<T extends A_TYPES__ScopeResolvableComponents>(constructorName: string): T | undefined;
-    resolveFlat<T extends A_TYPES__ScopeResolvableComponents>(
+    error: A_TYPES__Error_Constructor<T>): T | undefined;
+    resolveFlat<T extends A_TYPES__A_DependencyInjectable>(
     /**
-     * Provide a component, fragment or entity constructor or an array of constructors to resolve its instance(s) from the scope
+     * Provide a component, fragment or entity constructor to resolve its instance(s) from the scope
      */
-    param1: A_TYPES__InjectableConstructors): T | Array<T> | undefined;
-    resolveFlat<T extends A_TYPES__ScopeLinkedConstructors>(
+    constructorName: string): T | undefined;
+    resolveFlat<T extends A_TYPES__A_DependencyInjectable>(
     /**
      * Provide a component, fragment or entity constructor or an array of constructors to resolve its instance(s) from the scope
      */
-    param1: InstanceType<T>): T | Array<T> | undefined;
-    /**
-     * This method is used internally to resolve a component, fragment or entity by its constructor name
-     *
-     * [!] Note that this method checks for the component, fragment or entity in the current scope and all parent scopes
-     * [!!] Note: No parent scopes are checked
-     *
-     * @param name  - name of the component, fragment or entity to resolve (constructor name for components and fragments, static entity property for entities, static code property for commands)
-     * @returns
-     */
-    private resolveByName;
+    ctor: A_TYPES__Ctor<A_TYPES__A_DependencyInjectable>): T | undefined;
     /**
      * Resolves a component, fragment or entity from the scope without checking parent scopes
      *
      * @param component
      * @param instructions
      */
-    private resolveFlatOnce;
+    resolveFlatOnce<T extends A_TYPES__A_DependencyInjectable>(component: A_TYPES__Ctor<A_TYPES__A_DependencyInjectable> | string): T | undefined;
     /**
-     * This method is used internally to resolve a single component, fragment or entity from the scope
+     * This method is used internally to resolve a component, fragment or entity by its constructor name
      *
-     * @param component
-     * @param instructions
+     * [!] Note that this method checks for the component, fragment or entity in the current scope and all parent scopes
+     * [!!] Note: No parent scopes are checked
+     *
+     * @param name  - name of the component, fragment or entity to resolve (constructor name for components and fragments, static entity property for entities, static code property for commands)
      * @returns
      */
-    private resolveOnce;
+    private resolveByName;
     /**
      * Resolves the issuer of the scope by provided constructor
      *
@@ -3381,6 +3557,11 @@ declare class A_Scope<_MetaItems extends Record<string, any> = any, _ComponentTy
      * Provide an entity instance to register it in the scope
      */
     entity: T): void;
+    register<T extends A_TYPES__A_DependencyInjectable>(
+    /**
+     * Provide an entity instance to register it in the scope
+     */
+    entity: T): void;
     /**
      * This method is used to deregister the component from the scope
      *
@@ -3522,7 +3703,7 @@ declare class A_Component {
  * Scope constructor type
  * Uses the generic type T to specify the type of the Scope
  */
-type A_TYPES__Scope_Constructor<T = A_Scope> = new (...args: any[]) => T;
+type A_TYPES__Scope_Constructor<T = A_Scope> = A_TYPES__Ctor<T>;
 /**
  * Scope initialization type
  */
@@ -3567,17 +3748,13 @@ type A_TYPES__ScopeConfig = {
  */
 type A_TYPES__Scope_Serialized = {};
 /**
- *
+ * A list of constructors that can have a scope associated with them
  */
 type A_TYPES__ScopeLinkedConstructors = A_TYPES__Container_Constructor | A_TYPES__Feature_Constructor;
 /**
  * A list of components that can have a scope associated with them
  */
 type A_TYPES__ScopeLinkedComponents = A_Container | A_Feature;
-/**
- * A list of components that can be resolved by a scope
- */
-type A_TYPES__ScopeResolvableComponents = A_Component | A_Fragment | A_Entity | A_Error | A_Scope;
 /**
  * A list of components that are dependent on a scope and do not have their own scope
  */
@@ -3870,12 +4047,12 @@ declare class A_Context {
     /**
      * Get meta for the specific class or instance
      */
-    constructor: new (...args: any[]) => any): T;
+    constructor: A_TYPES__Ctor<any>): T;
     static meta<T extends Record<string, any>>(
     /**
      * Get meta for the specific class or instance
      */
-    constructor: new (...args: any[]) => any): A_Meta<T>;
+    constructor: A_TYPES__Ctor<any>): A_Meta<T>;
     /**
      * Allows to set meta for the specific class or instance.
      *
@@ -4109,6 +4286,21 @@ declare class A_CallerError extends A_Error {
     static readonly CallerInitializationError = "Unable to initialize A-Caller";
 }
 
+type A_TYPES__CallerComponent = A_Container | A_Component | A_Entity;
+/**
+ * Caller constructor type
+ * Uses the generic type T to specify the type of the caller component
+ */
+type A_TYPES__Caller_Constructor<T = A_Caller> = A_TYPES__Ctor<T>;
+/**
+ * Caller initialization type
+ */
+type A_TYPES__Caller_Init = {};
+/**
+ * Caller serialized type
+ */
+type A_TYPES__Caller_Serialized = {};
+
 declare const A_CONSTANTS__ERROR_CODES: {
     readonly UNEXPECTED_ERROR: "A-Error Unexpected Error";
     readonly VALIDATION_ERROR: "A-Error Validation Error";
@@ -4126,6 +4318,7 @@ declare class A_ScopeError extends A_Error {
     static readonly ResolutionError = "A-Scope Resolution Error";
     static readonly RegistrationError = "A-Scope Registration Error";
     static readonly CircularInheritanceError = "A-Scope Circular Inheritance Error";
+    static readonly CircularImportError = "A-Scope Circular Import Error";
     static readonly DeregistrationError = "A-Scope Deregistration Error";
 }
 
@@ -4136,119 +4329,14 @@ declare class A_ScopeError extends A_Error {
  *
  * @returns
  */
-declare function A_MetaDecorator<T extends A_Meta>(constructor: new (...args: any[]) => T): <TTarget extends A_TYPES__MetaLinkedComponentConstructors>(target: TTarget) => TTarget;
-
-/**
- * A-Dependency require decorator return type
- */
-type A_TYPES__A_Dependency_RequireDecoratorReturn<T = any> = (target: T, propertyKey: string | symbol | undefined, parameterIndex: number) => void;
-/**
- * A-Dependency load decorator return type
- */
-type A_TYPES__A_Dependency_LoadDecoratorReturn<T = any> = (target: T, propertyKey: string | symbol | undefined, parameterIndex: number) => void;
-/**
- * A-Dependency default decorator return type
- */
-type A_TYPES__A_Dependency_DefaultDecoratorReturn<T = any> = (target: T, propertyKey: string | symbol | undefined, parameterIndex: number) => void;
-type A_TYPES__A_Dependency_ParentDecoratorReturn<T = any> = (target: T, propertyKey: string | symbol | undefined, parameterIndex: number) => void;
-type A_TYPES__A_Dependency_FlatDecoratorReturn<T = any> = (target: T, propertyKey: string | symbol | undefined, parameterIndex: number) => void;
-
-/**
- * Should indicate which Default is required
- */
-declare function A_Dependency_Default(
-/**
- * Constructor Parameters that will be used to create the default instance
- */
-...args: any[]): A_TYPES__A_Dependency_DefaultDecoratorReturn;
-
-/**
- * Should indicate which dependency is required
- */
-declare function A_Dependency_Flat(): A_TYPES__A_Dependency_FlatDecoratorReturn;
-
-/**
- * Should indicate which Load is required
- */
-declare function A_Dependency_Load(
-/**
- * Path to load the dependency from
- */
-path: string): A_TYPES__A_Dependency_LoadDecoratorReturn;
-
-/**
- * Should indicate which dependency is required
- */
-declare function A_Dependency_Parent(
-/**
- * Indicates how many layers up the parent dependency should be resolved from current dependency
- *
- * Default: -1 (one layer up)
- */
-layerOffset?: number): A_TYPES__A_Dependency_ParentDecoratorReturn;
-
-/**
- * Should indicate which dependency is required
- */
-declare function A_Dependency_Require(): A_TYPES__A_Dependency_RequireDecoratorReturn;
-
-declare class A_Dependency {
-    /**
-     * Allows to indicate which Injected parameter is required
-     *
-     * [!] If parameter marked as required is not provided, an error will be thrown
-     *
-     * @returns
-     */
-    static get Required(): typeof A_Dependency_Require;
-    /**
-     * Allows to indicate which dependency should be loaded from a specific path
-     *
-     * @returns
-     */
-    static get Loaded(): typeof A_Dependency_Load;
-    /**
-     * Allows to indicate which dependency default parameters should be used
-     *
-     * @returns
-     */
-    static get Default(): typeof A_Dependency_Default;
-    /**
-     * Allows to indicate which parent dependency should be resolved
-     * e.g. from which layer up the parent should be taken
-     *
-     * @returns
-     */
-    static get Parent(): typeof A_Dependency_Parent;
-    /**
-     * Allows to indicate that the dependency should be resolved in a flat manner
-     * Only in the same scope, without going up to parent scopes
-     *
-     * @returns
-     */
-    static get Flat(): typeof A_Dependency_Flat;
-    protected _name: string;
-    /**
-     * Class instances allows to indentify dependencies by name and use them for better type checking
-     *
-     * @param name
-     */
-    constructor(name: string);
-    /**
-     * Gets the dependency name
-     *
-     * Can be identifier, url or any string value
-     *
-     * @returns
-     */
-    get name(): string;
-}
+declare function A_MetaDecorator<T extends A_Meta>(constructor: A_TYPES__Ctor<T>): <TTarget extends A_TYPES__MetaLinkedComponentConstructors>(target: TTarget) => TTarget;
 
 declare class A_DependencyError extends A_Error {
     static readonly InvalidDependencyTarget = "Invalid Dependency Target";
     static readonly InvalidLoadTarget = "Invalid Load Target";
     static readonly InvalidLoadPath = "Invalid Load Path";
     static readonly InvalidDefaultTarget = "Invalid Default Target";
+    static readonly ResolutionParametersError = "Dependency Resolution Parameters Error";
 }
 
 declare class A_InjectError extends A_Error {
@@ -4267,48 +4355,32 @@ declare class A_InjectError extends A_Error {
  * @param params - see overloads
  * @returns - decorator function
  */
-declare function A_Inject<T extends A_Scope>(
-/***
- * Provide the Scope constructor that will be associated with the injection.
- *
- * [!] It returns an instance of the Scope where the Entity/Component/Container is defined.
- */
-scope: A_TYPES__Scope_Constructor<T>): A_TYPES__A_InjectDecoratorReturn;
-declare function A_Inject<T extends A_Error>(
-/***
- * Provide the Error constructor that will be associated with the injection.
- *
- * [!] It returns an Instance of the Error what is executed.
- */
-error: A_TYPES__Error_Constructor<T>): A_TYPES__A_InjectDecoratorReturn;
-declare function A_Inject<T extends A_Feature>(
-/**
- * Provide the Feature constructor that will be associated with the injection.
- *
- * [!] It returns an Instance of the Feature what is executed.
- */
-feature: A_TYPES__Feature_Constructor<T>): A_TYPES__A_InjectDecoratorReturn;
 declare function A_Inject<T extends A_Component>(
 /**
  * Provide the Component constructor that will be associated with the injection.
  *
  * [!] It returns an Instance of the Component from current Scope or from Parent Scopes.
  */
-component: A_TYPES__Component_Constructor<T>): A_TYPES__A_InjectDecoratorReturn;
-declare function A_Inject(
+component: A_TYPES__Component_Constructor<T>, 
 /**
- * Provide the A_Caller constructor to inject the Caller instance
+ * Provide additional instructions on how to perform the injection
  *
- * [!] It returns initiator of the call, e.g. Container/Component/Command who called Feature
+ * [!] Default Pagination is 1 if it's necessary to get multiple Fragments please customize it in the instructions
  */
-caller: typeof A_Caller): A_TYPES__A_InjectDecoratorReturn;
+config?: Omit<Partial<A_TYPES__A_DependencyResolutionStrategy<T>>, 'query' | 'pagination'>): A_TYPES__A_InjectDecoratorReturn;
 declare function A_Inject<T extends A_Fragment>(
 /**
  * Provide the Fragment constructor to inject the Fragment instance
  *
  * [!] It returns the Fragment instance from current Scope or from Parent Scopes.
  */
-fragment: A_TYPES__Fragment_Constructor<T>): A_TYPES__A_InjectDecoratorReturn;
+fragment: A_TYPES__Fragment_Constructor<T>, 
+/**
+ * Provide additional instructions on how to perform the injection
+ *
+ * [!] Default Pagination is 1 if it's necessary to get multiple Fragments please customize it in the instructions
+ */
+config?: Omit<Partial<A_TYPES__A_DependencyResolutionStrategy<T>>, 'query' | 'pagination'>): A_TYPES__A_InjectDecoratorReturn;
 declare function A_Inject<T extends A_Entity>(
 /**
  * Provide the Entity constructor to inject the Entity instance
@@ -4323,7 +4395,7 @@ entity: A_TYPES__Entity_Constructor<T>,
  *
  * [!] Default Pagination is 1 if it's necessary to get multiple Entities please customize it in the instructions
  */
-config?: Partial<A_TYPES__A_InjectDecorator_EntityInjectionInstructions<T>>): A_TYPES__A_InjectDecoratorReturn<T>;
+config?: Partial<A_TYPES__A_DependencyResolutionStrategy<T>>): A_TYPES__A_InjectDecoratorReturn<T>;
 declare function A_Inject<T extends A_Component>(
 /**
  * Provide the name of Component constructor to inject the Component instance
@@ -4331,6 +4403,47 @@ declare function A_Inject<T extends A_Component>(
  * [!] You can use both customized one or original depending on your overriding strategy
  */
 ctor: string): A_TYPES__A_InjectDecoratorReturn;
+declare function A_Inject<T extends A_Caller>(
+/**
+ * Provide the A_Caller constructor to inject the Caller instance
+ *
+ * [!] It returns initiator of the call, e.g. Container/Component/Command who called Feature
+ */
+caller: A_TYPES__Caller_Constructor<T>): A_TYPES__A_InjectDecoratorReturn;
+declare function A_Inject<T extends A_Error>(
+/***
+ * Provide the Error constructor that will be associated with the injection.
+ *
+ * [!] It returns an Instance of the Error what is executed.
+ */
+error: A_TYPES__Error_Constructor<T>, 
+/**
+ * Provide additional instructions on how to perform the injection
+ *
+ * [!] Default Pagination is 1 if it's necessary to get multiple Fragments please customize it in the instructions
+ */
+config?: Omit<Partial<A_TYPES__A_DependencyResolutionStrategy<T>>, 'query' | 'pagination'>): A_TYPES__A_InjectDecoratorReturn;
+declare function A_Inject<T extends A_Feature>(
+/**
+ * Provide the Feature constructor that will be associated with the injection.
+ *
+ * [!] It returns an Instance of the Feature what is executed.
+ */
+feature: A_TYPES__Feature_Constructor<T>): A_TYPES__A_InjectDecoratorReturn;
+declare function A_Inject<T extends A_Scope>(
+/***
+ * Provide the Scope constructor that will be associated with the injection.
+ *
+ * [!] It returns an instance of the Scope where the Entity/Component/Container is defined.
+ */
+scope: A_TYPES__Scope_Constructor<T>): A_TYPES__A_InjectDecoratorReturn;
+declare function A_Inject<T extends A_TYPES__A_DependencyInjectable>(
+/***
+ * Provide the Scope constructor that will be associated with the injection.
+ *
+ * [!] It returns an instance of the Scope where the Entity/Component/Container is defined.
+ */
+dependency: A_Dependency<T>): A_TYPES__A_InjectDecoratorReturn;
 
 declare class A_CommonHelper {
     /**
@@ -4574,6 +4687,20 @@ declare class A_TypeGuards {
      * @returns
      */
     static isCallerConstructor(ctor: any): ctor is A_TYPES__Caller_Constructor;
+    /**
+     * Type guard to check if the constructor is of type A_Dependency
+     *
+     * @param ctor
+     * @returns
+     */
+    static isDependencyConstructor<T extends A_TYPES__A_DependencyInjectable>(ctor: any): ctor is A_Dependency<T>;
+    /**
+     * Type guard to check if the instance is of type A_Dependency
+     *
+     * @param instance
+     * @returns
+     */
+    static isDependencyInstance<T extends A_TYPES__A_DependencyInjectable>(instance: any): instance is A_Dependency<T>;
     /**
      * Type guard to check if the instance is of type A_Container
      *
@@ -4644,6 +4771,7 @@ declare class A_TypeGuards {
      * @returns
      */
     static isEntityMetaInstance(instance: any): instance is A_EntityMeta;
+    static hasASEID(value: any): value is A_Entity | A_Error;
     static isConstructorAllowedForScopeAllocation(target: any): target is A_TYPES__ScopeLinkedConstructors;
     static isInstanceAllowedForScopeAllocation(target: any): target is A_TYPES__ScopeLinkedComponents;
     static isConstructorAvailableForAbstraction(target: any): target is A_TYPES__AbstractionAvailableComponents;
@@ -4652,7 +4780,7 @@ declare class A_TypeGuards {
     static isAllowedForFeatureDefinition(param: any): param is A_TYPES__FeatureAvailableComponents;
     static isAllowedForFeatureExtension(param: any): param is A_TYPES__FeatureExtendDecoratorTarget;
     static isAllowedForAbstractionDefinition(param: any): param is A_TYPES__AbstractionAvailableComponents;
-    static isAllowedForDependencyDefaultCreation(param: any): param is A_TYPES__Entity_Constructor | A_TYPES__Component_Constructor;
+    static isAllowedForDependencyDefaultCreation(param: any): param is A_TYPES__Entity_Constructor | A_TYPES__Fragment_Constructor;
     /**
      * Allows to check if the provided param is of constructor type.
      *
@@ -4663,4 +4791,4 @@ declare class A_TypeGuards {
     static isErrorSerializedType<T extends A_TYPES__Error_Serialized>(param: any): param is T;
 }
 
-export { ASEID, ASEID_Error, A_Abstraction, A_AbstractionError, A_Abstraction_Extend, A_CONSTANTS__DEFAULT_ENV_VARIABLES, A_CONSTANTS__DEFAULT_ENV_VARIABLES_ARRAY, A_CONSTANTS__ERROR_CODES, A_CONSTANTS__ERROR_DESCRIPTION, A_Caller, A_CallerError, A_CommonHelper, A_Component, A_ComponentMeta, A_Concept, A_ConceptMeta, A_Container, A_ContainerMeta, A_Context, A_ContextError, A_Dependency, A_DependencyError, A_Dependency_Default, A_Dependency_Load, A_Dependency_Require, A_Entity, A_EntityError, A_EntityMeta, A_Error, A_Feature, A_FeatureError, A_Feature_Define, A_Feature_Extend, A_FormatterHelper, A_Fragment, type A_ID_TYPES__TimeId_Parts, A_IdentityHelper, A_Inject, A_InjectError, A_Meta, A_MetaDecorator, A_Scope, A_ScopeError, A_Stage, A_StageError, A_StepManagerError, A_StepsManager, type A_TYPES_ScopeDependentComponents, type A_TYPES_ScopeIndependentComponents, type A_TYPES_StageExecutionBehavior, type A_TYPES__ASEID_Constructor, type A_TYPES__ASEID_ConstructorConfig, type A_TYPES__ASEID_JSON, type A_TYPES__A_Dependency_DefaultDecoratorReturn, type A_TYPES__A_Dependency_FlatDecoratorReturn, type A_TYPES__A_Dependency_LoadDecoratorReturn, type A_TYPES__A_Dependency_ParentDecoratorReturn, type A_TYPES__A_Dependency_RequireDecoratorReturn, type A_TYPES__A_InjectDecoratorDescriptor, type A_TYPES__A_InjectDecoratorReturn, type A_TYPES__A_InjectDecorator_EntityInjectionInstructions, type A_TYPES__A_InjectDecorator_EntityInjectionPagination, type A_TYPES__A_InjectDecorator_EntityInjectionQuery, type A_TYPES__A_InjectDecorator_Meta, type A_TYPES__A_StageStep, type A_TYPES__A_StageStepProcessingExtraParams, A_TYPES__A_Stage_Status, type A_TYPES__AbstractionAvailableComponents, type A_TYPES__AbstractionDecoratorConfig, type A_TYPES__AbstractionDecoratorDescriptor, type A_TYPES__Abstraction_Constructor, type A_TYPES__Abstraction_Init, type A_TYPES__Abstraction_Serialized, type A_TYPES__CallerComponent, type A_TYPES__Caller_Constructor, type A_TYPES__Caller_Init, type A_TYPES__Caller_Serialized, type A_TYPES__ComponentMeta, type A_TYPES__ComponentMetaExtension, A_TYPES__ComponentMetaKey, type A_TYPES__Component_Constructor, type A_TYPES__Component_Init, type A_TYPES__Component_Serialized, type A_TYPES__ConceptAbstraction, type A_TYPES__ConceptAbstractionMeta, A_TYPES__ConceptAbstractions, type A_TYPES__ConceptENVVariables, A_TYPES__ConceptMetaKey, type A_TYPES__Concept_Constructor, type A_TYPES__Concept_Init, type A_TYPES__Concept_Serialized, type A_TYPES__ContainerMeta, type A_TYPES__ContainerMetaExtension, A_TYPES__ContainerMetaKey, type A_TYPES__Container_Constructor, type A_TYPES__Container_Init, type A_TYPES__Container_Serialized, type A_TYPES__ContextEnvironment, type A_TYPES__DeepPartial, type A_TYPES__Dictionary, A_TYPES__EntityFeatures, type A_TYPES__EntityMeta, A_TYPES__EntityMetaKey, type A_TYPES__Entity_Constructor, type A_TYPES__Entity_Init, type A_TYPES__Entity_Serialized, type A_TYPES__Error_Constructor, type A_TYPES__Error_Init, type A_TYPES__Error_Serialized, type A_TYPES__ExtractNested, type A_TYPES__ExtractProperties, type A_TYPES__FeatureAvailableComponents, type A_TYPES__FeatureAvailableConstructors, type A_TYPES__FeatureDefineDecoratorConfig, type A_TYPES__FeatureDefineDecoratorDescriptor, type A_TYPES__FeatureDefineDecoratorMeta, type A_TYPES__FeatureDefineDecoratorTarget, type A_TYPES__FeatureDefineDecoratorTemplateItem, type A_TYPES__FeatureError_Init, type A_TYPES__FeatureExtendDecoratorConfig, type A_TYPES__FeatureExtendDecoratorDescriptor, type A_TYPES__FeatureExtendDecoratorMeta, type A_TYPES__FeatureExtendDecoratorScopeConfig, type A_TYPES__FeatureExtendDecoratorScopeItem, type A_TYPES__FeatureExtendDecoratorTarget, type A_TYPES__FeatureExtendableMeta, A_TYPES__FeatureState, type A_TYPES__Feature_Constructor, type A_TYPES__Feature_Init, type A_TYPES__Feature_InitWithComponent, type A_TYPES__Feature_InitWithTemplate, type A_TYPES__Feature_Serialized, type A_TYPES__Fragment_Constructor, type A_TYPES__Fragment_Init, type A_TYPES__Fragment_Serialized, type A_TYPES__IEntity, type A_TYPES__InjectableConstructors, type A_TYPES__InjectableTargets, type A_TYPES__MetaLinkedComponentConstructors, type A_TYPES__MetaLinkedComponents, type A_TYPES__Meta_Constructor, type A_TYPES__NonObjectPaths, type A_TYPES__ObjectKeyEnum, type A_TYPES__Paths, type A_TYPES__PathsToObject, type A_TYPES__Required, type A_TYPES__ScopeConfig, type A_TYPES__ScopeLinkedComponents, type A_TYPES__ScopeLinkedConstructors, type A_TYPES__ScopeResolvableComponents, type A_TYPES__Scope_Constructor, type A_TYPES__Scope_Init, type A_TYPES__Scope_Serialized, type A_TYPES__Stage_Serialized, type A_TYPES__UnionToIntersection, A_TypeGuards };
+export { ASEID, ASEID_Error, A_Abstraction, A_AbstractionError, A_Abstraction_Extend, A_CONSTANTS__DEFAULT_ENV_VARIABLES, A_CONSTANTS__DEFAULT_ENV_VARIABLES_ARRAY, A_CONSTANTS__ERROR_CODES, A_CONSTANTS__ERROR_DESCRIPTION, A_Caller, A_CallerError, A_CommonHelper, A_Component, A_ComponentMeta, A_Concept, A_ConceptMeta, A_Container, A_ContainerMeta, A_Context, A_ContextError, A_Dependency, A_DependencyError, A_Dependency_Default, A_Dependency_Load, A_Dependency_Require, A_Entity, A_EntityError, A_EntityMeta, A_Error, A_Feature, A_FeatureError, A_Feature_Define, A_Feature_Extend, A_FormatterHelper, A_Fragment, type A_ID_TYPES__TimeId_Parts, A_IdentityHelper, A_Inject, A_InjectError, A_Meta, A_MetaDecorator, A_Scope, A_ScopeError, A_Stage, A_StageError, A_StepManagerError, A_StepsManager, type A_TYPES_ScopeDependentComponents, type A_TYPES_ScopeIndependentComponents, type A_TYPES_StageExecutionBehavior, type A_TYPES__ASEID_Constructor, type A_TYPES__ASEID_ConstructorConfig, type A_TYPES__ASEID_JSON, type A_TYPES__A_DependencyConstructor, type A_TYPES__A_DependencyInjectable, type A_TYPES__A_DependencyResolutionStrategy, type A_TYPES__A_DependencyResolutionType, type A_TYPES__A_Dependency_AllDecoratorReturn, type A_TYPES__A_Dependency_DefaultDecoratorReturn, type A_TYPES__A_Dependency_EntityInjectionPagination, type A_TYPES__A_Dependency_EntityInjectionQuery, type A_TYPES__A_Dependency_EntityResolutionConfig, type A_TYPES__A_Dependency_FlatDecoratorReturn, type A_TYPES__A_Dependency_LoadDecoratorReturn, type A_TYPES__A_Dependency_ParentDecoratorReturn, type A_TYPES__A_Dependency_RequireDecoratorReturn, type A_TYPES__A_Dependency_Serialized, type A_TYPES__A_InjectDecoratorDescriptor, type A_TYPES__A_InjectDecoratorReturn, type A_TYPES__A_InjectDecorator_Meta, type A_TYPES__A_StageStep, type A_TYPES__A_StageStepProcessingExtraParams, A_TYPES__A_Stage_Status, type A_TYPES__AbstractionAvailableComponents, type A_TYPES__AbstractionDecoratorConfig, type A_TYPES__AbstractionDecoratorDescriptor, type A_TYPES__Abstraction_Constructor, type A_TYPES__Abstraction_Init, type A_TYPES__Abstraction_Serialized, type A_TYPES__CallerComponent, type A_TYPES__Caller_Constructor, type A_TYPES__Caller_Init, type A_TYPES__Caller_Serialized, type A_TYPES__ComponentMeta, type A_TYPES__ComponentMetaExtension, A_TYPES__ComponentMetaKey, type A_TYPES__Component_Constructor, type A_TYPES__Component_Init, type A_TYPES__Component_Serialized, type A_TYPES__ConceptAbstraction, type A_TYPES__ConceptAbstractionMeta, A_TYPES__ConceptAbstractions, type A_TYPES__ConceptENVVariables, A_TYPES__ConceptMetaKey, type A_TYPES__Concept_Constructor, type A_TYPES__Concept_Init, type A_TYPES__Concept_Serialized, type A_TYPES__ContainerMeta, type A_TYPES__ContainerMetaExtension, A_TYPES__ContainerMetaKey, type A_TYPES__Container_Constructor, type A_TYPES__Container_Init, type A_TYPES__Container_Serialized, type A_TYPES__ContextEnvironment, type A_TYPES__Ctor, type A_TYPES__DeepPartial, type A_TYPES__Dictionary, A_TYPES__EntityFeatures, type A_TYPES__EntityMeta, A_TYPES__EntityMetaKey, type A_TYPES__Entity_Constructor, type A_TYPES__Entity_Init, type A_TYPES__Entity_Serialized, type A_TYPES__Error_Constructor, type A_TYPES__Error_Init, type A_TYPES__Error_Serialized, type A_TYPES__ExtractNested, type A_TYPES__ExtractProperties, type A_TYPES__FeatureAvailableComponents, type A_TYPES__FeatureAvailableConstructors, type A_TYPES__FeatureDefineDecoratorConfig, type A_TYPES__FeatureDefineDecoratorDescriptor, type A_TYPES__FeatureDefineDecoratorMeta, type A_TYPES__FeatureDefineDecoratorTarget, type A_TYPES__FeatureDefineDecoratorTemplateItem, type A_TYPES__FeatureError_Init, type A_TYPES__FeatureExtendDecoratorConfig, type A_TYPES__FeatureExtendDecoratorDescriptor, type A_TYPES__FeatureExtendDecoratorMeta, type A_TYPES__FeatureExtendDecoratorScopeConfig, type A_TYPES__FeatureExtendDecoratorScopeItem, type A_TYPES__FeatureExtendDecoratorTarget, type A_TYPES__FeatureExtendableMeta, A_TYPES__FeatureState, type A_TYPES__Feature_Constructor, type A_TYPES__Feature_Init, type A_TYPES__Feature_InitWithComponent, type A_TYPES__Feature_InitWithTemplate, type A_TYPES__Feature_Serialized, type A_TYPES__Fragment_Constructor, type A_TYPES__Fragment_Init, type A_TYPES__Fragment_Serialized, type A_TYPES__IEntity, type A_TYPES__InjectableTargets, type A_TYPES__MetaLinkedComponentConstructors, type A_TYPES__MetaLinkedComponents, type A_TYPES__Meta_Constructor, type A_TYPES__NonObjectPaths, type A_TYPES__ObjectKeyEnum, type A_TYPES__Paths, type A_TYPES__PathsToObject, type A_TYPES__Required, type A_TYPES__ScopeConfig, type A_TYPES__ScopeLinkedComponents, type A_TYPES__ScopeLinkedConstructors, type A_TYPES__Scope_Constructor, type A_TYPES__Scope_Init, type A_TYPES__Scope_Serialized, type A_TYPES__Stage_Serialized, type A_TYPES__UnionToIntersection, A_TypeGuards };