@axi-engine/fields 0.3.1 → 0.3.3

package/dist/index.d.mts

@@ -1,80 +1,86 @@
-import * as _axi_engine_utils from '@axi-engine/utils';
-import { Constructor, Subscribable, Emitter, PathType } from '@axi-engine/utils';
+import * as _axi_engine_utils0 from "@axi-engine/utils";
+import { Constructor, ConstructorRegistry, Emitter, PathType, Subscribable } from "@axi-engine/utils";
 
+//#region src/policies/policy.d.ts
 interface Policy<T> {
-    readonly id: string;
-    apply: (val: T) => T;
-    destroy?: () => void;
+  readonly id: string;
+  apply: (val: T) => T;
+  destroy?: () => void;
 }
-
+//#endregion
+//#region src/policies/clamp-policy.d.ts
 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;
+  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;
-
+//#endregion
+//#region src/policies/clamp-max-policy.d.ts
 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;
+  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;
-
+//#endregion
+//#region src/policies/clamp-min-policy.d.ts
 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;
+  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;
-
+//#endregion
+//#region src/policies/policies.d.ts
 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;
-}
-
+  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;
+}
+//#endregion
+//#region src/mixins/mixin-factory.d.ts
 /**
  * extract field type
  */
@@ -83,13 +89,7 @@ type GetValueType<TField extends Field<any>> = TField extends Field<infer U> ? U
  * 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>;
-};
+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.
@@ -99,39 +99,41 @@ type TypedMethods<TCtor extends Constructor<Field<any>>, TBaseName extends strin
  * @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>>;
-
+//#endregion
+//#region src/field.d.ts
 interface FieldOptions<T> {
-    policies?: Policy<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;
+  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;
+  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;
+  toggle(): boolean;
 }
 interface StringField extends Field<string> {
-    append(str: string | number): this;
-    prepend(str: string | number): this;
-    trim(): this;
-    isEmpty(): boolean;
-    clear(): void;
-}
-
+  append(str: string | number): this;
+  prepend(str: string | number): this;
+  trim(): this;
+  isEmpty(): boolean;
+  clear(): void;
+}
+//#endregion
+//#region src/field-definitions/core-field.d.ts
 /**
  * A state container that wraps a value.
  * It allows applying a pipeline of transformation or validation "policies" before any new value is set.
@@ -140,126 +142,89 @@ interface StringField extends Field<string> {
  *
  */
 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> {
-}
+  /** 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;
+}
+//#endregion
+//#region src/field-definitions/core-boolean-field.d.ts
+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> {
-}
+  static readonly typeName: string;
+  readonly typeName: string;
+  constructor(name: string, initialVal: boolean, options?: CoreBooleanFieldOptions);
+  toggle(): boolean;
+}
+//#endregion
+//#region src/field-definitions/core-string-field.d.ts
+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;
-}
-
+  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;
+}
+//#endregion
+//#region src/field-definitions/core-numeric-field.d.ts
 interface CoreNumericFieldOptions extends FieldOptions<number> {
-    min?: number;
-    max?: 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;
-}
-
-/**
- * A generic registry for mapping string identifiers to class constructors.
- *
- * This utility is fundamental for building extensible systems like dependency injection containers,
- * factories, and serialization engines where types need to be dynamically resolved.
- *
- * @template T - A base type that all registered constructors must produce an instance of.
- */
-declare class ConstructorRegistry<T> {
-    private readonly items;
-    /**
-     * Registers a constructor with a unique string identifier.
-     *
-     * @param typeId - The unique identifier for the constructor (e.g., a static `typeName` property from a class).
-     * @param ctor - The class constructor to register.
-     * @returns The registry instance for chainable calls.
-     * @throws If a constructor with the same `typeId` is already registered.
-     */
-    register(typeId: string, ctor: Constructor<T>): this;
-    /**
-     * Retrieves a constructor by its identifier.
-     *
-     * @param typeId - The identifier of the constructor to retrieve.
-     * @returns The found class constructor.
-     * @throws If no constructor is found for the given `typeId`.
-     */
-    get(typeId: string): Constructor<T>;
-    /**
-     * Checks if a constructor for a given identifier is registered.
-     * @param typeId - The identifier to check.
-     * @returns `true` if a constructor is registered, otherwise `false`.
-     */
-    has(typeId: string): boolean;
-    /**
-     * Clears all registered constructors from the registry.
-     */
-    clear(): void;
-}
-
-declare class FieldRegistry extends ConstructorRegistry<Field<any>> {
-}
-
+  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;
+}
+//#endregion
+//#region src/field-registry.d.ts
+declare class FieldRegistry extends ConstructorRegistry<Field<any>> {}
+//#endregion
+//#region src/fields.d.ts
 /**
  * A container for a collection of named `Field` instances.
  *
@@ -268,109 +233,112 @@ declare class FieldRegistry extends ConstructorRegistry<Field<any>> {
  * 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;
-}
-
+  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;
+}
+//#endregion
+//#region src/fields-factory.d.ts
 interface FieldsFactory<TFields extends Fields> {
-    fields(): TFields;
+  fields(): TFields;
 }
-
+//#endregion
+//#region src/field-tree-factory.d.ts
 /**
  * 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>;
+  fields(): TFields;
+  tree(): FieldTree<TFields>;
 }
-
+//#endregion
+//#region src/field-tree.d.ts
 /** A type alias for any container that can be a child node in a FieldTree */
 type TreeNode<F extends Fields> = FieldTree<F> | F;
 /**
@@ -383,309 +351,316 @@ type TreeNode<F extends Fields> = FieldTree<F> | F;
  *
  */
 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;
+  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;
+}
+//#endregion
+//#region src/core-fields.d.ts
+declare const CoreFields_base: _axi_engine_utils0.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_utils0.Emitter<[event: {
+    name: string;
+    field: Field<any>;
+  }]>;
+  onRemove: _axi_engine_utils0.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;
+  createNumeric: (name: string, initialValue: number, options?: CoreNumericFieldOptions | undefined) => CoreNumericField;
 } & {
-    upsetNumeric: (name: string, value: number, options?: CoreNumericFieldOptions | undefined) => CoreNumericField;
+  upsetNumeric: (name: string, value: number, options?: CoreNumericFieldOptions | undefined) => CoreNumericField;
 } & {
-    getNumeric: (name: string) => CoreNumericField;
+  getNumeric: (name: string) => CoreNumericField;
 } & {
-    createString: (name: string, initialValue: string, options?: CoreStringFieldOptions | undefined) => CoreStringField;
+  createString: (name: string, initialValue: string, options?: CoreStringFieldOptions | undefined) => CoreStringField;
 } & {
-    upsetString: (name: string, value: string, options?: CoreStringFieldOptions | undefined) => CoreStringField;
+  upsetString: (name: string, value: string, options?: CoreStringFieldOptions | undefined) => CoreStringField;
 } & {
-    getString: (name: string) => CoreStringField;
+  getString: (name: string) => CoreStringField;
 } & {
-    createBoolean: (name: string, initialValue: boolean, options?: CoreBooleanFieldOptions | undefined) => CoreBooleanField;
+  createBoolean: (name: string, initialValue: boolean, options?: CoreBooleanFieldOptions | undefined) => CoreBooleanField;
 } & {
-    upsetBoolean: (name: string, value: boolean, options?: CoreBooleanFieldOptions | undefined) => CoreBooleanField;
+  upsetBoolean: (name: string, value: boolean, options?: CoreBooleanFieldOptions | undefined) => CoreBooleanField;
 } & {
-    getBoolean: (name: string) => CoreBooleanField;
+  getBoolean: (name: string) => CoreBooleanField;
 }>;
-declare class CoreFields extends CoreFields_base {
-}
-
+declare class CoreFields extends CoreFields_base {}
+//#endregion
+//#region src/core-fields-factory.d.ts
 declare class CoreFieldsFactory implements FieldsFactory<CoreFields> {
-    protected readonly _fieldRegistry: FieldRegistry;
-    get fieldRegistry(): FieldRegistry;
-    constructor(fieldRegistry: FieldRegistry);
-    fields(): CoreFields;
-}
-
-declare class CoreFieldTree extends FieldTree<CoreFields> {
-}
-
+  protected readonly _fieldRegistry: FieldRegistry;
+  get fieldRegistry(): FieldRegistry;
+  constructor(fieldRegistry: FieldRegistry);
+  fields(): CoreFields;
+}
+//#endregion
+//#region src/core-field-tree.d.ts
+declare class CoreFieldTree extends FieldTree<CoreFields> {}
+//#endregion
+//#region src/core-field-tree-factory.d.ts
 /**
  * The default factory implementation that creates standard DefaultFields and FieldTree instances.
  */
 declare class CoreTreeNodeFactory extends CoreFieldsFactory implements FieldTreeFactory<CoreFields> {
-    constructor(fieldRegistry: FieldRegistry);
-    tree(): CoreFieldTree;
+  constructor(fieldRegistry: FieldRegistry);
+  tree(): CoreFieldTree;
 }
-
+//#endregion
+//#region src/serializer/policy-serializer.d.ts
 /**
  * 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;
+  /**
+       * 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>;
-}
-
+  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>;
+}
+//#endregion
+//#region src/serializer/policies/clamp-policy-serializer-handler.d.ts
 declare class ClampPolicySerializerHandler implements PolicySerializerHandler<ClampPolicy, {
+  min: number;
+  max: number;
+}> {
+  snapshot(policy: ClampPolicy): {
     min: number;
     max: number;
-}> {
-    snapshot(policy: ClampPolicy): {
-        min: number;
-        max: number;
-    };
-    hydrate(data: {
-        min: number;
-        max: number;
-    }): ClampPolicy;
+  };
+  hydrate(data: {
+    min: number;
+    max: number;
+  }): ClampPolicy;
 }
-
+//#endregion
+//#region src/serializer/policies/clamp-max-policy-serializer-handler.d.ts
 declare class ClampMaxPolicySerializerHandler implements PolicySerializerHandler<ClampMaxPolicy, {
-    max: number;
+  max: number;
 }> {
-    snapshot(policy: ClampMaxPolicy): {
-        max: number;
-    };
-    hydrate(data: {
-        max: number;
-    }): ClampMaxPolicy;
+  snapshot(policy: ClampMaxPolicy): {
+    max: number;
+  };
+  hydrate(data: {
+    max: number;
+  }): ClampMaxPolicy;
 }
-
+//#endregion
+//#region src/serializer/policies/clamp-min-policy-serializer-handler.d.ts
 declare class ClampMinPolicySerializerHandler implements PolicySerializerHandler<ClampMinPolicy, {
-    min: number;
+  min: number;
 }> {
-    snapshot(policy: ClampMinPolicy): {
-        min: number;
-    };
-    hydrate(data: {
-        min: number;
-    }): ClampMinPolicy;
+  snapshot(policy: ClampMinPolicy): {
+    min: number;
+  };
+  hydrate(data: {
+    min: number;
+  }): ClampMinPolicy;
 }
-
+//#endregion
+//#region src/serializer/field-serializer.d.ts
 /**
  * A plain object representation of a Field's state for serialization.
  */
 interface FieldSnapshot {
-    __type: string;
-    name: string;
-    value: any;
-    policies?: object[];
+  __type: string;
+  name: string;
+  value: any;
+  policies?: object[];
 }
 /**
  * Orchestrates the serialization and deserialization of Field instances.
@@ -701,38 +676,39 @@ interface FieldSnapshot {
  *       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>;
-}
-
+  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>;
+}
+//#endregion
+//#region src/serializer/fields-serializer.d.ts
 /**
  * A plain object representation of a Fields container's state for serialization.
  */
 interface FieldsSnapshot {
-    __type: string;
-    [fieldName: string]: FieldSnapshot | string;
+  __type: string;
+  [fieldName: string]: FieldSnapshot | string;
 }
 /**
  * Orchestrates the serialization and deserialization of `Fields` container instances.
@@ -746,33 +722,34 @@ interface FieldsSnapshot {
  *       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;
-}
-
+  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;
+}
+//#endregion
+//#region src/serializer/field-tree-serializer.d.ts
 /**
  * Represents the serializable state of a `FieldTree` container.
  *
@@ -783,8 +760,8 @@ declare class FieldsSerializer<TFields extends Fields> {
  *    The `| string` is included to ensure compatibility with the `__type` property.
  */
 interface FieldTreeSnapshot {
-    __type: string;
-    [fieldName: string]: FieldsSnapshot | FieldTreeSnapshot | string;
+  __type: string;
+  [fieldName: string]: FieldsSnapshot | FieldTreeSnapshot | string;
 }
 /**
  * Orchestrates the recursive serialization and deserialization of `FieldTree` instances.
@@ -803,25 +780,26 @@ interface FieldTreeSnapshot {
  *       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>;
-}
-
+  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>;
+}
+//#endregion
+//#region src/store.d.ts
 interface StoreCreateFieldOptions {
-    /** Allows to explicitly specify the field type, overriding the automatic type detection. */
-    fieldType?: string;
+  /** 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.
@@ -829,173 +807,176 @@ interface StoreCreateFieldOptions {
  * 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;
-}
-
+  /**
+       * 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;
+}
+//#endregion
+//#region src/data-store-field-resolver.d.ts
 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;
-}
-
+  /**
+       * 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;
+}
+//#endregion
+//#region src/data-store.d.ts
 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;
-}
-
+  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;
+}
+//#endregion
+//#region src/setup.d.ts
 /**
  * Creates and configures a FieldRegistry with all the core field types.
  * @returns {FieldRegistry} A pre-configured FieldRegistry instance.
@@ -1021,16 +1002,17 @@ declare function createCoreTreeNodeFactory(fieldRegistry: FieldRegistry): CoreTr
  */
 declare function createCoreTreeSerializer(fieldTreeNodeFactory: CoreTreeNodeFactory, policySerializer?: PolicySerializer): FieldTreeSerializer<CoreFields>;
 interface CoreFieldSystemConfig {
-    registry?: FieldRegistry;
-    policySerializer?: PolicySerializer;
+  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>;
+  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 };
+//#endregion
+export { BooleanField, ClampMaxPolicy, ClampMaxPolicySerializerHandler, ClampMinPolicy, ClampMinPolicySerializerHandler, ClampPolicy, ClampPolicySerializerHandler, CoreBooleanField, CoreBooleanFieldOptions, CoreField, CoreFieldSystemConfig, CoreFieldTree, CoreFields, CoreFieldsFactory, CoreNumericField, CoreNumericFieldOptions, CoreStringField, CoreStringFieldOptions, CoreTreeNodeFactory, DataStore, Field, FieldOptions, FieldRegistry, FieldSerializer, FieldSnapshot, FieldTree, FieldTreeFactory, FieldTreeSerializer, FieldTreeSnapshot, Fields, FieldsFactory, FieldsSerializer, FieldsSnapshot, NumericField, Policies, Policy, PolicySerializer, PolicySerializerHandler, Store, StoreCreateFieldOptions, StringField, TreeNode, clampMaxPolicy, clampMinPolicy, clampPolicy, createCoreFieldRegistry, createCoreFieldSystem, createCorePolicySerializer, createCoreTreeNodeFactory, createCoreTreeSerializer, createTypedMethodsMixin };
+//# sourceMappingURL=index.d.mts.map