entt-js 0.0.0

package/dist/entt.d.ts

@@ -0,0 +1,1069 @@
+interface DisposableConstructor {
+    new (): Disposable;
+    prototype: Disposable;
+}
+interface Disposable extends globalThis.Disposable {
+    dispose(): void;
+}
+declare const Disposable: DisposableConstructor;
+
+interface SpecializationDefinition {
+    predicate: (...args: any[]) => boolean;
+    render: (...args: any[]) => any;
+}
+interface InternalSpecializationDefinition extends SpecializationDefinition {
+    userland: boolean;
+}
+declare class Template<Render extends (...args: any[]) => any> extends Disposable {
+    private readonly _registry;
+    private _specializations;
+    instantiate: Render;
+    defaultRender: (this: Template<Render>, ...args: any[]) => any;
+    constructor(render: (this: Template<Render>, ...args: any[]) => any, specializations?: SpecializationDefinition[]);
+    selectSpecialization(...args: Parameters<Render>): ((...args: Parameters<Render>) => any) | null;
+    addSpecialization(spec: SpecializationDefinition): void;
+    removeSpecialization(spec: SpecializationDefinition): void;
+    removeAllUserlandSpecializations(): void;
+    dispose(): void;
+}
+declare function defineTemplate<Render extends (...args: any[]) => any>(render: (this: Template<Render>, ...args: any[]) => any, specializations?: SpecializationDefinition[]): Template<Render>;
+
+type SafeInstanceType<T, Default = any> = T extends BooleanConstructor ? boolean : T extends NumberConstructor ? number : T extends BigIntConstructor ? bigint : T extends StringConstructor ? string : T extends SymbolConstructor ? symbol : T extends new (...args: any[]) => infer R ? R : T extends (...args: any[]) => infer R ? R : Default;
+type SafeParameters<T> = T extends BooleanConstructor ? Parameters<BooleanConstructor> : T extends NumberConstructor ? Parameters<NumberConstructor> : T extends BigIntConstructor ? Partial<Parameters<BigIntConstructor>> : T extends StringConstructor ? Parameters<StringConstructor> : T extends SymbolConstructor ? Parameters<SymbolConstructor> : T extends abstract new (...args: infer P) => any ? P : T extends (...args: infer P) => any ? P : any[];
+declare const EmptyTypeOptimization: {
+    readonly Disabled: 0;
+    readonly Static: 1;
+    readonly 0: "Disabled";
+    readonly 1: "Static";
+};
+type EmptyTypeOptimization = Extract<typeof EmptyTypeOptimization[keyof typeof EmptyTypeOptimization], number>;
+declare const directCall: (Type: Function, ...args: any[]) => any;
+declare const config: {
+    customCalls: WeakMap<Function, (Type: Function, ...args: any[]) => any>;
+    emptyClasses: WeakMap<Function, boolean>;
+    eto: EmptyTypeOptimization;
+    mixin: boolean;
+    sparsePage: number;
+    packedPage: number;
+};
+declare function createSafeNew<T extends Function>(Type: T): (...args: SafeParameters<T> | []) => SafeInstanceType<T>;
+declare function isEmptyClass(Type: Function): boolean;
+
+type EntityConstructor = NumberConstructor | BigIntConstructor | CustomEntityConstructor<any, any>;
+interface CustomEntityConstructor<EC extends NumberConstructor | BigIntConstructor, R extends {
+    [Symbol.toPrimitive](): SafeInstanceType<EC>;
+}> {
+    EntityType: EC;
+    new (entt?: SafeInstanceType<EC>, ...args: any[]): R;
+    prototype: R;
+}
+interface InternalEnttTraits<VT extends EntityConstructor, EC extends NumberConstructor | BigIntConstructor, VC extends NumberConstructor | BigIntConstructor> {
+    ValueType: VT;
+    EntityType: EC;
+    VersionType: VC;
+    entityMask: SafeInstanceType<EC>;
+    versionMask: SafeInstanceType<EC>;
+}
+type InternalEnttTraitsReturn<VT> = VT extends NumberConstructor ? InternalEnttTraits<NumberConstructor, NumberConstructor, NumberConstructor> : VT extends BigIntConstructor ? InternalEnttTraits<BigIntConstructor, BigIntConstructor, NumberConstructor> : VT extends CustomEntityConstructor<any, any> ? InternalEnttTraits<VT, VT['EntityType'], NumberConstructor> : never;
+interface BasicEnttTraits<Traits extends InternalEnttTraits<any, any, any>> {
+    ValueType: Traits['ValueType'];
+    EntityType: Traits['EntityType'] & ((value: Traits['ValueType']) => SafeInstanceType<Traits['EntityType']>);
+    VersionType: Traits['VersionType'] & ((value: Traits['ValueType']) => SafeInstanceType<Traits['VersionType']>);
+    entityMask: Traits['entityMask'];
+    versionMask: Traits['versionMask'];
+    length: number;
+    null: SafeInstanceType<Traits['ValueType']>;
+    tombstone: SafeInstanceType<Traits['ValueType']>;
+    toIntegral: (value: SafeInstanceType<Traits['ValueType']>) => SafeInstanceType<Traits['EntityType']>;
+    toEntity: (value: SafeInstanceType<Traits['ValueType']>) => SafeInstanceType<Traits['EntityType']>;
+    toVersion: (value: SafeInstanceType<Traits['ValueType']>) => SafeInstanceType<Traits['VersionType']>;
+    next: (value: SafeInstanceType<Traits['ValueType']>) => SafeInstanceType<Traits['ValueType']>;
+    construct: (entity: SafeInstanceType<Traits['EntityType']>, version: SafeInstanceType<Traits['VersionType']>) => SafeInstanceType<Traits['ValueType']>;
+    combine: (lhs: SafeInstanceType<Traits['EntityType']>, rhs: SafeInstanceType<Traits['EntityType']>) => SafeInstanceType<Traits['ValueType']>;
+    isNull: (value: SafeInstanceType<Traits['ValueType']>) => boolean;
+    isTombstone: (value: SafeInstanceType<Traits['ValueType']>) => boolean;
+}
+interface EnttTraits<Type> extends BasicEnttTraits<InternalEnttTraitsReturn<Type>> {
+    BaseType?: BasicEnttTraits<InternalEnttTraitsReturn<Type>>;
+    pageSize: number;
+}
+interface InternalEnttTraitsTemplate {
+    <VT extends EntityConstructor>(ValueType: VT): InternalEnttTraitsReturn<VT>;
+}
+declare const internalEnttTraits: Template<InternalEnttTraitsTemplate>;
+interface BasicEnttTraitsTemplate {
+    <Traits extends InternalEnttTraits<any, any, any>>(traits: Traits): BasicEnttTraits<Traits>;
+}
+declare const basicEnttTraitsTemplate: Template<BasicEnttTraitsTemplate>;
+interface EnttTraitsTemplate {
+    <Type extends EntityConstructor>(ValueType: Type): EnttTraits<Type>;
+}
+declare const enttTraitsTemplate: Template<EnttTraitsTemplate>;
+
+interface Uint8Constructor extends NumberConstructor {
+    (num?: unknown): number;
+    readonly MIN_VALUE: 0;
+    readonly MAX_VALUE: 255;
+    is(instance: unknown): boolean;
+    super_: NumberConstructor;
+}
+declare const Uint8: Uint8Constructor;
+interface Float32Constructor extends NumberConstructor {
+    (num?: unknown): number;
+    super_: NumberConstructor;
+}
+declare const Float32: Float32Constructor;
+interface Float64Constructor extends NumberConstructor {
+    (num?: unknown): number;
+    readonly MIN_VALUE: number;
+    readonly MAX_VALUE: number;
+    is(instance: unknown): boolean;
+    super_: NumberConstructor;
+}
+declare const Float64: Float64Constructor;
+interface Int8Constructor extends NumberConstructor {
+    (num?: unknown): number;
+    readonly MIN_VALUE: -128;
+    readonly MAX_VALUE: 127;
+    is(instance: unknown): boolean;
+    super_: NumberConstructor;
+}
+declare const Int8: Int8Constructor;
+interface Uint16Constructor extends NumberConstructor {
+    (num?: unknown): number;
+    readonly MIN_VALUE: 0;
+    readonly MAX_VALUE: 65535;
+    is(instance: unknown): boolean;
+    super_: NumberConstructor;
+}
+declare const Uint16: Uint16Constructor;
+interface Int16Constructor extends NumberConstructor {
+    (num?: unknown): number;
+    readonly MIN_VALUE: -32768;
+    readonly MAX_VALUE: 32767;
+    is(instance: unknown): boolean;
+    super_: NumberConstructor;
+}
+declare const Int16: Int16Constructor;
+interface Uint32Constructor extends NumberConstructor {
+    (num?: unknown): number;
+    readonly MIN_VALUE: 0;
+    readonly MAX_VALUE: 4294967295;
+    is(instance: unknown): boolean;
+    super_: NumberConstructor;
+}
+declare const Uint32: Uint32Constructor;
+interface Int32Constructor extends NumberConstructor {
+    (num?: unknown): number;
+    readonly MIN_VALUE: -2147483648;
+    readonly MAX_VALUE: 2147483647;
+    is(instance: unknown): boolean;
+    super_: NumberConstructor;
+}
+declare const Int32: Int32Constructor;
+interface Uint64Constructor extends BigIntConstructor {
+    (num?: unknown): bigint;
+    readonly MIN_VALUE: 0n;
+    readonly MAX_VALUE: 18446744073709551615n;
+    is(instance: unknown): boolean;
+    super_: BigIntConstructor;
+}
+declare const Uint64: Uint64Constructor;
+interface Int64Constructor extends BigIntConstructor {
+    (num?: unknown): bigint;
+    readonly MIN_VALUE: -9223372036854775808n;
+    readonly MAX_VALUE: 9223372036854775807n;
+    is(instance: unknown): boolean;
+    super_: BigIntConstructor;
+}
+declare const Int64: Int64Constructor;
+interface DefaultEntityConstructor extends Uint32Constructor {
+    (num?: unknown): Entity;
+    super_: Uint32Constructor;
+}
+type Entity = number;
+declare const Entity: DefaultEntityConstructor;
+
+interface ForwardPointer<T, Self extends ForwardPointer<T, Self>> {
+    clone(target?: Self): Self;
+    swap(other: Self): void;
+    deref(): T;
+    write(value: T): T;
+    selfPlus(): this;
+    equals(other: Self): boolean;
+}
+interface BidirectionalPointer<T, Self extends BidirectionalPointer<T, Self>> extends ForwardPointer<T, Self> {
+    clone(target?: Self): Self;
+    swap(other: Self): void;
+    selfMinus(): this;
+}
+interface RandomAccessPointer<T, Self extends RandomAccessPointer<T, Self>> extends BidirectionalPointer<T, Self> {
+    clone(target?: Self): Self;
+    swap(other: Self): void;
+    selfPlus(n?: number): this;
+    plus(n: number): Self;
+    selfMinus(n?: number): this;
+    minus(n: number): Self;
+    diff(other: Self): number;
+    access(n: number): T;
+    set(n: number, value: T): void;
+    lt(other: Self): boolean;
+    gt(other: Self): boolean;
+    le(other: Self): boolean;
+    ge(other: Self): boolean;
+}
+interface Range<It extends ForwardPointer<any, any>> extends Iterable<It extends ForwardPointer<infer T, any> ? T : any> {
+    begin(): It;
+    end(): It;
+}
+interface ReversableRange<It extends BidirectionalPointer<any, any>> extends Range<It> {
+    rbegin(): ReversePointer<It>;
+    rend(): ReversePointer<It>;
+}
+interface IterableHelpers<K, V, T = any> extends Iterable<V> {
+    keys(): IteratorObject<K>;
+    values(): IteratorObject<V>;
+    entries(): IteratorObject<[K, V]>;
+    forEach(callback: (value: V, key: K, self: T) => void, thisArg?: any): void;
+}
+declare class ReversePointer<It extends BidirectionalPointer<any, any>> {
+    private readonly it;
+    constructor(it: It);
+    clone(target?: ReversePointer<It>): ReversePointer<It>;
+    swap(other: ReversePointer<It>): void;
+    base(): any;
+    selfPlus(n?: number): this;
+    selfMinus(n?: number): this;
+    plus(n: number): ReversePointer<It>;
+    minus(n: number): ReversePointer<It>;
+    diff(other: ReversePointer<It>): number;
+    equals(other: ReversePointer<It>): boolean;
+    lt(other: ReversePointer<It>): boolean;
+    gt(other: ReversePointer<It>): boolean;
+    le(other: ReversePointer<It>): boolean;
+    ge(other: ReversePointer<It>): boolean;
+    deref(): It extends BidirectionalPointer<infer U, any> ? U : never;
+    write(value: It extends BidirectionalPointer<infer U, any> ? U : never): It extends BidirectionalPointer<infer U, any> ? U : never;
+    access(value: number): It extends BidirectionalPointer<infer U, any> ? U : never;
+    set(off: number, value: It extends BidirectionalPointer<infer U, any> ? U : never): void;
+}
+declare function makeReversePointer<It extends BidirectionalPointer<any, any>>(it: It): ReversePointer<It>;
+declare function makeRangePointer<It extends ForwardPointer<any, any>, Sentinel extends ForwardPointer<any, any> = It>(first: Range<It> | It, last?: Sentinel): [It, Sentinel];
+declare class RangeIterator<It extends ForwardPointer<any, any>, Sentinel extends ForwardPointer<any, any> = It> extends Iterator<It extends ForwardPointer<infer U, any> ? U : any> {
+    private readonly first;
+    private readonly curr;
+    private readonly last;
+    constructor(first: It, last: Sentinel);
+    begin(): It;
+    end(): Sentinel;
+    next(): IteratorResult<It extends ForwardPointer<infer U, any> ? U : any>;
+    [Symbol.iterator](): this;
+}
+declare class AggregatePointer<const T extends Array<ForwardPointer<any, any>>> implements ForwardPointer<{
+    [K in keyof T]: T[K] extends ForwardPointer<infer U, any> ? U : any;
+}, AggregatePointer<T>> {
+    private pointers;
+    constructor(pointers: T);
+    base(): T[0];
+    deref(): {
+        [K in keyof T]: T[K] extends ForwardPointer<infer U, any> ? U : any;
+    };
+    write(value: {
+        [K in keyof T]: T[K] extends ForwardPointer<infer U, any> ? U : any;
+    }): {
+        [K in keyof T]: T[K] extends ForwardPointer<infer U, any> ? U : any;
+    };
+    clone(target?: AggregatePointer<T>): AggregatePointer<T>;
+    swap(other: AggregatePointer<T>): void;
+    selfPlus(): this;
+    equals(other: AggregatePointer<T>): boolean;
+}
+declare function toIterator<It extends ForwardPointer<any, any>>(first: Range<It>): RangeIterator<It, It>;
+declare function toIterator<It extends ForwardPointer<any, any>, Sentinel extends ForwardPointer<any, any> = It>(first: It, last: Sentinel): RangeIterator<It, Sentinel>;
+declare class ArrayPointer<T> implements RandomAccessPointer<T, ArrayPointer<T>> {
+    private array;
+    private pos;
+    constructor(array: T[], index: number);
+    clone(target?: ArrayPointer<T>): ArrayPointer<T>;
+    swap(other: ArrayPointer<T>): void;
+    selfPlus(n?: number): this;
+    plus(n: number): ArrayPointer<T>;
+    selfMinus(n?: number): this;
+    minus(n: number): ArrayPointer<T>;
+    diff(other: ArrayPointer<T>): number;
+    lt(other: ArrayPointer<T>): boolean;
+    gt(other: ArrayPointer<T>): boolean;
+    le(other: ArrayPointer<T>): boolean;
+    ge(other: ArrayPointer<T>): boolean;
+    equals(other: ArrayPointer<T>): boolean;
+    deref(): T;
+    write(value: T): T;
+    access(n: number): T;
+    set(n: number, value: T): void;
+}
+declare class ArrayRange<T> implements Range<ArrayPointer<T>> {
+    private readonly array;
+    constructor(array: T[]);
+    data(): T[];
+    begin(): ArrayPointer<T>;
+    end(): ArrayPointer<T>;
+    rbegin(): ReversePointer<ArrayPointer<T>>;
+    rend(): ReversePointer<ArrayPointer<T>>;
+    [Symbol.iterator](): RangeIterator<ArrayPointer<T>>;
+}
+declare function toRange<T>(value: T): T extends Array<infer U> ? ArrayRange<U> : Range<ForwardPointer<any, any>>;
+declare function distance<It extends ForwardPointer<any, any>>(first: It, last: It): number;
+
+declare const DeletionPolicy: {
+    readonly SwapAndPop: 0;
+    readonly InPlace: 1;
+    readonly SwapOnly: 2;
+    readonly Unspecified: 0;
+    readonly 0: "SwapAndPop";
+    readonly 1: "InPlace";
+    readonly 2: "SwapOnly";
+};
+type DeletionPolicy = Extract<typeof DeletionPolicy[keyof typeof DeletionPolicy], number>;
+interface BaseSparseSet<T, VersionType> extends Disposable {
+    mode: DeletionPolicy;
+    reserve(cap: number): void;
+    data(): T[];
+    policy(): DeletionPolicy;
+    type(): Function | undefined;
+    empty(): boolean;
+    isNull(entity: T): boolean;
+    isTombstone(entity: T): boolean;
+    inPlacePop(entity: T): void;
+    swapAndPop(entity: T): void;
+    swapOrMove(_lhs: number, _rhs: number): void;
+    tryEmplace(value: T, forcePush?: boolean, elem?: any): SparseSetPointer<T>;
+    pop(first: SparseSetPointer<T>, last: SparseSetPointer<T>): void;
+    popAll(): void;
+    freeList(value?: number | bigint): bigint;
+    contiguous(): boolean;
+    push(entity: T, elem?: any): SparseSetPointer<T>;
+    pushRange(iterable: Range<ForwardPointer<T, any>>): SparseSetPointer<T>;
+    pushRange(first: ForwardPointer<T, any>, last: ForwardPointer<T, any>): SparseSetPointer<T>;
+    add(value: T): this;
+    clear(): void;
+    erase(value: T): void;
+    erase(first: ForwardPointer<T, any>, last: ForwardPointer<T, any>): void;
+    delete(value: T): boolean;
+    remove(value: T): boolean;
+    remove(first: ForwardPointer<T, any>, last: ForwardPointer<T, any>): number;
+    contains(value: T): boolean;
+    has(value: T): boolean;
+    at(index: number): T;
+    access(pos: number): T | undefined;
+    current(value: T): VersionType;
+    bump(value: T): VersionType;
+    index(value: T): number;
+    find(value: T): SparseSetPointer<T>;
+    toIterator(entt: T): SparseSetPointer<T>;
+    bind(value: any): void;
+    compact(): void;
+    swapElements(lhs: T, rhs: T): void;
+    sortN(length: number, compareFn?: (a: T, b: T) => number, algo?: (arr: T[], compare?: (a: T, b: T) => number) => T[]): void;
+    sort(compareFn?: (a: T, b: T) => number, algo?: (arr: T[], compare?: (a: T, b: T) => number) => T[]): void;
+    sortAs(range: Range<ForwardPointer<T, any>>): SparseSetPointer<T>;
+    sortAs(first: ForwardPointer<T, any>, last: ForwardPointer<T, any>): SparseSetPointer<T>;
+    readonly size: number;
+}
+interface BasicSparseSet<T, VersionType> extends BaseSparseSet<T, VersionType>, ReversableRange<SparseSetPointer<T>>, IterableHelpers<T, T, BasicSparseSet<T, VersionType>> {
+}
+interface SparseSetConstructor<T extends EntityConstructor> {
+    BasicIterator: typeof SparseSetPointer<SafeInstanceType<T>>;
+    Iterator: typeof SparseSetPointer<SafeInstanceType<T>>;
+    ReverseIterator: typeof ReversePointer<SparseSetPointer<SafeInstanceType<T>>>;
+    TraitsType: EnttTraits<T>;
+    EntityType: EnttTraits<T>['ValueType'];
+    new (mode?: DeletionPolicy): BasicSparseSet<SafeInstanceType<T>, SafeInstanceType<EnttTraits<T>['VersionType']>>;
+    new (Type: Function, mode?: DeletionPolicy): BasicSparseSet<SafeInstanceType<T>, SafeInstanceType<EnttTraits<T>['VersionType']>>;
+    isTombstone(entity: SafeInstanceType<T>): boolean;
+    isNull(entity: SafeInstanceType<T>): boolean;
+    prototype: BasicSparseSet<SafeInstanceType<T>, SafeInstanceType<EnttTraits<T>['VersionType']>>;
+}
+declare class SparseSetPointer<T> implements RandomAccessPointer<T, SparseSetPointer<T>> {
+    private packed;
+    private offset;
+    constructor();
+    constructor(packed: T[], offset: number);
+    clone(target?: SparseSetPointer<T>): SparseSetPointer<T>;
+    swap(other: SparseSetPointer<T>): void;
+    data(): T[];
+    selfPlus(n?: number): this;
+    selfMinus(n?: number): this;
+    plus(n: number): SparseSetPointer<T>;
+    minus(n: number): SparseSetPointer<T>;
+    diff(other: SparseSetPointer<any>): number;
+    equals(other: SparseSetPointer<any>): boolean;
+    lt(other: SparseSetPointer<any>): boolean;
+    gt(other: SparseSetPointer<any>): boolean;
+    le(other: SparseSetPointer<any>): boolean;
+    ge(other: SparseSetPointer<any>): boolean;
+    deref(): T;
+    write(value: T): T;
+    access(value: number): T;
+    set(off: number, value: T): void;
+    index(): number;
+    [Symbol.toPrimitive](hint: string): string | number;
+}
+interface BasicSparseSetTemplate {
+    <EC extends EntityConstructor>(EntityType: EC): SparseSetConstructor<EC>;
+}
+declare const basicSparseSetTemplate: Template<BasicSparseSetTemplate>;
+declare const SparseSet: SparseSetConstructor<DefaultEntityConstructor>;
+
+interface ComponentTraits<T, E> {
+    ElementType: T;
+    EntityType: E;
+    pageSize: number;
+    inPlaceDelete: boolean;
+}
+interface ComponentTraitsTemplate {
+    <T extends Function, E extends EntityConstructor>(Type: T, Entity: E): ComponentTraits<T, E>;
+}
+declare const componentTraitsTemplate: Template<ComponentTraitsTemplate>;
+
+interface IRef<T> {
+    get(): T;
+    set(value: T): void;
+}
+declare function defaultSort<T>(arr: T[], compareFn?: (a: T, b: T) => number): T[];
+declare function insertionSort<T>(arr: T[], compareFn?: (a: T, b: T) => number): T[];
+type StorageKey<U extends Function | undefined> = U | [U, any];
+
+interface Storage<T, E, V> extends BaseSparseSet<E, V>, ReversableRange<StoragePointer<T>>, IterableHelpers<E, T, Storage<T, E, V>> {
+    capacity(): number;
+    reserve(cap: number): void;
+    get(entt: E): T | undefined;
+    getAsRef(entt: E): IRef<T | undefined>;
+    getAsTuple(entt: E): [T];
+    emplace(entt: E, ...args: ConstructorParameters<new (...args: any[]) => T>): T;
+    insert(first: ForwardPointer<E, any>, last: ForwardPointer<E, any>, value?: T): StoragePointer<T>;
+    insertRange(first: ForwardPointer<E, any>, last: ForwardPointer<E, any>, from: ForwardPointer<T, any>): StoragePointer<T>;
+    patch<F extends (instance: T) => T | undefined>(entt: E, ...func: F[]): T;
+    each(): RangeIterator<AggregatePointer<[SparseSetPointer<E>, StoragePointer<T>]>>;
+    reach(): RangeIterator<AggregatePointer<[ReversePointer<SparseSetPointer<E>>, ReversePointer<StoragePointer<T>>]>>;
+}
+interface EmptyStorage<E, V> extends BasicSparseSet<E, V> {
+    get(entt: E): undefined;
+    getAsRef(entt: E): IRef<undefined>;
+    getAsTuple(entt: E): [];
+    emplace(entt: E): void;
+    insert(first: ForwardPointer<E, any>, last: ForwardPointer<E, any>): void;
+    patch<F extends () => void>(entt: E, ...func: F[]): void;
+    each(): RangeIterator<AggregatePointer<[SparseSetPointer<E>]>>;
+    reach(): RangeIterator<AggregatePointer<[ReversePointer<SparseSetPointer<E>>]>>;
+}
+interface EntityStorage<T, V> extends BasicSparseSet<T, V> {
+    startFrom(hint: T): void;
+    get(entt: T): void;
+    getAsRef(entt: T): IRef<void>;
+    getAsTuple(entt: T): [];
+    patch<F extends () => void>(entt: T, ...func: F[]): void;
+    generate(hint?: T): T;
+    generateRange(range: Range<ForwardPointer<T, any>>): void;
+    generateRange(first: ForwardPointer<T, any>, last: ForwardPointer<T, any>): void;
+    insert(first: ForwardPointer<T, any>, last: ForwardPointer<T, any>): void;
+    each(): RangeIterator<AggregatePointer<[SparseSetPointer<T>]>>;
+    reach(): RangeIterator<AggregatePointer<[ReversePointer<SparseSetPointer<T>>]>>;
+}
+interface EntityStorageConstructor<T extends EntityConstructor> extends SparseSetConstructor<T> {
+    storagePolicy: DeletionPolicy;
+    TraitsType: EnttTraits<T>;
+    ElementType: T;
+    EntityType: T;
+    ValueType: undefined;
+    BaseType: SparseSetConstructor<T>;
+    Iterator: typeof SparseSetPointer<SafeInstanceType<T>>;
+    ReverseIterator: typeof ReversePointer<SparseSetPointer<SafeInstanceType<T>>>;
+    new (): EntityStorage<SafeInstanceType<T>, SafeInstanceType<EnttTraits<T>['VersionType']>>;
+    prototype: EntityStorage<SafeInstanceType<T>, SafeInstanceType<EnttTraits<T>['VersionType']>>;
+}
+interface EmptyStorageConstructor<T, E extends EntityConstructor> extends Omit<SparseSetConstructor<E>, 'Iterator' | 'ReverseIterator' | 'TraitsType' | 'prototype'> {
+    storagePolicy: DeletionPolicy;
+    TraitsType: ComponentTraits<T, E>;
+    ElementType: T;
+    EntityType: E;
+    ValueType: undefined;
+    BaseType: SparseSetConstructor<E>;
+    new (): EmptyStorage<SafeInstanceType<E>, SafeInstanceType<EnttTraits<E>['VersionType']>>;
+    prototype: EmptyStorage<SafeInstanceType<E>, SafeInstanceType<EnttTraits<E>['VersionType']>>;
+}
+interface BasicStorageConstructor<T, E extends EntityConstructor> extends Omit<SparseSetConstructor<E>, 'Iterator' | 'ReverseIterator' | 'TraitsType' | 'prototype'> {
+    storagePolicy: DeletionPolicy;
+    TraitsType: ComponentTraits<T, E>;
+    ElementType: T;
+    EntityType: E;
+    ValueType: T;
+    BaseType: SparseSetConstructor<E>;
+    Iterator: typeof StoragePointer<SafeInstanceType<T>>;
+    ReverseIterator: typeof ReversePointer<StoragePointer<SafeInstanceType<T>>>;
+    new (): Storage<SafeInstanceType<T>, SafeInstanceType<E>, SafeInstanceType<EnttTraits<E>['VersionType']>>;
+    prototype: Storage<SafeInstanceType<T>, SafeInstanceType<E>, SafeInstanceType<EnttTraits<E>['VersionType']>>;
+}
+declare class StoragePointer<T> implements RandomAccessPointer<T, StoragePointer<T>> {
+    private payload;
+    private offset;
+    private pageSize;
+    constructor();
+    constructor(pageSize: number, payload: T[][], offset: number);
+    dispose(): void;
+    clone(target?: StoragePointer<T>): StoragePointer<T>;
+    swap(other: StoragePointer<T>): void;
+    data(): T[][];
+    selfPlus(n?: number): this;
+    selfMinus(n?: number): this;
+    plus(n: number): StoragePointer<T>;
+    minus(n: number): StoragePointer<T>;
+    diff(other: StoragePointer<T>): number;
+    equals(other: StoragePointer<T>): boolean;
+    lt(other: StoragePointer<T>): boolean;
+    gt(other: StoragePointer<T>): boolean;
+    le(other: StoragePointer<T>): boolean;
+    ge(other: StoragePointer<T>): boolean;
+    deref(): T;
+    write(value: T): T;
+    access(value: number): T;
+    set(off: number, value: T): void;
+    index(): number;
+}
+type IsEmptyClass<T extends Function> = SafeInstanceType<T> extends object ? [keyof SafeInstanceType<T>] extends [never] ? true : false : false;
+interface BasicStorageTemplate {
+    <E extends EntityConstructor>(Type: E, Entity?: E): EntityStorageConstructor<E>;
+    <T extends Function, E extends EntityConstructor>(Type: T, Entity: E): IsEmptyClass<T> extends true ? EmptyStorageConstructor<T, E> : BasicStorageConstructor<T, E>;
+}
+declare const basicStorageTemplate: Template<BasicStorageTemplate>;
+interface StorageTemplate {
+    (Type: DefaultEntityConstructor): EntityStorageConstructor<DefaultEntityConstructor>;
+    <T extends Function>(Type: T): BasicStorageConstructor<T, DefaultEntityConstructor>;
+}
+declare const storageTemplate: Template<{
+    (Type: DefaultEntityConstructor): EntityStorageConstructor<DefaultEntityConstructor>;
+    <T extends Function>(Type: T): BasicStorageConstructor<T, DefaultEntityConstructor>;
+}>;
+declare const storageTypeTemplate: Template<(<T extends Function, E extends EntityConstructor>(Type: T, EntityType: E) => any)>;
+declare const storageTypeTTemplate: Template<(...args: any[]) => any>;
+
+type BasicView<Entity, Items extends any[]> = Items extends [infer U] ? BasicViewExtendsBasicStorageView<U, Entity, number | bigint, ForwardPointer<Entity, any>, ReversePointer<BidirectionalPointer<Entity, any>>> : BasicViewExtendsBasicCommonView<Items, Entity, number | bigint>;
+declare function commonType(...instances: any[]): any;
+interface ViewPointer<E, V> extends ForwardPointer<E, ViewPointer<E, V>> {
+    pools: Array<Storage<any, E, V>>;
+    valid(entt: E): boolean;
+    seekNext(): void;
+}
+interface ViewPointerConstructor<E extends EntityConstructor> {
+    new (): ViewPointer<SafeInstanceType<E>, SafeInstanceType<EnttTraits<E>['VersionType']>>;
+    new (first: SafeInstanceType<SparseSetConstructor<SafeInstanceType<E>>['Iterator']>, values: Array<Storage<any, any, any>>, excl: Array<Storage<any, any, any>>, idx: number): ViewPointer<SafeInstanceType<E>, SafeInstanceType<EnttTraits<E>['VersionType']>>;
+    prototype: ViewPointer<SafeInstanceType<E>, SafeInstanceType<EnttTraits<E>['VersionType']>>;
+}
+interface BasicCommonView<T, E, V> extends Iterable<E> {
+    pools: Array<Storage<T, E, V>>;
+    filter: Array<Storage<T, E, V>>;
+    refresh(): void;
+    handle(): Storage<any, E, V> | null;
+    sizeHint(): number;
+    begin(): ViewPointer<E, V>;
+    end(): ViewPointer<E, V>;
+    front(): E;
+    back(): E;
+    find(entt: E): ViewPointer<E, V>;
+    ok(): boolean;
+    [Symbol.toPrimitive](): boolean;
+    contains(entt: E): boolean;
+    poolAt(index: number): Storage<T, E, V>;
+    poolAt(index: number, elem: Storage<T, E, V> | null): void;
+    filterAt(index: number): Storage<T, E, V> | null;
+    filterAt(index: number, elem: Storage<T, E, V> | null): void;
+    noneOf(entt: E): boolean;
+}
+interface BasicCommonViewConstructor<T extends SparseSetConstructor<any>> {
+    Iterator: ViewPointerConstructor<T['EntityType']>;
+    CommonType: T;
+    EntityType: T['EntityType'];
+    new (): BasicCommonView<any, T['EntityType'], SafeInstanceType<EnttTraits<T['EntityType']>['VersionType']>>;
+    new (value: Array<Storage<any, any, any>>, excl: Array<Storage<any, any, any>>): BasicCommonView<any, T['EntityType'], SafeInstanceType<EnttTraits<T['EntityType']>['VersionType']>>;
+    prototype: BasicCommonView<any, T['EntityType'], SafeInstanceType<EnttTraits<T['EntityType']>['VersionType']>>;
+}
+type ExtractStorageConstructor<T> = T extends Storage<any, any, any> ? BasicStorageConstructor<any, any> : T extends EntityStorage<any, any> ? EntityStorageConstructor<any> : never;
+type ExtractStorageElement<T> = T extends Storage<infer Elem, any, any> ? Elem : unknown;
+type ExtractStorageEntity<T> = T extends Storage<any, infer E, any> ? E : T extends EntityStorage<infer E, any> ? E : unknown;
+type ExtractStorageVersion<T> = T extends Storage<any, any, infer V> ? V : T extends EntityStorage<any, infer V> ? V : unknown;
+interface BasicViewExtendsBasicStorageView<T, E, V, It, Rit> extends BasicStorageView<T, E, V, It, Rit> {
+    getStorageByElementType(_ElementType: any): Storage<T, E, V> | null;
+    getStorageByIndex(index?: number): Storage<T, E, V> | null;
+    setStorageByType(elem: Storage<T, E, V>): void;
+    setStorage(index: number, elem: Storage<T, E, V> | null): void;
+    access(entt: E): T | undefined;
+    getByElementType(entt: E, ElementType: any): T;
+    get(entt: E): [T];
+    get(entt: E, index: number): T;
+    each<ComponentsOnly extends boolean = false>(func: ComponentsOnly extends true ? ((component: T) => void) : ((entity: E, component: T) => void), componentsOnly?: ComponentsOnly): void;
+    each(): RangeIterator<ForwardPointer<[E, ...[T]], any>>;
+    bitOr(other: E): any;
+}
+interface BasicViewExtendsBasicStorageViewConstructor<S extends Storage<any, any, any> | EntityStorage<any, any>> extends Omit<BasicStorageViewConstructor<ExtractStorageConstructor<S>['BaseType'], ExtractStorageConstructor<S>['storagePolicy']>, 'new' | 'prototype'> {
+    CommonType: BasicStorageViewConstructor<ExtractStorageConstructor<S>['BaseType'], ExtractStorageConstructor<S>['storagePolicy']>['CommonType'];
+    EntityType: BasicStorageViewConstructor<ExtractStorageConstructor<S>['BaseType'], ExtractStorageConstructor<S>['storagePolicy']>['EntityType'];
+    Iterator: BasicStorageViewConstructor<ExtractStorageConstructor<S>['BaseType'], ExtractStorageConstructor<S>['storagePolicy']>['Iterator'];
+    ReverseIterator: BasicStorageViewConstructor<ExtractStorageConstructor<S>['BaseType'], ExtractStorageConstructor<S>['storagePolicy']>['ReverseIterator'];
+    new (value?: S | [S], _?: any): BasicViewExtendsBasicStorageView<ExtractStorageElement<S>, ExtractStorageEntity<S>, ExtractStorageVersion<S>, SafeInstanceType<BasicStorageViewConstructor<ExtractStorageConstructor<S>['BaseType'], ExtractStorageConstructor<S>['storagePolicy']>['Iterator']>, SafeInstanceType<BasicStorageViewConstructor<ExtractStorageConstructor<S>['BaseType'], ExtractStorageConstructor<S>['storagePolicy']>['ReverseIterator']>>;
+    prototype: BasicViewExtendsBasicStorageView<ExtractStorageElement<S>, ExtractStorageEntity<S>, ExtractStorageVersion<S>, SafeInstanceType<BasicStorageViewConstructor<ExtractStorageConstructor<S>['BaseType'], ExtractStorageConstructor<S>['storagePolicy']>['Iterator']>, SafeInstanceType<BasicStorageViewConstructor<ExtractStorageConstructor<S>['BaseType'], ExtractStorageConstructor<S>['storagePolicy']>['ReverseIterator'], never>>;
+}
+interface BasicViewExtendsBasicCommonView<Items extends any[], E, V> extends BasicCommonView<any, E, V> {
+    useByType(ElementType: any): void;
+    use(index: number): void;
+    getStorageByElementType(ElementType: any): Storage<any, E, V> | null;
+    getStorageByIndex(index: number): Storage<any, E, V> | null;
+    setStorageByType(elem: Storage<any, E, V>): void;
+    setStorage(index: number, elem: Storage<any, E, V> | null): void;
+    access(entt: E): Items;
+    getByElementType<Types extends Function[]>(entt: E, ...ElementTypes: Types): Types['length'] extends 1 ? SafeInstanceType<Types[0]> : {
+        [K in keyof Types]: SafeInstanceType<Types[K]>;
+    };
+    getByIndexes(entt: E, ...indexes: number[]): any[];
+    each<ComponentsOnly extends boolean = false>(func: ComponentsOnly extends true ? ((...args: Items) => void) : ((...args: [E, ...Items]) => void), componentsOnly?: ComponentsOnly): void;
+    each(): RangeIterator<ForwardPointer<[E, ...Items], any>>;
+    bitOr(other: any): any;
+}
+interface BasicViewExtendsBasicCommonViewConstructor<Gets extends Array<Storage<any, any, any>>, Excludes extends Array<Storage<any, any, any>>> extends Omit<BasicCommonViewConstructor<SparseSetConstructor<any>>, 'new' | 'prototype'> {
+    CommonType: SparseSetConstructor<any>;
+    EntityType: SparseSetConstructor<any>['EntityType'];
+    Iterator: ViewPointerConstructor<SparseSetConstructor<any>['EntityType']>;
+    new (value?: Gets, excl?: Excludes): BasicViewExtendsBasicCommonView<{
+        [K in keyof Gets]: ExtractStorageElement<Gets[K]>;
+    }, ExtractStorageEntity<Gets[number]>, ExtractStorageVersion<Gets[number]>>;
+    prototype: BasicViewExtendsBasicCommonView<{
+        [K in keyof Gets]: ExtractStorageElement<Gets[K]>;
+    }, ExtractStorageEntity<Gets[number]>, ExtractStorageVersion<Gets[number]>>;
+}
+interface BasicViewTemplate {
+    <const Gets extends Array<Storage<any, any, any>>, const Excludes extends Array<Storage<any, any, any>>>(Gets: Gets, Excludes?: Excludes): [Gets, Excludes] extends [[Storage<any, any, any> | EntityStorage<any, any>], [] | undefined | null] ? BasicViewExtendsBasicStorageViewConstructor<Gets[0]> : BasicViewExtendsBasicCommonViewConstructor<Gets, Excludes>;
+}
+declare const basicViewTemplate: Template<BasicViewTemplate>;
+declare function makeView(gets: any, excl?: any): BasicViewExtendsBasicStorageView<unknown, unknown, unknown, SparseSetPointer<any> | ViewPointer<any, number>, any>;
+interface BasicStorageView<T, E, V, It, Rit> extends Iterable<E> {
+    leading: Storage<T, E, V> | null;
+    handle(): Storage<T, E, V> | null;
+    size: number;
+    sizeHint(): number;
+    empty(): boolean;
+    begin(): It;
+    end(): It;
+    rbegin(): Rit;
+    rend(): Rit;
+    front(): E;
+    back(): E;
+    ok(): boolean;
+}
+interface BasicStorageViewConstructor<T extends SparseSetConstructor<any>, P extends DeletionPolicy> {
+    Iterator: P extends 1 ? ViewPointerConstructor<T['EntityType']> : T['Iterator'];
+    ReverseIterator: P extends 1 ? undefined : T['ReverseIterator'];
+    CommonType: T;
+    EntityType: T['EntityType'];
+    new (value?: Storage<any, any, any> | null): BasicStorageView<any, T['EntityType'], SafeInstanceType<EnttTraits<T['EntityType']>['VersionType']>, InstanceType<BasicStorageViewConstructor<T, P>['Iterator']>, SafeInstanceType<BasicStorageViewConstructor<T, P>['ReverseIterator'], never>>;
+    prototype: BasicStorageView<any, T['EntityType'], SafeInstanceType<EnttTraits<T['EntityType']>['VersionType']>, InstanceType<BasicStorageViewConstructor<T, P>['Iterator']>, SafeInstanceType<BasicStorageViewConstructor<T, P>['ReverseIterator'], never>>;
+}
+
+declare class Delegate<T extends (this: any, ...args: any[]) => any> extends Disposable {
+    private fn;
+    private instance;
+    constructor(fn: T, instance?: any);
+    dispose(): void;
+    reset(): void;
+    empty(): boolean;
+    connect(fn: T, instance?: any): void;
+    invoke(...args: Parameters<T>): ReturnType<T>;
+}
+declare class Sink<Ret, Args extends any[]> extends Disposable {
+    private signal;
+    constructor(signal?: Sigh<(...args: Args) => Ret>);
+    dispose(): void;
+    empty(): boolean;
+    private disconnectIf;
+    disconnect(fn?: (...args: Args) => Ret, instance?: any): void;
+    connect(fn: (...args: Args) => Ret, instance?: any): Connection;
+}
+declare class Sigh<T extends (this: any, ...args: any[]) => any> extends Disposable {
+    private readonly calls;
+    static SinkType: typeof Sink;
+    constructor();
+    dispose(): void;
+    get size(): number;
+    empty(): boolean;
+    publish(...args: Parameters<T>): void;
+    collect<U extends (value: ReturnType<T>) => boolean | undefined>(fn: U, ...args: Parameters<T>): void;
+}
+declare class Connection {
+    private readonly signal;
+    private readonly disconnect;
+    constructor(fn: Delegate<(signal: any) => void>, ref: any);
+    empty(): boolean;
+    release(): void;
+}
+declare class ScopedConnection extends Disposable {
+    private readonly conn;
+    constructor(conn: Connection);
+    dispose(): void;
+    empty(): boolean;
+    release(): void;
+}
+declare class BasicDispatcher extends Disposable {
+    private readonly pools;
+    constructor();
+    dispose(): void;
+    private assure;
+    private constAssure;
+    size<C extends Function>(Type?: C): number;
+    sink<C extends Function>(Type: C): Sink<void, [payload: SafeInstanceType<C>]>;
+    trigger<C extends Function>(Type: C, event: SafeInstanceType<C>): void;
+    enqueue<C extends Function>(Type: C, ...args: SafeParameters<C>): void;
+    disconnect(instance: any): void;
+    clear<C extends Function>(Type?: C): void;
+    update<C extends Function>(Type?: C): void;
+}
+declare class Emitter<Derived extends Emitter<Derived>> extends Disposable {
+    private readonly handlers;
+    constructor();
+    dispose(): void;
+    on<C extends Function>(Type: C, fn: (value: SafeInstanceType<C>, thisArg: Derived) => void): void;
+    publish(value: NonNullable<unknown>): void;
+    erase(Type: Function): void;
+    clear(): void;
+    contains(Type: Function): boolean;
+    empty(): boolean;
+}
+
+type BasicSighMixin<S, R, E> = S & {
+    onConstruct(): Sink<void, [R, E]>;
+    onUpdate(): Sink<void, [R, E]>;
+    onDestroy(): Sink<void, [R, E]>;
+    registry(): R;
+};
+type BasicSighMixinConstructor<T extends new (...args: any[]) => any, R, E> = Exclude<T, 'new' | 'prototype'> & {
+    UnderlyingType: T;
+    new (...args: ConstructorParameters<T>): BasicSighMixin<InstanceType<T>, R, E>;
+    prototype: BasicSighMixin<InstanceType<T>, R, E>;
+};
+declare const basicSighMixinTemplate: Template<(...args: any[]) => any>;
+
+declare class GroupDescriptor extends Disposable {
+    /** @virtual */
+    owned(_id: any): boolean;
+}
+interface GroupHandlerTemplate {
+    <T extends SparseSetConstructor<any>>(Type: T, Get: number, Exclude: number): GroupHandlerConstructor<T>;
+    <T extends SparseSetConstructor<any>>(Type: T, Owned: 0, Get: number, Exclude: number): GroupHandlerConstructor<T>;
+    <T extends SparseSetConstructor<any>>(Type: T, Owned: number, Get: number, Exclude: number): OwningGroupHandlerConstructor<T>;
+}
+interface OwningGroupHandlerConstructor<T extends SparseSetConstructor<any>> {
+    EntityType: T['EntityType'];
+    CommonType: T;
+    new (ogpool: Array<BasicSighMixin<Storage<any, SafeInstanceType<T['EntityType']>, SafeInstanceType<T['TraitsType']['VersionType']>>, any, SafeInstanceType<T['EntityType']>>>, epool: Array<BasicSighMixin<Storage<any, SafeInstanceType<T['EntityType']>, SafeInstanceType<T['TraitsType']['VersionType']>>, any, SafeInstanceType<T['EntityType']>>>): OwningGroupHandler<T['EntityType'], SafeInstanceType<T['TraitsType']['VersionType']>>;
+}
+interface GroupHandlerConstructor<T extends SparseSetConstructor<any>> {
+    EntityType: T['EntityType'];
+    CommonType: T;
+    new (gpool: Array<BasicSighMixin<Storage<any, SafeInstanceType<T['EntityType']>, SafeInstanceType<T['TraitsType']['VersionType']>>, any, SafeInstanceType<T['EntityType']>>>, epool: Array<BasicSighMixin<Storage<any, SafeInstanceType<T['EntityType']>, SafeInstanceType<T['TraitsType']['VersionType']>>, any, SafeInstanceType<T['EntityType']>>>): GroupHandler<T['EntityType'], SafeInstanceType<T['TraitsType']['VersionType']>>;
+}
+interface GroupHandler<E, V> extends GroupDescriptor {
+    handle(): BasicSparseSet<E, V>;
+    storage(index: number): BasicSparseSet<E, V>;
+}
+interface OwningGroupHandler<E, V> extends GroupDescriptor {
+    length(): number;
+    storage(index: number): BasicSparseSet<E, V>;
+}
+interface NonOwningGroup<Get extends Array<Storage<any, any, any> | EntityStorage<any, any>>, Exclude extends Array<Storage<any, any, any> | EntityStorage<any, any>>, E = ExtractStorageEntity<Get[number]>, V = ExtractStorageVersion<Get[number]>> extends Iterable<E> {
+    handle(): BasicSparseSet<E, V> | null;
+    storage<Index extends number>(index: Index): [...Get, ...Exclude][Index] | null;
+    storage<T extends Function>(ElementType: T): ([SafeInstanceType<T>] extends [E] ? EntityStorage<SafeInstanceType<T>, V> : Storage<SafeInstanceType<T>, E, V>) | null;
+    size(): number;
+    capacity(): number;
+    empty(): boolean;
+    begin(): SparseSetPointer<E>;
+    end(): SparseSetPointer<E>;
+    rbegin(): ReversePointer<SparseSetPointer<E>>;
+    rend(): ReversePointer<SparseSetPointer<E>>;
+    front(): E;
+    back(): E;
+    access(pos: number): E;
+    ok(): boolean;
+    find(entt: E): SparseSetPointer<E>;
+    contains(entt: E): boolean;
+    get<const Types extends Function[]>(entt: E, ...types: Types): Types['length'] extends 0 ? {
+        [K in keyof Get]: ExtractStorageElement<Get[K]>;
+    } : Types['length'] extends 1 ? SafeInstanceType<Types[0]> : {
+        [K in keyof Types]: SafeInstanceType<Types[K]>;
+    };
+    getByIndexes<const Indexes extends number[]>(entt: E, ...indexes: Indexes): Indexes['length'] extends 0 ? {
+        [K in keyof Get]: ExtractStorageElement<Get[K]>;
+    } : Indexes['length'] extends 1 ? ExtractStorageElement<Get[Indexes[0]]> : {
+        [K in keyof Indexes]: ExtractStorageElement<Get[Indexes[K]]>;
+    };
+    each<ComponentsOnly extends boolean = false>(func: ComponentsOnly extends true ? (...components: {
+        [K in keyof Get]: ExtractStorageElement<Get[K]>;
+    }) => void : (...components: [E, ...{
+        [K in keyof Get]: ExtractStorageElement<Get[K]>;
+    }]) => void, componentsOnly?: ComponentsOnly): void;
+    each(): IterableIterator<[E, ...{
+        [K in keyof Get]: ExtractStorageElement<Get[K]>;
+    }]>;
+    sort<const Types extends Function[], X = Types['length'] extends 0 ? E : {
+        [K in keyof Types]: SafeInstanceType<Types[K]>;
+    }>(compareFn: (lhs: X, rhs: X) => number, types: Types, algo?: (arr: E[], compare?: (a: E, b: E) => number) => E[]): void;
+    sortByIndexes<const Indexes extends number[], X = Indexes['length'] extends 0 ? E : {
+        [K in keyof Indexes]: ExtractStorageElement<Get[Indexes[K]]>;
+    }>(compareFn: (lhs: X, rhs: X) => number, indexes: Indexes, algo?: (arr: E[], compare?: (a: E, b: E) => number) => E[]): void;
+    sortAs(first: ForwardPointer<any, any>, last: ForwardPointer<any, any>): void;
+}
+interface OwningGroup<Owned extends Array<Storage<any, any, any> | EntityStorage<any, any>>, Get extends Array<Storage<any, any, any> | EntityStorage<any, any>>, Exclude extends Array<Storage<any, any, any> | EntityStorage<any, any>>, E = ExtractStorageEntity<[...Owned, ...Get][number]>, V = ExtractStorageVersion<[...Owned, ...Get][number]>> extends Iterable<ExtractStorageEntity<Owned[number]>> {
+    handle(): BasicSparseSet<E, V> | null;
+    storage<Index extends number>(index: Index): [...Owned, ...Get, ...Exclude][Index] | null;
+    storage<T extends Function>(ElementType: T): ([SafeInstanceType<T>] extends [E] ? EntityStorage<SafeInstanceType<T>, V> : Storage<SafeInstanceType<T>, E, V>) | null;
+    size(): number;
+    empty(): boolean;
+    begin(): SparseSetPointer<E>;
+    end(): SparseSetPointer<E>;
+    rbegin(): ReversePointer<SparseSetPointer<E>>;
+    rend(): ReversePointer<SparseSetPointer<E>>;
+    front(): E;
+    back(): E;
+    access(pos: number): E;
+    ok(): boolean;
+    find(entt: E): SparseSetPointer<E>;
+    contains(entt: E): boolean;
+    get<const Types extends Function[]>(entt: E, ...types: Types): Types['length'] extends 0 ? {
+        [K in keyof [...Owned, ...Get]]: ExtractStorageElement<[...Owned, ...Get][K]>;
+    } : Types['length'] extends 1 ? SafeInstanceType<Types[0]> : {
+        [K in keyof Types]: SafeInstanceType<Types[K]>;
+    };
+    getByIndexes<const Indexes extends number[]>(entt: E, ...indexes: Indexes): Indexes['length'] extends 0 ? {
+        [K in keyof [...Owned, ...Get]]: ExtractStorageElement<[...Owned, ...Get][K]>;
+    } : Indexes['length'] extends 1 ? ExtractStorageElement<[...Owned, ...Get][Indexes[0]]> : {
+        [K in keyof Indexes]: ExtractStorageElement<[...Owned, ...Get][Indexes[K]]>;
+    };
+    each<ComponentsOnly extends boolean = false>(func: ComponentsOnly extends true ? (...args: [...{
+        [K in keyof Owned]: ExtractStorageElement<Owned[K]>;
+    }, ...{
+        [K in keyof Get]: ExtractStorageElement<Get[K]>;
+    }]) => void : (...args: [E, ...{
+        [K in keyof Owned]: ExtractStorageElement<Owned[K]>;
+    }, ...{
+        [K in keyof Get]: ExtractStorageElement<Get[K]>;
+    }]) => void, componentsOnly?: ComponentsOnly): void;
+    each(): IterableIterator<[E, ...{
+        [K in keyof Owned]: ExtractStorageElement<Owned[K]>;
+    }, ...{
+        [K in keyof Get]: ExtractStorageElement<Get[K]>;
+    }]>;
+    sort<const Types extends Function[], X = Types['length'] extends 0 ? E : {
+        [K in keyof Types]: SafeInstanceType<Types[K]>;
+    }>(compareFn: (lhs: X, rhs: X) => number, types: Types, algo?: (arr: E[], compare?: (a: E, b: E) => number) => E[]): void;
+    sortByIndexes<const Indexes extends number[], X = Indexes['length'] extends 0 ? E : {
+        [K in keyof Indexes]: ExtractStorageElement<[...Owned, ...Get][Indexes[K]]>;
+    }>(compareFn: (lhs: X, rhs: X) => number, indexes: Indexes, algo?: (arr: E[], compare?: (a: E, b: E) => number) => E[]): void;
+}
+interface NonOwningGroupConstructor<Get extends Array<Storage<any, any, any>>, Exclude extends Array<Storage<any, any, any>>> {
+    Handler: GroupHandlerConstructor<SparseSetConstructor<ExtractStorageEntity<Get[number]>>>;
+    groupId(): string;
+    new (handler?: GroupHandler<ExtractStorageEntity<Get[number]>, ExtractStorageVersion<Get[number]>>): NonOwningGroup<Get, Exclude>;
+    prototype: NonOwningGroup<Get, Exclude>;
+}
+interface OwningGroupConstructor<Owned extends Array<Storage<any, any, any>>, Get extends Array<Storage<any, any, any>>, Exclude extends Array<Storage<any, any, any>>> {
+    Handler: OwningGroupHandlerConstructor<SparseSetConstructor<ExtractStorageEntity<[...Owned, ...Get][number]>>>;
+    groupId(): string;
+    new (handler?: OwningGroupHandler<ExtractStorageEntity<[...Owned, ...Get][number]>, ExtractStorageVersion<[...Owned, ...Get][number]>>): OwningGroup<Owned, Get, Exclude>;
+    prototype: OwningGroup<Owned, Get, Exclude>;
+}
+interface GroupTemplate {
+    <const Owned extends Array<Storage<any, any, any>>, const Get extends Array<Storage<any, any, any>>, const Exclude extends Array<Storage<any, any, any>>>(owned: Owned, get: Get, exclude: Exclude): Owned['length'] extends 0 ? NonOwningGroupConstructor<Get, Exclude> : OwningGroupConstructor<Owned, Get, Exclude>;
+}
+declare const basicGroupTemplate: Template<GroupTemplate>;
+declare function makeGroup<const Owned extends Array<Storage<any, any, any>>, const Get extends Array<Storage<any, any, any>>, const Exclude extends Array<Storage<any, any, any>> = []>(owned: Owned, get: Get, exclude?: Exclude): Owned['length'] extends 0 ? NonOwningGroup<Get, Exclude> : OwningGroup<Owned, Get, Exclude>;
+
+interface BasicRegistryConstructor<T extends EntityConstructor> {
+    new (): BasicRegistry<SafeInstanceType<T>, SafeInstanceType<EnttTraits<T>['VersionType']>>;
+    prototype: BasicRegistry<SafeInstanceType<T>, SafeInstanceType<EnttTraits<T>['VersionType']>>;
+    EntityType: T;
+    TraitsType: EnttTraits<T>;
+    CommonType: SparseSetConstructor<T>;
+}
+type StorageType<T> = T extends [infer U, any] ? U : T extends Function ? T : T extends undefined ? undefined : never;
+type MapStorageKeyToStorage<E, Arr> = {
+    [K in keyof Arr]: SafeInstanceType<StorageType<Arr[K]>> extends E ? EntityStorage<SafeInstanceType<StorageType<Arr[K]>>, any> : Storage<SafeInstanceType<StorageType<Arr[K]>>, E, any>;
+};
+interface BasicRegistry<T, V> extends Disposable {
+    create(hint?: T): T;
+    createRange(range: Range<ForwardPointer<T, any>>): void;
+    createRange(first: ForwardPointer<T, any>, last: ForwardPointer<T, any>): void;
+    dispose(): void;
+    ctx(): Record<string, any>;
+    storage(): IteratorObject<[PropertyKey | Function, Storage<any, T, V>]>;
+    getStorage<K extends StorageKey<Function | undefined> | PropertyKey>(k: K, forceConst?: boolean): K extends StorageKey<infer U> ? BasicSighMixin<U extends undefined ? EmptyStorage<T, V> : Storage<SafeInstanceType<U>, T, V>, BasicRegistry<T, V>, T> : (BasicSighMixin<Storage<SafeInstanceType<unknown>, T, V>, BasicRegistry<T, V>, T> | undefined);
+    reset(id: any): boolean;
+    valid(entt: T): boolean;
+    current(entt: T): V;
+    destroy(entt: T, version?: V): V;
+    destroyRange(iterable: Range<ForwardPointer<T, any>>): void;
+    destroyRange(iterable: ForwardPointer<T, any>, last: ForwardPointer<T, any>): void;
+    insert<U extends Function>(ComponentType: StorageKey<U>, first: ForwardPointer<T, any>, last: ForwardPointer<T, any>, value?: SafeInstanceType<U>): void;
+    insertRange<U extends Function>(ComponentType: StorageKey<U>, first: ForwardPointer<T, any>, last: ForwardPointer<T, any>, from: ForwardPointer<SafeInstanceType<U>, any>): void;
+    emplace<U extends Function>(entt: T, ComponentType: StorageKey<U>, ...args: SafeParameters<U>): SafeInstanceType<U>;
+    emplaceOrReplace<U extends Function>(entt: T, ComponentType: StorageKey<U>, ...args: SafeParameters<U>): SafeInstanceType<U>;
+    patch<U extends Function, F extends (component: SafeInstanceType<U>) => SafeInstanceType<U> | undefined>(entt: T, ComponentType: StorageKey<U>, ...func: F[]): SafeInstanceType<U>;
+    replace<U extends Function>(entt: T, ComponentType: StorageKey<U>, ...args: SafeParameters<U>): SafeInstanceType<U>;
+    remove(entt: T, ...ComponentTypes: Array<StorageKey<Function>>): number;
+    removeRange(first: ForwardPointer<T, any>, last: ForwardPointer<T, any>, ...ComponentTypes: Array<StorageKey<Function>>): number;
+    eraseIf(entt: T, func: (id: Function | PropertyKey, storage: Storage<any, T, V>) => boolean): void;
+    erase(entt: T, ...ComponentTypes: Array<StorageKey<Function>>): void;
+    eraseRange(first: ForwardPointer<T, any>, last: ForwardPointer<T, any>, ...ComponentTypes: Array<StorageKey<Function>>): void;
+    compact(...ComponentTypes: Array<StorageKey<Function>>): void;
+    allOf(entt: T, ...ComponentTypes: Array<StorageKey<Function>>): boolean;
+    anyOf(entt: T, ...ComponentTypes: Array<StorageKey<Function>>): boolean;
+    tryGet<U extends Array<StorageKey<Function>>>(entt: T, ...ComponentType: U): [U['length']] extends [1] ? (SafeInstanceType<StorageType<U[0]>> | undefined) : {
+        [K in keyof U]: SafeInstanceType<StorageType<U[K]>> | undefined;
+    };
+    get<U extends Array<StorageKey<Function>>>(entt: T, ...ComponentType: U): [U['length']] extends [1] ? (SafeInstanceType<StorageType<U[0]>>) : {
+        [K in keyof U]: SafeInstanceType<StorageType<U[K]>>;
+    };
+    getOrEmplace<U extends Function>(entt: T, ComponentType: StorageKey<U>, ...args: SafeParameters<U>): SafeInstanceType<U>;
+    clear(...ComponentTypes: Array<StorageKey<Function>>): void;
+    orphan(entt: T): boolean;
+    onConstruct<U extends Function>(ComponentType: StorageKey<U>): Sink<void, [BasicRegistry<T, V>, T]>;
+    onUpdate<U extends Function>(ComponentType: StorageKey<U>): Sink<void, [BasicRegistry<T, V>, T]>;
+    onDestroy<U extends Function>(ComponentType: StorageKey<U>): Sink<void, [BasicRegistry<T, V>, T]>;
+    sort<U extends Function>(ComponentType: StorageKey<U>, compare: (lhs: SafeInstanceType<U>, rhs: SafeInstanceType<U>) => number, algo?: (arr: T[], compare?: (a: T, b: T) => number) => T[]): void;
+    sortByEntity(ComponentType: StorageKey<Function>, compare: (lhs: T, rhs: T) => number, algo?: (arr: T[], compare?: (a: T, b: T) => number) => T[]): void;
+    sortAs(To: StorageKey<Function>, From: StorageKey<Function>): void;
+    view<const Contains extends Array<StorageKey<Function>>>(types: Contains, excludes?: Array<StorageKey<Function>>): BasicView<T, {
+        [K in keyof Contains]: SafeInstanceType<StorageType<Contains[K]>>;
+    }>;
+    group<const Owned extends Array<StorageKey<Function>>, const Get extends Array<StorageKey<Function>> = [], const Exclude extends Array<StorageKey<Function>> = []>(owned: Owned, get?: Get, exclude?: Exclude): Owned['length'] extends 0 ? NonOwningGroup<MapStorageKeyToStorage<T, Get>, MapStorageKeyToStorage<T, Exclude>> : OwningGroup<MapStorageKeyToStorage<T, Owned>, MapStorageKeyToStorage<T, Get>, MapStorageKeyToStorage<T, Exclude>>;
+    groupIfExists<const Owned extends Array<StorageKey<Function>>, const Get extends Array<StorageKey<Function>> = [], const Exclude extends Array<StorageKey<Function>> = []>(owned: Owned, get?: Get, exclude?: Exclude): Owned['length'] extends 0 ? NonOwningGroup<MapStorageKeyToStorage<T, Get>, MapStorageKeyToStorage<T, Exclude>> : OwningGroup<MapStorageKeyToStorage<T, Owned>, MapStorageKeyToStorage<T, Get>, MapStorageKeyToStorage<T, Exclude>>;
+    owned(...Types: Function[]): boolean;
+}
+interface BasicRegistryTemplate {
+    <T extends EntityConstructor>(ValueType: T): BasicRegistryConstructor<T>;
+}
+declare const basicRegistryTemplate: Template<BasicRegistryTemplate>;
+declare const Registry: BasicRegistryConstructor<DefaultEntityConstructor>;
+
+declare class RuntimeViewIterator<E> implements BidirectionalPointer<E, RuntimeViewIterator<E>> {
+    private pools;
+    private filter;
+    private it;
+    private tombstoneCheck;
+    private valid;
+    constructor();
+    constructor(cpools: Array<BaseSparseSet<E, any>>, curr: SparseSetPointer<E>, ignore: Array<BaseSparseSet<E, any>>);
+    clone(target?: RuntimeViewIterator<E>): RuntimeViewIterator<E>;
+    swap(other: RuntimeViewIterator<E>): void;
+    write(value: E): E;
+    deref(): E;
+    selfPlus(): this;
+    selfMinus(): this;
+    equals(other: RuntimeViewIterator<E>): boolean;
+}
+interface BasicRuntimeView<E> {
+    clear(): void;
+    dispose(): void;
+    iterate(base: BaseSparseSet<E, any>): this;
+    exclude(base: BaseSparseSet<E, any>): this;
+    sizeHint(): number;
+    begin(): RuntimeViewIterator<E>;
+    end(): RuntimeViewIterator<E>;
+    ok(): boolean;
+    contains(entt: E): boolean;
+    each(func: (entity: E) => void): void;
+    [Symbol.iterator](): RangeIterator<RuntimeViewIterator<E>>;
+}
+interface BasicRuntimeViewConstructor<T extends SparseSetConstructor<any>> {
+    EntityType: T['EntityType'];
+    CommonType: T;
+    Iterator: typeof RuntimeViewIterator<SafeInstanceType<T['EntityType']>>;
+    new (): BasicRuntimeView<SafeInstanceType<T['EntityType']>>;
+    prototype: BasicRuntimeView<SafeInstanceType<T['EntityType']>>;
+}
+interface BasicRuntimeViewTemplate {
+    <T extends SparseSetConstructor<any>>(Type: T): BasicRuntimeViewConstructor<T>;
+}
+declare const basicRuntimeViewTemplate: Template<BasicRuntimeViewTemplate>;
+declare const RuntimeView: BasicRuntimeViewConstructor<SparseSetConstructor<DefaultEntityConstructor>>;
+
+interface NotConstructorErrorConstructor extends TypeErrorConstructor {
+    new (message?: string): NotConstructorError;
+    (message?: string): never;
+    readonly prototype: NotConstructorError;
+}
+interface NotConstructorError extends TypeError {
+    name: 'NotConstructorError';
+}
+declare const NotConstructorError: NotConstructorErrorConstructor;
+
+interface BasicSnapshotTemplate {
+    <R extends BasicRegistryConstructor<any>>(Registry: R): BasicSnapshotConstructor<R>;
+}
+interface BasicSnapshotLoaderTemplate {
+    <R extends BasicRegistryConstructor<any>>(Registry: R): BasicSnapshotLoaderConstructor<R>;
+}
+interface BasicContinuousLoaderTemplate {
+    <R extends BasicRegistryConstructor<any>>(Registry: R): BasicContinuousLoaderConstructor<R>;
+}
+interface BasicSnapshotConstructor<R extends BasicRegistryConstructor<any>> {
+    new (registry: SafeInstanceType<R>): BasicSnapshot<SafeInstanceType<R['EntityType']>, SafeInstanceType<EnttTraits<R['EntityType']>['EntityType']>>;
+    prototype: BasicSnapshot<SafeInstanceType<R['EntityType']>, SafeInstanceType<EnttTraits<R['EntityType']>['EntityType']>>;
+    TraitsType: EnttTraits<SafeInstanceType<R['EntityType']>>;
+    RegistryType: R;
+    EntityType: SafeInstanceType<R['EntityType']>;
+}
+interface BasicSnapshot<E, UE> extends Disposable {
+    get(archive: OutputArchive<E, UE>, Type: StorageKey<Function>): this;
+    getRange(archive: OutputArchive<E, UE>, first: ForwardPointer<E, any>, last: ForwardPointer<E, any>, Type: StorageKey<Function>): this;
+}
+interface BasicSnapshotLoaderConstructor<R extends BasicRegistryConstructor<any>> {
+    new (registry: SafeInstanceType<R>): BasicSnapshotLoader<SafeInstanceType<R['EntityType']>, SafeInstanceType<EnttTraits<R['EntityType']>['EntityType']>>;
+    prototype: BasicSnapshotLoader<SafeInstanceType<R['EntityType']>, SafeInstanceType<EnttTraits<R['EntityType']>['EntityType']>>;
+    TraitsType: EnttTraits<SafeInstanceType<R['EntityType']>>;
+    RegistryType: R;
+    EntityType: SafeInstanceType<R['EntityType']>;
+}
+interface BasicSnapshotLoader<E, UE> extends Disposable {
+    get(archive: InputArchive<E, UE>, Type: StorageKey<Function>): this;
+    orphans(): this;
+}
+interface BasicContinuousLoaderConstructor<R extends BasicRegistryConstructor<any>> {
+    new (registry: SafeInstanceType<R>): BasicContinuousLoader<SafeInstanceType<R['EntityType']>, SafeInstanceType<EnttTraits<R['EntityType']>['EntityType']>>;
+    prototype: BasicContinuousLoader<SafeInstanceType<R['EntityType']>, SafeInstanceType<EnttTraits<R['EntityType']>['EntityType']>>;
+    TraitsType: EnttTraits<SafeInstanceType<R['EntityType']>>;
+    RegistryType: R;
+    EntityType: SafeInstanceType<R['EntityType']>;
+}
+interface BasicContinuousLoader<E, UE> extends Disposable {
+    get(archive: InputArchive<E, UE>, Type: StorageKey<Function>): this;
+    orphans(): this;
+    contains(entt: E): boolean;
+    map(entt: E): E;
+}
+interface OutputArchive<EntityType, UnderlyingEntityType> {
+    saveSize(size: UnderlyingEntityType): void;
+    saveEntity(entity: EntityType): void;
+    saveComponent(component: any): void;
+}
+interface InputArchive<EntityType, UnderlyingEntityType> {
+    loadSize(size: IRef<UnderlyingEntityType>): void;
+    loadEntity(entity: IRef<EntityType>): void;
+    loadComponent(component: IRef<any>): void;
+}
+declare const basicSnapshotTemplate: Template<BasicSnapshotTemplate>;
+declare const basicSnapshotLoaderTemplate: Template<BasicSnapshotLoaderTemplate>;
+declare const basicContinuousLoaderTemplate: Template<BasicContinuousLoaderTemplate>;
+declare const Snapshot: BasicSnapshotConstructor<BasicRegistryConstructor<DefaultEntityConstructor>>;
+declare const SnapshotLoader: BasicSnapshotLoaderConstructor<BasicRegistryConstructor<DefaultEntityConstructor>>;
+declare const ContinuousLoader: BasicContinuousLoaderConstructor<BasicRegistryConstructor<DefaultEntityConstructor>>;
+
+declare const version: string;
+
+export { AggregatePointer, ArrayPointer, ArrayRange, BasicDispatcher, Connection, ContinuousLoader, Delegate, DeletionPolicy, Disposable, Emitter, EmptyTypeOptimization, Entity, Float32, Float64, GroupDescriptor, Int16, Int32, Int64, Int8, NotConstructorError, RangeIterator, Registry, ReversePointer, RuntimeView, RuntimeViewIterator, ScopedConnection, Sigh, Sink, Snapshot, SnapshotLoader, SparseSet, SparseSetPointer, StoragePointer, Template, Uint16, Uint32, Uint64, Uint8, basicContinuousLoaderTemplate, basicEnttTraitsTemplate, basicGroupTemplate, basicRegistryTemplate, basicRuntimeViewTemplate, basicSighMixinTemplate, basicSnapshotLoaderTemplate, basicSnapshotTemplate, basicSparseSetTemplate, basicStorageTemplate, basicViewTemplate, commonType, componentTraitsTemplate, config, createSafeNew, defineTemplate, directCall, distance, enttTraitsTemplate, insertionSort, internalEnttTraits, isEmptyClass, makeGroup, makeRangePointer, makeReversePointer, makeView, defaultSort as stdSort, storageTemplate, storageTypeTTemplate, storageTypeTemplate, toIterator, toRange, version };
+export type { BaseSparseSet, BasicContinuousLoader, BasicContinuousLoaderConstructor, BasicContinuousLoaderTemplate, BasicEnttTraits, BasicEnttTraitsTemplate, BasicRegistry, BasicRegistryConstructor, BasicRegistryTemplate, BasicRuntimeView, BasicRuntimeViewConstructor, BasicRuntimeViewTemplate, BasicSighMixin, BasicSighMixinConstructor, BasicSnapshot, BasicSnapshotConstructor, BasicSnapshotLoader, BasicSnapshotLoaderConstructor, BasicSnapshotLoaderTemplate, BasicSnapshotTemplate, BasicSparseSet, BasicSparseSetTemplate, BasicStorageConstructor, BasicStorageTemplate, BasicView, BasicViewExtendsBasicCommonView, BasicViewExtendsBasicCommonViewConstructor, BasicViewExtendsBasicStorageView, BasicViewExtendsBasicStorageViewConstructor, BasicViewTemplate, BidirectionalPointer, ComponentTraits, ComponentTraitsTemplate, CustomEntityConstructor, DefaultEntityConstructor, DisposableConstructor, EmptyStorage, EmptyStorageConstructor, EntityConstructor, EntityStorage, EntityStorageConstructor, EnttTraits, EnttTraitsTemplate, ExtractStorageConstructor, ExtractStorageElement, ExtractStorageEntity, ExtractStorageVersion, Float32Constructor, Float64Constructor, ForwardPointer, GroupHandler, GroupHandlerConstructor, GroupHandlerTemplate, GroupTemplate, InputArchive, Int16Constructor, Int32Constructor, Int64Constructor, Int8Constructor, InternalEnttTraits, InternalEnttTraitsReturn, InternalEnttTraitsTemplate, InternalSpecializationDefinition, IsEmptyClass, IterableHelpers, MapStorageKeyToStorage, NonOwningGroup, NonOwningGroupConstructor, NotConstructorErrorConstructor, OutputArchive, OwningGroup, OwningGroupConstructor, OwningGroupHandler, OwningGroupHandlerConstructor, RandomAccessPointer, Range, ReversableRange, SafeInstanceType, SafeParameters, SparseSetConstructor, SpecializationDefinition, Storage, StorageTemplate, StorageType, Uint16Constructor, Uint32Constructor, Uint64Constructor, Uint8Constructor };