xt-components 0.6.3 → 0.7.0

package/types/xt-components.d.ts

@@ -0,0 +1,1367 @@
+import * as _angular_core from '@angular/core';
+import { Signal, WritableSignal, InputSignal, OutputEmitterRef, ModelSignal, Type, InjectionToken, AfterViewInit, OnInit } from '@angular/core';
+import { FormGroup, AbstractControl, FormBuilder } from '@angular/forms';
+import { XtTypeInfo, XtTypeReference, XtTypeResolver, XtTypeHandler, MappingHelper } from 'xt-type';
+import * as xt_components from 'xt-components';
+import { Observable } from 'rxjs';
+import { NgComponentOutlet } from '@angular/common';
+
+/**
+ * Just declare a type marker for Workflows
+ */
+type XtWorkflow = {};
+
+/** Information about a registered component plugin */
+type XtComponentInfo<T> = {
+    componentName: string;
+    componentClass: T;
+    typesHandled: string[];
+    outputs?: XtOutputType[];
+};
+/** Information about a registered workflow plugin */
+type XtWorkflowInfo<T extends XtWorkflow> = {
+    name: string;
+    class: T;
+    workflowsHandled: string[];
+};
+/** Information about a registered type handler plugin */
+type XtTypeHandlerInfo<T> = {
+    typesHandled: string[];
+    handlerClass: T;
+};
+/** Information about a registered action */
+type XtActionInfo<T> = {
+    description: string;
+    visible: boolean;
+    handlerClass: any;
+    iconUrl?: string;
+};
+/** Information about a registered action handler that groups actions by type */
+type XtActionHandlerInfo<T> = {
+    types: string[];
+    actions: {
+        [name: string]: XtActionInfo<T>;
+    };
+};
+/** Information about a registered plugin containing components, workflows, types, and action handlers */
+type XtPluginInfo = {
+    name: string;
+    uriLogo?: string;
+    components?: XtComponentInfo<any>[];
+    workflows?: XtWorkflowInfo<any>[];
+    types?: XtTypeInfo;
+    typeHandlers?: XtTypeHandlerInfo<any>[];
+    actionHandlers?: XtActionHandlerInfo<any>[];
+};
+
+/** Represents a registered action with its metadata and enabled state */
+declare class XtAction<T> {
+    /** The unique name of the action */
+    name: string;
+    /** Metadata describing the action */
+    info: XtActionInfo<T>;
+    /** Signal indicating whether the action is currently enabled */
+    enabled: _angular_core.WritableSignal<boolean>;
+    /**
+     * Creates a new XtAction instance
+     * @param name - The unique name of the action
+     * @param info - Metadata describing the action
+     * @param enabled - Whether the action is initially enabled (defaults to false)
+     */
+    constructor(name: string, info: XtActionInfo<T>, enabled?: boolean);
+}
+
+/**
+ * A XtContext provides all the necessary information for an ng-extended component to operate. It is passed from parent to child component and pass
+ * - The display mode - View, Inline view or Edit
+ * - The value, either directly as a signal or in a formgroup when editing.
+ * - The valueType, necessary to find the right ng-extended component to display
+ *
+ * To do this, it maintains a hierarchy of context and subContexts by name.
+ */
+type XtContext<T> = {
+    displayMode: XtDisplayMode;
+    subName?: string;
+    parentFormGroup?: FormGroup;
+    localFormGroup?: FormGroup;
+    /**
+     * When the value in the context is a reference to another type
+     */
+    reference?: XtTypeReference;
+    /**
+     * If it's a reference, we keep the context referenced
+     */
+    referencedContext?: XtContext<any>;
+    /**
+     * creates the referencedContext by using this referenced value
+     * @param val
+     *
+    updateReferencedContext(val: any, valueType?:string): void;*/
+    /**
+     * Signal when all the asynchronously defined subreferences are resolved.
+     *
+    subReferencesResolved: WritableSignal<boolean>;
+  */
+    parentContext?: XtContext<any>;
+    isInForm(): boolean;
+    formGroup(): FormGroup | undefined;
+    formControlNameOrNull(): string | null;
+    formControlValue(): any | null;
+    subValue(subName?: string): T | null | undefined;
+    subContext(subName: string | undefined | null, subType?: string, typeResolver?: XtTypeResolver | null): XtContext<any>;
+    elementSetContext(subElement: any): XtContext<any>;
+    displayValue: Signal<T | null>;
+    setDisplayValue(newValue: T | null | undefined, type?: string): XtContext<T>;
+    setFormValue(newValue: T | null | undefined, markAsDirty?: boolean): boolean;
+    value(): T | null | undefined;
+    valueType?: string;
+    toString(): string;
+    listActions: WritableSignal<XtAction<T>[] | null>;
+    isReference(): boolean;
+    setReferenceInfo(ref: XtTypeReference): void;
+};
+/** Display modes controlling how a value is presented: inline, full view, editable, or list. */
+type XtDisplayMode = 'INLINE_VIEW' | 'FULL_VIEW' | 'FULL_EDITABLE' | 'LIST_VIEW';
+/**
+ * Base implementation of the XtContext interface.
+ * Manages display mode, form integration, child context hierarchy, and value tracking
+ * for an ng-extended component.
+ */
+declare class XtBaseContext<T> implements XtContext<T> {
+    /** The current display mode for this context. Defaults to FULL_VIEW. */
+    displayMode: XtDisplayMode;
+    /**
+     * When editable, the value is stored in a parent formGroup
+     */
+    subName?: string;
+    /** The parent FormGroup when this context is a child within a reactive form. */
+    parentFormGroup?: FormGroup<any>;
+    /**
+     * When the context is a child, it potentially needs to update its parent value
+     */
+    parentContext?: XtBaseContext<any>;
+    /**
+     * All child contexts are kept in this map
+     */
+    protected childContexts?: Map<string, XtBaseContext<any>>;
+    /**
+     * localFormGroup exists only for composite components: it's children are all gathered in a form group
+     */
+    localFormGroup?: FormGroup<any>;
+    /**
+     * When not managed by a form, the value is here
+     */
+    nonFormValue?: WritableSignal<T | null>;
+    /** The type identifier for the value contained in this context. */
+    valueType?: string;
+    /**
+     * When the value in the context is a reference to another type
+     */
+    reference?: XtTypeReference;
+    /**
+     * If it's a reference, we keep the context referenced
+     *
+    referencedContext?:XtContext<any>;*/
+    /**
+     * Keeps track of all the possible actions for this context
+     * @protected
+     */
+    listActions: WritableSignal<XtAction<T>[] | null>;
+    /**
+     * Creates a new XtBaseContext instance.
+     * @param displayMode - The display mode for this context
+     * @param subName - Optional sub-name used within a parent form group
+     * @param parentGroup - Optional parent FormGroup for reactive form integration
+     * @param parentContext - Optional parent context for hierarchy management
+     */
+    constructor(displayMode: XtDisplayMode, subName?: string, parentGroup?: FormGroup, parentContext?: XtBaseContext<any>);
+    /**
+     * Sets the display value for this context when not managed by a reactive form.
+     * Propagates changes to child contexts and optionally notifies the parent context.
+     * @param newValue - The new value to set
+     * @param type - Optional type identifier to assign
+     * @param updateParent - Whether to propagate the change to the parent context (default true)
+     * @returns This context instance for chaining
+     */
+    setDisplayValue(newValue: T | null | undefined, type?: string, updateParent?: boolean): XtBaseContext<T>;
+    /** Computed signal that returns the current display value from non-form storage. */
+    displayValue: Signal<T | null>;
+    /**
+     * Checks whether this context is bound to a reactive form group.
+     * @returns True if a form group exists
+     */
+    isInForm(): boolean;
+    /**
+     * Returns the sub-name used as the form control name, or null if not in a form.
+     * @returns The sub-name or null
+     */
+    formControlNameOrNull(): string | null;
+    /**
+     * Returns the current value from either the non-form signal or the form control.
+     * @returns The current value, or null/undefined
+     */
+    value(): T | null | undefined;
+    /**
+     * Returns a sub-value by name from the current value object.
+     * @param subsubName - Optional sub-key to retrieve from the value object
+     * @returns The sub-value or the full value if no key is given
+     */
+    subValue(subsubName?: string): any | null | undefined;
+    /**
+     * Enable child contexts to update its own value in the parent context whenever it's value changes
+     */
+    protected updateSubDisplayValue(subName: string, subValue: any): void;
+    /**
+     * Retrieves the value from the parent form group for this context's sub-name.
+     * @returns The form control value, or undefined if not in a form
+     */
+    formControlValue(): T | null | undefined;
+    /**
+     * Sets the value in the parent form group for this context's sub-name.
+     * @param newValue - The new value to set on the form control
+     * @param markAsDirty - Whether to mark the control as dirty (default false)
+     * @returns True if the value was successfully set
+     */
+    setFormValue(newValue: T | null | undefined, markAsDirty?: boolean): boolean;
+    /**
+     * Returns the context associated with a specific element in a set.
+     * Value must be an array.
+     * @param elementIndex
+     */
+    elementSetContext(elementIndex: number): XtContext<any>;
+    /**
+     * Returns or creates a child context for the given sub-name.
+     * Resolves type information and references when a typeResolver is provided.
+     * @param subName - The sub-name for the child context
+     * @param subType - Optional type hint for the child
+     * @param typeResolver - Optional type resolver for resolving sub-types and references
+     * @returns The child XtContext
+     */
+    subContext(subName: string | undefined | null, subType?: string, typeResolver?: XtTypeResolver | null): XtContext<any>;
+    /**
+     * Returns the available form group, preferring localFormGroup over parentFormGroup.
+     * @returns The form group or undefined
+     */
+    formGroup(): FormGroup | undefined;
+    /**
+     * Checks whether this context holds a reference to another type.
+     * @returns True if a reference is set
+     */
+    isReference(): boolean;
+    /**
+     * Sets the type reference information for this context.
+     * @param reference - The type reference to set
+     */
+    setReferenceInfo(reference: XtTypeReference): void;
+    /**
+     * creates the referencedContext by using this referenced value
+     * @param val
+     *
+    updateReferencedContext(val: any, valueType?:string): void {
+      if (!this.isReference()) throw new Error ('This context '+this.toString()+' is not a reference.');
+  
+      if( this.referencedContext==null) {
+        let refDisplayMode = 'INLINE_VIEW' as XtDisplayMode;
+        if (this.displayMode=='FULL_VIEW') refDisplayMode = 'FULL_VIEW';
+        this.referencedContext = new XtBaseContext(refDisplayMode);
+      }
+      this.referencedContext.setDisplayValue(val);
+      if( valueType!=null) this.referencedContext.valueType=valueType;
+    }*/
+    /**
+     * Returns a string representation of this context, including its name, type, value, and reference info.
+     * @returns A human-readable description of the context
+     */
+    toString(): string;
+}
+
+/**
+ * Interface for ng-extended components. Defines the contract all XtComponents must implement,
+ * including context handling, input/output bindings, and form integration.
+ */
+type XtComponent<T = any> = {
+    context: InputSignal<XtContext<T>>;
+    inputsObject?: XtComponentInput;
+    outputsObject?: XtComponentOutput;
+    modelsObject?: XtComponentModel;
+    models?: InputSignal<XtComponentModel | undefined>;
+    inputs?: InputSignal<XtComponentInput>;
+    outputs?: OutputEmitterRef<XtComponentOutput>;
+    isInForm(): boolean;
+    formControlName(): string | undefined;
+    formGroup(): FormGroup;
+    formGroupIfAny(): FormGroup | undefined;
+};
+/** Possible output types emitted by an XtComponent. */
+type XtOutputType = 'valueSelected';
+/** Possible input types accepted by an XtComponent. */
+type XtInputType = 'valueSelected';
+/** Possible model types for two-way binding on an XtComponent. */
+type XtModelType = 'valueSelected' | 'sortBy' | 'filterBy';
+/** Defines the model signals available for two-way binding on a component. */
+type XtComponentModel = {
+    [key in XtModelType]?: ModelSignal<any> | undefined;
+};
+/** Defines the output emitter map for a component. */
+type XtComponentOutput = {
+    [key in XtOutputType]: OutputEmitterRef<any> | undefined;
+};
+/** Defines the input signal map for a component. */
+type XtComponentInput = {
+    [key in XtInputType]: InputSignal<any> | undefined;
+};
+
+/**
+ * Represents a resolved component with its name, class reference, and output capability.
+ * Created by the resolver to indicate which XtComponent should be used for a given context.
+ */
+declare class XtResolvedComponent {
+    /** The registered name of the resolved component. */
+    componentName: string;
+    /** The Angular component class reference. */
+    componentClass: any;
+    /** Whether the component emits any outputs. */
+    outputs: boolean;
+    /**
+     * Creates a new XtResolvedComponent instance.
+     * @param componentName - The registered component name
+     * @param componentClass - The Angular component class
+     * @param outputs - Whether the component has outputs (default false)
+     */
+    constructor(componentName: string, componentClass: any, outputs?: boolean);
+    /**
+     * Creates an XtResolvedComponent from an XtComponentInfo.
+     * @param info - The component info from the plugin registry
+     * @returns A new XtResolvedComponent instance
+     */
+    static from(info: XtComponentInfo<any>): XtResolvedComponent;
+}
+
+/** Interface for component resolvers that find the best component to render for a given context */
+type XtResolver = {
+    resolve<T>(baseContext: XtContext<T>, subName?: string): XtResolvedComponent | null;
+};
+
+/**
+ * Maintain the list of plugins loaded, with their components and actions
+ *
+ */
+declare class XtPluginRegistry {
+    /** Map of all registered plugins by name */
+    pluginRegistry: Map<string, XtPluginInfo>;
+    /** Map of all registered components by component name */
+    componentRegistry: Map<string, XtComponentInfo<any>>;
+    /** Cache of components found by value type */
+    componentByTypeCache: Map<string, XtComponentInfo<any>[]>;
+    /** Map of all registered workflows by name */
+    protected workflowRegistry: Map<string, XtWorkflowInfo<any>>;
+    /** Map of actions registered by type, then by action name */
+    protected actionByTypeRegistry: Map<string, Map<string, XtActionInfo<any>>>;
+    /** Signal listing all registered component infos */
+    listComponents: _angular_core.WritableSignal<XtComponentInfo<any>[]>;
+    /** Signal listing all registered plugin infos */
+    listPlugins: _angular_core.WritableSignal<XtPluginInfo[]>;
+    /**
+     * The component can manage any standard javascript primitives types. That's usually the default whenever we don't know any particular type
+     * string
+     * number
+     * bigint
+     * boolean
+     * undefined
+     * null
+     * symbol is not managed
+     * Date, while an object and not a primitive, is managed
+     */
+    static readonly ANY_PRIMITIVE_TYPE = "ANY_PRIMITIVE_TYPE";
+    /**
+     * The components can manage any composite javascript type. Default when no type has been defined and it's a user defined javascript object (not a data type)
+     */
+    static readonly ANY_OBJECT_TYPE = "ANY_OBJECT_TYPE";
+    /** Components can manage any set of primitive types */
+    static readonly ANY_PRIMITIVE_SET = "ANY_PRIMITIVE_SET";
+    /** Components can manage any set of object types */
+    static readonly ANY_OBJECT_SET = "ANY_OBJECT_SET";
+    /**
+     * Whenever a component can handle any type of reference to a single entity or to multiple entities.
+     */
+    static readonly ANY_SINGLE_REFERENCE = "ANY_SINGLE_REFERENCE";
+    /** Whenever a component can handle any type of reference to multiple entities */
+    static readonly ANY_MULTIPLE_REFERENCE = "ANY_MULTIPLE_REFERENCE";
+    /**
+     * Registers a plugin with its components, actions, and workflows
+     * @param info - The plugin information to register
+     */
+    registerPlugin(info: XtPluginInfo): void;
+    /**
+     * Registers a workflow component
+     * @param info - The workflow information to register
+     */
+    registerWorkflow<T extends XtWorkflow>(info: XtWorkflowInfo<T>): void;
+    /**
+     * Registers a component in the component registry
+     * @param info - The component information to register
+     */
+    registerComponent<T>(info: XtComponentInfo<T>): void;
+    /**
+     * Finds components that can handle the given value type
+     * @param valueType - The value type to search for, or null/undefined to infer from the value
+     * @param value - The optional value to infer the type from
+     * @returns An array of matching component infos
+     */
+    findComponentsForType<T>(valueType: string | null | undefined, value?: T): XtComponentInfo<any>[];
+    /**
+     * Returns the global singleton plugin registry
+     * @returns The global XtPluginRegistry instance
+     */
+    static registry(): XtPluginRegistry;
+    /**
+     * Finds component info for the given component class type
+     * @param type - The component class type to search for
+     * @returns The component info or null if not found
+     */
+    findComponentInfo(type: Type<XtComponent<any>>): XtComponentInfo<any> | null;
+    /**
+     * Gets component info for the given component class type, throwing if not found
+     * @param type - The component class type to search for
+     * @returns The component info
+     * @throws Error if no component is found with the given class
+     */
+    getComponentInfo(type: Type<XtComponent<any>>): XtComponentInfo<any>;
+    /**
+     * Finds all the workflow components that can handle the given workflow type
+     * @param type
+     */
+    listWorkflowsForType(type: string): XtWorkflowInfo<any>[];
+    /**
+     * Finds workflow info by name
+     * @param name - The workflow name to search for
+     * @returns The workflow info or undefined if not found
+     */
+    findWorkflowInfo(name: string): XtWorkflowInfo<any> | undefined;
+    /**
+     * Registers action handlers grouped by type
+     * @param handlerInfo - The action handler information to register
+     */
+    registerActionHandler<T>(handlerInfo: XtActionHandlerInfo<T>): void;
+    /**
+     * Finds action info for the given type and action name
+     * @param type - The type to look up
+     * @param actionName - The action name to find
+     * @returns The action info or undefined if not found
+     */
+    findActionInfo<T>(type: string, actionName: string): XtActionInfo<T> | undefined;
+    /**
+     * Lists all action infos registered for the given type
+     * @param type - The type to list actions for
+     * @returns An array of action name and info pairs
+     */
+    listActionInfos<T>(type: string): {
+        name: string;
+        info: XtActionInfo<T>;
+    }[];
+}
+
+/**
+ * Wrapper around xt-store manager: You can use it to check if xt-store is included or not, and decide what to do
+ *
+ * This allows plugins to potentially use xt-store whenever included in the applications running the plugin
+ */
+
+declare class StoreSupport {
+    /** Optional test store manager override for testing */
+    protected static testStoreManager?: IStoreManager;
+    /**
+     * Checks if a store manager is available (either test or global)
+     * @returns true if a store manager is available
+     */
+    static isStoreManagerAvailable(): boolean;
+    /**
+     * Gets the current store manager (test or global)
+     * @returns The IStoreManager instance
+     */
+    static getStoreManager(): IStoreManager;
+    /**
+     * Sets a test store manager for testing purposes
+     * @param testStoreManager - The test store manager to use
+     */
+    static setTestStoreManager(testStoreManager: IStoreManager): void;
+    /**
+     * Creates a new store criteria for filtering
+     * @param name - The property name to filter on
+     * @param value - The value to filter by
+     * @param operator - The comparison operator (defaults to '=')
+     * @returns A new IStoreCriteria instance
+     */
+    static newStoreCriteria<T = any>(name: keyof T, value: any, operator?: IStoreCriteriaOperator): IStoreCriteria<T>;
+}
+/**
+ * Interface definition for xt-store component.
+ * We re-define them here to avoid importing xt-store in all plugins that don't need it.
+ */
+/** Interface for transforming data after it has been loaded from the store */
+interface IDataTransformer<T> {
+    /**
+     * Enable transformation of data right after it has been loaded from the store
+     * @param source
+     */
+    postLoadingTransformation(source: any[]): T[];
+}
+/** Information about a stored document */
+interface IDocumentInfo {
+    /** The name of the document */
+    documentName: string;
+    /** Whether the document is accessible via URL */
+    isUrl: boolean;
+    /** Optional document identifier */
+    documentId?: string;
+}
+/** Supported operators for store criteria comparisons */
+type IStoreCriteriaOperator = '=' | '<' | '<=';
+/** Criteria for filtering store queries */
+interface IStoreCriteria<T> {
+    /** The property name to filter on */
+    name: keyof T;
+    /** The value to filter by */
+    value: any;
+    /** The comparison operator */
+    operator: IStoreCriteriaOperator;
+}
+/** Sort criteria for store queries */
+type ISortBy<T> = {
+    by: keyof T;
+    direction: ISortByDirection;
+};
+/** Sort direction options */
+declare enum ISortByDirection {
+    /** No sorting */
+    None = "None",
+    /** Sort in ascending order */
+    Ascending = "Ascending",
+    /** Sort in descending order */
+    Descending = "Descending"
+}
+/** Interface for a store provider that handles CRUD operations on entities */
+interface IStoreProvider<T> {
+    /**
+     * Stores an entity in the data store
+     * @param name - The entity/collection name
+     * @param entity - The entity to store
+     * @returns A promise that resolves to the stored entity
+     */
+    storeEntity(name: string, entity: T): Promise<T>;
+    /**
+     * Rejects the promise if the entity is not found
+     * @param name
+     * @param key
+     */
+    /**
+     * Rejects the promise if the entity is not found
+     * @param name - The entity/collection name
+     * @param key - The entity key/ID
+     */
+    safeLoadEntity(name: string, key: any): Promise<T>;
+    /**
+     * Loads an entity from the data store
+     * @param name - The entity/collection name
+     * @param key - The entity key/ID
+     * @returns A promise that resolves to the entity or undefined if not found
+     */
+    loadEntity(name: string, key: any): Promise<T | undefined>;
+    /**
+     * Deletes an entity from the data store
+     * @param name - The entity/collection name
+     * @param key - The entity key/ID
+     * @returns A promise that resolves to true if deletion was successful
+     */
+    deleteEntity(name: string, key: any): Promise<boolean>;
+    /**
+     * Searches for entities matching the given criteria
+     * @param name - The entity/collection name
+     * @param criteria - Filter criteria to apply
+     * @returns An observable emitting matching entities
+     */
+    searchEntities(name: string, ...criteria: IStoreCriteria<T>[]): Observable<Array<T>>;
+    /**
+     * Searches for entities and optionally sorts, groups, and transforms the results
+     * @param name - The entity/collection name
+     * @param sort - Optional sort criteria
+     * @param groupBy - Optional grouping configuration
+     * @param transformer - Optional data transformer
+     * @param criteria - Additional filter criteria
+     * @returns An observable emitting the processed results
+     */
+    searchAndPrepareEntities(name: string, sort?: ISortBy<T>, groupBy?: any, transformer?: IDataTransformer<T>, ...criteria: any[]): Observable<any>;
+    /**
+     * Checks whether this provider can store documents
+     * @returns true if document storage is supported
+     */
+    canStoreDocument(): boolean;
+    /**
+     * Upload one document to a server store and returns the url or the id needed to retrieve them.
+     * @param toStore - The file to upload
+     */
+    storeDocument(toStore: File): Promise<IDocumentInfo>;
+    /**
+     * Upload documents to a server store and returns the url or the id needed to retrieve them.
+     * @param toStore - The files to upload
+     */
+    storeDocuments(toStore: File[]): Observable<IDocumentInfo>;
+}
+/** Interface for a store manager that provides access to store providers */
+interface IStoreManager {
+    /**
+     * Gets a store provider by name
+     * @param name - Optional provider name (defaults to the default provider)
+     * @returns The store provider or undefined if not found
+     */
+    getProvider<T = never>(name?: string): IStoreProvider<T> | undefined;
+    /**
+     * Gets a store provider by name, throwing if not found
+     * @param name - Optional provider name (defaults to the default provider)
+     * @returns The store provider
+     * @throws Error if no provider is found
+     */
+    getProviderSafe<T = never>(name?: string): IStoreProvider<T>;
+    /**
+     * Gets the default store provider
+     * @returns The default provider or undefined if none is set
+     */
+    getDefaultProvider<T = never>(): IStoreProvider<T> | undefined;
+    /**
+     * Gets the default store provider, throwing if not found
+     * @returns The default store provider
+     * @throws Error if no default provider is set
+     */
+    getDefaultProviderSafe<T = never>(): IStoreProvider<T>;
+    /**
+     * Creates a new store criteria instance
+     * @param name - The property name to filter on
+     * @param value - The value to filter by
+     * @param operator - The comparison operator
+     * @returns A new IStoreCriteria instance
+     */
+    newStoreCriteria<T = never>(name: keyof T, value: any, operator: IStoreCriteriaOperator): IStoreCriteria<T>;
+}
+
+/**
+ * An all in one helper class, enabling manipulation of the context, with data and type associated with it.
+ */
+declare class XtResolverService {
+    /** Injected plugin registry for component and type registration. */
+    pluginRegistry: xt_components.XtPluginRegistry;
+    /** Optional base resolver injected via DI token. */
+    protected baseResolver: XtResolver | null;
+    /** Optional base type resolver injected via DI token. */
+    protected baseTypeResolver: XtTypeResolver | null;
+    /** The resolver used to find components for a given context. */
+    resolver: XtResolver;
+    /** The type resolver for type hierarchy and reference resolution. */
+    typeResolver: XtTypeResolver;
+    constructor();
+    /**
+     * Finds the best matching component for the given context and optional sub-name.
+     * @param baseContext - The context to resolve against
+     * @param subName - Optional sub-name for nested resolution
+     * @returns The resolved component descriptor
+     */
+    findBestComponent<T>(baseContext: XtContext<T>, subName?: string): XtResolvedComponent;
+    /**
+     * Resolves the type name for the given context and optional sub-name.
+     * @param baseContext - The context to query
+     * @param subName - Optional sub-name for nested type resolution
+     * @param value - Optional value for type inference
+     * @returns The type name, or null/undefined
+     */
+    findTypeOf<T>(baseContext: XtContext<T>, subName?: string, value?: T): string | null | undefined;
+    /**
+     * Finds the type handler for the given context, resolving references if necessary.
+     * @param baseContext - The context to query
+     * @param subName - Optional sub-name for nested resolution
+     * @param value - Optional value for handler inference
+     * @returns An object with the type name and its handler
+     */
+    findTypeHandlerOf<T>(baseContext: XtContext<T>, subName?: string, value?: T): {
+        typeName?: string | null;
+        handler?: XtTypeHandler<any>;
+    };
+    /**
+     * Lists the sub-names defined by the type of the given context.
+     * @param baseContext - The context to query
+     * @param value - Optional value for type inference
+     * @returns An array of sub-name strings
+     */
+    listSubNamesOf<T>(baseContext: XtContext<T>, value?: T): string[];
+    /**
+     * Lists the sub-names defined by a given value type string.
+     * @param valueType - The type string to query
+     * @param value - Optional value for type inference
+     * @returns An array of sub-name strings
+     */
+    listSubNamesOfType<T>(valueType: string, value?: T): string[];
+    /**
+     * Registers a full plugin including its types and type handlers.
+     * @param info - The plugin information to register
+     */
+    registerPlugin(info: XtPluginInfo): void;
+    /**
+     * Registers type definitions and optional type handlers with the type resolver.
+     * @param types - The type definitions to register
+     * @param handlers - Optional type handler definitions
+     */
+    registerTypes(types: XtTypeInfo | undefined, handlers?: XtTypeHandlerInfo<any>[]): void;
+    /**
+     * Calculates all the possible actions for a given context
+     * @param context
+     * @param onlyVisible
+     */
+    possibleActions<T>(context: XtContext<T>, onlyVisible?: boolean): Array<XtAction<T>>;
+    /**
+     * Finds the possible action with the given name for the current type, and runs it in the current value.
+     * If the action is not possible in this context, try a parent context
+     * @param actionName
+     */
+    runAction<T>(context: XtContext<T>, actionName: string, storeMgr?: any): Promise<XtActionResult<any>>;
+    /**
+     * Checks if a handler is defined for the given type among the provided handler infos.
+     * @param newType - The type to check
+     * @param handlers - The handler definitions to search
+     * @returns A handler instance or null
+     */
+    protected handlerDefinedFor(newType: string, handlers: XtTypeHandlerInfo<any>[] | undefined): any;
+    /**
+     * Gets the resolved component info for a given component type.
+     * @param type - The component type class
+     * @returns The resolved component descriptor
+     */
+    getComponentInfo<T>(type: Type<XtComponent<T>>): XtResolvedComponent;
+    /**
+     * Finds the resolved component info for a given component type, returning null if not found.
+     * @param type - The component type class
+     * @returns The resolved component descriptor or null
+     */
+    findComponentInfo<T>(type: Type<XtComponent<T>>): XtResolvedComponent | null;
+    /** Computed signal that lists all registered components. */
+    listComponents: _angular_core.Signal<XtComponentInfo<any>[]>;
+    /** Computed signal that lists all registered plugins. */
+    listPlugins: _angular_core.Signal<XtPluginInfo[]>;
+    /**
+     * Dynamically load a register a plugin from the given url
+     * The plugin must export at least a Register entrypoint that will be called right after loading..
+     * @returns a Promise with the module loaded and already registered.
+     * @param module
+     */
+    registerPluginModule(module: {
+        registerPlugin: (resolver: XtResolverService) => string;
+    }, url: URL | string): boolean;
+    /**
+     * Based on the type & value of the element, find which property is on its type and returns it's value
+     * @param context
+     * @param subPropertyType
+     * @param value
+     */
+    findSubPropertyWithType<T>(context: XtContext<T>, subPropertyType: string, value: T): any;
+    /**
+     * Creates a duplicate of an object, using our knowledge on its type given by the context
+     * @param context
+     * @param value
+     */
+    safeDuplicate<T>(context: XtContext<T>, value: T): T;
+    /**
+     * Resolves a mapping helper from the context's value type to a target type.
+     * @param context - The source context
+     * @param targetType - The target type to map to
+     * @param value - Optional value for handler inference
+     * @returns A MappingHelper if a mapping exists, otherwise undefined
+     */
+    resolveMappingOf<U, T>(context: XtContext<T>, targetType: string, value?: T): MappingHelper<U, T> | undefined;
+    /**
+     * Resolves the referenced value for a context that holds a type reference, using the provided store manager.
+     * @param context - The context with a reference to resolve
+     * @param storeMgr - The store manager for entity lookup
+     * @returns The resolved referenced value(s), or null/undefined
+     */
+    resolveReferencedValue<T, U>(context: XtContext<T>, storeMgr: IStoreManager): Promise<U | U[] | null | undefined>;
+    /**
+     * Resolves all pending type references in the type resolver.
+     */
+    resolvePendingReferences(): void;
+    /**
+     * Calculates the values that can be referenced by the reference & value of this context
+     * @param context
+     */
+    findPossibleReferences<T, U>(context: XtContext<T>): Observable<U[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<XtResolverService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<XtResolverService>;
+}
+
+/** Result of executing an action on an item */
+type XtActionResult<Type> = {
+    status: 'success' | 'error' | 'none';
+    warnings?: string[];
+    errors?: string[];
+    value?: Type | null;
+};
+/** Defines an action handler that can run actions on items under a given context */
+type XtActionHandler<Type> = {
+    /**
+     * Runs an action on a item under the context
+     * @param context
+     * @param actionName
+     * @param resolver
+     * @param storeMgr
+     */
+    runAction(context: XtContext<Type>, actionName: string, resolver: XtResolverService, storeMgr?: any): Promise<XtActionResult<Type>>;
+};
+
+/**
+ * The global plugin registry.
+ * Plugins will register to this when loaded.
+ */
+
+declare global {
+    var XT_REGISTRY: XtPluginRegistry;
+}
+declare function initXtPluginRegistry(): void;
+declare function xtPluginRegistry(): XtPluginRegistry;
+
+/** Injection token for providing a custom component resolver */
+declare const XT_RESOLVER_TOKEN: InjectionToken<XtResolver>;
+/** Injection token for providing a custom type resolver */
+declare const XT_TYPE_RESOLVER_TOKEN: InjectionToken<XtTypeResolver>;
+/** Injection token for providing the plugin registry with a default factory */
+declare const XT_REGISTRY_TOKEN: InjectionToken<XtPluginRegistry>;
+
+/** Default implementation of XtComponentOutput */
+declare class XtBaseOutput implements XtComponentOutput {
+    /** Output emitter for when a value is selected */
+    valueSelected: OutputEmitterRef<any> | undefined;
+}
+
+/** Default implementation of XtComponentInput */
+declare class XtBaseInput implements XtComponentInput {
+    /** Input signal for the value selected by the user */
+    valueSelected: InputSignal<any> | undefined;
+}
+
+/**
+ * Offers a nice and easy to dynamically embed a component.
+ * You set the type, the display mode, and either the value or the formgroup & subName to use.
+ * XtRender will then instantiate the component, bind it to the value or form, and display it.
+ */
+declare class XtRenderComponent<T> implements AfterViewInit {
+    /** Injected resolver service for finding the best component */
+    resolverService: XtResolverService;
+    /** Optional explicit component type to render */
+    componentType: _angular_core.InputSignal<Type<XtComponent<T>> | undefined>;
+    /** The display mode (e.g. EDIT, VIEW, etc.) */
+    displayMode: _angular_core.InputSignal<XtDisplayMode>;
+    /** The value type identifier used for component resolution */
+    valueType: _angular_core.InputSignal<string | undefined>;
+    /** The value to display/edit (used when not inside a form) */
+    value: _angular_core.ModelSignal<T | undefined>;
+    /** The parent form group (used when inside a form) */
+    formGroup: _angular_core.InputSignal<FormGroup<any> | undefined>;
+    /** The sub-name within the form group */
+    subName: _angular_core.InputSignal<string | undefined>;
+    /** Object holding the output emitters from the rendered component */
+    outputsObject: XtBaseOutput;
+    /** Inputs to pass through to the rendered component */
+    inputs: _angular_core.InputSignal<XtBaseInput | undefined>;
+    /** Emits the outputs from the rendered component */
+    outputs: _angular_core.OutputEmitterRef<XtComponentOutput>;
+    /** Model signals to pass through to the rendered component */
+    models: _angular_core.InputSignal<XtComponentModel | undefined>;
+    /** Reference to the NgComponentOutlet used to dynamically render the component */
+    outlet: Signal<NgComponentOutlet<any>>;
+    constructor();
+    /** Computed context derived from display mode, form group, value, and value type */
+    context: Signal<XtContext<any>>;
+    /** Computed context that resolves references (if any) */
+    realContext: Signal<XtContext<any>>;
+    /** Computed component type to render, resolved from the context if not explicitly set */
+    type: Signal<Type<XtComponent<T>> | null>;
+    /**
+     * Transfers the input and outputs from the host to the rendered component
+     */
+    ngAfterViewInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<XtRenderComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<XtRenderComponent<any>, "xt-render", never, { "componentType": { "alias": "componentType"; "required": false; "isSignal": true; }; "displayMode": { "alias": "displayMode"; "required": true; "isSignal": true; }; "valueType": { "alias": "valueType"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "formGroup": { "alias": "formGroup"; "required": false; "isSignal": true; }; "subName": { "alias": "subName"; "required": false; "isSignal": true; }; "inputs": { "alias": "inputs"; "required": false; "isSignal": true; }; "models": { "alias": "models"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "outputs": "outputs"; }, never, never, true, never>;
+}
+
+/**
+ * Dynamically render a component that will display the given subValue.
+ * To be used only inside an XtSimpleComponent or XtCompositeComponent
+ */
+declare class XtRenderSubComponent<T> implements AfterViewInit {
+    /** The context containing display mode, form group, and value for the sub-component */
+    context: _angular_core.InputSignal<XtContext<T>>;
+    /** Optional explicit component type to render */
+    componentType: _angular_core.InputSignal<Type<XtComponent<T>> | undefined>;
+    /** Object holding the output emitters from the rendered sub-component */
+    outputsObject: XtBaseOutput;
+    /** Inputs to pass through to the rendered sub-component */
+    inputs: _angular_core.InputSignal<XtBaseInput | undefined>;
+    /** Emits the outputs from the rendered sub-component */
+    outputs: _angular_core.OutputEmitterRef<XtComponentOutput>;
+    /** Model signals to pass through to the rendered sub-component */
+    models: _angular_core.InputSignal<XtComponentModel | undefined>;
+    /** Reference to the NgComponentOutlet used to dynamically render the sub-component */
+    outlet: Signal<NgComponentOutlet<any>>;
+    /** Injected resolver service for finding the best component */
+    resolverService: XtResolverService;
+    /** Computed context that resolves references (if any) */
+    realContext: Signal<XtContext<T>>;
+    /** Computed component type to render, resolved from the context if not explicitly set */
+    type: Signal<Type<XtComponent<T>> | null>;
+    /**
+     * Transfers the input and outputs from the host to the rendered component
+     */
+    ngAfterViewInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<XtRenderSubComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<XtRenderSubComponent<any>, "xt-render-sub", never, { "context": { "alias": "context"; "required": true; "isSignal": true; }; "componentType": { "alias": "componentType"; "required": false; "isSignal": true; }; "inputs": { "alias": "inputs"; "required": false; "isSignal": true; }; "models": { "alias": "models"; "required": false; "isSignal": true; }; }, { "outputs": "outputs"; }, never, never, true, never>;
+}
+
+/**
+ * An XtSimpleComponent just displays the given value or element in a form.
+ * If you need to dynamically embed other XtComponents to display sub elements, then please use the XtCompositeComponent
+ */
+declare class XtSimpleComponent<T = any> implements XtComponent<T>, OnInit {
+    /** Required input signal providing the XtContext for this component. */
+    context: _angular_core.InputSignal<XtContext<T>>;
+    /** Object holding the base output definitions for this component. */
+    outputsObject: XtBaseOutput;
+    /** Object holding the base input definitions for this component. */
+    inputsObject: XtBaseInput;
+    /** Output emitter that publishes the component's output map. */
+    outputs: _angular_core.OutputEmitterRef<XtComponentOutput>;
+    /** Input signal accepting model bindings for two-way data flow. */
+    models: _angular_core.InputSignal<XtComponentModel | undefined>;
+    /** Computed signal indicating whether this component is inside a reactive form. */
+    isInForm: _angular_core.Signal<boolean>;
+    /** Computed signal returning the form control name, if any. */
+    formControlNameIfAny: _angular_core.Signal<string | undefined>;
+    /** Computed signal returning the form group if one exists, or undefined. */
+    formGroupIfAny: _angular_core.Signal<FormGroup<any> | undefined>;
+    /** Computed signal returning the form group, throwing if none exists. */
+    formGroup: _angular_core.Signal<FormGroup<any>>;
+    /**
+     * Returns the component form name, which is for now the subName
+     */
+    componentNameInForm: _angular_core.Signal<string>;
+    constructor();
+    /**
+     * Angular lifecycle hook. Sets up input/output bindings and emits outputs
+     * if any output objects have been defined.
+     */
+    ngOnInit(): void;
+    /**
+     * Manages a form control within the component's form group, optionally creating it if it does not exist.
+     * Can be safely called even when no form group is available.
+     * @param ctrlName - The name of the form control
+     * @param create - Whether to create the control if it does not exist (default true)
+     * @returns The AbstractControl, or undefined if no form group is available
+     */
+    manageFormControl<T>(ctrlName: string, create?: boolean): AbstractControl<T> | undefined;
+    /** Computed signal that safely returns the sub-name, throwing if it is null. */
+    safelyGetSubName: _angular_core.Signal<string>;
+    /**
+     * Computed signal returning the form control name for this component.
+     */
+    formControlName: _angular_core.Signal<string>;
+    /** Computed signal that retrieves the existing AbstractControl for this component's sub-name. */
+    formControl: _angular_core.Signal<AbstractControl<any, any, any>>;
+    /**
+     * Returns a human-readable descriptor for this component.
+     * @returns A string describing the component type and context
+     */
+    componentDescriptor(): string;
+    /** Computed signal exposing the raw value from the context. */
+    getValue: _angular_core.Signal<T | null | undefined>;
+    /** Computed signal exposing the display value from the context. */
+    displayValue: _angular_core.Signal<T | null>;
+    /**
+     * This is where components can assign their output() and input() into the XtComponent inputs and outputs member
+     * @protected
+     */
+    protected setupInputOutput(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<XtSimpleComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<XtSimpleComponent<any>, "ng-component", never, { "context": { "alias": "context"; "required": true; "isSignal": true; }; "models": { "alias": "models"; "required": false; "isSignal": true; }; }, { "outputs": "outputs"; }, never, never, true, never>;
+}
+
+/**
+ * A composite XtComponent that manages a form group for its sub-elements.
+ * Extends XtSimpleComponent to provide context-based form group management
+ * and sub-context resolution for nested components.
+ * Selector: not directly used (abstract base via template).
+ */
+declare class XtCompositeComponent<T = any> extends XtSimpleComponent<T> {
+    /** Injected service for resolving components and type information. */
+    resolverService: XtResolverService;
+    /**
+     * Computes the local form group for this composite, creating one from the parent form group if it does not exist.
+     * Overrides the base implementation to manage a dedicated form group for sub-elements.
+     */
+    formGroupIfAny: _angular_core.Signal<FormGroup<any> | undefined>;
+    /**
+     * We need to create a new form group to manage the sub elements.
+     */
+    formGroup: _angular_core.Signal<FormGroup<any>>;
+    /**
+     * Helper function to calculate the sub context for a named child element.
+     * @param subName - The name of the sub-element
+     * @param subType - Optional type hint for the sub-element
+     * @returns The sub-context for the given child
+     */
+    subContext(subName: string, subType?: string): XtContext<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<XtCompositeComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<XtCompositeComponent<any>, "ng-component", never, {}, {}, never, never, true, never>;
+}
+
+/** Default implementation of XtComponentModel */
+declare class XtBaseModel<T> implements XtComponentModel {
+    /** Model signal for the currently selected value */
+    valueSelected?: ModelSignal<T | null> | undefined;
+    /** Model signal for sort criteria */
+    sortBy?: ModelSignal<ISortBy<T>[]> | undefined;
+    /** Model signal for filter criteria */
+    filterBy?: ModelSignal<IStoreCriteria<T>[]> | undefined;
+}
+
+declare class XtMessageHandler {
+    /**
+     * Handles an error occurrence by logging it to the console
+     * @param error - The error object
+     * @param errorMsg - Optional custom error message
+     */
+    errorOccurred(error: any, errorMsg?: string): void;
+    /**
+     * Handles a warning occurrence by logging it to the console
+     * @param warningMsg - Optional warning message
+     */
+    warningOccurred(warningMsg?: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<XtMessageHandler, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<XtMessageHandler>;
+}
+
+/**
+ * Attaches a value to a form group by creating either a FormControl or nested FormGroup based on the value type
+ * @param formGroup - The form group to attach to
+ * @param controlName - The control name within the form group
+ * @param value - The value to attach
+ * @param valueType - Optional type identifier for type resolution
+ * @param resolver - Optional type resolver for determining if the value is primitive
+ */
+declare function attachToFormGroup(formGroup: FormGroup, controlName: string, value: any, valueType?: string, resolver?: XtTypeResolver): void;
+/**
+ * Updates a form group with the properties from a value object, adding, updating, or removing controls as needed
+ * @param formGroup - The form group to update
+ * @param value - The value object containing the properties to sync
+ * @param valueType - Optional type identifier for type resolution
+ * @param resolver - Optional type resolver for determining property types
+ */
+declare function updateFormGroupWithValue(formGroup: FormGroup, value: {
+    [key: string]: any;
+}, valueType?: string, resolver?: XtTypeResolver): void;
+
+/**
+ * Helper class to ease unit testing
+ */
+declare class XtUnitTestHelper {
+    /**
+     * Asynchronously wait for test function to return true. By default try 20 times with a delay of 50ms
+     * @param test
+     * @param tries
+     * @param timer
+     */
+    static waitFor(test: () => boolean, tries?: number, timer?: number): Promise<void>;
+}
+
+/**
+ * Component that can be used to bootstrap tests.
+ * Just set the value and component type, and it will be injected in your test.
+ */
+declare class HostTestSimpleComponent {
+    /** Required input for the component type to render. */
+    type: _angular_core.InputSignal<Type<XtComponent<any>>>;
+    /** Input for the display mode. Defaults to FULL_VIEW. */
+    displayMode: _angular_core.InputSignal<XtDisplayMode>;
+    /** Input for the value to pass to the rendered component. */
+    value: _angular_core.InputSignal<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HostTestSimpleComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HostTestSimpleComponent, "test-host", never, { "type": { "alias": "type"; "required": true; "isSignal": true; }; "displayMode": { "alias": "displayMode"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * Same as HostTestSimpleComponent but it includes everything in a form.
+ * Just set the component type, the formGroup and the component  name, and your component will be run.
+ * You can as well easily read and set the value.
+ */
+declare class HostTestFormComponent {
+    /** Injected FormBuilder for creating form groups. */
+    builder: FormBuilder;
+    /** Required input for the component type to render. */
+    type: _angular_core.InputSignal<Type<XtComponent<any>>>;
+    /** Required input for the form control name. */
+    controlName: _angular_core.InputSignal<string>;
+    /** Input for the form description object used to generate the form group. */
+    formDescription: _angular_core.InputSignal<any>;
+    /** Input to provide an existing FormGroup directly. */
+    formGroup: _angular_core.InputSignal<FormGroup<any> | undefined>;
+    /** The parent FormGroup that contains the component's form group. */
+    parentFormGroup: FormGroup<{
+        [x: string]: AbstractControl<any, any, any>;
+    }>;
+    /** Computed signal returning the created form group. */
+    createdFormGroup: _angular_core.Signal<FormGroup<any>>;
+    /**
+     * Computes the form group from the input, either using a provided form group or generating one from the form description.
+     * @returns The created FormGroup
+     */
+    protected computeFormGroup(): FormGroup;
+    /**
+     * Patches the component's form control with a new value.
+     * @param newVal - The value to patch
+     */
+    patchValue(newVal: any): void;
+    /**
+     * Retrieves the current value from the component's form control.
+     * @returns The current form value
+     */
+    retrieveValue(): any;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HostTestFormComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HostTestFormComponent, "test-form-host", never, { "type": { "alias": "type"; "required": true; "isSignal": true; }; "controlName": { "alias": "controlName"; "required": true; "isSignal": true; }; "formDescription": { "alias": "formDescription"; "required": false; "isSignal": true; }; "formGroup": { "alias": "formGroup"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * Component that can be used to test your component based on the type it handles
+ * Just set the type hierarchy to register, the value, and it will instantiate the right component in your plugin
+ */
+declare class HostTestTypedComponent {
+    /** Input for the display mode. Defaults to FULL_VIEW. */
+    displayMode: _angular_core.InputSignal<XtDisplayMode>;
+    /** Input for the value to display. */
+    value: _angular_core.InputSignal<any>;
+    /** Input for the value type string used for context creation. */
+    valueType: _angular_core.InputSignal<string | undefined>;
+    /** Computed signal that creates the XtBaseContext from the input values. */
+    context: _angular_core.Signal<XtBaseContext<unknown>>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HostTestTypedComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HostTestTypedComponent, "test-typed-host", never, { "displayMode": { "alias": "displayMode"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "valueType": { "alias": "valueType"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * Same as HostTestSimpleComponent but it includes everything in a form.
+ * Just set the component type, the formGroup and the component  name, and your component will be run.
+ * You can as well easily read and set the value.
+ */
+declare class HostTestTypedFormComponent implements OnInit {
+    /** Injected FormBuilder for creating form groups. */
+    builder: FormBuilder;
+    /** Injected resolver service for type resolution. */
+    resolver: XtResolverService;
+    /** Default control name used if none is provided. */
+    static readonly CONTROL_NAME = "ForTest";
+    /** Input for the value type string. */
+    valueType: _angular_core.InputSignal<string | undefined>;
+    /** Input for the form control name. */
+    controlName: _angular_core.InputSignal<string | undefined>;
+    /** Input for the form description used to generate the form group. */
+    formDescription: _angular_core.InputSignal<any>;
+    /** Input to provide an existing FormGroup directly. */
+    formGroup: _angular_core.InputSignal<FormGroup<any> | undefined>;
+    /** The parent FormGroup that contains the component's form group. */
+    parentFormGroup: FormGroup<{
+        [x: string]: AbstractControl<any, any, any>;
+    }>;
+    /** Computed signal returning the created form group. */
+    createdFormGroup: _angular_core.Signal<FormGroup<any>>;
+    ngOnInit(): void;
+    /**
+     * Computes the form group from inputs, generating one from description or type if needed.
+     * @returns The created FormGroup
+     */
+    protected computeFormGroup(): FormGroup;
+    /** Computed signal that builds the XtBaseContext from form group and control name. */
+    subContext: _angular_core.Signal<XtBaseContext<any>>;
+    /**
+     * Patches a form control with a new value.
+     * @param controlName - The name of the control to patch
+     * @param newVal - The value to set
+     */
+    patchValue(controlName: string, newVal: any): void;
+    /**
+     * Retrieves the current value from a form control.
+     * @param controlName - The name of the control to read
+     * @returns The current form value
+     */
+    retrieveValue(controlName: string): any;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HostTestTypedFormComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HostTestTypedFormComponent, "test-typed-form-host", never, { "valueType": { "alias": "valueType"; "required": false; "isSignal": true; }; "controlName": { "alias": "controlName"; "required": false; "isSignal": true; }; "formDescription": { "alias": "formDescription"; "required": false; "isSignal": true; }; "formGroup": { "alias": "formGroup"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * A very light and not 100% compatible storemanager in case you are not using xt-store.
+ * It can emulate XtStoreManager to some extends for doing some tests
+ */
+declare class StoreTestHelper {
+    /**
+     * Sets a TestStoreManager as the test store manager in StoreSupport.
+     * Call this in test setup to use the in-memory store provider.
+     */
+    static ensureTestProviderOnly(): void;
+}
+/**
+ * A test implementation of IStoreManager that always returns a single TestStoreProvider.
+ * Used to emulate xt-store for unit testing purposes.
+ */
+declare class TestStoreManager implements IStoreManager {
+    /** The default provider returned for all store operations. */
+    protected defaultProvider: TestStoreProvider<never>;
+    /**
+     * Returns the default test store provider.
+     * @param name - Ignored; always returns the same provider
+     * @returns The default TestStoreProvider
+     */
+    getProvider<T = never>(name?: string): IStoreProvider<T> | undefined;
+    /**
+     * Returns the default test store provider (safe variant).
+     * @param name - Ignored; always returns the same provider
+     * @returns The default TestStoreProvider
+     */
+    getProviderSafe<T = never>(name?: string): IStoreProvider<T>;
+    /**
+     * Returns the default test store provider.
+     * @returns The default TestStoreProvider or undefined
+     */
+    getDefaultProvider<T = never>(): IStoreProvider<T> | undefined;
+    /**
+     * Returns the default test store provider (safe variant).
+     * @returns The default TestStoreProvider
+     */
+    getDefaultProviderSafe<T = never>(): IStoreProvider<T>;
+    /**
+     * Creates a new TestStoreCriteria instance.
+     * @param name - The field name for the criteria
+     * @param value - The value to match
+     * @param operator - The comparison operator
+     * @returns A new TestStoreCriteria
+     */
+    newStoreCriteria<T = any>(name: keyof T, value: any, operator: IStoreCriteriaOperator): IStoreCriteria<T>;
+}
+/**
+ * A test implementation of IStoreProvider that stores entities in an in-memory map.
+ * Supports basic CRUD and filtering operations for unit testing.
+ */
+declare class TestStoreProvider<T = never> implements IStoreProvider<T> {
+    /** In-memory data store, keyed by entity type name then by entity key. */
+    protected data: Map<string, Map<string, any>>;
+    /**
+     * Gets or creates a named entity map within the data store.
+     * @param name - The entity type name
+     * @returns The map of entities for the given type
+     */
+    protected getOrCreateArray(name: string): Map<string, T>;
+    /**
+     * Extracts a unique key from a value object, using _id, id, or generating a new one.
+     * @param value - The value to extract the key from
+     * @param create - Whether to generate a new key if none exists
+     * @returns The extracted or generated key string
+     */
+    protected extractKey(value: any, create?: boolean): string;
+    /**
+     * Stores an entity in the in-memory data store.
+     * @param name - The entity type name
+     * @param entity - The entity to store
+     * @returns A promise resolving to the stored entity
+     */
+    storeEntity(name: string, entity: T): Promise<T>;
+    /**
+     * Loads an entity by key, throwing if not found.
+     * @param name - The entity type name
+     * @param key - The entity key
+     * @returns A promise resolving to the entity
+     */
+    safeLoadEntity(name: string, key: any): Promise<T>;
+    /**
+     * Loads an entity by key, returning undefined if not found.
+     * @param name - The entity type name
+     * @param key - The entity key
+     * @returns A promise resolving to the entity or undefined
+     */
+    loadEntity(name: string, key: any): Promise<T | undefined>;
+    /**
+     * Deletes an entity by key.
+     * @param name - The entity type name
+     * @param key - The entity key
+     * @returns A promise resolving to true if deleted, false otherwise
+     */
+    deleteEntity(name: string, key: any): Promise<boolean>;
+    /**
+     * Searches entities by optional criteria. Returns all entities if no criteria provided.
+     * @param name - The entity type name
+     * @param criteria - Optional filter criteria
+     * @returns An observable of matching entities
+     */
+    searchEntities(name: string, ...criteria: IStoreCriteria<T>[]): Observable<T[]>;
+    /**
+     * Search and prepare entities with sorting, grouping, and transformation (not implemented).
+     */
+    searchAndPrepareEntities(name: string, sort?: any, groupBy?: any, transformer?: IDataTransformer<T> | undefined, ...criteria: any[]): Observable<any>;
+    /**
+     * Indicates that this provider supports document storage.
+     * @returns True
+     */
+    canStoreDocument(): boolean;
+    /**
+     * Stores a document file and returns its document info.
+     * @param toStore - The file to store
+     * @returns A promise resolving to the document info
+     */
+    storeDocument(toStore: File): Promise<IDocumentInfo>;
+    /**
+     * Stores multiple document files (not implemented).
+     */
+    storeDocuments(toStore: File[]): Observable<IDocumentInfo>;
+}
+/**
+ * A test implementation of IDocumentInfo for testing document storage operations.
+ */
+declare class TestDocumentInfo implements IDocumentInfo {
+    /** The name of the stored document. */
+    documentName: string;
+    /** Whether the document is referenced by URL. */
+    isUrl: boolean;
+    /** Optional document identifier. */
+    documentId?: string;
+    /**
+     * Creates a new TestDocumentInfo instance.
+     * @param documentName - The document name
+     * @param isUrl - Whether the document is a URL
+     * @param documentId - Optional document identifier
+     */
+    constructor(documentName: string, isUrl: boolean, documentId?: string);
+}
+/**
+ * A test implementation of IStoreCriteria that filters entities by field comparison.
+ */
+declare class TestStoreCriteria<T = any> implements IStoreCriteria<T> {
+    /** The field name to filter on. */
+    name: keyof T;
+    /** The value to compare against. */
+    value: any;
+    /** The comparison operator (=, <=, <). */
+    operator: '=' | '<=' | '<';
+    /**
+     * Creates a new TestStoreCriteria instance.
+     * @param name - The field name to filter on
+     * @param value - The value to compare against
+     * @param operator - The comparison operator (default '=')
+     */
+    constructor(name: keyof T, value: any, operator?: IStoreCriteriaOperator);
+    /**
+     * Filters an entity by comparing its field value against the criteria value.
+     * @param toFilter - The entity to test
+     * @returns True if the entity matches the criteria
+     */
+    filter(toFilter: any): boolean;
+}
+
+export { HostTestFormComponent, HostTestSimpleComponent, HostTestTypedComponent, HostTestTypedFormComponent, ISortByDirection, StoreSupport, StoreTestHelper, TestDocumentInfo, TestStoreCriteria, TestStoreManager, TestStoreProvider, XT_REGISTRY_TOKEN, XT_RESOLVER_TOKEN, XT_TYPE_RESOLVER_TOKEN, XtBaseContext, XtBaseInput, XtBaseModel, XtBaseOutput, XtCompositeComponent, XtMessageHandler, XtPluginRegistry, XtRenderComponent, XtRenderSubComponent, XtResolvedComponent, XtResolverService, XtSimpleComponent, XtUnitTestHelper, attachToFormGroup, initXtPluginRegistry, updateFormGroupWithValue, xtPluginRegistry };
+export type { IDataTransformer, IDocumentInfo, ISortBy, IStoreCriteria, IStoreCriteriaOperator, IStoreManager, IStoreProvider, XtActionHandler, XtActionHandlerInfo, XtActionInfo, XtActionResult, XtComponent, XtComponentInfo, XtComponentInput, XtComponentModel, XtComponentOutput, XtContext, XtDisplayMode, XtInputType, XtModelType, XtOutputType, XtPluginInfo, XtResolver, XtTypeHandlerInfo, XtWorkflow, XtWorkflowInfo };