## API Report File for "@dcl/ecs"

> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).

```ts

// @public (undocumented)
export function ArrayType<T>(type: EcsType<T>): EcsType<Array<T>>;

// Warning: (ae-forgotten-export) The symbol "createByteBuffer" needs to be exported by the entry point index.d.ts
//
// @public (undocumented)
export type ByteBuffer = ReturnType<typeof createByteBuffer>;

// @public (undocumented)
export type ComponentDefinition<T extends EcsType = EcsType<any>> = {
    _id: number;
    has(entity: Entity): boolean;
    getFrom(entity: Entity): DeepReadonly<ComponentType<T>>;
    getOrNull(entity: Entity): DeepReadonly<ComponentType<T>> | null;
    create(entity: Entity, val?: ComponentType<T>): ComponentType<T>;
    mutable(entity: Entity): ComponentType<T>;
    createOrReplace(entity: Entity, val?: ComponentType<T>): ComponentType<T>;
    deleteFrom(entity: Entity): ComponentType<T> | null;
    upsertFromBinary(entity: Entity, data: ByteBuffer): ComponentType<T> | null;
    updateFromBinary(entity: Entity, data: ByteBuffer): ComponentType<T> | null;
    toBinary(entity: Entity): ByteBuffer;
    writeToByteBuffer(entity: Entity, buffer: ByteBuffer): void;
    iterator(): Iterable<[Entity, ComponentType<T>]>;
    dirtyIterator(): Iterable<Entity>;
    clearDirty(): void;
    isDirty(entity: Entity): boolean;
};

// @public (undocumented)
export type ComponentEcsType<T extends [ComponentDefinition, ...ComponentDefinition[]]> = {
    [K in keyof T]: T[K] extends ComponentDefinition ? ReturnType<T[K]['mutable']> : never;
};

// Warning: (ae-forgotten-export) The symbol "EcsResult" needs to be exported by the entry point index.d.ts
//
// @public (undocumented)
export type ComponentType<T extends EcsType> = EcsResult<T>;

// @public
export type DeepReadonly<T> = {
    readonly [P in keyof T]: DeepReadonly<T[P]>;
};

// @public
export const DEG2RAD: number;

// @public (undocumented)
export type double = number;

// @public (undocumented)
export const EcsBoolean: EcsType<boolean>;

// @public (undocumented)
export const EcsString: EcsType<string>;

// @public (undocumented)
export type EcsType<T = any> = {
    serialize(value: T, builder: ByteBuffer): void;
    deserialize(reader: ByteBuffer): T;
    create(): T;
};

// @public (undocumented)
export function Engine({ transports }?: IEngineParams): IEngine;

// @alpha
export const engine: IEngine;

// @public (undocumented)
export type Entity = number & {
    [entitySymbol]: true;
};

// @public (undocumented)
export function Enum<T>(type: EcsType<any>): EcsType<T>;

// @public
export const Epsilon = 0.000001;

// @public (undocumented)
export const FlatString: EcsType<string>;

// @public (undocumented)
export type float = number;

// @public (undocumented)
export const Float32: EcsType<number>;

// @public (undocumented)
export const Float64: EcsType<number>;

// @public (undocumented)
export type FloatArray = number[];

// @public (undocumented)
export type IEngine = {
    addEntity(dynamic?: boolean): Entity;
    addDynamicEntity(): Entity;
    removeEntity(entity: Entity): void;
    addSystem(system: Update, priority?: number, name?: string): void;
    removeSystem(selector: string | Update): boolean;
    defineComponent<T extends EcsType>(componentId: number, spec: T): ComponentDefinition<T>;
    mutableGroupOf<T extends [ComponentDefinition, ...ComponentDefinition[]]>(...components: T): Iterable<[Entity, ...ComponentEcsType<T>]>;
    groupOf<T extends [ComponentDefinition, ...ComponentDefinition[]]>(...components: T): Iterable<[Entity, ...DeepReadonly<ComponentEcsType<T>>]>;
    getComponent<T extends EcsType>(componentId: number): ComponentDefinition<T>;
    update(dt: number): void;
    baseComponents: SdkComponents;
};

// @public (undocumented)
export type IEngineParams = {
    transports?: Transport[];
};

// @public (undocumented)
export const Int16: EcsType<number>;

// @public (undocumented)
export const Int32: EcsType<number>;

// @public (undocumented)
export const Int64: EcsType<number>;

// @public (undocumented)
export const Int8: EcsType<number>;

// @public
export interface ISize {
    height: number;
    width: number;
}

// @public (undocumented)
export function MapType<T extends Spec>(spec: T): EcsType<Result<T>>;

// @public (undocumented)
export type Nullable<T> = T | null;

// @public (undocumented)
export function Optional<T>(spec: EcsType<T>): EcsType<T | undefined>;

// @public
export enum Orientation {
    CCW = 1,
    CW = 0
}

// @public (undocumented)
export namespace Quaternion {
    export function add(q1: ReadonlyQuaternion, q2: ReadonlyQuaternion): MutableQuaternion;
    export function angle(quat1: ReadonlyQuaternion, quat2: ReadonlyQuaternion): number;
    // (undocumented)
    export function angleAxis(degress: number, axis: Vector3.ReadonlyVector3): MutableQuaternion;
    export function create(
    x?: number,
    y?: number,
    z?: number,
    w?: number): MutableQuaternion;
    export function dot(left: ReadonlyQuaternion, right: ReadonlyQuaternion): number;
    export function euler(x: number, y: number, z: number): MutableQuaternion;
    export function eulerAngles(q: MutableQuaternion): Vector3.MutableVector3;
    // Warning: (ae-forgotten-export) The symbol "Matrix" needs to be exported by the entry point index.d.ts
    export function fromRotationMatrixToRef(matrix: Matrix.ReadonlyMatrix, result: Quaternion.MutableQuaternion): void;
    export function fromToRotation(from: Vector3.ReadonlyVector3, to: Vector3.ReadonlyVector3, up?: Vector3.ReadonlyVector3): MutableQuaternion;
    export function Identity(): MutableQuaternion;
    export function length(q: ReadonlyQuaternion): number;
    export function lengthSquared(q: ReadonlyQuaternion): number;
    export function lookRotation(forward: Vector3.ReadonlyVector3, up?: Vector3.ReadonlyVector3): MutableQuaternion;
    export function multiply(self: ReadonlyQuaternion, q1: ReadonlyQuaternion): MutableQuaternion;
    export function multiplyToRef(self: ReadonlyQuaternion, q1: ReadonlyQuaternion, result: MutableQuaternion): void;
    // (undocumented)
    export type MutableQuaternion = {
        y: number;
        x: number;
        z: number;
        w: number;
    };
    export function normalize(q: ReadonlyQuaternion): MutableQuaternion;
    // (undocumented)
    export type ReadonlyQuaternion = DeepReadonly<MutableQuaternion>;
    export function rotateTowards(from: ReadonlyQuaternion, to: ReadonlyQuaternion, maxDegreesDelta: number): MutableQuaternion;
    export function rotationYawPitchRoll(yaw: number, pitch: number, roll: number): MutableQuaternion;
    export function rotationYawPitchRollToRef(yaw: number, pitch: number, roll: number, result: Quaternion.MutableQuaternion): void;
    export function slerp(left: ReadonlyQuaternion, right: ReadonlyQuaternion, amount: number): MutableQuaternion;
    export function slerpToRef(left: ReadonlyQuaternion, right: ReadonlyQuaternion, amount: number, result: MutableQuaternion): void;
    export function Zero(): MutableQuaternion;
}

// @public
export const RAD2DEG: number;

// Warning: (ae-forgotten-export) The symbol "ToOptional" needs to be exported by the entry point index.d.ts
//
// @public (undocumented)
export type Result<T extends Spec> = ToOptional<{
    [K in keyof T]: T[K] extends EcsType ? ReturnType<T[K]['deserialize']> : T[K] extends Spec ? Result<T[K]> : never;
}>;

// Warning: (ae-forgotten-export) The symbol "defineSdkComponents" needs to be exported by the entry point index.d.ts
//
// @public (undocumented)
export type SdkComponents = ReturnType<typeof defineSdkComponents>;

// @public
export enum Space {
    BONE = 2,
    LOCAL = 0,
    WORLD = 1
}

// @public (undocumented)
export interface Spec {
    // (undocumented)
    [key: string]: EcsType;
}

// @public
export const ToGammaSpace: number;

// @public
export const ToLinearSpace = 2.2;

// @public (undocumented)
export type Unpacked<T> = T extends (infer U)[] ? U : T;

// @public (undocumented)
export namespace Vector3 {
    export function add(vector1: ReadonlyVector3, vector2: ReadonlyVector3): MutableVector3;
    export function Backward(): MutableVector3;
    export function clone(source: ReadonlyVector3): MutableVector3;
    export function copy(source: ReadonlyVector3, dest: MutableVector3): void;
    export function create(
    x?: number,
    y?: number,
    z?: number): MutableVector3;
    export function cross(left: ReadonlyVector3, right: ReadonlyVector3): MutableVector3;
    export function crossToRef(left: ReadonlyVector3, right: ReadonlyVector3, result: MutableVector3): void;
    export function dot(left: ReadonlyVector3, right: ReadonlyVector3): number;
    export function Down(): MutableVector3;
    export function Forward(): MutableVector3;
    export function Left(): MutableVector3;
    export function length(vector: ReadonlyVector3): number;
    export function lengthSquared(vector: ReadonlyVector3): number;
    export function lerp(start: ReadonlyVector3, end: ReadonlyVector3, amount: number): MutableVector3;
    export function lerpToRef(start: ReadonlyVector3, end: ReadonlyVector3, amount: number, result: MutableVector3): void;
    // (undocumented)
    export type MutableVector3 = {
        y: number;
        x: number;
        z: number;
    };
    export function normalize(vector: ReadonlyVector3): MutableVector3;
    export function normalizeFromLength(vector: ReadonlyVector3, len: number): MutableVector3;
    export function normalizeFromLengthToRef(vector: ReadonlyVector3, len: number, result: MutableVector3): void;
    export function normalizeToRef(vector: ReadonlyVector3, result: MutableVector3): void;
    export function One(): MutableVector3;
    export function opposite(value: ReadonlyVector3): MutableVector3;
    // (undocumented)
    export type ReadonlyVector3 = DeepReadonly<MutableVector3>;
    export function Right(): MutableVector3;
    export function rotate(vector: ReadonlyVector3, q: Quaternion.ReadonlyQuaternion): MutableVector3;
    export function scale(vector: ReadonlyVector3, scale: number): MutableVector3;
    export function scaleToRef(vector: ReadonlyVector3, scale: number, result: MutableVector3): void;
    export function subtract(minuend: ReadonlyVector3, subtrahend: ReadonlyVector3): MutableVector3;
    export function subtractToRef(minuend: ReadonlyVector3, subtrahend: ReadonlyVector3, result: MutableVector3): void;
    export function Up(): MutableVector3;
    export function Zero(): MutableVector3;
}

// Warnings were encountered during analysis:
//
// dist/engine/types.d.ts:25:5 - (ae-forgotten-export) The symbol "Update" needs to be exported by the entry point index.d.ts
// dist/engine/types.d.ts:38:5 - (ae-forgotten-export) The symbol "Transport" needs to be exported by the entry point index.d.ts

// (No @packageDocumentation comment for this package)

```