@axi-engine/fields 0.3.2 → 0.3.4

package/dist/index.d.ts

@@ -1,997 +1,18 @@
-import * as _axi_engine_utils from '@axi-engine/utils';
-import { Constructor, Subscribable, ConstructorRegistry, Emitter, PathType } from '@axi-engine/utils';
-
-interface Policy<T> {
-    readonly id: string;
-    apply: (val: T) => T;
-    destroy?: () => void;
-}
-
-declare class ClampPolicy implements Policy<number> {
-    min: number;
-    max: number;
-    static readonly id = "clamp";
-    readonly id = "clamp";
-    constructor(min: number, max: number);
-    apply(val: number): number;
-    updateBounds(min: number, max: number): void;
-}
-declare function clampPolicy(min: number, max: number): ClampPolicy;
-
-declare class ClampMaxPolicy implements Policy<number> {
-    max: number;
-    static readonly id = "clampMax";
-    readonly id = "clampMax";
-    constructor(max: number);
-    apply(val: number): number;
-    updateBounds(max: number): void;
-}
-declare function clampMaxPolicy(max: number): ClampMaxPolicy;
-
-declare class ClampMinPolicy implements Policy<number> {
-    min: number;
-    static readonly id = "clampMin";
-    readonly id = "clampMin";
-    constructor(min: number);
-    apply(val: number): number;
-    updateBounds(min: number): void;
-}
-declare function clampMinPolicy(min: number): ClampMinPolicy;
-
-declare class Policies<T> {
-    private readonly policies;
-    get items(): Map<string, Policy<T>>;
-    /**
-     * Retrieves a specific policy instance by its ID.
-     * Useful for accessing a policy's internal state or methods.
-     * @template P The expected type of the policy.
-     * @param id The unique ID of the policy to retrieve.
-     * @returns The policy instance, or `undefined` if not found.
-     */
-    get<P extends Policy<T>>(id: string): P | undefined;
-    /**
-     * Adds a new policy to the field or replaces an existing one with the same ID.
-     * The new policy will be applied on the next `set()` operation.
-     * If a policy with the same ID already exists, its `destroy` method will be called before it is replaced.
-     * @param policy The policy instance to add.
-     */
-    add(policy: Policy<T>): this;
-    /**
-     * Removes a policy from the field by its ID and call `destroy` method.
-     * @param policyId The unique ID of the policy to remove.
-     * @returns `true` if the policy was found and removed, otherwise `false`.
-     */
-    remove(policyId: string): boolean;
-    isEmpty(): boolean;
-    /**
-     * Removes all policies from the field.
-     * After this, `set()` will no longer apply any transformations to the value until new policies are added.
-     */
-    clear(): void;
-    /**
-     * Forces the current value to be re-processed by all policies.
-     * Useful if a policy's logic has changed and you need to re-evaluate the current state.
-     */
-    apply(val: T): T;
-}
-
-/**
- * extract field type
- */
-type GetValueType<TField extends Field<any>> = TField extends Field<infer U> ? U : any;
-/**
- * A mapped type that creates the method signatures for a typed mixin.
- * e.g., createBoolean, upsetBoolean, getBoolean
- */
-type TypedMethods<TCtor extends Constructor<Field<any>>, TBaseName extends string> = {
-    [K in `create${TBaseName}`]: (name: string, initialValue: GetValueType<InstanceType<TCtor>>, options?: ConstructorParameters<TCtor>[2]) => InstanceType<TCtor>;
-} & {
-    [K in `upset${TBaseName}`]: (name: string, value: GetValueType<InstanceType<TCtor>>, options?: ConstructorParameters<TCtor>[2]) => InstanceType<TCtor>;
-} & {
-    [K in `get${TBaseName}`]: (name: string) => InstanceType<TCtor>;
-};
-/**
- * A higher-order function that generates a mixin for a specific Field type.
- * This factory removes the need to write boilerplate mixin code for every new field type.
- *
- * @param typeName The `typeName` of the Field to create (e.g., 'boolean', 'my-signal-field').
- * @param baseMethodName The base name for the generated methods (e.g., 'Boolean', 'MySignal').
- * @returns A fully functional, typed mixin.
- */
-declare function createTypedMethodsMixin<TCtor extends Constructor<Field<any>>, TBaseName extends string>(typeName: string, baseMethodName: TBaseName): <TBase extends Constructor<Fields>>(Base: TBase) => Constructor<InstanceType<TBase> & TypedMethods<TCtor, TBaseName>>;
-
-interface FieldOptions<T> {
-    policies?: Policy<T>[];
-}
-interface Field<T> {
-    readonly typeName: string;
-    readonly name: string;
-    value: T;
-    policies: Policies<T>;
-    setValueSilently(val: T): void;
-    batchUpdate(updateFn: (currentValue: T) => T): void;
-    onChange: Subscribable<[newValue: T, oldValue: T]>;
-    destroy(): void;
-}
-interface NumericField extends Field<number> {
-    readonly min: number | undefined;
-    readonly max: number | undefined;
-    isMin(): boolean;
-    isMax(): boolean;
-    inc(val: number): void;
-    dec(val: number): void;
-}
-interface BooleanField extends Field<boolean> {
-    toggle(): boolean;
-}
-interface StringField extends Field<string> {
-    append(str: string | number): this;
-    prepend(str: string | number): this;
-    trim(): this;
-    isEmpty(): boolean;
-    clear(): void;
-}
-
-/**
- * A state container that wraps a value.
- * It allows applying a pipeline of transformation or validation "policies" before any new value is set.
- *
- * @template T The type of the value this field holds.
- *
- */
-declare class CoreField<T> implements Field<T> {
-    /** A type keyword of the field */
-    static readonly typeName: string;
-    readonly typeName: string;
-    /** A unique identifier for the field. */
-    private readonly _name;
-    private _value;
-    private readonly _onChange;
-    readonly onChange: Subscribable<[newValue: T, oldvalue: T]>;
-    readonly policies: Policies<T>;
-    get name(): string;
-    /**
-     * Gets the current raw value of the field.
-     * For reactive updates, it's recommended to use the `.signal` property instead.
-     */
-    get value(): T;
-    /**
-     * Sets a new value for the field.
-     * The provided value will be processed by all registered policies before the underlying signal is updated.
-     * @param val The new value to set.
-     */
-    set value(val: T);
-    /**
-     * Creates an instance of a Field.
-     * @param name A unique identifier for the field.
-     * @param initialVal The initial value of the field.
-     * @param options Optional configuration for the field.
-     * @param options.policies An array of policies to apply to the field's value on every `set` operation.
-     * @param options.isEqual An function for compare old and new value, by default uses the strictEquals from `utils`
-     *
-     */
-    constructor(name: string, initialVal: T, options?: FieldOptions<T>);
-    setValueSilently(val: T): void;
-    batchUpdate(updateFn: (currentValue: T) => T): void;
-    /**
-     * Cleans up resources used by the field and its policies.
-     * This should be called when the field is no longer needed to prevent memory leaks from reactive policies.
-     */
-    destroy(): void;
-}
-
-interface CoreBooleanFieldOptions extends FieldOptions<boolean> {
-}
-declare class CoreBooleanField extends CoreField<boolean> implements BooleanField {
-    static readonly typeName: string;
-    readonly typeName: string;
-    constructor(name: string, initialVal: boolean, options?: CoreBooleanFieldOptions);
-    toggle(): boolean;
-}
-
-interface CoreStringFieldOptions extends FieldOptions<string> {
-}
-declare class CoreStringField extends CoreField<string> implements StringField {
-    static readonly typeName: string;
-    readonly typeName: string;
-    constructor(name: string, initialVal: string, options?: CoreStringFieldOptions);
-    append(str: string | number): this;
-    prepend(str: string | number): this;
-    trim(): this;
-    isEmpty(): boolean;
-    clear(): void;
-}
-
-interface CoreNumericFieldOptions extends FieldOptions<number> {
-    min?: number;
-    max?: number;
-}
-declare class CoreNumericField extends CoreField<number> implements NumericField {
-    static readonly typeName: string;
-    readonly typeName: string;
-    get min(): number | undefined;
-    get max(): number | undefined;
-    constructor(name: string, initialVal: number, options?: CoreNumericFieldOptions);
-    isMin(): boolean;
-    isMax(): boolean;
-    inc(amount?: number): void;
-    dec(amount?: number): void;
-}
-
-declare class FieldRegistry extends ConstructorRegistry<Field<any>> {
-}
-
-/**
- * A container for a collection of named `Field` instances.
- *
- * This class acts as a "leaf" node in the `FieldTree` hierarchy, managing a flat
- * key-value store of reactive data points. It uses a `FieldRegistry` to dynamically
- * create `Field` instances of different types.
- */
-declare class Fields {
-    static readonly typeName = "fields";
-    readonly typeName = "fields";
-    readonly _fields: Map<string, Field<any>>;
-    readonly _fieldRegistry: FieldRegistry;
-    /**
-     * An event emitter that fires when a new field is added to the collection.
-     * @event
-     * @param {object} event - The event payload.
-     * @param {string} event.name - The name of the added field.
-     * @param {Field<any>} event.field - The `Field` instance that was added.
-     */
-    onAdd: Emitter<[event: {
-        name: string;
-        field: Field<any>;
-    }]>;
-    /**
-     * An event emitter that fires after one or more fields have been removed.
-     * @event
-     * @param {object} event - The event payload.
-     * @param {string[]} event.names - An array of names of the fields that were successfully removed.
-     */
-    onRemove: Emitter<[event: {
-        names: string[];
-    }]>;
-    /**
-     * Gets the read-only map of all `Field` instances in this container.
-     * @returns {Map<string, Field<any>>} The collection of fields.
-     */
-    get fields(): Map<string, Field<any>>;
-    /**
-     * Creates an instance of Fields.
-     * @param {FieldRegistry} fieldRegistry - The registry used to create new `Field` instances.
-     */
-    constructor(fieldRegistry: FieldRegistry);
-    /**
-     * Checks if a field with the given name exists in the collection.
-     * @param {string} name The name of the field to check.
-     * @returns {boolean} `true` if the field exists, otherwise `false`.
-     */
-    has(name: string): boolean;
-    /**
-     * Adds a pre-existing `Field` instance to the collection and fires the `onAdd` event.
-     * @template T - The specific `Field` type being added.
-     * @param {Field<any>} field - The `Field` instance to add.
-     * @returns {T} The added `Field` instance, cast to type `T`.
-     * @throws If a field with the same name already exists.
-     */
-    add<T extends Field<any>>(field: Field<any>): T;
-    /**
-     * Creates a new `Field` instance of a specified type, adds it to the collection, and returns it.
-     * This is the primary factory method for creating fields within this container.
-     * @template T - The expected `Field` type to be returned.
-     * @param {string} typeName - The registered type name of the field to create (e.g., 'numeric', 'boolean').
-     * @param {string} name - The unique name for the new field.
-     * @param {*} initialValue - The initial value for the new field.
-     * @param {*} [options] - Optional configuration passed to the field's constructor.
-     * @returns {T} The newly created `Field` instance.
-     */
-    create<T extends Field<any>>(typeName: string, name: string, initialValue: any, options?: any): T;
-    /**
-     * Updates an existing field's value or creates a new one if it doesn't exist.
-     * @template T - The expected `Field` type.
-     * @param {string} typeName - The type name to use if a new field needs to be created.
-     * @param {string} name - The name of the field to update or create.
-     * @param {*} value - The new value to set.
-     * @param {*} [options] - Optional configuration, used only if a new field is created.
-     * @returns {T} The existing or newly created `Field` instance.
-     */
-    upset<T extends Field<any>>(typeName: string, name: string, value: any, options?: any): T;
-    /**
-     * Retrieves a field by its name.
-     * @template TField - The expected `Field` type to be returned.
-     * @param {string} name - The name of the field to retrieve.
-     * @returns {TField} The `Field` instance.
-     * @throws If the field does not exist.
-     */
-    get<TField extends Field<any>>(name: string): TField;
-    /**
-     * Removes one or more fields from the collection.
-     * This method ensures that the `destroy` method of each removed field is called to clean up its resources.
-     * @param {string| string[]} names A single name or an array of names to remove.
-     */
-    remove(names: string | string[]): void;
-    /**
-     * Removes all fields from the collection, ensuring each is properly destroyed.
-     */
-    clear(): void;
-    destroy(): void;
-}
-
-interface FieldsFactory<TFields extends Fields> {
-    fields(): TFields;
-}
-
-/**
- * Defines the contract for a factory that creates nodes for a FieldTree.
- * This allows for custom implementations of Fields and FieldTree to be used.
- */
-interface FieldTreeFactory<TFields extends Fields> extends FieldsFactory<TFields> {
-    fields(): TFields;
-    tree(): FieldTree<TFields>;
-}
-
-/** A type alias for any container that can be a child node in a FieldTree */
-type TreeNode<F extends Fields> = FieldTree<F> | F;
-/**
- * Represents a hierarchical data structure for managing the global state of the system.
- *
- * This class acts as the single source of truth for long-term data that exists
- * across different scenes and scripts, such as player stats, inventory,
- * and overall game progress. It uses a path-based system for accessing and
- * manipulating nested data, similar to a file system.
- *
- */
-declare class FieldTree<TFields extends Fields> {
-    static readonly typeName = "fieldTree";
-    readonly typeName = "fieldTree";
-    /** @private The internal map storing child nodes (branches or leaves). */
-    private readonly _nodes;
-    /** @private The factory used to create new child nodes. */
-    private readonly _factory;
-    /**
-     * An event emitter that fires immediately after a new node is added to this tree branch.
-     * @event
-     * @param {object} event - The event payload.
-     * @param {string} event.name - The name (key) of the added node.
-     * @param event.node - The node instance that was added.
-     * @example
-     * myTree.onAdd.subscribe(({ name, node }) => {
-     *   console.log(`Node '${name}' was added.`, node);
-     * });
-     */
-    onAdd: Emitter<[event: {
-        name: string;
-        node: TreeNode<TFields>;
-    }]>;
-    /**
-     * An event emitter that fires once after one or more nodes have been successfully removed.
-     * @event
-     * @param {object} event - The event payload.
-     * @param {string[]} event.names - An array of names of the nodes that were removed.
-     * @example
-     * myTree.onRemove.subscribe(({ names }) => {
-     *   console.log(`Nodes removed: ${names.join(', ')}`);
-     * });
-     */
-    onRemove: Emitter<[event: {
-        names: string[];
-    }]>;
-    /**
-     * Gets the collection of direct child nodes of this tree branch.
-     */
-    get nodes(): Map<string, TreeNode<TFields>>;
-    /**
-     * Creates an instance of FieldTree.
-     * @param {FieldTreeFactory} factory - A factory responsible for creating new nodes within the tree.
-     */
-    constructor(factory: FieldTreeFactory<TFields>);
-    /**
-     * Checks if a direct child node with the given name exists.
-     * @param {string} name - The name of the direct child node.
-     * @returns {boolean} `true` if the node exists, otherwise `false`.
-     */
-    has(name: string): boolean;
-    /**
-     * Checks if a node exists at a given path, traversing the tree.
-     * @param {PathType} path - The path to check (e.g., 'player/stats' or ['player', 'stats']).
-     * @returns {boolean} `true` if the entire path resolves to a node, otherwise `false`.
-     */
-    hasPath(path: PathType): boolean;
-    /**
-     * Adds a pre-existing node as a direct child of this tree branch.
-     * @param {string} name - The name to assign to the new child node.
-     * @param {TreeNode} node - The node instance to add.
-     * @returns {TreeNode} The added node.
-     * @throws If a node with the same name already exists.
-     */
-    addNode(name: string, node: TreeNode<TFields>): TreeNode<TFields>;
-    /**
-     * Retrieves a direct child node by its name.
-     * @param {string} name - The name of the child node.
-     * @returns {TreeNode} The retrieved node.
-     * @throws If a node with the given name cannot be found.
-     */
-    getNode(name: string): TreeNode<TFields>;
-    /**
-     * Removes one or more nodes from this tree branch.
-     *
-     * This method first validates that all specified nodes exist. If validation passes,
-     * it recursively calls `destroy()` on each node to ensure proper cleanup of the entire subtree.
-     * Finally, it emits a single `onRemove` event with the names of all successfully removed nodes.
-     *
-     * @param {string | string[]} names - A single name or an array of names of the nodes to remove.
-     * @throws If any of the specified names do not correspond to an existing node.
-     */
-    removeNode(names: string | string[]): void;
-    /**
-     * Creates a new `FieldTree` (branch) node at the specified path.
-     * @param {PathType} path - The path where the new `FieldTree` should be created.
-     * @param {boolean} [createPath=false] - If `true`, any missing parent branches in the path will be created automatically.
-     * @returns {FieldTree} The newly created `FieldTree` instance.
-     * @throws If the path is invalid or a node already exists at the target location.
-     */
-    createFieldTree<T extends FieldTree<TFields>>(path: PathType, createPath?: boolean): T;
-    /**
-     * Creates a new `Fields` (leaf) container at the specified path.
-     * @param {PathType} path - The path where the new `Fields` container should be created.
-     * @param {boolean} [createPath=false] - If `true`, any missing parent branches in the path will be created automatically.
-     * @returns {Fields} The newly created `Fields` instance.
-     * @throws If the path is invalid or a node already exists at the target location.
-     */
-    createFields(path: PathType, createPath?: boolean): TFields;
-    /**
-     * Retrieves a `FieldTree` (branch) node from a specified path.
-     * @param {PathType} path - The path to the `FieldTree` node.
-     * @returns {FieldTree} The `FieldTree` instance at the specified path.
-     * @throws If the path is invalid or the node at the path is not a `FieldTree`.
-     */
-    getFieldTree(path: PathType): FieldTree<TFields>;
-    /**
-     * Retrieves a `Fields` (leaf) container from a specified path.
-     * @param {PathType} path - The path to the `Fields` container.
-     * @returns {Fields} The `Fields` instance at the specified path.
-     * @throws If the path is invalid or the node at the path is not a `Fields` container.
-     */
-    getFields(path: PathType): TFields;
-    /**
-     * Retrieves a `FieldTree` at the specified path. If it or any part of the path doesn't exist, it will be created.
-     * @param {PathType} path - The path to the `FieldTree` node.
-     * @returns {FieldTree} The existing or newly created `FieldTree` instance.
-     */
-    getOrCreateFieldTree(path: PathType): FieldTree<TFields>;
-    /**
-     * Retrieves a `Fields` container at the specified path. If it or any part of the path doesn't exist, it will be created.
-     * @param {PathType} path - The path to the `Fields` container.
-     * @returns {Fields} The existing or newly created `Fields` instance.
-     */
-    getOrCreateFields(path: PathType): TFields;
-    /**
-     * Finds the parent node for a given path.
-     * @param path The path to the target node.
-     * @returns The parent node (either a FieldTree or Fields).
-     * @throws An error if the path is invalid or any intermediate node is not a FieldTree.
-     */
-    findParentNode(path: PathType): FieldTree<TFields> | TFields;
-    /**
-     * Removes all child nodes from this tree branch.
-     * This method ensures that `destroy()` is called on each child node, allowing for
-     * a full, recursive cleanup of the entire subtree.
-     */
-    clear(): void;
-    /**
-     * Performs a complete cleanup of this node and its entire subtree.
-     *
-     * It recursively destroys all child nodes by calling `clear()` and then
-     * unsubscribes all listeners from its own event emitters.
-     * This method should be called when a node is no longer needed.
-     */
-    destroy(): void;
-    /**
-     * @private
-     * Navigates the tree to the parent of a target node.
-     * This is the core traversal logic for all path-based operations.
-     * @param {PathType} path - The full path to the target node.
-     * @param {boolean} [createPath=false] - If `true`, creates missing `FieldTree` branches along the path.
-     * @returns {{branch: FieldTree, leafName: string}} An object containing the final branch (parent node) and the name of the leaf (target node).
-     * @throws If the path is empty, invalid, or contains a `Fields` container as an intermediate segment.
-     */
-    private traversePath;
-}
-
-declare const CoreFields_base: _axi_engine_utils.Constructor<{
-    createGeneric<T>(name: string, initialValue: T, options?: FieldOptions<T> | undefined): CoreField<T>;
-    upsetGeneric<T>(name: string, value: T, options?: FieldOptions<T> | undefined): CoreField<T>;
-    getGeneric<T>(name: string): CoreField<T>;
-    readonly typeName: "fields";
-    readonly _fields: Map<string, Field<any>>;
-    readonly _fieldRegistry: FieldRegistry;
-    onAdd: _axi_engine_utils.Emitter<[event: {
-        name: string;
-        field: Field<any>;
-    }]>;
-    onRemove: _axi_engine_utils.Emitter<[event: {
-        names: string[];
-    }]>;
-    get fields(): Map<string, Field<any>>;
-    has(name: string): boolean;
-    add<T extends Field<any>>(field: Field<any>): T;
-    create<T extends Field<any>>(typeName: string, name: string, initialValue: any, options?: any): T;
-    upset<T extends Field<any>>(typeName: string, name: string, value: any, options?: any): T;
-    get<TField extends Field<any>>(name: string): TField;
-    remove(names: string | string[]): void;
-    clear(): void;
-    destroy(): void;
-} & Fields & {
-    createNumeric: (name: string, initialValue: number, options?: CoreNumericFieldOptions | undefined) => CoreNumericField;
-} & {
-    upsetNumeric: (name: string, value: number, options?: CoreNumericFieldOptions | undefined) => CoreNumericField;
-} & {
-    getNumeric: (name: string) => CoreNumericField;
-} & {
-    createString: (name: string, initialValue: string, options?: CoreStringFieldOptions | undefined) => CoreStringField;
-} & {
-    upsetString: (name: string, value: string, options?: CoreStringFieldOptions | undefined) => CoreStringField;
-} & {
-    getString: (name: string) => CoreStringField;
-} & {
-    createBoolean: (name: string, initialValue: boolean, options?: CoreBooleanFieldOptions | undefined) => CoreBooleanField;
-} & {
-    upsetBoolean: (name: string, value: boolean, options?: CoreBooleanFieldOptions | undefined) => CoreBooleanField;
-} & {
-    getBoolean: (name: string) => CoreBooleanField;
-}>;
-declare class CoreFields extends CoreFields_base {
-}
-
-declare class CoreFieldsFactory implements FieldsFactory<CoreFields> {
-    protected readonly _fieldRegistry: FieldRegistry;
-    get fieldRegistry(): FieldRegistry;
-    constructor(fieldRegistry: FieldRegistry);
-    fields(): CoreFields;
-}
-
-declare class CoreFieldTree extends FieldTree<CoreFields> {
-}
-
-/**
- * The default factory implementation that creates standard DefaultFields and FieldTree instances.
- */
-declare class CoreTreeNodeFactory extends CoreFieldsFactory implements FieldTreeFactory<CoreFields> {
-    constructor(fieldRegistry: FieldRegistry);
-    tree(): CoreFieldTree;
-}
-
-/**
- * Defines the contract for a handler that can serialize and deserialize a specific type of Policy.
- * @template T - The specific Policy class this handler manages.
- * @template S - The shape of the plain object this handler produces/consumes.
- */
-interface PolicySerializerHandler<T extends Policy<any>, S extends object> {
-    /**
-     * Converts a Policy instance into a serializable plain object.
-     * @param policy The Policy instance to serialize.
-     * @returns A plain object representing the policy's state.
-     */
-    snapshot(policy: T): S;
-    /**
-     * Creates a new Policy instance from a plain object.
-     * @param snapshotData The plain object containing the policy's state.
-     * @returns A new instance of the Policy.
-     */
-    hydrate(snapshotData: S): T;
-}
-declare class PolicySerializer {
-    private readonly handlers;
-    register(policyId: string, handler: PolicySerializerHandler<any, any>): this;
-    clearHandlers(): void;
-    /**
-     * Creates a serializable snapshot of a policy instance.
-     * The snapshot includes the policy's state and a `__type` identifier.
-     * @param policy The policy instance to snapshot.
-     * @returns A plain object ready for JSON serialization.
-     * @throws If no handler is registered for the policy's ID.
-     */
-    snapshot(policy: Policy<any>): object;
-    /**
-     * Restores a policy instance from its snapshot representation.
-     * @param snapshot The plain object snapshot, which must contain a `__type` property.
-     * @returns A new, fully functional policy instance.
-     * @throws If the snapshot is invalid or no handler is registered for its `__type`.
-     */
-    hydrate(snapshot: any): Policy<any>;
-}
-
-declare class ClampPolicySerializerHandler implements PolicySerializerHandler<ClampPolicy, {
-    min: number;
-    max: number;
-}> {
-    snapshot(policy: ClampPolicy): {
-        min: number;
-        max: number;
-    };
-    hydrate(data: {
-        min: number;
-        max: number;
-    }): ClampPolicy;
-}
-
-declare class ClampMaxPolicySerializerHandler implements PolicySerializerHandler<ClampMaxPolicy, {
-    max: number;
-}> {
-    snapshot(policy: ClampMaxPolicy): {
-        max: number;
-    };
-    hydrate(data: {
-        max: number;
-    }): ClampMaxPolicy;
-}
-
-declare class ClampMinPolicySerializerHandler implements PolicySerializerHandler<ClampMinPolicy, {
-    min: number;
-}> {
-    snapshot(policy: ClampMinPolicy): {
-        min: number;
-    };
-    hydrate(data: {
-        min: number;
-    }): ClampMinPolicy;
-}
-
-/**
- * A plain object representation of a Field's state for serialization.
- */
-interface FieldSnapshot {
-    __type: string;
-    name: string;
-    value: any;
-    policies?: object[];
-}
-/**
- * Orchestrates the serialization and deserialization of Field instances.
- *
- * This class acts as a central point for converting complex Field objects into
- * plain, storable data (snapshots) and vice-versa. It uses a `FieldRegistry`
- * to resolve class constructors and a `PolicySerializer` to handle the state
- * of any attached policies.
- *
- * @todo Implement a `patch(field, snapshot)` method.
- *       Unlike `hydrate`, which creates a new
- *       instance, `patch` should update the state of an *existing* field instance
- *       without breaking external references to it.
- */
-declare class FieldSerializer {
-    private readonly fieldRegistry;
-    private readonly policySerializer;
-    /**
-     * Creates an instance of FieldSerializer.
-     * @param {FieldRegistry} fieldRegistry - A registry that maps string type names to Field constructors.
-     * @param {PolicySerializer} policySerializer - A serializer dedicated to handling Policy instances.
-     */
-    constructor(fieldRegistry: FieldRegistry, policySerializer: PolicySerializer);
-    /**
-     * Creates a serializable snapshot of a Field instance.
-     * The snapshot includes the field's type, name, current value, and the state of all its policies.
-     * @param {Field<any>} field - The Field instance to serialize.
-     * @returns {FieldSnapshot} A plain object ready for JSON serialization.
-     */
-    snapshot(field: Field<any>): FieldSnapshot;
-    /**
-     * Restores a Field instance from its snapshot representation.
-     * It uses the `__type` property to find the correct constructor and hydrates
-     * the field with its value and all its policies.
-     * @param {FieldSnapshot} snapshot - The plain object snapshot to deserialize.
-     * @returns {Field<any>} A new, fully functional Field instance.
-     * @throws If the snapshot is invalid, missing a `__type`, or if the type is not registered.
-     */
-    hydrate(snapshot: FieldSnapshot): Field<any>;
-}
-
-/**
- * A plain object representation of a Fields container's state for serialization.
- */
-interface FieldsSnapshot {
-    __type: string;
-    [fieldName: string]: FieldSnapshot | string;
-}
-/**
- * Orchestrates the serialization and deserialization of `Fields` container instances.
- *
- * This class acts as a high-level composer, responsible for converting an entire `Fields` object
- * into a storable snapshot and back.
- * It delegates the actual serialization of each `Field` and `Policy` to their respective serializers.
- *
- * @todo Implement a `patch(fields, snapshot)` method. It should perform a non-destructive
- *       update, creating new fields, removing missing ones, and patching existing ones
- *       in place, preserving the container instance itself.
- */
-declare class FieldsSerializer<TFields extends Fields> {
-    private readonly fieldsFactory;
-    private readonly fieldSerializer;
-    /**
-     * Creates an instance of FieldsSerializer.
-     * @param {FieldsFactory} fieldsFactory - A registry that maps string type names to Field constructors.
-     * @param {FieldSerializer} fieldSerializer - A serializer of field instances.
-     */
-    constructor(fieldsFactory: FieldsFactory<TFields>, fieldSerializer: FieldSerializer);
-    /**
-     * Creates a serializable snapshot of a `Fields` container.
-     *
-     * The snapshot includes a `__type` identifier (currently hardcoded) and an array of snapshots
-     * for each `Field` within the container.
-     * @param {Fields} fields - The `Fields` instance to serialize.
-     * @returns {FieldsSnapshot} A plain object ready for JSON serialization.
-     */
-    snapshot(fields: Fields): FieldsSnapshot;
-    /**
-     * Restores a `Fields` container instance from its snapshot representation.
-     *
-     * It iterates through the field snapshots and hydrates them individually, adding them to the new container.
-     * @param {FieldsSnapshot} snapshot - The plain object snapshot to deserialize.
-     * @returns {Fields} A new `DefaultFields` instance populated with the restored fields.
-     */
-    hydrate(snapshot: FieldsSnapshot): TFields;
-}
-
-/**
- * Represents the serializable state of a `FieldTree` container.
- *
- * This type describes a plain object that has:
- * 1. A required `__type` property to identify the tree's class.
- * 2. An arbitrary number of other properties, where each key is the `name`
- *    of a child node, and the value is the snapshot of that child node.
- *    The `| string` is included to ensure compatibility with the `__type` property.
- */
-interface FieldTreeSnapshot {
-    __type: string;
-    [fieldName: string]: FieldsSnapshot | FieldTreeSnapshot | string;
-}
-/**
- * Orchestrates the recursive serialization and deserialization of `FieldTree` instances.
- *
- * This class handles the conversion of an entire `FieldTree` object graph into a
- * plain, storable snapshot and vice-versa. It delegates the processing of `Fields`
- * leaf nodes to a dedicated `FieldsSerializer`.
- * @todo Refactoring: The current implementation uses `if/else` logic in `snapshot` and `hydrate`
- *       to process different node types. A more extensible approach would be to use a
- *       registry of dedicated handlers for each node type.
- *       This would allow new node types to be supported without
- *       modifying this class, adhering to the Open/Closed Principle.
- *
- * @todo Implement a `patch(tree, snapshot)` method for recursive, non-destructive
- *       updates. This method should traverse the existing tree and the snapshot,
- *       patching nodes in place to maintain object references.
- */
-declare class FieldTreeSerializer<TFields extends Fields> {
-    private readonly fieldTreeNodeFactory;
-    private readonly fieldsSerializer;
-    constructor(fieldTreeNodeFactory: FieldTreeFactory<TFields>, fieldsSerializer: FieldsSerializer<TFields>);
-    /**
-     * Creates a serializable snapshot of the entire tree and its contained fields.
-     * @returns A plain JavaScript object representing the complete state managed by this tree.
-     */
-    snapshot(tree: FieldTree<TFields>): FieldTreeSnapshot;
-    /**
-     * Restores the state of the tree from a snapshot.
-     * It intelligently creates missing nodes based on `__type` metadata and delegates hydration to child nodes.
-     * @param snapshot The snapshot object to load.
-     */
-    hydrate(snapshot: FieldTreeSnapshot): FieldTree<TFields>;
-}
-
-interface StoreCreateFieldOptions {
-    /** Allows to explicitly specify the field type, overriding the automatic type detection. */
-    fieldType?: string;
-}
-/**
- * Defines the primary high-level API for interacting with the state management system.
- * It acts as a facade, simplifying access to the underlying FieldTree and providing
- * both type-safe and dynamic methods for manipulating data.
- */
-interface Store {
-    /**
-     * Retrieves the raw value of a Field at a specific path.
-     * @template T The expected type of the value.
-     * @param path The path to the field (e.g., 'player.stats.hp').
-     * @returns {T} The raw value stored in the field.
-     * @throws An error if the path is invalid or no field exists at the path.
-     */
-    getValue<T>(path: PathType): T;
-    /**
-     * Strictly sets the value of an *existing* Field at a specific path.
-     * @template T The type of the value being set.
-     * @param path The path to the existing field.
-     * @param val The new value to set.
-     * @returns {T} The value that was set.
-     * @throws An error if no field exists at the specified path.
-     */
-    setValue<T>(path: PathType, val: T): T;
-    /**
-     * Creates a new Field at a specified path, inferring its type from the provided value.
-     * This is a strict operation and will fail if a node already exists at the target path.
-     * @template T The type of the initial value.
-     * @param path The full path where the new field will be created.
-     * @param val The initial value for the field.
-     * @param options Optional configuration, including policies and the ability to override field type.
-     * @returns {T} value of the newly created Field instance.
-     * @throws An error if a node already exists at the path or if the parent path is invalid.
-     */
-    createValue<T>(path: PathType, val: T, options?: FieldOptions<T> & StoreCreateFieldOptions): T;
-    /**
-     * Creates new or update a Field at a specified path, inferring its type from the provided value.
-     * @template T The type of the initial value.
-     * @param path The full path where the new field will be created.
-     * @param val The initial value for the field.
-     * @param options Optional configuration, including policies and the ability to override field type.
-     * @returns {T} value of the newly created Field instance.
-     * @throws An error if a node already exists at the path or if the parent path is invalid.
-     */
-    upsetValue<T>(path: PathType, val: T, options?: FieldOptions<T> & StoreCreateFieldOptions): T;
-    /**
-     * Creates a new, strongly-typed CoreBooleanField.
-     * @throws An error if a node already exists at the path.
-     */
-    createBoolean(path: PathType, initialValue: boolean, options?: CoreBooleanFieldOptions): CoreBooleanField;
-    /**
-     * Creates a new, strongly-typed CoreNumericField.
-     * @throws An error if a node already exists at the path.
-     */
-    createNumeric(path: PathType, initialValue: number, options?: CoreNumericFieldOptions): CoreNumericField;
-    /**
-     * Creates a new, strongly-typed CoreStringField.
-     * @throws An error if a node already exists at the path.
-     */
-    createString(path: PathType, initialValue: string, options?: CoreStringFieldOptions): CoreStringField;
-    /**
-     * Creates a new, generic CoreField instance for any data type.
-     * @throws An error if a node already exists at the path.
-     */
-    createGeneric<T>(path: PathType, initialValue: T, options?: FieldOptions<T>): CoreField<T>;
-    /**
-     * Retrieves a strongly-typed CoreBooleanField instance.
-     * @throws An error if the path is invalid or the field is not of the expected type.
-     */
-    getBoolean(path: PathType): CoreBooleanField;
-    /**
-     * Retrieves a strongly-typed CoreNumericField instance.
-     * @throws An error if the path is invalid or the field is not of the expected type.
-     */
-    getNumeric(path: PathType): CoreNumericField;
-    /**
-     * Retrieves a strongly-typed CoreStringField instance.
-     * @throws An error if the path is invalid or the field is not of the expected type.
-     */
-    getString(path: PathType): CoreStringField;
-    /**
-     * Retrieves a generic CoreField instance.
-     * @throws An error if the path is invalid.
-     */
-    getGeneric<T>(path: PathType): CoreField<T>;
-    /**
-     * A generic method to retrieve a Field instance with a specific asserted type.
-     * @template TField The expected Field class or interface.
-     * @throws An error if the path is invalid or the field cannot be cast to the specified type.
-     */
-    getField<TField extends Field<any>>(path: PathType): TField;
-    /**
-     * Strictly creates a new CoreFields container.
-     * Any missing parent nodes in the path will be created automatically.
-     * @param path The path where the new Fields container will be created.
-     * @returns {CoreFields} The newly created CoreFields instance.
-     * @throws An error if a node already exists at the target path.
-     */
-    createFields(path: PathType): CoreFields;
-    /**
-     * Strictly creates a new CoreFieldTree node.
-     * Any missing parent nodes in the path will be created automatically.
-     * @param path The path where the new FieldTree node will be created.
-     * @returns {CoreFieldTree} The newly created CoreFieldTree instance.
-     * @throws An error if a node already exists at the target path.
-     */
-    createTree(path: PathType): CoreFieldTree;
-    /**
-     * Retrieves an existing CoreFields container.
-     * @param path The path to the Fields container.
-     * @returns {CoreFields} The found CoreFields instance.
-     * @throws An error if the path is invalid or the node at the path is not a Fields container.
-     */
-    getFields(path: PathType): CoreFields;
-    /**
-     * Retrieves an existing CoreFieldTree node.
-     * @param path The path to the FieldTree node.
-     * @returns {CoreFieldTree} The found CoreFieldTree instance.
-     * @throws An error if the path is invalid or the node at the path is not a FieldTree.
-     */
-    getTree(path: PathType): CoreFieldTree;
-    /**
-     * Removes the node (Field, Fields, or FieldTree) at the end of the specified path.
-     * This method does not remove parent nodes if they become empty.
-     * @param path The path to the node to remove.
-     */
-    remove(path: PathType): void;
-}
-
-interface DataStoreFieldResolver {
-    /**
-     * The typeName this resolver corresponds to in the FieldRegistry.
-     * e.g., 'numeric', 'boolean', 'vector'
-     */
-    typeName: string;
-    /**
-     * Checks if this resolver can handle the given value.
-     * @param value The value to check.
-     * @returns {boolean} True if the value is supported, otherwise false.
-     */
-    supports(value: unknown): boolean;
-}
-
-declare class DataStore implements Store {
-    private readonly tree;
-    private readonly resolvers;
-    private readonly rootFieldsName;
-    private _rootFields;
-    private get rootFields();
-    constructor(tree: CoreFieldTree);
-    registerResolver(resolver: DataStoreFieldResolver): void;
-    clearResolvers(): void;
-    getValue<T>(path: PathType): T;
-    setValue<T>(path: PathType, val: T): T;
-    createValue<T>(path: PathType, val: T, options?: FieldOptions<T> & StoreCreateFieldOptions): T;
-    upsetValue<T>(path: PathType, val: T, options?: FieldOptions<T> & StoreCreateFieldOptions): T;
-    createBoolean(path: PathType, initialValue: boolean, options?: CoreBooleanFieldOptions): CoreBooleanField;
-    createNumeric(path: PathType, initialValue: number, options?: CoreNumericFieldOptions): CoreNumericField;
-    createString(path: PathType, initialValue: string, options?: CoreStringFieldOptions): CoreStringField;
-    createGeneric<T>(path: PathType, initialValue: T, options?: FieldOptions<T>): CoreField<T>;
-    getBoolean(path: PathType): CoreBooleanField;
-    getNumeric(path: PathType): CoreNumericField;
-    getString(path: PathType): CoreStringField;
-    getGeneric<T>(path: PathType): CoreField<T>;
-    getField<TField extends Field<any>>(path: PathType): TField;
-    createFields(path: PathType): CoreFields;
-    createTree(path: PathType): CoreFieldTree;
-    getFields(path: PathType): CoreFields;
-    getTree(path: PathType): CoreFieldTree;
-    remove(path: PathType): void;
-    private isPathToRootFields;
-    private getDestinationFields;
-}
-
-/**
- * Creates and configures a FieldRegistry with all the core field types.
- * @returns {FieldRegistry} A pre-configured FieldRegistry instance.
- */
-declare function createCoreFieldRegistry(): FieldRegistry;
-/**
- * Creates and configures a PolicySerializer with handlers for core policies.
- * @returns {PolicySerializer} A pre-configured PolicySerializer instance.
- */
-declare function createCorePolicySerializer(): PolicySerializer;
-/**
- * Creates a factory for CoreFieldTree and CoreFields nodes.
- * @param {FieldRegistry} fieldRegistry - The registry to be used by the factory.
- * @returns {CoreTreeNodeFactory} A new CoreTreeNodeFactory instance.
- */
-declare function createCoreTreeNodeFactory(fieldRegistry: FieldRegistry): CoreTreeNodeFactory;
-/**
- * Creates a fully configured serializer for a FieldTree.
- * This function composes all necessary serializers (FieldTree, Fields, Field) for a complete setup.
- * @param {CoreTreeNodeFactory} fieldTreeNodeFactory - The factory used to create new tree nodes during deserialization.
- * @param policySerializer
- * @returns {FieldTreeSerializer<CoreFields>} A top-level serializer for the entire field tree.
- */
-declare function createCoreTreeSerializer(fieldTreeNodeFactory: CoreTreeNodeFactory, policySerializer?: PolicySerializer): FieldTreeSerializer<CoreFields>;
-interface CoreFieldSystemConfig {
-    registry?: FieldRegistry;
-    policySerializer?: PolicySerializer;
-}
-/**
- * Creates a complete core setup for the field system.
- * @returns {{factory: CoreTreeNodeFactory, serializer: FieldTreeSerializer<CoreFields>}}
- */
-declare function createCoreFieldSystem(config?: CoreFieldSystemConfig): {
-    factory: CoreTreeNodeFactory;
-    serializer: FieldTreeSerializer<CoreFields>;
-};
-
-export { type BooleanField, ClampMaxPolicy, ClampMaxPolicySerializerHandler, ClampMinPolicy, ClampMinPolicySerializerHandler, ClampPolicy, ClampPolicySerializerHandler, CoreBooleanField, type CoreBooleanFieldOptions, CoreField, type CoreFieldSystemConfig, CoreFieldTree, CoreFields, CoreFieldsFactory, CoreNumericField, type CoreNumericFieldOptions, CoreStringField, type CoreStringFieldOptions, CoreTreeNodeFactory, DataStore, type Field, type FieldOptions, FieldRegistry, FieldSerializer, type FieldSnapshot, FieldTree, type FieldTreeFactory, FieldTreeSerializer, type FieldTreeSnapshot, Fields, type FieldsFactory, FieldsSerializer, type FieldsSnapshot, type NumericField, Policies, type Policy, PolicySerializer, type PolicySerializerHandler, type Store, type StoreCreateFieldOptions, type StringField, type TreeNode, clampMaxPolicy, clampMinPolicy, clampPolicy, createCoreFieldRegistry, createCoreFieldSystem, createCorePolicySerializer, createCoreTreeNodeFactory, createCoreTreeSerializer, createTypedMethodsMixin };
+export * from './policies/index';
+export * from './mixins/mixin-factory';
+export * from './field';
+export * from './field-definitions';
+export * from './field-registry';
+export * from './fields';
+export * from './field-tree';
+export * from './fields-factory';
+export * from './field-tree-factory';
+export * from './core-fields';
+export * from './core-fields-factory';
+export * from './core-field-tree';
+export * from './core-field-tree-factory';
+export * from './serializer/index';
+export * from './store';
+export * from './data-store';
+export * from './setup';
+//# sourceMappingURL=index.d.ts.map