## API Report File for "hilo3d"

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

```ts

import { mat3 } from 'gl-matrix';
import { mat4 } from 'gl-matrix';
import { quat } from 'gl-matrix';
import { vec2 } from 'gl-matrix';
import { vec3 } from 'gl-matrix';
import { vec4 } from 'gl-matrix';

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

// @public
export class AmbientLight extends Light {
    constructor(params?: AmbientLightParameters);
    // (undocumented)
    autoUpdateWorldMatrix: boolean;
    // (undocumented)
    className: string;
    // (undocumented)
    isAmbientLight: boolean;
    // (undocumented)
    static readonly typeName = "AmbientLight";
}

// @public (undocumented)
export type AmbientLightParameters = LightParameters;

// @public
class Animation_2 extends EventDispatcher {
    constructor(params?: AnimationParameters);
    addClip(name: string, start: number, end: number, animStatesList: AnimationStates[]): void;
    // (undocumented)
    static readonly _anims: Animation_2[];
    get animStatesList(): AnimationStates[];
    set animStatesList(value: AnimationStates[]);
    // (undocumented)
    className: string;
    clipEndTime: number;
    // (undocumented)
    clips: Record<string, AnimationClip | null>;
    clipStartTime: number;
    clone(rootNode: Node_2): Animation_2;
    currentLoopCount: number;
    currentTime: number;
    endTime: number;
    getAnimStatesListTimeInfo(animStatesList: AnimationStates[]): AnimationTimeRange;
    // (undocumented)
    readonly id: string;
    _initNodeNameMap(): void;
    // (undocumented)
    isAnimation: boolean;
    loop: number;
    // (undocumented)
    nodeNameMap: Record<string, Node_2>;
    pause(): void;
    paused: boolean;
    play(startOrClipName?: number | string, end?: number): void;
    removeClip(name: string): void;
    resume(): void;
    get rootNode(): Node_2 | null;
    set rootNode(value: Node_2 | null);
    startTime: number;
    stop(): void;
    static tick(dt: number): void;
    tick(dt: number): void;
    timeScale: number;
    updateAnimStates(): this;
    validAnimationIds: Readonly<Record<string, boolean>> | null;
}
export { Animation_2 as Animation }

// @public (undocumented)
export interface AnimationClip {
    // (undocumented)
    animStatesList?: AnimationStates[];
    // (undocumented)
    end: number;
    // (undocumented)
    start: number;
}

// @public (undocumented)
export type AnimationInterpolationType = 'LINEAR' | 'STEP' | 'CUBICSPLINE';

// @public (undocumented)
export interface AnimationParameters {
    // (undocumented)
    animStatesList?: AnimationStates[];
    // (undocumented)
    clips?: Record<string, AnimationClip | null>;
    // (undocumented)
    currentLoopCount?: number;
    // (undocumented)
    currentTime?: number;
    // (undocumented)
    endTime?: number;
    // (undocumented)
    loop?: number;
    // (undocumented)
    paused?: boolean;
    // (undocumented)
    rootNode?: Node_2 | null;
    // (undocumented)
    startTime?: number;
    // (undocumented)
    timeScale?: number;
    // (undocumented)
    validAnimationIds?: Readonly<Record<string, boolean>> | null;
}

// @public (undocumented)
export type AnimationStateHandler = (node: Node_2, state: unknown) => void;

// @public
export class AnimationStates {
    constructor(params?: AnimationStatesParameters);
    // (undocumented)
    readonly className = "AnimationStates";
    // (undocumented)
    clone(): AnimationStates;
    // (undocumented)
    findIndexByTime(time: number): [number, number];
    // (undocumented)
    getState(time: number): unknown;
    // (undocumented)
    getStateByIndex(index: number): unknown;
    // (undocumented)
    static getType(name: string): AnimationStateType;
    // (undocumented)
    readonly id: string;
    // (undocumented)
    static readonly interpolation: Record<AnimationInterpolationType, InterpolationFunction>;
    // (undocumented)
    interpolation(first: unknown, second?: unknown, ratio?: number, timeRange?: number): InterpolatedValue;
    // (undocumented)
    interpolationType: AnimationInterpolationType;
    // (undocumented)
    readonly isAnimationStates = true;
    // (undocumented)
    keyTime: number[];
    // (undocumented)
    nodeName: string;
    // (undocumented)
    static registerStateHandler(name: string, handler: AnimationStateHandler): void;
    // (undocumented)
    states: unknown[];
    // (undocumented)
    static readonly StateType: Readonly<{
        TRANSLATE: "Translation";
        POSITION: "Translation";
        TRANSLATION: "Translation";
        SCALE: "Scale";
        ROTATE: "Rotation";
        ROTATION: "Rotation";
        QUATERNION: "Quaternion";
        WEIGHTS: "Weights";
    }>;
    // (undocumented)
    type: AnimationStateType;
    // (undocumented)
    updateNodeQuaternion(node: Node_2, value: unknown): void;
    // (undocumented)
    updateNodeScale(node: Node_2, value: unknown): void;
    // (undocumented)
    updateNodeState(time: number, node?: Node_2): void;
    // (undocumented)
    updateNodeTranslation(node: Node_2, value: unknown): void;
    // (undocumented)
    updateNodeWeights(node: Node_2, value: unknown): void;
}

// @public (undocumented)
export interface AnimationStatesParameters {
    // (undocumented)
    interpolationType?: AnimationInterpolationType;
    // (undocumented)
    keyTime?: number[];
    // (undocumented)
    nodeName?: string;
    // (undocumented)
    states?: unknown[];
    // (undocumented)
    type?: AnimationStateType;
}

// @public (undocumented)
export type AnimationStateType = BuiltInAnimationStateType | (string & {});

// @public (undocumented)
export interface AnimationTimeRange {
    // (undocumented)
    endTime: number;
    // (undocumented)
    startTime: number;
}

// @public
export class AreaLight extends Light {
    constructor(params?: AreaLightParameters);
    // (undocumented)
    className: string;
    // (undocumented)
    get enabled(): boolean;
    set enabled(value: boolean);
    height: number;
    static initializeLtcTexture(): void;
    // (undocumented)
    isAreaLight: boolean;
    static ltcTexture1: DataTexture | null;
    get ltcTexture1(): DataTexture | null;
    set ltcTexture1(texture: DataTexture | null);
    static ltcTexture2: DataTexture | null;
    get ltcTexture2(): DataTexture | null;
    set ltcTexture2(texture: DataTexture | null);
    static ltcTextureReady: boolean;
    // (undocumented)
    static readonly typeName = "AreaLight";
    width: number;
}

// @public (undocumented)
export interface AreaLightInfo {
    // (undocumented)
    colors: Float32Array;
    // (undocumented)
    height: Float32Array;
    // (undocumented)
    ltcTexture1: Texture | null;
    // (undocumented)
    ltcTexture2: Texture | null;
    // (undocumented)
    poses: Float32Array;
    // (undocumented)
    width: Float32Array;
}

// @public (undocumented)
export interface AreaLightParameters extends LightParameters {
    // (undocumented)
    height?: number;
    // (undocumented)
    width?: number;
}

// @public (undocumented)
export type AxisAlignedBox = readonly [ArrayLike<number>, ArrayLike<number>];

// @public
export class AxisHelper extends Node_2 {
    constructor(params?: AxisHelperParameters);
    // (undocumented)
    className: string;
    // (undocumented)
    isAxisHelper: boolean;
    size: number;
    // (undocumented)
    static readonly typeName: string;
}

// @public (undocumented)
export interface AxisHelperParameters extends NodeParameters {
    // (undocumented)
    size?: number;
}

// @public
export class AxisNetHelper extends Mesh {
    constructor(params?: AxisNetHelperParameters);
    // (undocumented)
    className: string;
    // (undocumented)
    color: Color;
    // (undocumented)
    isAxisNetHelper: boolean;
    size: number;
    // (undocumented)
    static readonly typeName: string;
}

// @public (undocumented)
export interface AxisNetHelperParameters extends MeshParameters {
    // (undocumented)
    color?: Color;
    // (undocumented)
    size?: number;
}

// @public (undocumented)
export interface BackEaseObject extends TweenEaseObject {
    // (undocumented)
    config(overshoot: number): void;
    // (undocumented)
    o: number;
    // (undocumented)
    s: number;
}

// @public (undocumented)
export type BasicLightType = 'NONE' | 'PHONG' | 'BLINN-PHONG' | 'LAMBERT';

// @public
export class BasicLoader extends EventDispatcher {
    // (undocumented)
    static readonly cache: LoadCache<Error | BasicResource>;
    // (undocumented)
    readonly className: string;
    // (undocumented)
    static clearCache(): void;
    // (undocumented)
    static deleteCache(key: string): void;
    // (undocumented)
    static disableCache(): void;
    // (undocumented)
    static enableCache(): void;
    // (undocumented)
    isBase64(url: string): boolean;
    // (undocumented)
    readonly isBasicLoader = true;
    // (undocumented)
    isCrossOrigin(url: string): boolean;
    // (undocumented)
    load(data: BasicLoadRequest): Promise<BasicResource>;
    // (undocumented)
    loadImg(url: string, crossOrigin?: ImageCrossOrigin): Promise<HTMLImageElement>;
    // (undocumented)
    loadRes(url: string, type?: string): Promise<JsonValue | ArrayBuffer>;
    // (undocumented)
    request(options: ResourceRequestOptions): Promise<JsonValue | ArrayBuffer>;
    // (undocumented)
    static readonly TYPE_BUFFER = "buffer";
    // (undocumented)
    static readonly TYPE_IMAGE = "img";
    // (undocumented)
    static readonly TYPE_JSON = "json";
    // (undocumented)
    static readonly TYPE_TEXT = "text";
}

// @public (undocumented)
export type BasicLoaderResource = Awaited<ReturnType<BasicLoader['loadRes']>>;

// @public (undocumented)
export interface BasicLoadRequest extends LoaderRequest {
    // (undocumented)
    src: string;
}

// @public
export class BasicMaterial extends Material {
    constructor(params?: BasicMaterialParameters);
    ambient: MaterialTextureValue;
    // (undocumented)
    readonly className: string;
    diffuse: MaterialTextureValue;
    emission: MaterialTextureValue;
    // (undocumented)
    getRenderOption(option?: ShaderOptions): ShaderOptions;
    // (undocumented)
    protected initializeBasicMaterialBindings(): void;
    // (undocumented)
    isBasicMaterial: boolean;
    lightType: BasicLightType;
    reflectivity: number;
    refractivity: number;
    refractRatio: number;
    shininess: number;
    specular: MaterialTextureValue;
    specularEnvMap: MaterialTexture | null;
    specularEnvMatrix: Matrix4 | null;
    // (undocumented)
    usedUniformVectors: number;
}

// @public (undocumented)
export interface BasicMaterialParameters extends MaterialParameters {
    // (undocumented)
    ambient?: MaterialTextureValue;
    // (undocumented)
    diffuse?: MaterialTextureValue;
    // (undocumented)
    emission?: MaterialTextureValue;
    // (undocumented)
    lightType?: BasicLightType;
    // (undocumented)
    reflectivity?: number;
    // (undocumented)
    refractivity?: number;
    // (undocumented)
    refractRatio?: number;
    // (undocumented)
    shininess?: number;
    // (undocumented)
    specular?: MaterialTextureValue;
    // (undocumented)
    specularEnvMap?: MaterialTexture | null;
    // (undocumented)
    specularEnvMatrix?: Matrix4 | null;
}

// @public (undocumented)
export type BasicResource = HTMLImageElement | ArrayBuffer | JsonValue;

// @public (undocumented)
export type BasicResourceType = 'img' | 'json' | 'buffer' | 'text';

// @public (undocumented)
export interface Bounds {
    // (undocumented)
    depth: number;
    // (undocumented)
    height: number;
    // (undocumented)
    width: number;
    // (undocumented)
    x: number;
    // (undocumented)
    xMax: number;
    // (undocumented)
    xMin: number;
    // (undocumented)
    y: number;
    // (undocumented)
    yMax: number;
    // (undocumented)
    yMin: number;
    // (undocumented)
    z: number;
    // (undocumented)
    zMax: number;
    // (undocumented)
    zMin: number;
}

// @public
export class BoxGeometry extends Geometry {
    constructor(params?: BoxGeometryParameters);
    // (undocumented)
    build(): void;
    // (undocumented)
    buildWithSegments(): void;
    // (undocumented)
    readonly className: string;
    depth: number;
    depthSegments: number;
    height: number;
    heightSegments: number;
    // (undocumented)
    isBoxGeometry: boolean;
    // (undocumented)
    isSegments(): boolean;
    // (undocumented)
    _raycast(ray: Ray, side: GLenum): Vector3[] | null;
    setAllRectUV(uv: readonly UV[]): this;
    setBackUV(uv: readonly UV[]): void;
    setBottomUV(uv: readonly UV[]): void;
    setFrontUV(uv: readonly UV[]): void;
    setLeftUV(uv: readonly UV[]): void;
    setRightUV(uv: readonly UV[]): void;
    setTopUV(uv: readonly UV[]): void;
    width: number;
    widthSegments: number;
}

// @public (undocumented)
export interface BoxGeometryParameters extends GeometryParameters {
    // (undocumented)
    depth?: number;
    // (undocumented)
    depthSegments?: number;
    // (undocumented)
    height?: number;
    // (undocumented)
    heightSegments?: number;
    // (undocumented)
    width?: number;
    // (undocumented)
    widthSegments?: number;
}

// @public (undocumented)
export const browser: BrowserFeatures;

// @public (undocumented)
export interface BrowserFeatures {
    // (undocumented)
    readonly POINTER_CANCEL: 'pointercancel';
    // (undocumented)
    readonly POINTER_END: 'pointerup';
    // (undocumented)
    readonly POINTER_MOVE: 'pointermove';
    // (undocumented)
    readonly POINTER_OUT: 'pointerout';
    // (undocumented)
    readonly POINTER_START: 'pointerdown';
    // (undocumented)
    supportCanvas: boolean;
    // (undocumented)
    supportDeviceMotion: boolean;
    // (undocumented)
    supportOrientation: boolean;
    // (undocumented)
    supportPointerEvents: boolean;
    // (undocumented)
    supportStorage: boolean;
    // (undocumented)
    supportTouch: boolean;
}

// @public (undocumented)
export const BUILTIN_UNIFORM_BLOCK_BINDING_COUNT = 9;

// @public (undocumented)
export type BuiltInAnimationStateType = (typeof STATE_TYPES)[keyof typeof STATE_TYPES];

// @public
class Cache_2<Value = unknown> {
    // (undocumented)
    add(id: string, value: Value): void;
    // (undocumented)
    each(callback: (value: Value, id: string) => void): void;
    // (undocumented)
    get(id: string): Value | undefined;
    // (undocumented)
    getObject(object: object): Value | undefined;
    // (undocumented)
    remove(id: string): void;
    // (undocumented)
    removeAll(): void;
    // (undocumented)
    removeObject(object: object): void;
    // @internal
    get size(): number;
}
export { Cache_2 as Cache }

// @public
export class Camera extends Node_2 {
    constructor(params?: CameraParameters);
    // (undocumented)
    className: string;
    // (undocumented)
    protected readonly _frustum: Frustum;
    // (undocumented)
    protected _geometry: Geometry | null;
    getGeometry(forceUpdate?: boolean): Geometry;
    getModelProjectionMatrix(node: Node_2, out?: Matrix4): Matrix4;
    getModelViewMatrix(node: Node_2, out?: Matrix4): Matrix4;
    // (undocumented)
    isCamera: boolean;
    // (undocumented)
    protected _isGeometryDirty: boolean;
    isMeshVisible(mesh: Mesh): boolean;
    // (undocumented)
    isOrthographicCamera: boolean;
    // (undocumented)
    isPerspectiveCamera: boolean;
    isPointVisible(point: Vector3): boolean;
    protected _needUpdateProjectionMatrix: boolean;
    // (undocumented)
    readonly projectionMatrix: Matrix4;
    projectVector(vector: Vector3, width?: number, height?: number): Vector3;
    // (undocumented)
    static readonly typeName: string;
    unprojectVector(vector: Vector3, width?: number, height?: number): Vector3;
    updateFrustum(matrix: Matrix4): this;
    updateProjectionMatrix(): void;
    updateViewMatrix(): this;
    updateViewProjectionMatrix(): this;
    // (undocumented)
    readonly viewMatrix: Matrix4;
    // (undocumented)
    readonly viewProjectionMatrix: Matrix4;
}

// @public
export class CameraHelper extends Mesh {
    constructor(params?: CameraHelperParameters);
    // (undocumented)
    camera: Camera | null;
    // (undocumented)
    className: string;
    color: Color;
    // (undocumented)
    isCameraHelper: boolean;
    // (undocumented)
    onUpdate: ((deltaTime: number) => void) | null;
    // (undocumented)
    static readonly typeName: string;
}

// @public (undocumented)
export interface CameraHelperParameters extends MeshParameters {
    // (undocumented)
    camera?: Camera | null;
    // (undocumented)
    color?: Color;
}

// @public (undocumented)
export type CameraParameters = NodeParameters;

// @public (undocumented)
export function collectionEntries<Value>(collection: GLTFCollection<Value> | undefined): (readonly [string, Value])[];

// @public
export class Color extends Vector4 {
    constructor(r?: number, g?: number, b?: number, a?: number);
    // (undocumented)
    get a(): number;
    set a(value: number);
    // (undocumented)
    get b(): number;
    set b(value: number);
    className: string;
    fromHEX(hex: string | number): this;
    fromUintArray(array: ArrayLike<number>, offset?: number): this;
    // (undocumented)
    get g(): number;
    set g(value: number);
    // (undocumented)
    isColor: boolean;
    // (undocumented)
    get r(): number;
    set r(value: number);
    toHEX(): string;
    toRGBArray(array?: number[], offset?: number): number[];
}

// @public
export interface ComputeBufferBinding {
    readonly buffer: RenderGraphBufferHandle;
    readonly byteLength?: number;
    readonly byteOffset?: number;
}

// @public
export type ComputeDispatch = Readonly<{
    x: number;
    y?: number;
    z?: number;
}> | Readonly<{
    indirectBuffer: RenderGraphBufferHandle;
    indirectOffset?: number;
}>;

// @public
export class ComputeKernel {
    constructor(descriptor: Readonly<ComputeKernelDescriptor>);
    readonly constants: Readonly<Record<string, ComputePipelineConstant>>;
    readonly label: string;
    readonly shader: ComputeShader;
}

// @public
export interface ComputeKernelDescriptor {
    readonly constants?: Readonly<Record<string, ComputePipelineConstant>>;
    readonly label?: string;
    readonly shader: ComputeShader;
}

// @public
export type ComputePipelineConstant = number | boolean;

// @public
export class ComputeRenderPass implements ScriptableRenderPass<ComputeRenderPassParameters> {
    constructor(kernel: ComputeKernel, name?: string);
    execute(_context: ScriptableRenderPassContext, _parameters: ComputeRenderPassParameters): void;
    readonly kernel: ComputeKernel;
    readonly name: string;
    setup(builder: ScriptableRenderPassBuilder, parameters: ComputeRenderPassParameters): void;
}

// @public
export interface ComputeRenderPassParameters {
    readonly buffers: readonly ComputeBufferBinding[];
    readonly dispatch: ComputeDispatch;
    readonly samplers?: readonly ComputeSampler[];
    readonly textures: readonly ComputeTextureBinding[];
    readonly uniformBuffers?: readonly ComputeUniformBufferBinding[];
}

// @public
export class ComputeSampler {
    constructor(descriptor?: Readonly<ComputeSamplerDescriptor>);
    readonly addressModeU: ComputeSamplerAddressMode;
    readonly addressModeV: ComputeSamplerAddressMode;
    readonly addressModeW: ComputeSamplerAddressMode;
    readonly compare: RenderTargetCompareFunction | undefined;
    readonly label: string;
    readonly lodMaxClamp: number;
    readonly lodMinClamp: number;
    readonly magFilter: ComputeSamplerFilterMode;
    readonly maxAnisotropy: number;
    readonly minFilter: ComputeSamplerFilterMode;
    readonly mipmapFilter: ComputeSamplerFilterMode;
}

// @public
export type ComputeSamplerAddressMode = 'clamp-to-edge' | 'repeat' | 'mirror-repeat';

// @public
export interface ComputeSamplerDescriptor {
    readonly addressModeU?: ComputeSamplerAddressMode;
    readonly addressModeV?: ComputeSamplerAddressMode;
    readonly addressModeW?: ComputeSamplerAddressMode;
    readonly compare?: RenderTargetCompareFunction;
    readonly label?: string;
    readonly lodMaxClamp?: number;
    readonly lodMinClamp?: number;
    readonly magFilter?: ComputeSamplerFilterMode;
    readonly maxAnisotropy?: number;
    readonly minFilter?: ComputeSamplerFilterMode;
    readonly mipmapFilter?: ComputeSamplerFilterMode;
}

// @public
export type ComputeSamplerFilterMode = 'nearest' | 'linear';

// @public
export class ComputeShader {
    constructor(descriptor: Readonly<ComputeShaderDescriptor>);
    readonly bindings: readonly ComputeShaderBinding[];
    readonly entryPoint: string;
    readonly label: string;
    readonly source: string;
    readonly workgroupSize: NormalizedComputeWorkgroupSize;
}

// @public
export type ComputeShaderBinding = Readonly<{
    name: string;
    group: number;
    binding: number;
    kind: 'uniform-buffer' | 'read-only-storage-buffer';
    minBindingSize?: number;
    dynamicOffset?: boolean;
}> | Readonly<{
    name: string;
    group: number;
    binding: number;
    kind: 'sampled-texture';
    sampleType: ComputeTextureSampleType;
    viewDimension?: ComputeTextureViewDimension;
}> | Readonly<{
    name: string;
    group: number;
    binding: number;
    kind: 'sampler' | 'non-filtering-sampler' | 'comparison-sampler';
}> | Readonly<{
    name: string;
    group: number;
    binding: number;
    kind: 'storage-buffer';
    access: ComputeStorageBufferAccess;
    minBindingSize?: number;
    dynamicOffset?: boolean;
}> | Readonly<{
    name: string;
    group: number;
    binding: number;
    kind: 'storage-texture';
    access: 'write-only';
    format: ComputeStorageTextureFormat;
    viewDimension?: ComputeStorageTextureViewDimension;
}>;

// @public
export interface ComputeShaderDescriptor {
    readonly bindings: readonly ComputeShaderBinding[];
    readonly entryPoint?: string;
    readonly label?: string;
    readonly source: string;
    readonly workgroupSize: readonly [number, number?, number?];
}

// @public
export type ComputeStorageBufferAccess = 'read-write' | 'write-discard';

// @public
export type ComputeStorageTextureFormat = Exclude<RenderTargetColorFormat, 'rgba8unorm-srgb'>;

// @public
export type ComputeStorageTextureViewDimension = '2d';

// @public
export interface ComputeTextureBinding {
    readonly texture: RenderGraphTextureHandle;
}

// @public
export type ComputeTextureSampleType = 'float' | 'unfilterable-float' | 'depth';

// @public
export type ComputeTextureViewDimension = '2d';

// @public
export type ComputeUniformBufferBinding = UniformBuffer | UniformBufferRange;

// @public
export const constants: {
    readonly webgl: typeof webglConstants;
    readonly webglExtensions: typeof webglExtensionConstants;
    readonly webgl2: typeof webgl2Constants;
    readonly Hilo: typeof engineConstants;
    readonly POSITION: "POSITION";
    readonly NORMAL: "NORMAL";
    readonly DEPTH: "DEPTH";
    readonly DISTANCE: "DISTANCE";
    readonly READ_BUFFER: 3074;
    readonly UNPACK_ROW_LENGTH: 3314;
    readonly UNPACK_SKIP_ROWS: 3315;
    readonly UNPACK_SKIP_PIXELS: 3316;
    readonly PACK_ROW_LENGTH: 3330;
    readonly PACK_SKIP_ROWS: 3331;
    readonly PACK_SKIP_PIXELS: 3332;
    readonly TEXTURE_BINDING_3D: 32874;
    readonly UNPACK_SKIP_IMAGES: 32877;
    readonly UNPACK_IMAGE_HEIGHT: 32878;
    readonly MAX_3D_TEXTURE_SIZE: 32883;
    readonly MAX_ELEMENTS_VERTICES: 33000;
    readonly MAX_ELEMENTS_INDICES: 33001;
    readonly MAX_TEXTURE_LOD_BIAS: 34045;
    readonly MAX_FRAGMENT_UNIFORM_COMPONENTS: 35657;
    readonly MAX_VERTEX_UNIFORM_COMPONENTS: 35658;
    readonly MAX_ARRAY_TEXTURE_LAYERS: 35071;
    readonly MIN_PROGRAM_TEXEL_OFFSET: 35076;
    readonly MAX_PROGRAM_TEXEL_OFFSET: 35077;
    readonly MAX_VARYING_COMPONENTS: 35659;
    readonly FRAGMENT_SHADER_DERIVATIVE_HINT: 35723;
    readonly RASTERIZER_DISCARD: 35977;
    readonly VERTEX_ARRAY_BINDING: 34229;
    readonly MAX_VERTEX_OUTPUT_COMPONENTS: 37154;
    readonly MAX_FRAGMENT_INPUT_COMPONENTS: 37157;
    readonly MAX_SERVER_WAIT_TIMEOUT: 37137;
    readonly MAX_ELEMENT_INDEX: 36203;
    readonly RED: 6403;
    readonly RGB8: 32849;
    readonly RGBA8: 32856;
    readonly RGB10_A2: 32857;
    readonly TEXTURE_3D: 32879;
    readonly TEXTURE_WRAP_R: 32882;
    readonly TEXTURE_MIN_LOD: 33082;
    readonly TEXTURE_MAX_LOD: 33083;
    readonly TEXTURE_BASE_LEVEL: 33084;
    readonly TEXTURE_MAX_LEVEL: 33085;
    readonly TEXTURE_COMPARE_MODE: 34892;
    readonly TEXTURE_COMPARE_FUNC: 34893;
    readonly SRGB: 35904;
    readonly SRGB8: 35905;
    readonly SRGB8_ALPHA8: 35907;
    readonly COMPARE_REF_TO_TEXTURE: 34894;
    readonly RGBA32F: 34836;
    readonly RGB32F: 34837;
    readonly RGBA16F: 34842;
    readonly RGB16F: 34843;
    readonly TEXTURE_2D_ARRAY: 35866;
    readonly TEXTURE_BINDING_2D_ARRAY: 35869;
    readonly R11F_G11F_B10F: 35898;
    readonly RGB9_E5: 35901;
    readonly RGBA32UI: 36208;
    readonly RGB32UI: 36209;
    readonly RGBA16UI: 36214;
    readonly RGB16UI: 36215;
    readonly RGBA8UI: 36220;
    readonly RGB8UI: 36221;
    readonly RGBA32I: 36226;
    readonly RGB32I: 36227;
    readonly RGBA16I: 36232;
    readonly RGB16I: 36233;
    readonly RGBA8I: 36238;
    readonly RGB8I: 36239;
    readonly RED_INTEGER: 36244;
    readonly RGB_INTEGER: 36248;
    readonly RGBA_INTEGER: 36249;
    readonly R8: 33321;
    readonly RG8: 33323;
    readonly R16F: 33325;
    readonly R32F: 33326;
    readonly RG16F: 33327;
    readonly RG32F: 33328;
    readonly R8I: 33329;
    readonly R8UI: 33330;
    readonly R16I: 33331;
    readonly R16UI: 33332;
    readonly R32I: 33333;
    readonly R32UI: 33334;
    readonly RG8I: 33335;
    readonly RG8UI: 33336;
    readonly RG16I: 33337;
    readonly RG16UI: 33338;
    readonly RG32I: 33339;
    readonly RG32UI: 33340;
    readonly R8_SNORM: 36756;
    readonly RG8_SNORM: 36757;
    readonly RGB8_SNORM: 36758;
    readonly RGBA8_SNORM: 36759;
    readonly RGB10_A2UI: 36975;
    readonly TEXTURE_IMMUTABLE_FORMAT: 37167;
    readonly TEXTURE_IMMUTABLE_LEVELS: 33503;
    readonly UNSIGNED_INT_2_10_10_10_REV: 33640;
    readonly UNSIGNED_INT_10F_11F_11F_REV: 35899;
    readonly UNSIGNED_INT_5_9_9_9_REV: 35902;
    readonly FLOAT_32_UNSIGNED_INT_24_8_REV: 36269;
    readonly UNSIGNED_INT_24_8: 34042;
    readonly HALF_FLOAT: 5131;
    readonly RG: 33319;
    readonly RG_INTEGER: 33320;
    readonly INT_2_10_10_10_REV: 36255;
    readonly URRENT_QUERY: 34917;
    readonly QUERY_RESULT: 34918;
    readonly QUERY_RESULT_AVAILABLE: 34919;
    readonly ANY_SAMPLES_PASSED: 35887;
    readonly ANY_SAMPLES_PASSED_CONSERVATIVE: 36202;
    readonly MAX_DRAW_BUFFERS: 34852;
    readonly DRAW_BUFFER0: 34853;
    readonly DRAW_BUFFER1: 34854;
    readonly DRAW_BUFFER2: 34855;
    readonly DRAW_BUFFER3: 34856;
    readonly DRAW_BUFFER4: 34857;
    readonly DRAW_BUFFER5: 34858;
    readonly DRAW_BUFFER6: 34859;
    readonly DRAW_BUFFER7: 34860;
    readonly DRAW_BUFFER8: 34861;
    readonly DRAW_BUFFER9: 34862;
    readonly DRAW_BUFFER10: 34863;
    readonly DRAW_BUFFER11: 34864;
    readonly DRAW_BUFFER12: 34865;
    readonly DRAW_BUFFER13: 34866;
    readonly DRAW_BUFFER14: 34867;
    readonly DRAW_BUFFER15: 34868;
    readonly MAX_COLOR_ATTACHMENTS: 36063;
    readonly COLOR_ATTACHMENT1: 36065;
    readonly COLOR_ATTACHMENT2: 36066;
    readonly COLOR_ATTACHMENT3: 36067;
    readonly COLOR_ATTACHMENT4: 36068;
    readonly COLOR_ATTACHMENT5: 36069;
    readonly COLOR_ATTACHMENT6: 36070;
    readonly COLOR_ATTACHMENT7: 36071;
    readonly COLOR_ATTACHMENT8: 36072;
    readonly COLOR_ATTACHMENT9: 36073;
    readonly COLOR_ATTACHMENT10: 36074;
    readonly COLOR_ATTACHMENT11: 36075;
    readonly COLOR_ATTACHMENT12: 36076;
    readonly COLOR_ATTACHMENT13: 36077;
    readonly COLOR_ATTACHMENT14: 36078;
    readonly COLOR_ATTACHMENT15: 36079;
    readonly COMPRESSED_R11_EAC: 37488;
    readonly COMPRESSED_SIGNED_R11_EAC: 37489;
    readonly COMPRESSED_RG11_EAC: 37490;
    readonly COMPRESSED_SIGNED_RG11_EAC: 37491;
    readonly COMPRESSED_RGB8_ETC2: 37492;
    readonly COMPRESSED_SRGB8_ETC2: 37493;
    readonly COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2: 37494;
    readonly COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2: 37495;
    readonly COMPRESSED_RGBA8_ETC2_EAC: 37496;
    readonly COMPRESSED_SRGB8_ALPHA8_ETC2_EAC: 37497;
    readonly SAMPLER_3D: 35679;
    readonly SAMPLER_2D_SHADOW: 35682;
    readonly SAMPLER_2D_ARRAY: 36289;
    readonly SAMPLER_2D_ARRAY_SHADOW: 36292;
    readonly SAMPLER_CUBE_SHADOW: 36293;
    readonly INT_SAMPLER_2D: 36298;
    readonly INT_SAMPLER_3D: 36299;
    readonly INT_SAMPLER_CUBE: 36300;
    readonly INT_SAMPLER_2D_ARRAY: 36303;
    readonly UNSIGNED_INT_SAMPLER_2D: 36306;
    readonly UNSIGNED_INT_SAMPLER_3D: 36307;
    readonly UNSIGNED_INT_SAMPLER_CUBE: 36308;
    readonly UNSIGNED_INT_SAMPLER_2D_ARRAY: 36311;
    readonly MAX_SAMPLES: 36183;
    readonly SAMPLER_BINDING: 35097;
    readonly PIXEL_PACK_BUFFER: 35051;
    readonly PIXEL_UNPACK_BUFFER: 35052;
    readonly PIXEL_PACK_BUFFER_BINDING: 35053;
    readonly PIXEL_UNPACK_BUFFER_BINDING: 35055;
    readonly COPY_READ_BUFFER: 36662;
    readonly COPY_WRITE_BUFFER: 36663;
    readonly COPY_READ_BUFFER_BINDING: 36662;
    readonly COPY_WRITE_BUFFER_BINDING: 36663;
    readonly FLOAT_MAT2x3: 35685;
    readonly FLOAT_MAT2x4: 35686;
    readonly FLOAT_MAT3x2: 35687;
    readonly FLOAT_MAT3x4: 35688;
    readonly FLOAT_MAT4x2: 35689;
    readonly FLOAT_MAT4x3: 35690;
    readonly UNSIGNED_INT_VEC2: 36294;
    readonly UNSIGNED_INT_VEC3: 36295;
    readonly UNSIGNED_INT_VEC4: 36296;
    readonly UNSIGNED_NORMALIZED: 35863;
    readonly SIGNED_NORMALIZED: 36764;
    readonly VERTEX_ATTRIB_ARRAY_INTEGER: 35069;
    readonly VERTEX_ATTRIB_ARRAY_DIVISOR: 35070;
    readonly TRANSFORM_FEEDBACK_BUFFER_MODE: 35967;
    readonly MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS: 35968;
    readonly TRANSFORM_FEEDBACK_VARYINGS: 35971;
    readonly TRANSFORM_FEEDBACK_BUFFER_START: 35972;
    readonly TRANSFORM_FEEDBACK_BUFFER_SIZE: 35973;
    readonly TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN: 35976;
    readonly MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS: 35978;
    readonly MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS: 35979;
    readonly INTERLEAVED_ATTRIBS: 35980;
    readonly SEPARATE_ATTRIBS: 35981;
    readonly TRANSFORM_FEEDBACK_BUFFER: 35982;
    readonly TRANSFORM_FEEDBACK_BUFFER_BINDING: 35983;
    readonly TRANSFORM_FEEDBACK: 36386;
    readonly TRANSFORM_FEEDBACK_PAUSED: 36387;
    readonly TRANSFORM_FEEDBACK_ACTIVE: 36388;
    readonly TRANSFORM_FEEDBACK_BINDING: 36389;
    readonly FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING: 33296;
    readonly FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE: 33297;
    readonly FRAMEBUFFER_ATTACHMENT_RED_SIZE: 33298;
    readonly FRAMEBUFFER_ATTACHMENT_GREEN_SIZE: 33299;
    readonly FRAMEBUFFER_ATTACHMENT_BLUE_SIZE: 33300;
    readonly FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE: 33301;
    readonly FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE: 33302;
    readonly FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE: 33303;
    readonly FRAMEBUFFER_DEFAULT: 33304;
    readonly DEPTH_STENCIL_ATTACHMENT: 33306;
    readonly DEPTH_STENCIL: 34041;
    readonly DEPTH24_STENCIL8: 35056;
    readonly DRAW_FRAMEBUFFER_BINDING: 36006;
    readonly READ_FRAMEBUFFER: 36008;
    readonly DRAW_FRAMEBUFFER: 36009;
    readonly READ_FRAMEBUFFER_BINDING: 36010;
    readonly RENDERBUFFER_SAMPLES: 36011;
    readonly FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER: 36052;
    readonly FRAMEBUFFER_INCOMPLETE_MULTISAMPLE: 36182;
    readonly UNIFORM_BUFFER: 35345;
    readonly UNIFORM_BUFFER_BINDING: 35368;
    readonly UNIFORM_BUFFER_START: 35369;
    readonly UNIFORM_BUFFER_SIZE: 35370;
    readonly MAX_VERTEX_UNIFORM_BLOCKS: 35371;
    readonly MAX_FRAGMENT_UNIFORM_BLOCKS: 35373;
    readonly MAX_COMBINED_UNIFORM_BLOCKS: 35374;
    readonly MAX_UNIFORM_BUFFER_BINDINGS: 35375;
    readonly MAX_UNIFORM_BLOCK_SIZE: 35376;
    readonly MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS: 35377;
    readonly MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS: 35379;
    readonly UNIFORM_BUFFER_OFFSET_ALIGNMENT: 35380;
    readonly ACTIVE_UNIFORM_BLOCKS: 35382;
    readonly UNIFORM_TYPE: 35383;
    readonly UNIFORM_SIZE: 35384;
    readonly UNIFORM_BLOCK_INDEX: 35386;
    readonly UNIFORM_OFFSET: 35387;
    readonly UNIFORM_ARRAY_STRIDE: 35388;
    readonly UNIFORM_MATRIX_STRIDE: 35389;
    readonly UNIFORM_IS_ROW_MAJOR: 35390;
    readonly UNIFORM_BLOCK_BINDING: 35391;
    readonly UNIFORM_BLOCK_DATA_SIZE: 35392;
    readonly UNIFORM_BLOCK_ACTIVE_UNIFORMS: 35394;
    readonly UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES: 35395;
    readonly UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER: 35396;
    readonly UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER: 35398;
    readonly OBJECT_TYPE: 37138;
    readonly SYNC_CONDITION: 37139;
    readonly SYNC_STATUS: 37140;
    readonly SYNC_FLAGS: 37141;
    readonly SYNC_FENCE: 37142;
    readonly SYNC_GPU_COMMANDS_COMPLETE: 37143;
    readonly UNSIGNALED: 37144;
    readonly SIGNALED: 37145;
    readonly ALREADY_SIGNALED: 37146;
    readonly TIMEOUT_EXPIRED: 37147;
    readonly CONDITION_SATISFIED: 37148;
    readonly WAIT_FAILED: 37149;
    readonly SYNC_FLUSH_COMMANDS_BIT: 1;
    readonly COLOR: 6144;
    readonly STENCIL: 6146;
    readonly MIN: 32775;
    readonly MAX: 32776;
    readonly DEPTH_COMPONENT24: 33190;
    readonly STREAM_READ: 35041;
    readonly STREAM_COPY: 35042;
    readonly STATIC_READ: 35045;
    readonly STATIC_COPY: 35046;
    readonly DYNAMIC_READ: 35049;
    readonly DYNAMIC_COPY: 35050;
    readonly DEPTH_COMPONENT32F: 36012;
    readonly DEPTH32F_STENCIL8: 36013;
    readonly INVALID_INDEX: 4294967295;
    readonly TIMEOUT_IGNO: number;
    readonly MAX_CLIENT_WAIT_TIMEOUT_WEBGL: 37447;
    readonly UNMASKED_VENDOR_WEBGL: 37445;
    readonly UNMASKED_RENDERER_WEBGL: 37446;
    readonly MAX_TEXTURE_MAX_ANISOTROPY_EXT: 34047;
    readonly TEXTURE_MAX_ANISOTROPY_EXT: 34046;
    readonly COMPRESSED_RGB_S3TC_DXT1_EXT: 33776;
    readonly COMPRESSED_RGBA_S3TC_DXT1_EXT: 33777;
    readonly COMPRESSED_RGBA_S3TC_DXT3_EXT: 33778;
    readonly COMPRESSED_RGBA_S3TC_DXT5_EXT: 33779;
    readonly COMPRESSED_SRGB_S3TC_DXT1_EXT: 35916;
    readonly COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT: 35917;
    readonly COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT: 35918;
    readonly COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT: 35919;
    readonly COMPRESSED_RGB_PVRTC_4BPPV1_IMG: 35840;
    readonly COMPRESSED_RGB_PVRTC_2BPPV1_IMG: 35841;
    readonly COMPRESSED_RGBA_PVRTC_4BPPV1_IMG: 35842;
    readonly COMPRESSED_RGBA_PVRTC_2BPPV1_IMG: 35843;
    readonly COMPRESSED_RGB_ETC1_WEBGL: 36196;
    readonly COMPRESSED_RGB_ATC_WEBGL: 35986;
    readonly COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL: 35987;
    readonly COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL: 34798;
    readonly COMPRESSED_RGBA_ASTC_4X4_KHR: 37808;
    readonly COMPRESSED_SRGB8_ALPHA8_ASTC_4X4_KHR: 37840;
    readonly QUERY_COUNTER_BITS_EXT: 34916;
    readonly CURRENT_QUERY_EXT: 34917;
    readonly QUERY_RESULT_EXT: 34918;
    readonly QUERY_RESULT_AVAILABLE_EXT: 34919;
    readonly TIME_ELAPSED_EXT: 35007;
    readonly TIMESTAMP_EXT: 36392;
    readonly GPU_DISJOINT_EXT: 36795;
    readonly ACTIVE_ATTRIBUTES: 35721;
    readonly ACTIVE_ATTRIBUTE_MAX_LENGTH: 35722;
    readonly ACTIVE_TEXTURE: 34016;
    readonly ACTIVE_UNIFORMS: 35718;
    readonly ACTIVE_UNIFORM_MAX_LENGTH: 35719;
    readonly ALIASED_LINE_WIDTH_RANGE: 33902;
    readonly ALIASED_POINT_SIZE_RANGE: 33901;
    readonly ALPHA: 6406;
    readonly ALPHA_BITS: 3413;
    readonly ALWAYS: 519;
    readonly ARRAY_BUFFER: 34962;
    readonly ARRAY_BUFFER_BINDING: 34964;
    readonly ATTACHED_SHADERS: 35717;
    readonly BACK: 1029;
    readonly BLEND: 3042;
    readonly BLEND_COLOR: 32773;
    readonly BLEND_DST_ALPHA: 32970;
    readonly BLEND_DST_RGB: 32968;
    readonly BLEND_EQUATION: 32777;
    readonly BLEND_EQUATION_ALPHA: 34877;
    readonly BLEND_EQUATION_RGB: 32777;
    readonly BLEND_SRC_ALPHA: 32971;
    readonly BLEND_SRC_RGB: 32969;
    readonly BLUE_BITS: 3412;
    readonly BOOL: 35670;
    readonly BOOL_VEC2: 35671;
    readonly BOOL_VEC3: 35672;
    readonly BOOL_VEC4: 35673;
    readonly BROWSER_DEFAULT_WEBGL: 37444;
    readonly BUFFER_SIZE: 34660;
    readonly BUFFER_USAGE: 34661;
    readonly BYTE: 5120;
    readonly CCW: 2305;
    readonly CLAMP_TO_EDGE: 33071;
    readonly COLOR_ATTACHMENT0: 36064;
    readonly COLOR_BUFFER_BIT: 16384;
    readonly COLOR_CLEAR_VALUE: 3106;
    readonly COLOR_WRITEMASK: 3107;
    readonly COMPILE_STATUS: 35713;
    readonly COMPRESSED_TEXTURE_FORMATS: 34467;
    readonly CONSTANT_ALPHA: 32771;
    readonly CONSTANT_COLOR: 32769;
    readonly CONTEXT_LOST_WEBGL: 37442;
    readonly CULL_FACE: 2884;
    readonly CULL_FACE_MODE: 2885;
    readonly CURRENT_PROGRAM: 35725;
    readonly CURRENT_VERTEX_ATTRIB: 34342;
    readonly CW: 2304;
    readonly DECR: 7683;
    readonly DECR_WRAP: 34056;
    readonly DELETE_STATUS: 35712;
    readonly DEPTH_ATTACHMENT: 36096;
    readonly DEPTH_BITS: 3414;
    readonly DEPTH_BUFFER_BIT: 256;
    readonly DEPTH_CLEAR_VALUE: 2931;
    readonly DEPTH_COMPONENT: 6402;
    readonly DEPTH_COMPONENT16: 33189;
    readonly DEPTH_FUNC: 2932;
    readonly DEPTH_RANGE: 2928;
    readonly DEPTH_TEST: 2929;
    readonly DEPTH_WRITEMASK: 2930;
    readonly DITHER: 3024;
    readonly DONT_CARE: 4352;
    readonly DST_ALPHA: 772;
    readonly DST_COLOR: 774;
    readonly DYNAMIC_DRAW: 35048;
    readonly ELEMENT_ARRAY_BUFFER: 34963;
    readonly ELEMENT_ARRAY_BUFFER_BINDING: 34965;
    readonly EQUAL: 514;
    readonly FASTEST: 4353;
    readonly FLOAT: 5126;
    readonly FLOAT_MAT2: 35674;
    readonly FLOAT_MAT3: 35675;
    readonly FLOAT_MAT4: 35676;
    readonly FLOAT_VEC2: 35664;
    readonly FLOAT_VEC3: 35665;
    readonly FLOAT_VEC4: 35666;
    readonly FRAGMENT_SHADER: 35632;
    readonly FRAMEBUFFER: 36160;
    readonly FRAMEBUFFER_ATTACHMENT_OBJECT_NAME: 36049;
    readonly FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE: 36048;
    readonly FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE: 36051;
    readonly FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL: 36050;
    readonly FRAMEBUFFER_BINDING: 36006;
    readonly FRAMEBUFFER_COMPLETE: 36053;
    readonly FRAMEBUFFER_INCOMPLETE_ATTACHMENT: 36054;
    readonly FRAMEBUFFER_INCOMPLETE_DIMENSIONS: 36057;
    readonly FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: 36055;
    readonly FRAMEBUFFER_UNSUPPORTED: 36061;
    readonly FRONT: 1028;
    readonly FRONT_AND_BACK: 1032;
    readonly FRONT_FACE: 2886;
    readonly FUNC_ADD: 32774;
    readonly FUNC_REVERSE_SUBTRACT: 32779;
    readonly FUNC_SUBTRACT: 32778;
    readonly GENERATE_MIPMAP_HINT: 33170;
    readonly GEQUAL: 518;
    readonly GREATER: 516;
    readonly GREEN_BITS: 3411;
    readonly HIGH_FLOAT: 36338;
    readonly HIGH_INT: 36341;
    readonly INCR: 7682;
    readonly INCR_WRAP: 34055;
    readonly INFO_LOG_LENGTH: 35716;
    readonly INT: 5124;
    readonly INT_VEC2: 35667;
    readonly INT_VEC3: 35668;
    readonly INT_VEC4: 35669;
    readonly INVALID_ENUM: 1280;
    readonly INVALID_FRAMEBUFFER_OPERATION: 1286;
    readonly INVALID_OPERATION: 1282;
    readonly INVALID_VALUE: 1281;
    readonly INVERT: 5386;
    readonly KEEP: 7680;
    readonly LEQUAL: 515;
    readonly LESS: 513;
    readonly LINEAR: 9729;
    readonly LINEAR_MIPMAP_LINEAR: 9987;
    readonly LINEAR_MIPMAP_NEAREST: 9985;
    readonly LINES: 1;
    readonly LINE_LOOP: 2;
    readonly LINE_STRIP: 3;
    readonly LINE_WIDTH: 2849;
    readonly LINK_STATUS: 35714;
    readonly LOW_FLOAT: 36336;
    readonly LOW_INT: 36339;
    readonly LUMINANCE: 6409;
    readonly LUMINANCE_ALPHA: 6410;
    readonly MAX_COMBINED_TEXTURE_IMAGE_UNITS: 35661;
    readonly MAX_CUBE_MAP_TEXTURE_SIZE: 34076;
    readonly MAX_FRAGMENT_UNIFORM_VECTORS: 36349;
    readonly MAX_RENDERBUFFER_SIZE: 34024;
    readonly MAX_TEXTURE_IMAGE_UNITS: 34930;
    readonly MAX_TEXTURE_SIZE: 3379;
    readonly MAX_VARYING_VECTORS: 36348;
    readonly MAX_VERTEX_ATTRIBS: 34921;
    readonly MAX_VERTEX_TEXTURE_IMAGE_UNITS: 35660;
    readonly MAX_VERTEX_UNIFORM_VECTORS: 36347;
    readonly MAX_VIEWPORT_DIMS: 3386;
    readonly MEDIUM_FLOAT: 36337;
    readonly MEDIUM_INT: 36340;
    readonly MIRRORED_REPEAT: 33648;
    readonly NEAREST: 9728;
    readonly NEAREST_MIPMAP_LINEAR: 9986;
    readonly NEAREST_MIPMAP_NEAREST: 9984;
    readonly NEVER: 512;
    readonly NICEST: 4354;
    readonly NONE: 0;
    readonly NOTEQUAL: 517;
    readonly NO_ERROR: 0;
    readonly NUM_COMPRESSED_TEXTURE_FORMATS: 34466;
    readonly ONE: 1;
    readonly ONE_MINUS_CONSTANT_ALPHA: 32772;
    readonly ONE_MINUS_CONSTANT_COLOR: 32770;
    readonly ONE_MINUS_DST_ALPHA: 773;
    readonly ONE_MINUS_DST_COLOR: 775;
    readonly ONE_MINUS_SRC_ALPHA: 771;
    readonly ONE_MINUS_SRC_COLOR: 769;
    readonly OUT_OF_MEMORY: 1285;
    readonly PACK_ALIGNMENT: 3333;
    readonly POINTS: 0;
    readonly POLYGON_OFFSET_FACTOR: 32824;
    readonly POLYGON_OFFSET_FILL: 32823;
    readonly POLYGON_OFFSET_UNITS: 10752;
    readonly RED_BITS: 3410;
    readonly RENDERBUFFER: 36161;
    readonly RENDERBUFFER_ALPHA_SIZE: 36179;
    readonly RENDERBUFFER_BINDING: 36007;
    readonly RENDERBUFFER_BLUE_SIZE: 36178;
    readonly RENDERBUFFER_DEPTH_SIZE: 36180;
    readonly RENDERBUFFER_GREEN_SIZE: 36177;
    readonly RENDERBUFFER_HEIGHT: 36163;
    readonly RENDERBUFFER_INTERNAL_FORMAT: 36164;
    readonly RENDERBUFFER_RED_SIZE: 36176;
    readonly RENDERBUFFER_STENCIL_SIZE: 36181;
    readonly RENDERBUFFER_WIDTH: 36162;
    readonly RENDERER: 7937;
    readonly REPEAT: 10497;
    readonly REPLACE: 7681;
    readonly RGB: 6407;
    readonly RGB5_A1: 32855;
    readonly RGB565: 36194;
    readonly RGBA: 6408;
    readonly RGBA4: 32854;
    readonly SAMPLER_2D: 35678;
    readonly SAMPLER_CUBE: 35680;
    readonly SAMPLES: 32937;
    readonly SAMPLE_ALPHA_TO_COVERAGE: 32926;
    readonly SAMPLE_BUFFERS: 32936;
    readonly SAMPLE_COVERAGE: 32928;
    readonly SAMPLE_COVERAGE_INVERT: 32939;
    readonly SAMPLE_COVERAGE_VALUE: 32938;
    readonly SCISSOR_BOX: 3088;
    readonly SCISSOR_TEST: 3089;
    readonly SHADER_COMPILER: 36346;
    readonly SHADER_SOURCE_LENGTH: 35720;
    readonly SHADER_TYPE: 35663;
    readonly SHADING_LANGUAGE_VERSION: 35724;
    readonly SHORT: 5122;
    readonly SRC_ALPHA: 770;
    readonly SRC_ALPHA_SATURATE: 776;
    readonly SRC_COLOR: 768;
    readonly STATIC_DRAW: 35044;
    readonly STENCIL_ATTACHMENT: 36128;
    readonly STENCIL_BACK_FAIL: 34817;
    readonly STENCIL_BACK_FUNC: 34816;
    readonly STENCIL_BACK_PASS_DEPTH_FAIL: 34818;
    readonly STENCIL_BACK_PASS_DEPTH_PASS: 34819;
    readonly STENCIL_BACK_REF: 36003;
    readonly STENCIL_BACK_VALUE_MASK: 36004;
    readonly STENCIL_BACK_WRITEMASK: 36005;
    readonly STENCIL_BITS: 3415;
    readonly STENCIL_BUFFER_BIT: 1024;
    readonly STENCIL_CLEAR_VALUE: 2961;
    readonly STENCIL_FAIL: 2964;
    readonly STENCIL_FUNC: 2962;
    readonly STENCIL_INDEX: 6401;
    readonly STENCIL_INDEX8: 36168;
    readonly STENCIL_PASS_DEPTH_FAIL: 2965;
    readonly STENCIL_PASS_DEPTH_PASS: 2966;
    readonly STENCIL_REF: 2967;
    readonly STENCIL_TEST: 2960;
    readonly STENCIL_VALUE_MASK: 2963;
    readonly STENCIL_WRITEMASK: 2968;
    readonly STREAM_DRAW: 35040;
    readonly SUBPIXEL_BITS: 3408;
    readonly TEXTURE: 5890;
    readonly TEXTURE0: 33984;
    readonly TEXTURE1: 33985;
    readonly TEXTURE2: 33986;
    readonly TEXTURE3: 33987;
    readonly TEXTURE4: 33988;
    readonly TEXTURE5: 33989;
    readonly TEXTURE6: 33990;
    readonly TEXTURE7: 33991;
    readonly TEXTURE8: 33992;
    readonly TEXTURE9: 33993;
    readonly TEXTURE10: 33994;
    readonly TEXTURE11: 33995;
    readonly TEXTURE12: 33996;
    readonly TEXTURE13: 33997;
    readonly TEXTURE14: 33998;
    readonly TEXTURE15: 33999;
    readonly TEXTURE16: 34000;
    readonly TEXTURE17: 34001;
    readonly TEXTURE18: 34002;
    readonly TEXTURE19: 34003;
    readonly TEXTURE20: 34004;
    readonly TEXTURE21: 34005;
    readonly TEXTURE22: 34006;
    readonly TEXTURE23: 34007;
    readonly TEXTURE24: 34008;
    readonly TEXTURE25: 34009;
    readonly TEXTURE26: 34010;
    readonly TEXTURE27: 34011;
    readonly TEXTURE28: 34012;
    readonly TEXTURE29: 34013;
    readonly TEXTURE30: 34014;
    readonly TEXTURE31: 34015;
    readonly TEXTURE_2D: 3553;
    readonly TEXTURE_BINDING_2D: 32873;
    readonly TEXTURE_BINDING_CUBE_MAP: 34068;
    readonly TEXTURE_CUBE_MAP: 34067;
    readonly TEXTURE_CUBE_MAP_NEGATIVE_X: 34070;
    readonly TEXTURE_CUBE_MAP_NEGATIVE_Y: 34072;
    readonly TEXTURE_CUBE_MAP_NEGATIVE_Z: 34074;
    readonly TEXTURE_CUBE_MAP_POSITIVE_X: 34069;
    readonly TEXTURE_CUBE_MAP_POSITIVE_Y: 34071;
    readonly TEXTURE_CUBE_MAP_POSITIVE_Z: 34073;
    readonly TEXTURE_MAG_FILTER: 10240;
    readonly TEXTURE_MIN_FILTER: 10241;
    readonly TEXTURE_WRAP_S: 10242;
    readonly TEXTURE_WRAP_T: 10243;
    readonly TRIANGLES: 4;
    readonly TRIANGLE_FAN: 6;
    readonly TRIANGLE_STRIP: 5;
    readonly UNPACK_ALIGNMENT: 3317;
    readonly UNPACK_COLORSPACE_CONVERSION_WEBGL: 37443;
    readonly UNPACK_FLIP_Y_WEBGL: 37440;
    readonly UNPACK_PREMULTIPLY_ALPHA_WEBGL: 37441;
    readonly UNSIGNED_BYTE: 5121;
    readonly UNSIGNED_INT: 5125;
    readonly UNSIGNED_SHORT: 5123;
    readonly UNSIGNED_SHORT_4_4_4_4: 32819;
    readonly UNSIGNED_SHORT_5_5_5_1: 32820;
    readonly UNSIGNED_SHORT_5_6_5: 33635;
    readonly VALIDATE_STATUS: 35715;
    readonly VENDOR: 7936;
    readonly VERSION: 7938;
    readonly VERTEX_ATTRIB_ARRAY_BUFFER_BINDING: 34975;
    readonly VERTEX_ATTRIB_ARRAY_ENABLED: 34338;
    readonly VERTEX_ATTRIB_ARRAY_NORMALIZED: 34922;
    readonly VERTEX_ATTRIB_ARRAY_POINTER: 34373;
    readonly VERTEX_ATTRIB_ARRAY_SIZE: 34339;
    readonly VERTEX_ATTRIB_ARRAY_STRIDE: 34340;
    readonly VERTEX_ATTRIB_ARRAY_TYPE: 34341;
    readonly VERTEX_SHADER: 35633;
    readonly VIEWPORT: 2978;
    readonly ZERO: 0;
};

// @public (undocumented)
export function createEmptyGLTFRoot(): GLTFRoot;

// @public (undocumented)
export function createStd140Layout<const Schema extends Std140Schema>(schema: Schema): Std140Layout<Schema>;

// @public
export function createStorageLayout<const Schema extends StorageSchema>(schema: Schema): StorageLayout<Schema>;

// @public
export class CubeTexture extends Texture<CubeTextureImage> {
    constructor(params?: CubeTextureParameters);
    get back(): HTMLImageElement | undefined;
    set back(img: HTMLImageElement | undefined);
    get bottom(): HTMLImageElement | undefined;
    set bottom(img: HTMLImageElement | undefined);
    // (undocumented)
    readonly className: string;
    get front(): HTMLImageElement | undefined;
    set front(img: HTMLImageElement | undefined);
    // (undocumented)
    isCubeTexture: boolean;
    get left(): HTMLImageElement | undefined;
    set left(img: HTMLImageElement | undefined);
    get right(): HTMLImageElement | undefined;
    set right(img: HTMLImageElement | undefined);
    get top(): HTMLImageElement | undefined;
    set top(img: HTMLImageElement | undefined);
}

// @public (undocumented)
export type CubeTextureImage = (TextureImageSource | null)[];

// @public (undocumented)
export class CubeTextureLoader {
    // (undocumented)
    readonly className = "CubeTextureLoader";
    // (undocumented)
    readonly isCubeTextureLoader = true;
    // (undocumented)
    load(params: CubeTextureLoadRequest): Promise<CubeTexture>;
}

// @public (undocumented)
export type CubeTextureLoadRequest = LoaderRequest & Partial<Omit<CubeTextureParameters, 'image' | 'type'>> & {
    images?: readonly string[];
    right?: string;
    left?: string;
    top?: string;
    bottom?: string;
    front?: string;
    back?: string;
};

// @public (undocumented)
export interface CubeTextureParameters extends Omit<TextureParameters<CubeTextureImage>, 'target'> {
    // (undocumented)
    image?: CubeTextureImage | null;
}

// @public
export interface CullingOptions {
    readonly camera?: Camera;
    readonly frustumCulling?: boolean;
}

// @public
export type CullingResultsHandle = number & {
    readonly [cullingResultsHandleBrand]: true;
};

// @public (undocumented)
const cullingResultsHandleBrand: unique symbol;

// @public (undocumented)
export type CustomRenderOptionProvider = (option: ShaderOptions) => ShaderOptions;

// @public
export class DataTexture extends Texture<TypedArray> {
    constructor(params?: DataTextureParameters);
    // (undocumented)
    readonly className: string;
    get data(): TypedArray | null;
    set data(_data: ArrayLike<number> | TypedArray | null);
    // (undocumented)
    dataLength: number;
    // (undocumented)
    isDataTexture: boolean;
}

// @public (undocumented)
export interface DataTextureParameters extends Omit<TextureParameters<TypedArray>, 'image' | 'target'> {
    // (undocumented)
    data?: ArrayLike<number> | TypedArray | null;
    // (undocumented)
    image?: TypedArray | null;
}

// @public (undocumented)
const DEPTH$1 = "DEPTH";

// @public
export function detectBrowserFeatures(): BrowserFeatures;

// @public (undocumented)
export function detectWebGLSupport(): boolean;

// @public
export class DirectionalLight extends Light {
    constructor(params?: DirectionalLightParameters);
    // (undocumented)
    className: string;
    // (undocumented)
    direction: Vector3;
    getViewDirection(camera: Camera): Vector3;
    getWorldDirection(): Vector3;
    // (undocumented)
    isDirectionalLight: boolean;
    // (undocumented)
    static readonly typeName = "DirectionalLight";
}

// Warning: (ae-forgotten-export) The symbol "ShadowInfo" needs to be exported by the entry point Hilo3d.d.ts
//
// @public (undocumented)
export interface DirectionalLightInfo extends ShadowInfo {
    // (undocumented)
    colors: Float32Array;
    // (undocumented)
    infos: Float32Array;
}

// @public (undocumented)
export interface DirectionalLightParameters extends ShadowCastingLightParameters {
    // (undocumented)
    direction?: Vector3;
}

// @public
export interface DispatchEvent {
    // (undocumented)
    detail?: unknown;
    // (undocumented)
    stopImmediatePropagation?: () => void;
    // (undocumented)
    _stopped?: boolean;
    // (undocumented)
    target?: unknown;
    // (undocumented)
    type: string;
}

// @public (undocumented)
const DISTANCE = "DISTANCE";

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

// @public (undocumented)
export interface ElasticEaseObject extends TweenEaseObject {
    // (undocumented)
    a: number;
    // (undocumented)
    config(amplitude: number, period: number): void;
    // (undocumented)
    p: number;
    // (undocumented)
    s: number;
}

// @public (undocumented)
export namespace engineConstants {
    export {
        DEPTH$1 as DEPTH,
        Hilo_DISTANCE as DISTANCE,
        Hilo_NORMAL as NORMAL,
        Hilo_POSITION as POSITION,
    };
}

// @public (undocumented)
export class Euler {
    constructor(x?: number, y?: number, z?: number);
    className: string;
    clone(): Euler;
    copy(euler: Euler): this;
    get degX(): number;
    set degX(value: number);
    // (undocumented)
    protected _degX: number;
    get degY(): number;
    set degY(value: number);
    // (undocumented)
    protected _degY: number;
    get degZ(): number;
    set degZ(value: number);
    // (undocumented)
    protected _degZ: number;
    // (undocumented)
    elements: Float32Array;
    fromArray(array: ArrayLike<number>, offset?: number): this;
    fromMat4(mat: Matrix4, order?: EulerOrder): this;
    fromQuat(quat: Quaternion, order?: EulerOrder): this;
    // (undocumented)
    isEuler: boolean;
    order: EulerOrder;
    set(x: number, y: number, z: number): this;
    setDegree(degX: number, degY: number, degZ: number): this;
    toArray(array?: MutableNumberArray, offset?: number): MutableNumberArray;
    // (undocumented)
    updateDegrees(): this;
    // (undocumented)
    updateRadians(): this;
    get x(): number;
    set x(value: number);
    get y(): number;
    set y(value: number);
    get z(): number;
    set z(value: number);
}

// @public
export class EulerNotifier extends Euler {
    constructor(x?: number, y?: number, z?: number);
    className: string;
    get degX(): number;
    set degX(value: number);
    get degY(): number;
    set degY(value: number);
    get degZ(): number;
    set degZ(value: number);
    // (undocumented)
    isEulerNotifier: boolean;
    onUpdate(): void;
    // (undocumented)
    updateDegrees(): this;
    // (undocumented)
    updateRadians(): this;
    get x(): number;
    set x(value: number);
    get y(): number;
    set y(value: number);
    get z(): number;
    set z(value: number);
}

// @public (undocumented)
export type EulerOrder = 'XYZ' | 'YXZ' | 'ZXY' | 'ZYX' | 'YZX' | 'XZY';

// @public
export class EventDispatcher {
    // (undocumented)
    fire(typeOrEvent?: string | DispatchEvent, detail?: unknown): boolean;
    // (undocumented)
    _listeners: ListenerMap | null;
    // (undocumented)
    off(type?: string, listener?: EventListener_2): this;
    // (undocumented)
    on(type: string, listener: EventListener_2, once?: boolean): this;
}

// @public (undocumented)
type EventListener_2<Event extends DispatchEvent = DispatchEvent> = (event: Event) => void;
export { EventListener_2 as EventListener }

// @public (undocumented)
export class Fog {
    constructor(params?: FogParameters);
    // (undocumented)
    className: string;
    // (undocumented)
    color: Color;
    density: number;
    end: number;
    getInfo(): Float32Array | number;
    // (undocumented)
    getRenderOption(option?: Record<string, number>): Record<string, number>;
    // (undocumented)
    readonly id: string;
    // (undocumented)
    isFog: boolean;
    mode: FogMode;
    start: number;
}

// @public (undocumented)
export type FogMode = 'LINEAR' | 'EXP' | 'EXP2';

// @public (undocumented)
export interface FogParameters {
    // (undocumented)
    color?: Color;
    // (undocumented)
    density?: number;
    // (undocumented)
    end?: number;
    // (undocumented)
    mode?: FogMode;
    // (undocumented)
    start?: number;
}

// @public
export interface ForwardRenderFeatureContext {
    readonly cullingResults: CullingResultsHandle;
    readonly pipeline: RenderPipelineContext;
    readonly resources: ForwardRenderPipelineResources;
}

// @public
export interface ForwardRenderFeatureRequirements extends RenderPipelineRequirements {
    readonly sampledDepth: boolean;
    readonly sampledSceneColor: boolean;
}

// @public
export type ForwardRenderInjectionPoint = 'before-shadow' | 'after-shadow' | 'before-opaque' | 'after-opaque' | 'before-transparent' | 'after-transparent' | 'before-post-process' | 'after-post-process' | 'before-output';

// @public
export class ForwardRenderPipelineFactory implements RenderPipelineFactory {
    constructor(options?: ForwardRenderPipelineFactoryOptions);
    create(context: RenderPipelineCreateContext): RenderPipeline;
    readonly features: readonly ForwardRenderPipelineFeature[];
    readonly name = "forward";
    readonly requirements: Readonly<RenderPipelineRequirements>;
}

// @public
export interface ForwardRenderPipelineFactoryOptions {
    readonly features?: readonly ForwardRenderPipelineFeature[];
}

// @public
export interface ForwardRenderPipelineFeature {
    create(context: RenderPipelineCreateContext): ForwardRenderPipelineFeatureRuntime;
    readonly injectionPoint: ForwardRenderInjectionPoint;
    readonly name: string;
    readonly requirements: Readonly<ForwardRenderFeatureRequirements>;
}

// @public
export interface ForwardRenderPipelineFeatureRuntime {
    destroy(): void;
    record(context: ForwardRenderFeatureContext): unknown;
}

// @public
export interface ForwardRenderPipelineResources {
    readonly color: RenderGraphTextureHandle | null;
    readonly depth: RenderGraphTextureHandle | null;
    replaceColor(texture: RenderGraphTextureHandle): void;
}

// @public
export class Frustum {
    constructor();
    className: string;
    clone(): Frustum;
    copy(frustum: Frustum): this;
    fromMatrix(mat: Matrix4): this;
    intersectsSphere(sphere: Sphere): boolean;
    // (undocumented)
    isFrustum: boolean;
    // (undocumented)
    planes: [Plane, Plane, Plane, Plane, Plane, Plane];
}

// @public
export class FullscreenRenderPass implements ScriptableRenderPass<FullscreenRenderPassParameters> {
    constructor(options: Readonly<FullscreenRenderPassOptions>);
    execute(context: ScriptableRenderPassContext, parameters: FullscreenRenderPassParameters): void;
    readonly material: Material;
    readonly name: string;
    setup(builder: ScriptableRenderPassBuilder, parameters: FullscreenRenderPassParameters): void;
    readonly shader: Shader;
    readonly uniformBuffers: readonly UniformBuffer[];
}

// @public
export interface FullscreenRenderPassOptions {
    readonly material: Material;
    readonly name?: string;
    readonly shader: Shader;
    readonly uniformBuffers?: readonly UniformBuffer[];
}

// @public
export interface FullscreenRenderPassParameters {
    readonly colorAttachments: readonly Readonly<RenderPipelineColorAttachment>[];
    readonly depthStencilAttachment?: Readonly<RenderPipelineDepthStencilAttachment>;
    readonly inputTextures: readonly RenderGraphTextureHandle[];
    readonly scissor?: RendererViewport;
    readonly stencilReference?: number;
    readonly viewport?: RendererViewport;
}

// @public
export class Geometry {
    constructor(params?: GeometryParameters);
    _aabbRaycast(ray: Ray): Vector3[] | null;
    addFace(p1: Point3, p2: Point3, p3: Point3): void;
    addIndices(...indices: number[]): void;
    addLine(p1: Point3, p2: Point3): void;
    addPoints(...points: Point3[]): number;
    addRect(p1: Point3, p2: Point3, p3: Point3, p4: Point3): void;
    // (undocumented)
    calculateNormals(): void;
    // (undocumented)
    readonly className: string;
    clone(): Geometry;
    colors: GeometryData | null;
    convertToLinesMode(): void;
    convertToNoIndices(verticesItemLen?: 3 | 4): void;
    // (undocumented)
    currentIndicesCount: number;
    // (undocumented)
    currentVerticesCount: number;
    getBounds(matrix?: Matrix4, bounds?: Bounds): Bounds;
    getLocalBounds(force?: boolean): Bounds;
    getLocalSphereBounds(force?: boolean): Sphere;
    // (undocumented)
    getRenderOption(opt?: ShaderOptions): ShaderOptions;
    // (undocumented)
    getShaderKey(): string;
    getSize(): number;
    getSphereBounds(matrix?: Matrix4): Sphere;
    // (undocumented)
    readonly id: string;
    indices: GeometryData | null;
    // (undocumented)
    get isDirty(): boolean;
    set isDirty(value: boolean);
    // (undocumented)
    readonly isGeometry = true;
    // (undocumented)
    readonly isMorphGeometry: boolean;
    isStatic: boolean;
    merge(geometry: Geometry, matrix?: Matrix4): this;
    mode: number;
    // (undocumented)
    normalDecodeMat: Float32Array | number[] | null;
    normalizePrimitiveTopology(): boolean;
    get normals(): GeometryData | null;
    set normals(data: GeometryData | null);
    // (undocumented)
    positionDecodeMat: Float32Array | number[] | null;
    raycast(ray: Ray, side: GLenum, sort?: boolean): Vector3[] | null;
    _raycast(ray: Ray, side: GLenum): Vector3[] | null;
    get revision(): number;
    rotate(x?: number, y?: number, z?: number): this;
    scale(x?: number, y?: number, z?: number): this;
    setFaceUV(start: number, p1: Point2, p2: Point2, p3: Point2): void;
    setRectUV(start: number, p1: Point2, p2: Point2, p3: Point2, p4: Point2): void;
    setVertexUV(start: number, uvs: readonly Point2[]): void;
    skinIndices: GeometryData | null;
    skinWeights: GeometryData | null;
    get tangents(): GeometryData | null;
    set tangents(data: GeometryData | null);
    get tangents1(): GeometryData | null;
    set tangents1(data: GeometryData | null);
    transformMat4(mat4: Matrix4): this;
    translate(x?: number, y?: number, z?: number): this;
    useAABBRaycast: boolean;
    userData: unknown;
    // (undocumented)
    uv1DecodeMat: Float32Array | number[] | null;
    // (undocumented)
    uvDecodeMat: Float32Array | number[] | null;
    uvs: GeometryData | null;
    uvs1: GeometryData | null;
    vertices: GeometryData | null;
}

// @public (undocumented)
export type GeometryAttributeValue = number | Vector2 | Vector3 | Vector4 | Matrix3 | Matrix4;

// @public (undocumented)
export type GeometryComponentSize = 1 | 2 | 3 | 4 | 9 | 16;

// @public
export class GeometryData {
    constructor(data: TypedArray, size: GeometryComponentSize, params?: GeometryDataParameters);
    // (undocumented)
    bufferViewId: string;
    readonly className = "GeometryData";
    clearSubData(): void;
    clone(): GeometryData;
    copy(geometryData: GeometryData): this;
    // (undocumented)
    get count(): number;
    set data(data: TypedArray);
    // (undocumented)
    get data(): TypedArray;
    get fullDataRevision(): number;
    get(index: number): GeometryAttributeValue;
    getByOffset(offset: number): GeometryAttributeValue;
    getByteLength(): number;
    getCopy(index: number): GeometryAttributeValue;
    getOffset(index: number): number;
    getSubDataUpdatesSince(revision: number): readonly SubDataUpdate[] | null;
    // (undocumented)
    readonly id: string;
    // (undocumented)
    get isAllDataDirty(): boolean;
    // (undocumented)
    get isDirty(): boolean;
    set isDirty(value: boolean);
    readonly isGeometryData = true;
    // (undocumented)
    get length(): number;
    // (undocumented)
    merge(geometryData: GeometryData, transform?: (component: number, index: number) => number): this;
    normalized: boolean;
    get offset(): number;
    set offset(value: number);
    // (undocumented)
    offsetSize: number;
    // (undocumented)
    get realLength(): number;
    get revision(): number;
    set(index: number, value: GeometryAttributeValue): number;
    setByOffset(offset: number, value: GeometryAttributeValue): void;
    setSubData(offset: number, data: TypedArray): void;
    size: GeometryComponentSize;
    get stride(): number;
    set stride(value: number);
    // (undocumented)
    strideSize: number;
    // (undocumented)
    get subDataUpdates(): readonly SubDataUpdate[];
    traverse(callback: GeometryDataTraverseCallback): boolean;
    traverseByComponent(callback: GeometryDataComponentCallback): boolean;
    type: GLenum;
}

// @public (undocumented)
export type GeometryDataComponentCallback = (component: number, index: number, offset: number) => boolean | undefined;

// @public (undocumented)
export interface GeometryDataLike<Value> {
    // (undocumented)
    readonly data: ArrayLike<Value>;
    // (undocumented)
    readonly isGeometryData: true;
}

// @public (undocumented)
export interface GeometryDataParameters {
    // (undocumented)
    bufferViewId?: string;
    // (undocumented)
    normalized?: boolean;
    // (undocumented)
    offset?: number;
    // (undocumented)
    stride?: number;
    // (undocumented)
    type?: GLenum;
}

// @public (undocumented)
export type GeometryDataTraverseCallback = (attribute: GeometryAttributeValue, index: number, offset: number) => boolean | undefined;

// @public
export class GeometryMaterial extends BasicMaterial {
    constructor(params?: GeometryMaterialParameters);
    // (undocumented)
    readonly className: string;
    // (undocumented)
    getRenderOption(option?: ShaderOptions): ShaderOptions;
    // (undocumented)
    isGeometryMaterial: boolean;
    // (undocumented)
    lightType: "NONE";
    vertexType: GeometryVertexType;
    writeOriginData: boolean;
}

// @public (undocumented)
export interface GeometryMaterialParameters extends BasicMaterialParameters {
    // (undocumented)
    vertexType?: GeometryVertexType;
    // (undocumented)
    writeOriginData?: boolean;
}

// @public (undocumented)
export interface GeometryParameters {
    // (undocumented)
    colors?: GeometryData | null;
    // (undocumented)
    indices?: GeometryData | null;
    // (undocumented)
    isDirty?: boolean;
    // (undocumented)
    isStatic?: boolean;
    // (undocumented)
    mode?: GLenum;
    // (undocumented)
    normalDecodeMat?: Float32Array | number[] | null;
    // (undocumented)
    normals?: GeometryData | null;
    // (undocumented)
    positionDecodeMat?: Float32Array | number[] | null;
    // (undocumented)
    skinIndices?: GeometryData | null;
    // (undocumented)
    skinWeights?: GeometryData | null;
    // (undocumented)
    tangents?: GeometryData | null;
    // (undocumented)
    tangents1?: GeometryData | null;
    // (undocumented)
    useAABBRaycast?: boolean;
    // (undocumented)
    userData?: unknown;
    // (undocumented)
    uv1DecodeMat?: Float32Array | number[] | null;
    // (undocumented)
    uvDecodeMat?: Float32Array | number[] | null;
    // (undocumented)
    uvs?: GeometryData | null;
    // (undocumented)
    uvs1?: GeometryData | null;
    // (undocumented)
    vertices?: GeometryData | null;
}

// Warning: (ae-forgotten-export) The symbol "POSITION" needs to be exported by the entry point Hilo3d.d.ts
// Warning: (ae-forgotten-export) The symbol "NORMAL" needs to be exported by the entry point Hilo3d.d.ts
// Warning: (ae-forgotten-export) The symbol "DEPTH$1" needs to be exported by the entry point Hilo3d.d.ts
// Warning: (ae-forgotten-export) The symbol "DISTANCE" needs to be exported by the entry point Hilo3d.d.ts
//
// @public (undocumented)
export type GeometryVertexType = typeof POSITION | typeof NORMAL | typeof DEPTH$1 | typeof DISTANCE;

// @public (undocumented)
export function getCollectionItem<Value>(collection: GLTFCollection<Value> | undefined, key: GLTFIndex): Value | undefined;

// @public (undocumented)
function getElementRect(elem: HTMLElement): {
    left: number;
    top: number;
    width: number;
    height: number;
};

// @public (undocumented)
export function getUniformBlockBinding(name: string): number;

// @public (undocumented)
export interface GLTFAccessor extends GLTFProperty {
    // (undocumented)
    bufferView?: GLTFIndex;
    // (undocumented)
    byteOffset?: number;
    byteStride?: number;
    // (undocumented)
    componentType: GLTFComponentType;
    // (undocumented)
    count: number;
    // (undocumented)
    max?: readonly number[];
    // (undocumented)
    min?: readonly number[];
    // (undocumented)
    normalized?: boolean;
    // (undocumented)
    sparse?: GLTFSparseAccessor;
    // (undocumented)
    type: GLTFAccessorType;
}

// @public (undocumented)
export type GLTFAccessorResult = GeometryData;

// @public (undocumented)
export type GLTFAccessorType = 'SCALAR' | 'VEC2' | 'VEC3' | 'VEC4' | 'MAT2' | 'MAT3' | 'MAT4';

// @public (undocumented)
export interface GLTFAnimation extends GLTFProperty {
    // (undocumented)
    channels: readonly GLTFAnimationChannel[];
    parameters?: Readonly<Record<string, GLTFIndex>>;
    // (undocumented)
    samplers: GLTFCollection<GLTFAnimationSampler>;
}

// @public (undocumented)
export interface GLTFAnimationChannel {
    // (undocumented)
    sampler: GLTFIndex;
    // (undocumented)
    target: GLTFAnimationTarget;
}

// @public (undocumented)
export type GLTFAnimationClipsExtension = Readonly<Record<string, readonly [number, number]>>;

// @public (undocumented)
export interface GLTFAnimationSampler {
    // (undocumented)
    input: GLTFIndex;
    // (undocumented)
    interpolation?: 'LINEAR' | 'STEP' | 'CUBICSPLINE';
    // (undocumented)
    output: GLTFIndex;
}

// @public (undocumented)
export interface GLTFAnimationTarget {
    // (undocumented)
    id?: GLTFIndex;
    // (undocumented)
    node?: GLTFIndex;
    // (undocumented)
    path: 'translation' | 'rotation' | 'scale' | 'weights';
}

// @public (undocumented)
export interface GLTFAsset extends GLTFProperty {
    // (undocumented)
    copyright?: string;
    // (undocumented)
    generator?: string;
    // (undocumented)
    minVersion?: string;
    // (undocumented)
    version: string;
}

// @public (undocumented)
export interface GLTFBoundingBoxExtension {
    // (undocumented)
    max: readonly [number, number, number];
    // (undocumented)
    min: readonly [number, number, number];
}

// @public (undocumented)
export interface GLTFBounds {
    // (undocumented)
    center: number[];
    // (undocumented)
    depth: number;
    // (undocumented)
    height: number;
    // (undocumented)
    max: number[];
    // (undocumented)
    min: number[];
    // (undocumented)
    size: number;
    // (undocumented)
    width: number;
}

// @public (undocumented)
export interface GLTFBuffer extends GLTFProperty {
    // (undocumented)
    byteLength: number;
    // (undocumented)
    uri?: string;
}

// @public (undocumented)
export interface GLTFBufferView extends GLTFProperty {
    // (undocumented)
    buffer: GLTFIndex;
    // (undocumented)
    byteLength: number;
    // (undocumented)
    byteOffset?: number;
    // (undocumented)
    byteStride?: number;
    // (undocumented)
    target?: number;
}

// @public (undocumented)
export interface GLTFBufferViewRuntime {
    // (undocumented)
    readonly buffer: ArrayBuffer;
    // (undocumented)
    readonly byteLength: number;
    // (undocumented)
    readonly byteOffset: number;
    // (undocumented)
    readonly byteStride?: number;
    // (undocumented)
    readonly id: string;
}

// @public (undocumented)
export interface GLTFCamera extends GLTFProperty {
    aspectRatio?: number;
    // (undocumented)
    orthographic?: GLTFOrthographicCamera;
    // (undocumented)
    perspective?: GLTFPerspectiveCamera;
    // (undocumented)
    type: 'perspective' | 'orthographic';
}

// @public (undocumented)
export interface GLTFClearcoatExtension {
    // (undocumented)
    clearcoatFactor?: number;
    // (undocumented)
    clearcoatNormalTexture?: GLTFTextureInfo;
    // (undocumented)
    clearcoatRoughnessFactor?: number;
    // (undocumented)
    clearcoatRoughnessTexture?: GLTFTextureInfo;
    // (undocumented)
    clearcoatTexture?: GLTFTextureInfo;
}

// @public (undocumented)
export type GLTFCollection<Value> = readonly (Value | null)[] | Readonly<Record<string, Value | null>>;

// @public (undocumented)
export type GLTFComponentType = 5120 | 5121 | 5122 | 5123 | 5125 | 5126;

// @public (undocumented)
export interface GLTFExtensionHandler {
    // (undocumented)
    getUsedTextureNameMap?(extensionData: unknown, map: Record<string, true>, parser: GLTFParser): void;
    // (undocumented)
    init?(loader: GLTFResourceLoader, parser: GLTFParser): unknown;
    // (undocumented)
    parse?(extensionData: unknown, parser: GLTFParser, result: unknown, options: GLTFExtensionOptions): unknown;
    // (undocumented)
    parseOnEnd?(extensionData: unknown, parser: GLTFParser, result: unknown, options: GLTFExtensionOptions): unknown;
    // (undocumented)
    parseOnLoad?(extensionData: unknown, parser: GLTFParser, result: unknown, options: GLTFExtensionOptions): unknown;
}

// @public (undocumented)
export type GLTFExtensionHandlerRegistry = Record<string, GLTFExtensionHandler>;

// @public (undocumented)
export type GLTFExtensionMap = Readonly<Record<string, unknown>>;

// @public (undocumented)
export type GLTFExtensionMethodName = 'parse' | 'parseOnLoad' | 'parseOnEnd';

// @public (undocumented)
export interface GLTFExtensionOptions {
    // (undocumented)
    ignoreExtensions?: Readonly<Record<string, boolean | number>>;
    // (undocumented)
    isAccessor?: boolean;
    // (undocumented)
    isCamera?: boolean;
    // (undocumented)
    isDecode?: boolean;
    // (undocumented)
    isGlobal?: boolean;
    // (undocumented)
    isMaterial?: boolean;
    // (undocumented)
    isNode?: boolean;
    // (undocumented)
    isPrimitive?: boolean;
    // (undocumented)
    isScene?: boolean;
    // (undocumented)
    methodName?: GLTFExtensionMethodName;
    // (undocumented)
    primitive?: GLTFPrimitive;
}

// @public (undocumented)
export namespace GLTFExtensions {
    export {
        GLTFExtensions_d_ALI_animation_clips as ALI_animation_clips,
        GLTFExtensions_d_ALI_bounding_box as ALI_bounding_box,
        GLTFExtensions_d_HILO_animation_clips as HILO_animation_clips,
        GLTFExtensions_d_KHR_lights_punctual as KHR_lights_punctual,
        GLTFExtensions_d_KHR_materials_clearcoat as KHR_materials_clearcoat,
        GLTFExtensions_d_KHR_materials_pbrSpecularGlossiness as KHR_materials_pbrSpecularGlossiness,
        GLTFExtensions_d_WEB3D_quantized_attributes as WEB3D_quantized_attributes,
    };
}

// @public (undocumented)
export interface GLTFImage extends GLTFProperty {
    // (undocumented)
    bufferView?: GLTFIndex;
    // (undocumented)
    mimeType?: string;
    // (undocumented)
    uri?: string;
}

// @public (undocumented)
export type GLTFIndex = string | number;

// @public
export class GLTFLoader extends EventDispatcher implements GLTFResourceLoader {
    constructor(transport?: BasicLoader);
    // (undocumented)
    readonly className = "GLTFLoader";
    // (undocumented)
    readonly isGLTFLoader = true;
    // (undocumented)
    load(params: GLTFLoadRequest | LoaderRequest): Promise<GLTFModel>;
    // (undocumented)
    loadRes(url: string, type?: string): Promise<BasicLoaderResource>;
}

// @public (undocumented)
export interface GLTFLoadRequest extends LoaderRequest, GLTFParserParameters {
    // (undocumented)
    src: string;
}

// @public (undocumented)
export interface GLTFMaterial extends GLTFProperty {
    // (undocumented)
    alphaCutoff?: number;
    // (undocumented)
    alphaMode?: 'OPAQUE' | 'MASK' | 'BLEND';
    // (undocumented)
    doubleSided?: boolean;
    // (undocumented)
    emissiveFactor?: readonly number[];
    // (undocumented)
    emissiveTexture?: GLTFTextureInfo;
    // (undocumented)
    normalTexture?: GLTFTextureInfo;
    // (undocumented)
    occlusionTexture?: GLTFTextureInfo;
    // (undocumented)
    pbrMetallicRoughness?: GLTFPBRMetallicRoughness;
    // (undocumented)
    technique?: GLTFIndex;
    // (undocumented)
    transparencyTexture?: GLTFTextureInfo;
    // (undocumented)
    values?: Readonly<Record<string, GLTFMaterialValue>>;
}

// @public (undocumented)
export interface GLTFMaterialsCommonExtension {
    // (undocumented)
    doubleSided?: boolean;
    // (undocumented)
    technique?: 'CONSTANT' | 'LAMBERT' | 'PHONG' | 'BLINN';
    // (undocumented)
    transparency?: number;
    // (undocumented)
    transparent?: boolean;
    // (undocumented)
    values: Readonly<Record<string, GLTFMaterialValue>>;
}

// @public (undocumented)
export type GLTFMaterialValue = boolean | number | string | readonly number[] | GLTFTextureInfo | null;

// @public (undocumented)
export interface GLTFMesh extends GLTFProperty {
    // (undocumented)
    primitives: readonly GLTFPrimitive[];
    // (undocumented)
    weights?: readonly number[];
}

// @public (undocumented)
export interface GLTFModel {
    // (undocumented)
    anim?: Animation_2;
    // (undocumented)
    bounds?: GLTFBounds;
    // (undocumented)
    cameras: Camera[];
    // (undocumented)
    json: GLTFRoot;
    // (undocumented)
    lights: Light[];
    // (undocumented)
    materials: Material[];
    // (undocumented)
    meshes: Mesh[];
    // (undocumented)
    node: Node_2;
    ready: Promise<void>;
    resourceErrors: readonly Error[];
    // (undocumented)
    scene: Node_2;
    // (undocumented)
    textures: Texture[];
}

// @public (undocumented)
export type GLTFMorphTarget = Readonly<Record<string, GLTFIndex>>;

// @public (undocumented)
export interface GLTFNode extends GLTFProperty {
    // (undocumented)
    camera?: GLTFIndex;
    // (undocumented)
    children?: readonly GLTFIndex[];
    // (undocumented)
    jointName?: string;
    // (undocumented)
    matrix?: readonly number[];
    // (undocumented)
    mesh?: GLTFIndex;
    // (undocumented)
    meshes?: readonly GLTFIndex[];
    // (undocumented)
    rotation?: readonly number[];
    // (undocumented)
    scale?: readonly number[];
    // (undocumented)
    skin?: GLTFIndex;
    // (undocumented)
    translation?: readonly number[];
    // (undocumented)
    weights?: readonly number[];
}

// @public (undocumented)
export interface GLTFOrthographicCamera {
    // (undocumented)
    xmag: number;
    // (undocumented)
    ymag: number;
    // (undocumented)
    zfar: number;
    // (undocumented)
    znear: number;
}

// @public
export class GLTFParser {
    constructor(content?: ArrayBuffer | string, params?: GLTFParserParameters);
    // (undocumented)
    binaryBody: ArrayBuffer | null;
    // (undocumented)
    buffers: Record<string, ArrayBuffer>;
    // (undocumented)
    bufferViews: Record<string, GLTFBufferViewRuntime>;
    // (undocumented)
    cameras: Record<string, Camera>;
    // (undocumented)
    readonly className = "GLTFParser";
    // (undocumented)
    readonly content: ArrayBuffer | string;
    // (undocumented)
    createMorphGeometry(primitive: GLTFPrimitive, weights?: readonly number[]): MorphGeometry;
    // (undocumented)
    createPBRMaterial(materialData: GLTFMaterial): PBRMaterial;
    // (undocumented)
    customMaterialCreator: GLTFParserParameters['customMaterialCreator'];
    // (undocumented)
    defaultScene: GLTFIndex | undefined;
    // (undocumented)
    static readonly extensionHandlers: GLTFExtensionHandlerRegistry;
    // (undocumented)
    extensionHandlers: Readonly<GLTFExtensionHandlerRegistry> | null;
    // (undocumented)
    extensionsUsed: Record<string, true>;
    // (undocumented)
    fixProgressiveGeometry(primitive: GLTFPrimitive, geometry: Geometry): void;
    // (undocumented)
    forceCreateNewBuffer: boolean;
    // (undocumented)
    getAccessorData(name: GLTFIndex, isDecode?: boolean): GeometryData;
    // (undocumented)
    getAccessorDecodeMatrix(data: GeometryData): number[] | undefined;
    // (undocumented)
    getArrayByAccessor(name: GLTFIndex, isDecode?: boolean): AccessorArray;
    // (undocumented)
    getBufferUri(bufferName: GLTFIndex): string;
    // (undocumented)
    getBufferView(name: GLTFIndex): GLTFBufferViewRuntime;
    // (undocumented)
    getColorOrTexture(value: GLTFMaterialValue | undefined): Color | Texture | null;
    // (undocumented)
    getDefaultSceneName(): GLTFIndex;
    // (undocumented)
    getExtensionHandler(name: string): GLTFExtensionHandler | undefined;
    // (undocumented)
    getImageType(imageName: GLTFIndex): string;
    // (undocumented)
    getImageUri(imageName: GLTFIndex): string;
    // (undocumented)
    getTexture(textureInfo: GLTFTextureInfo): Texture | null;
    // (undocumented)
    getUsedTextureNameMap(): Record<string, true>;
    // (undocumented)
    glTFVersion: number;
    // (undocumented)
    handlerGeometry(initial: Geometry | undefined, primitive: GLTFPrimitive): Geometry | Promise<Geometry>;
    // (undocumented)
    handlerNodeTransform(node: Node_2, data: GLTFNode): void;
    // (undocumented)
    handlerSkinnedMesh(mesh: Mesh, skeleton: Skeleton | undefined): void;
    // (undocumented)
    ignoreTextureError: boolean;
    // (undocumented)
    isBinary: boolean;
    // (undocumented)
    isGLTF2: boolean;
    // (undocumented)
    readonly isGLTFParser = true;
    // (undocumented)
    isLoadAllTextures: boolean;
    // (undocumented)
    isMultiAnim: boolean;
    // (undocumented)
    isProgressive: boolean;
    // (undocumented)
    isUnQuantizeInShader: boolean;
    // (undocumented)
    isUseExtension(data: GLTFProperty | GLTFRoot | undefined, extensionName: string): boolean;
    // (undocumented)
    jointMap: Record<string, Node_2>;
    // (undocumented)
    json: GLTFRoot;
    // (undocumented)
    lights: Light[];
    // (undocumented)
    loadBuffers(loader: GLTFResourceLoader): Promise<void>;
    // (undocumented)
    loadResources(loader: GLTFResourceLoader): Promise<void>;
    // (undocumented)
    loadTextures(): Promise<void>;
    // (undocumented)
    static readonly MAGIC = "glTF";
    // (undocumented)
    materials: Record<string, Material>;
    // (undocumented)
    meshes: Mesh[];
    // (undocumented)
    node: Node_2;
    // (undocumented)
    parse(loader: GLTFResourceLoader): Promise<GLTFModel>;
    // (undocumented)
    parseAnimations(): Animation_2 | null;
    // (undocumented)
    parseBinary(buffer: ArrayBuffer): void;
    // (undocumented)
    parseBufferViews(): void;
    // (undocumented)
    parseCameras(): void;
    // (undocumented)
    parseExtension(extensions: GLTFExtensionMap | undefined, name: string, result?: unknown, options?: GLTFExtensionOptions): unknown;
    // (undocumented)
    parseExtensions(extensions: GLTFExtensionMap | undefined, result?: unknown, options?: GLTFExtensionOptions): unknown;
    // (undocumented)
    parseExtensionUsed(): void;
    // (undocumented)
    parseGeometries(): Promise<void>;
    // (undocumented)
    parseMaterialCommonProps(material: Material, materialData: GLTFMaterial): void;
    // (undocumented)
    parseMaterials(): void;
    // (undocumented)
    parseMesh(meshName: GLTFIndex, node: Node_2, nodeData: GLTFNode): void;
    // (undocumented)
    parseNode(nodeName: GLTFIndex, parentNode: Node_2): Node_2;
    // (undocumented)
    parseScene(): GLTFModel;
    // (undocumented)
    parseSkins(): void;
    // (undocumented)
    parseTechnique(materialData: GLTFMaterial, material: Material): void;
    // (undocumented)
    preHandlerBufferURI: GLTFParserParameters['preHandlerBufferURI'];
    // (undocumented)
    preHandlerImageURI: GLTFParserParameters['preHandlerImageURI'];
    // (undocumented)
    preHandlerShaderURI: GLTFParserParameters['preHandlerShaderURI'];
    // (undocumented)
    programs: Record<string, unknown>;
    // (undocumented)
    static registerExtensionHandler(name: string, handler: GLTFExtensionHandler): void;
    // (undocumented)
    resetSkinInfo(rootNode: Node_2): void;
    // (undocumented)
    readonly resourceErrors: Error[];
    // (undocumented)
    setAccessorDecodeMatrix(data: GeometryData, matrix: readonly number[]): void;
    // (undocumented)
    shaders: Record<string, string>;
    // (undocumented)
    skins: Record<string, Skeleton>;
    // (undocumented)
    sparseAccessorHandler(data: GeometryData, sparse: GLTFSparseAccessor): GeometryData;
    // (undocumented)
    src: string;
    // (undocumented)
    techniques: Record<string, unknown>;
    // (undocumented)
    textures: Record<string, Texture>;
    // (undocumented)
    static unregisterExtensionHandler(name: string): void;
    // (undocumented)
    useInstanced: boolean;
}

// @public (undocumented)
export interface GLTFParserParameters {
    // (undocumented)
    customMaterialCreator?: ((name: string, material: GLTFMaterial, json: GLTFRoot, parser: GLTFParser) => Material | null | undefined) | null;
    // (undocumented)
    defaultScene?: GLTFIndex;
    // (undocumented)
    extensionHandlers?: Readonly<GLTFExtensionHandlerRegistry> | null;
    // (undocumented)
    forceCreateNewBuffer?: boolean;
    // (undocumented)
    ignoreTextureError?: boolean;
    // (undocumented)
    isLoadAllTextures?: boolean;
    // (undocumented)
    isMultiAnim?: boolean;
    // (undocumented)
    isProgressive?: boolean;
    // (undocumented)
    isUnQuantizeInShader?: boolean;
    // (undocumented)
    preHandlerBufferURI?: ((uri: string, buffer: GLTFBuffer) => string) | null;
    // (undocumented)
    preHandlerImageURI?: ((uri: string, image: GLTFImage) => string) | null;
    // (undocumented)
    preHandlerShaderURI?: ((uri: string, index: GLTFIndex, shader: unknown) => string) | null;
    // (undocumented)
    src?: string;
    // (undocumented)
    useInstanced?: boolean;
}

// @public (undocumented)
export interface GLTFPBRMetallicRoughness {
    // (undocumented)
    baseColorFactor?: readonly number[];
    // (undocumented)
    baseColorTexture?: GLTFTextureInfo;
    // (undocumented)
    metallicFactor?: number;
    // (undocumented)
    metallicRoughnessTexture?: GLTFTextureInfo;
    // (undocumented)
    roughnessFactor?: number;
}

// @public (undocumented)
export interface GLTFPBRSpecularGlossinessExtension {
    // (undocumented)
    diffuseFactor?: readonly [number, number, number, number];
    // (undocumented)
    diffuseTexture?: GLTFTextureInfo;
    // (undocumented)
    glossinessFactor?: number;
    // (undocumented)
    specularFactor?: readonly [number, number, number];
    // (undocumented)
    specularGlossinessTexture?: GLTFTextureInfo;
}

// @public (undocumented)
export interface GLTFPerspectiveCamera {
    // (undocumented)
    aspectRatio?: number;
    // (undocumented)
    yfov: number;
    // (undocumented)
    zfar?: number;
    // (undocumented)
    znear: number;
}

// @public (undocumented)
export interface GLTFPrimitive extends GLTFProperty {
    // (undocumented)
    attributes: Readonly<Record<string, GLTFIndex>>;
    // (undocumented)
    indices?: GLTFIndex;
    // (undocumented)
    material?: GLTFIndex;
    // (undocumented)
    mode?: number;
    // (undocumented)
    targets?: readonly GLTFMorphTarget[];
}

// @public (undocumented)
export interface GLTFProgram extends GLTFProperty {
    // (undocumented)
    attributes?: readonly string[];
    // (undocumented)
    fragmentShader: GLTFIndex;
    // (undocumented)
    vertexShader: GLTFIndex;
}

// @public (undocumented)
export interface GLTFProgressivePrimitiveState {
    // (undocumented)
    geometry?: Geometry;
    // (undocumented)
    meshes: Mesh[];
}

// @public (undocumented)
export interface GLTFProperty {
    // (undocumented)
    extensions?: GLTFExtensionMap;
    // (undocumented)
    extras?: JsonValue;
    // (undocumented)
    name?: string;
}

// @public (undocumented)
export interface GLTFPunctualLight extends GLTFProperty {
    // (undocumented)
    color?: readonly [number, number, number];
    // (undocumented)
    intensity?: number;
    // (undocumented)
    range?: number;
    // (undocumented)
    spot?: GLTFPunctualSpotLight;
    // (undocumented)
    type: 'directional' | 'point' | 'spot';
}

// @public (undocumented)
export interface GLTFPunctualLightNodeExtension {
    // (undocumented)
    light: GLTFIndex;
}

// @public (undocumented)
export interface GLTFPunctualLightsExtension {
    // (undocumented)
    lights: GLTFCollection<GLTFPunctualLight>;
}

// @public (undocumented)
export interface GLTFPunctualSpotLight {
    // (undocumented)
    innerConeAngle?: number;
    // (undocumented)
    outerConeAngle?: number;
}

// @public (undocumented)
export interface GLTFQuantizedAttributesExtension {
    // (undocumented)
    decodeMatrix: readonly number[];
}

// @public (undocumented)
export interface GLTFResourceLoader {
    // (undocumented)
    loadRes(url: string, type?: string): Promise<BasicLoaderResource>;
}

// @public (undocumented)
export interface GLTFRoot extends GLTFProperty {
    // (undocumented)
    accessors?: GLTFCollection<GLTFAccessor>;
    // (undocumented)
    animations?: GLTFCollection<GLTFAnimation>;
    // (undocumented)
    asset: GLTFAsset;
    // (undocumented)
    buffers?: GLTFCollection<GLTFBuffer>;
    // (undocumented)
    bufferViews?: GLTFCollection<GLTFBufferView>;
    // (undocumented)
    cameras?: GLTFCollection<GLTFCamera>;
    // (undocumented)
    extensionsRequired?: readonly string[];
    // (undocumented)
    extensionsUsed?: readonly string[];
    // (undocumented)
    images?: GLTFCollection<GLTFImage>;
    // (undocumented)
    materials?: GLTFCollection<GLTFMaterial>;
    // (undocumented)
    meshes?: GLTFCollection<GLTFMesh>;
    // (undocumented)
    nodes?: GLTFCollection<GLTFNode>;
    // (undocumented)
    programs?: GLTFCollection<GLTFProgram>;
    // (undocumented)
    samplers?: GLTFCollection<GLTFSampler>;
    // (undocumented)
    scene?: GLTFIndex;
    // (undocumented)
    scenes?: GLTFCollection<GLTFScene>;
    // (undocumented)
    shaders?: GLTFCollection<GLTFShader>;
    // (undocumented)
    skins?: GLTFCollection<GLTFSkin>;
    // (undocumented)
    techniques?: GLTFCollection<GLTFTechnique>;
    // (undocumented)
    textures?: GLTFCollection<GLTFTexture>;
}

// @public (undocumented)
export interface GLTFSampler extends GLTFProperty {
    // (undocumented)
    magFilter?: number;
    // (undocumented)
    minFilter?: number;
    // (undocumented)
    wrapS?: number;
    // (undocumented)
    wrapT?: number;
}

// @public (undocumented)
export interface GLTFScene extends GLTFProperty {
    // (undocumented)
    nodes?: readonly GLTFIndex[];
}

// @public (undocumented)
export interface GLTFShader extends GLTFProperty {
    // (undocumented)
    bufferView?: GLTFIndex;
    // (undocumented)
    type?: number;
    // (undocumented)
    uri?: string;
}

// @public (undocumented)
export interface GLTFSkin extends GLTFProperty {
    // (undocumented)
    bindShapeMatrix?: readonly number[];
    // (undocumented)
    inverseBindMatrices?: GLTFIndex;
    jointNames?: readonly string[];
    // (undocumented)
    joints?: readonly GLTFIndex[];
    // (undocumented)
    skeleton?: GLTFIndex;
}

// @public (undocumented)
export interface GLTFSparseAccessor {
    // (undocumented)
    count: number;
    // (undocumented)
    indices: GLTFSparseIndices;
    // (undocumented)
    values: GLTFSparseValues;
}

// @public (undocumented)
export interface GLTFSparseIndices {
    // (undocumented)
    bufferView: GLTFIndex;
    // (undocumented)
    byteOffset?: number;
    // (undocumented)
    componentType: 5121 | 5123 | 5125;
}

// @public (undocumented)
export interface GLTFSparseValues {
    // (undocumented)
    bufferView: GLTFIndex;
    // (undocumented)
    byteOffset?: number;
}

// @public (undocumented)
export interface GLTFTechnique extends GLTFProperty {
    // (undocumented)
    attributes?: Readonly<Record<string, GLTFTechniqueBinding | GLTFIndex>>;
    // (undocumented)
    parameters?: Readonly<Record<string, GLTFTechniqueBinding>>;
    // (undocumented)
    program?: GLTFIndex;
    // (undocumented)
    states?: GLTFTechniqueStates;
    // (undocumented)
    uniforms?: Readonly<Record<string, GLTFTechniqueBinding | GLTFIndex>>;
}

// @public (undocumented)
export interface GLTFTechniqueBinding {
    // (undocumented)
    count?: number;
    // (undocumented)
    node?: GLTFIndex;
    // (undocumented)
    semantic?: string;
    // (undocumented)
    type?: number;
    // (undocumented)
    value?: JsonValue;
}

// @public (undocumented)
export interface GLTFTechniqueStates {
    // (undocumented)
    enable?: readonly number[];
    // (undocumented)
    functions?: Readonly<Record<string, readonly number[]>>;
}

// @public (undocumented)
export interface GLTFTexture extends GLTFProperty {
    // (undocumented)
    sampler?: GLTFIndex;
    source?: GLTFIndex;
}

// @public (undocumented)
export interface GLTFTextureInfo {
    // (undocumented)
    extensions?: GLTFExtensionMap;
    // (undocumented)
    index: GLTFIndex;
    // (undocumented)
    scale?: number;
    // (undocumented)
    strength?: number;
    // (undocumented)
    texCoord?: number;
}

// @public (undocumented)
export interface GLTFTextureTransformExtension {
    // (undocumented)
    offset?: readonly [number, number];
    // (undocumented)
    rotation?: number;
    // (undocumented)
    scale?: readonly [number, number];
    // (undocumented)
    texCoord?: number;
}

// @public
export type GPUDrivenDraw = Readonly<{
    kind: 'draw';
    vertexCount: number;
    instanceCount?: number;
    firstVertex?: number;
    firstInstance?: number;
}> | Readonly<{
    kind: 'draw-indirect';
    buffer: RenderGraphBufferHandle;
    byteOffset?: number;
}> | Readonly<{
    kind: 'draw-indexed-indirect';
    buffer: RenderGraphBufferHandle;
    byteOffset?: number;
}>;

// @public
export class GPUDrivenRenderPass implements ScriptableRenderPass<GPUDrivenRenderPassParameters> {
    constructor(options: Readonly<GPUDrivenRenderPassOptions>);
    execute(context: ScriptableRenderPassContext, parameters: GPUDrivenRenderPassParameters): void;
    readonly indexFormat: 'uint16' | 'uint32' | undefined;
    readonly material: Material;
    readonly name: string;
    setup(builder: ScriptableRenderPassBuilder, parameters: GPUDrivenRenderPassParameters): void;
    readonly shader: StorageGraphicsShader;
    readonly vertexLayouts: readonly Readonly<GPUDrivenVertexBufferLayout>[];
}

// @public
export interface GPUDrivenRenderPassOptions {
    readonly indexFormat?: 'uint16' | 'uint32';
    readonly material: Material;
    readonly name?: string;
    readonly shader: StorageGraphicsShader;
    readonly vertexLayouts?: readonly GPUDrivenVertexBufferLayout[];
}

// @public
export interface GPUDrivenRenderPassParameters {
    readonly buffers: readonly ComputeBufferBinding[];
    readonly colorAttachments: readonly Readonly<RenderPipelineColorAttachment>[];
    readonly depthStencilAttachment?: Readonly<RenderPipelineDepthStencilAttachment>;
    readonly draw: GPUDrivenDraw;
    readonly indexBuffer?: ComputeBufferBinding;
    readonly samplers?: readonly ComputeSampler[];
    readonly scissor?: RendererViewport;
    readonly stencilReference?: number;
    readonly textures?: readonly ComputeTextureBinding[];
    readonly uniformBuffers?: readonly (UniformBuffer | UniformBufferRange)[];
    readonly vertexBuffers?: readonly ComputeBufferBinding[];
    readonly viewport?: RendererViewport;
}

// @public
export interface GPUDrivenVertexAttribute {
    readonly byteOffset: number;
    readonly format: GPUDrivenVertexFormat;
    readonly shaderLocation: number;
}

// @public
export interface GPUDrivenVertexBufferLayout {
    readonly arrayStride: number;
    readonly attributes: readonly GPUDrivenVertexAttribute[];
    readonly stepMode?: 'vertex' | 'instance';
}

// @public
export type GPUDrivenVertexFormat = 'uint8x2' | 'uint8x4' | 'sint8x2' | 'sint8x4' | 'unorm8x2' | 'unorm8x4' | 'snorm8x2' | 'snorm8x4' | 'uint16x2' | 'uint16x4' | 'sint16x2' | 'sint16x4' | 'unorm16x2' | 'unorm16x4' | 'snorm16x2' | 'snorm16x4' | 'float16x2' | 'float16x4' | 'float32' | 'float32x2' | 'float32x3' | 'float32x4' | 'uint32' | 'uint32x2' | 'uint32x3' | 'uint32x4' | 'sint32' | 'sint32x2' | 'sint32x3' | 'sint32x4';

// @public (undocumented)
export class HDRLoader {
    // (undocumented)
    readonly className = "HDRLoader";
    // (undocumented)
    readonly isHDRLoader = true;
    // (undocumented)
    load(params: HDRLoadRequest): Promise<Texture<Float32Array>>;
}

// @public (undocumented)
export type HDRLoadRequest = BasicLoadRequest & LoaderTextureOptions<Float32Array> & {
    src: string;
};

// @public
export class HiloEvent<Detail = unknown> implements DispatchEvent {
    constructor(type: string, target: unknown, detail?: Detail);
    // (undocumented)
    readonly detail: Detail | undefined;
    // (undocumented)
    stopImmediatePropagation(): void;
    // (undocumented)
    _stopped: boolean;
    // (undocumented)
    readonly target: unknown;
    // (undocumented)
    readonly type: string;
}

// @public (undocumented)
export type ImageCrossOrigin = boolean | '' | 'anonymous' | 'use-credentials';

// @public (undocumented)
export interface InstancedUniform {
    // (undocumented)
    info: MaterialBindingInfo;
    // (undocumented)
    name: string;
}

// @public (undocumented)
export type InterpolatedValue = number | number[] | Vector3 | Quaternion;

// @public (undocumented)
export type InterpolationFunction = (first: unknown, second?: unknown, ratio?: number, timeRange?: number) => InterpolatedValue;

// @public (undocumented)
export function isArrayCollection<Value>(collection: GLTFCollection<Value>): collection is readonly (Value | null)[];

// @public
export function isGLTFRoot(value: unknown): value is GLTFRoot;

// @public (undocumented)
export type JsonPrimitive = string | number | boolean | null;

// @public (undocumented)
export type JsonValue = JsonPrimitive | JsonValue[] | {
    [key: string]: JsonValue;
};

// @public (undocumented)
export class KTXLoader {
    // (undocumented)
    static readonly astc = "WEBGL_compressed_texture_astc";
    // (undocumented)
    static readonly atc = "WEBGL_compressed_texture_atc";
    // (undocumented)
    readonly className = "KTXLoader";
    // (undocumented)
    createTexture(params: KTXLoadRequest, buffer: ArrayBuffer, baseOffset?: number): Texture<Uint8Array>;
    // (undocumented)
    static readonly etc = "WEBGL_compressed_texture_etc";
    // (undocumented)
    static readonly etc1 = "WEBGL_compressed_texture_etc1";
    // (undocumented)
    readonly isKTXLoader = true;
    // (undocumented)
    load(params: KTXLoadRequest | LoaderRequest): Promise<Texture<Uint8Array>>;
    // (undocumented)
    static readonly pvrtc = "WEBGL_compressed_texture_pvrtc";
    // (undocumented)
    static readonly s3tc = "WEBGL_compressed_texture_s3tc";
    // (undocumented)
    static readonly s3tcSrgb = "WEBGL_compressed_texture_s3tc_srgb";
}

// @public (undocumented)
export type KTXLoadRequest = Omit<LoaderRequest, 'src'> & KTXTextureOptions & {
    src: string | ArrayBuffer | ArrayBufferView;
};

// @public
export type KTXTextureOptions = Pick<LoaderTextureOptions<Uint8Array>, 'isImageCanRelease' | 'magFilter' | 'minFilter' | 'wrapS' | 'wrapT' | 'name' | 'uv' | 'anisotropic'>;

// @public
export class LazyTexture extends Texture {
    constructor(params?: LazyTextureParameters);
    // (undocumented)
    autoLoad: boolean;
    // (undocumented)
    readonly className = "LazyTexture";
    // (undocumented)
    crossOrigin: ImageCrossOrigin;
    // (undocumented)
    readonly isLazyTexture = true;
    // (undocumented)
    load(): Promise<void>;
    // (undocumented)
    static loader: Loader | null;
    // (undocumented)
    placeHolder: HTMLImageElement | null;
    // (undocumented)
    resType: string;
    // (undocumented)
    get src(): string;
    set src(src: string);
}

// @public (undocumented)
export interface LazyTextureParameters extends TextureParameters {
    // (undocumented)
    autoLoad?: boolean;
    // (undocumented)
    crossOrigin?: ImageCrossOrigin;
    // (undocumented)
    placeHolder?: HTMLImageElement | null;
    // (undocumented)
    resType?: string;
    // (undocumented)
    src?: string;
}

// @public
export class Light extends Node_2 {
    constructor(params?: LightParameters);
    amount: number;
    // (undocumented)
    className: string;
    // (undocumented)
    color: Color;
    constantAttenuation: number;
    // (undocumented)
    get enabled(): boolean;
    set enabled(value: boolean);
    protected enabledValue: boolean;
    getRealColor(): Color;
    // (undocumented)
    isAmbientLight: boolean;
    // (undocumented)
    isAreaLight: boolean;
    // (undocumented)
    isDirectionalLight: boolean;
    isDirty: boolean;
    // (undocumented)
    isLight: boolean;
    // (undocumented)
    isPointLight: boolean;
    // (undocumented)
    isSpotLight: boolean;
    linearAttenuation: number;
    quadraticAttenuation: number;
    get range(): number;
    set range(value: number);
    // (undocumented)
    get shadow(): LightShadowOptions | null;
    set shadow(value: LightShadowOptions | null);
    toInfoArray(out: number[] | Float32Array, offset: number): this;
    // (undocumented)
    static readonly typeName: string;
}

// @public (undocumented)
export type LightGroupName = 'AMBIENT_LIGHTS' | 'POINT_LIGHTS' | 'DIRECTIONAL_LIGHTS' | 'SPOT_LIGHTS' | 'AREA_LIGHTS';

// @public (undocumented)
export interface LightInfo {
    // (undocumented)
    AMBIENT_LIGHTS: number;
    // (undocumented)
    AREA_LIGHTS: number;
    // (undocumented)
    DIRECTIONAL_LIGHTS: number;
    // (undocumented)
    POINT_LIGHTS: number;
    // (undocumented)
    SHADOW_DIRECTIONAL_LIGHTS: number;
    // (undocumented)
    SHADOW_POINT_LIGHTS: number;
    // (undocumented)
    SHADOW_SPOT_LIGHTS: number;
    // (undocumented)
    SPOT_LIGHTS: number;
    // (undocumented)
    uid: string;
}

// @public
export class LightManager {
    constructor(params?: LightManagerParameters);
    addLight(light: Light): this;
    // (undocumented)
    ambientInfo: Float32Array;
    // (undocumented)
    ambientLights: AmbientLight[];
    // (undocumented)
    areaInfo: AreaLightInfo | null;
    // (undocumented)
    areaLights: AreaLight[];
    // (undocumented)
    className: string;
    // (undocumented)
    directionalInfo: DirectionalLightInfo | null;
    // (undocumented)
    directionalLights: DirectionalLight[];
    getAmbientInfo(): Float32Array;
    getAreaInfo(camera: Camera): AreaLightInfo;
    getDirectionalInfo(camera: Camera): DirectionalLightInfo;
    getInfo(): LightInfo;
    getPointInfo(camera: Camera): PointLightInfo;
    // (undocumented)
    getRenderOption(option?: Record<string, number>): Record<string, number>;
    getShadowMapCount(type: LightGroupName): number;
    getSpotInfo(camera: Camera): SpotLightInfo;
    // (undocumented)
    isLightManager: boolean;
    // (undocumented)
    lightInfo: LightInfo;
    // (undocumented)
    pointInfo: PointLightInfo | null;
    // (undocumented)
    pointLights: PointLight[];
    // (undocumented)
    pointShadowMatrices: Float32Array;
    reset(): void;
    // (undocumented)
    shadowAtlas: Texture<unknown> | null;
    // (undocumented)
    shadowAtlasRects: Float32Array;
    // (undocumented)
    shadowAtlasSize: Float32Array;
    shadowEnabled: boolean;
    // (undocumented)
    spotInfo: SpotLightInfo | null;
    // (undocumented)
    spotLights: SpotLight[];
    updateCustomInfo: ((manager: LightManager, camera: Camera) => void) | null;
    updateInfo(camera: Camera): void;
}

// @public (undocumented)
export interface LightManagerParameters {
    // (undocumented)
    shadowEnabled?: boolean;
    // (undocumented)
    updateCustomInfo?: ((manager: LightManager, camera: Camera) => void) | null;
}

// @public (undocumented)
export interface LightParameters extends NodeParameters {
    // (undocumented)
    amount?: number;
    // (undocumented)
    color?: Color;
    // (undocumented)
    constantAttenuation?: number;
    // (undocumented)
    enabled?: boolean;
    // (undocumented)
    isDirty?: boolean;
    // (undocumented)
    linearAttenuation?: number;
    // (undocumented)
    quadraticAttenuation?: number;
    // (undocumented)
    range?: number;
}

// @public (undocumented)
export interface LightShadowOptions {
    // (undocumented)
    cameraInfo?: ShadowCameraParameters;
    debug?: boolean;
    // (undocumented)
    height?: number;
    // (undocumented)
    maxBias?: number;
    // (undocumented)
    minBias?: number;
    // (undocumented)
    width?: number;
}

// @public (undocumented)
export interface ListenerEntry {
    // (undocumented)
    listener: EventListener_2;
    // (undocumented)
    once: boolean;
}

// @public (undocumented)
export type ListenerMap = Record<string, ListenerEntry[]>;

// @public
export class LoadCache<Data = unknown> extends EventDispatcher {
    // (undocumented)
    readonly className = "LoadCache";
    // (undocumented)
    clear(): void;
    // (undocumented)
    enabled: boolean;
    // (undocumented)
    static readonly FAILED: 3;
    // (undocumented)
    get(key: string): LoadCacheFile<Data> | null;
    // (undocumented)
    getLoaded(key: string): Data | null;
    // (undocumented)
    readonly isLoadCache = true;
    // (undocumented)
    static readonly LOADED: 2;
    // (undocumented)
    static readonly PENDING: 1;
    // (undocumented)
    remove(key: string): void;
    // (undocumented)
    update(key: string, state: LoadStateValue, data?: Data): void;
    // (undocumented)
    wait(file: LoadCacheFile<Data> | null): Promise<Data>;
}

// @public (undocumented)
export interface LoadCacheFile<Data = unknown> {
    // (undocumented)
    data: Data | undefined;
    // (undocumented)
    key: string;
    // (undocumented)
    state: LoadStateValue;
}

// @public
export class Loader {
    // (undocumented)
    static addLoader(extension: string, LoaderClass: ResourceLoaderConstructor): void;
    // (undocumented)
    readonly className = "Loader";
    // (undocumented)
    static getLoader(extension: string): ResourceLoader;
    // (undocumented)
    readonly isLoader = true;
    // (undocumented)
    load(data: LoaderRequest): Promise<unknown>;
    // (undocumented)
    load(data: readonly LoaderRequest[]): Promise<unknown[]>;
    // (undocumented)
    preHandlerUrl: ((url: string) => string) | null;
}

// @public (undocumented)
export interface LoaderRequest {
    // (undocumented)
    crossOrigin?: ImageCrossOrigin;
    // (undocumented)
    defaultType?: string;
    // (undocumented)
    src?: string;
    // (undocumented)
    type?: string;
}

// @public (undocumented)
export type LoaderTextureOptions<Image> = Omit<TextureParameters<Image>, 'image' | 'type'>;

// @public
export class LoadQueue<Request extends LoaderRequest = LoaderRequest> extends EventDispatcher {
    constructor(source?: LoadQueueSource<Request>);
    // (undocumented)
    add(source: LoadQueueSource<Request>): this;
    // (undocumented)
    readonly className = "LoadQueue";
    // (undocumented)
    get(id: string): LoadQueueItem<Request> | null;
    // (undocumented)
    getAllContent(): unknown[];
    // (undocumented)
    getContent(id: string): unknown;
    // (undocumented)
    getLoaded(): number;
    // (undocumented)
    getSize(loaded: boolean): number;
    // (undocumented)
    getTotal(): number;
    // (undocumented)
    readonly isLoadQueue = true;
    // (undocumented)
    get maxConnections(): number;
    set maxConnections(value: number);
    // (undocumented)
    start(): this;
}

// @public (undocumented)
export type LoadQueueItem<Request extends LoaderRequest = LoaderRequest> = Request & {
    id?: string;
    size?: number;
    loaded?: boolean;
    content?: unknown;
    error?: unknown;
};

// @public (undocumented)
export type LoadQueueSource<Request extends LoaderRequest = LoaderRequest> = LoadQueueItem<Request> | readonly LoadQueueItem<Request>[];

// @public (undocumented)
export const LoadState: {
    readonly PENDING: 1;
    readonly LOADED: 2;
    readonly FAILED: 3;
};

// @public (undocumented)
export type LoadStateValue = (typeof LoadState)[keyof typeof LoadState];

// @public (undocumented)
export const log: Logger;

// @public
export class Logger {
    constructor(output?: Console);
    // (undocumented)
    clearOnceCache(): this;
    // (undocumented)
    console: Console;
    // (undocumented)
    error(...params: readonly unknown[]): this;
    // (undocumented)
    errorOnce(id: string, ...params: readonly unknown[]): this;
    // (undocumented)
    level: number;
    // (undocumented)
    readonly LEVEL_ERROR: 4;
    // (undocumented)
    readonly LEVEL_LOG: 1;
    // (undocumented)
    readonly LEVEL_NONE: 0;
    // (undocumented)
    readonly LEVEL_WARN: 2;
    // (undocumented)
    log(...params: readonly unknown[]): this;
    // (undocumented)
    logOnce(id: string, ...params: readonly unknown[]): this;
    // (undocumented)
    warn(...params: readonly unknown[]): this;
    // (undocumented)
    warnOnce(id: string, ...params: readonly unknown[]): this;
}

// @public (undocumented)
export const LogLevel: {
    readonly NONE: 0;
    readonly LOG: 1;
    readonly WARN: 2;
    readonly ERROR: 4;
    readonly ALL: number;
};

// @public (undocumented)
export type LogLevelValue = (typeof LogLevel)[keyof typeof LogLevel];

// @public
export class Material {
    constructor(params?: MaterialParameters, initializeBindings?: boolean);
    addBasicAttributes(): void;
    addBasicUniforms(): void;
    addTextureUniforms(textureUniforms: Readonly<Record<string, string>>): void;
    alphaCutoff: number;
    // (undocumented)
    attributes: MaterialBindingMap;
    blend: boolean;
    blendDst: number;
    blendDstAlpha: number;
    blendEquation: number;
    blendEquationAlpha: number;
    blendSrc: number;
    blendSrcAlpha: number;
    castShadows: boolean;
    // (undocumented)
    readonly className: string;
    clone(): Material;
    protected copyBindings(origin: MaterialBindingMap, data: Readonly<MaterialBindingMap>): void;
    get cullFace(): boolean;
    set cullFace(value: boolean);
    get cullFaceType(): GLenum;
    set cullFaceType(value: GLenum);
    depthFunc: number;
    depthMask: boolean;
    depthRange: [number, number];
    depthTest: boolean;
    destroyTextures(): void;
    // (undocumented)
    emission: MaterialTextureValue;
    enableDrawBuffers: boolean;
    enableTextureLod: boolean;
    exposure: number;
    frontFace: number;
    gammaCorrection: boolean;
    gammaFactor: number;
    // (undocumented)
    getAttributeData(name: string, mesh: Mesh, programInfo: ProgramBindingInfo): unknown;
    // (undocumented)
    getAttributeInfo(name: string): MaterialBindingInfo;
    getInstancedUniforms(): InstancedUniform[];
    getRenderOption(option?: ShaderOptions): ShaderOptions;
    getShadowMaterial(shadowMaterial: Material): Material;
    getTextures(): MaterialTexture[];
    // (undocumented)
    getUniformData(name: string, mesh: Mesh, programInfo: ProgramBindingInfo): unknown;
    // (undocumented)
    getUniformInfo(name: string): MaterialBindingInfo;
    // (undocumented)
    readonly id: string;
    ignoreTransparent: boolean;
    // (undocumented)
    protected initializeBindings(): void;
    isDiffuseEnvAndAmbientLightWorkTogether: boolean;
    get isDirty(): boolean;
    set isDirty(value: boolean);
    // (undocumented)
    readonly isMaterial = true;
    lightType: string;
    name: string | null;
    needBasicAttributes: boolean;
    needBasicUniforms: boolean;
    normalMap: Texture | null;
    normalMapScale: number;
    // (undocumented)
    onBeforeCompile: MaterialBeforeCompile | null;
    parallaxMap: Texture | null;
    get premultiplyAlpha(): boolean;
    set premultiplyAlpha(value: boolean);
    receiveShadows: boolean;
    renderOrder: number;
    get revision(): number;
    sampleAlphaToCoverage: boolean;
    // (undocumented)
    setDefaultTransparentBlend(): void;
    shaderCacheId: string | null;
    shaderName: string | null;
    get side(): GLenum;
    set side(value: GLenum);
    stencilFunc: number;
    stencilFuncMask: number;
    stencilFuncRef: number;
    stencilMask: number;
    stencilOpFail: number;
    stencilOpZFail: number;
    stencilOpZPass: number;
    stencilTest: boolean;
    // Warning: (ae-forgotten-export) The symbol "TextureOptionBuilder" needs to be exported by the entry point Hilo3d.d.ts
    //
    // (undocumented)
    protected readonly textureOption: TextureOptionBuilder;
    transparency: number | Texture;
    get transparent(): boolean;
    set transparent(value: boolean);
    uniformBlocks: Record<string, UniformBuffer>;
    uniforms: MaterialBindingMap;
    useHDR: boolean;
    usePhysicsLight: boolean;
    userData: unknown;
    uvMatrix: Matrix3 | null;
    uvMatrix1: Matrix3 | null;
    wireframe: boolean;
}

// @public (undocumented)
export type MaterialBeforeCompile = (vs: string, fs: string) => MaterialShaderSource;

// @public (undocumented)
export type MaterialBinding = string | MaterialBindingInfo;

// @public (undocumented)
export interface MaterialBindingInfo {
    // (undocumented)
    get(mesh: Mesh, material: Material, programInfo: ProgramBindingInfo): unknown;
    // (undocumented)
    readonly isBlankInfo?: boolean;
    // (undocumented)
    readonly isDependMesh?: boolean;
    // (undocumented)
    readonly notSupportInstanced?: boolean;
}

// @public (undocumented)
export type MaterialBindingMap = Record<string, MaterialBinding>;

// @public (undocumented)
export interface MaterialParameters {
    // (undocumented)
    alphaCutoff?: number;
    // (undocumented)
    attributes?: MaterialBindingMap;
    // (undocumented)
    blend?: boolean;
    // (undocumented)
    blendDst?: GLenum;
    // (undocumented)
    blendDstAlpha?: GLenum;
    // (undocumented)
    blendEquation?: GLenum;
    // (undocumented)
    blendEquationAlpha?: GLenum;
    // (undocumented)
    blendSrc?: GLenum;
    // (undocumented)
    blendSrcAlpha?: GLenum;
    // (undocumented)
    castShadows?: boolean;
    // (undocumented)
    cullFace?: boolean;
    // (undocumented)
    cullFaceType?: GLenum;
    // (undocumented)
    depthFunc?: GLenum;
    // (undocumented)
    depthMask?: boolean;
    // (undocumented)
    depthRange?: [number, number];
    // (undocumented)
    depthTest?: boolean;
    // (undocumented)
    emission?: MaterialTextureValue;
    // (undocumented)
    enableDrawBuffers?: boolean;
    // (undocumented)
    enableTextureLod?: boolean;
    // (undocumented)
    exposure?: number;
    // (undocumented)
    frontFace?: GLenum;
    // (undocumented)
    gammaCorrection?: boolean;
    // (undocumented)
    gammaFactor?: number;
    // (undocumented)
    ignoreTransparent?: boolean;
    // (undocumented)
    isDiffuseEnvAndAmbientLightWorkTogether?: boolean;
    // (undocumented)
    isDirty?: boolean;
    // (undocumented)
    lightType?: string;
    // (undocumented)
    name?: string | null;
    // (undocumented)
    needBasicAttributes?: boolean;
    // (undocumented)
    needBasicUniforms?: boolean;
    // (undocumented)
    normalMap?: Texture | null;
    // (undocumented)
    normalMapScale?: number;
    // (undocumented)
    onBeforeCompile?: MaterialBeforeCompile | null;
    // (undocumented)
    parallaxMap?: Texture | null;
    // (undocumented)
    premultiplyAlpha?: boolean;
    // (undocumented)
    receiveShadows?: boolean;
    // (undocumented)
    renderOrder?: number;
    // (undocumented)
    sampleAlphaToCoverage?: boolean;
    // (undocumented)
    shaderCacheId?: string | null;
    // (undocumented)
    shaderName?: string | null;
    // (undocumented)
    side?: GLenum;
    // (undocumented)
    stencilFunc?: GLenum;
    // (undocumented)
    stencilFuncMask?: number;
    // (undocumented)
    stencilFuncRef?: number;
    // (undocumented)
    stencilMask?: number;
    // (undocumented)
    stencilOpFail?: GLenum;
    // (undocumented)
    stencilOpZFail?: GLenum;
    // (undocumented)
    stencilOpZPass?: GLenum;
    // (undocumented)
    stencilTest?: boolean;
    // (undocumented)
    transparency?: number | Texture;
    // (undocumented)
    transparent?: boolean;
    uniformBlocks?: Record<string, UniformBuffer>;
    uniforms?: MaterialBindingMap;
    // (undocumented)
    useHDR?: boolean;
    // (undocumented)
    usePhysicsLight?: boolean;
    // (undocumented)
    userData?: unknown;
    // (undocumented)
    uvMatrix?: Matrix3 | null;
    // (undocumented)
    uvMatrix1?: Matrix3 | null;
    // (undocumented)
    wireframe?: boolean;
}

// @public (undocumented)
export interface MaterialShaderSource {
    // (undocumented)
    fs: string;
    // (undocumented)
    vs: string;
}

// @public (undocumented)
export type MaterialTexture = Texture<unknown>;

// @public (undocumented)
export type MaterialTextureValue = MaterialTexture | Color | null;

// @public
export const math: {
    DEG2RAD: number;
    RAD2DEG: number;
    generateUUID: (prefix?: string) => string;
    clamp(value: number, min: number, max: number): number;
    degToRad(degrees: number): number;
    radToDeg(radians: number): number;
    isPowerOfTwo(value: number): boolean;
    nearestPowerOfTwo(value: number): number;
    nextPowerOfTwo(value: number): number;
};

// @public
export class Matrix3 {
    constructor();
    add(a: Matrix3, b?: Matrix3): this;
    adjoint(m?: Matrix3): this;
    className: string;
    clone(): Matrix3;
    copy(m: Matrix3): this;
    determinant(): number;
    // (undocumented)
    elements: mat3;
    equals(a: Matrix3, b?: Matrix3): boolean;
    exactEquals(a: Matrix3, b?: Matrix3): boolean;
    frob(): number;
    fromArray(array: ArrayLike<number>, offset?: number): this;
    fromMat4(m: Matrix4): this;
    fromQuat(q: Quaternion): this;
    fromRotation(rad: number): this;
    fromRotationTranslationScale(rotation: number, x: number, y: number, scaleX: number, scaleY: number): this;
    fromScaling(v: Vector2): this;
    fromTranslation(v: Vector2): this;
    identity(): this;
    invert(m?: Matrix3): this;
    // (undocumented)
    isMatrix3: boolean;
    // (undocumented)
    mul(a: Matrix3, b?: Matrix3): this;
    multiply(a: Matrix3, b?: Matrix3): this;
    normalFromMat4(m: Matrix4): this;
    premultiply(m: Matrix3): this;
    rotate(rad: number): this;
    scale(v: Vector2): this;
    set(m00: number, m01: number, m02: number, m10: number, m11: number, m12: number, m20: number, m21: number, m22: number): this;
    // (undocumented)
    sub(a: Matrix3, b?: Matrix3): this;
    subtract(a: Matrix3, b?: Matrix3): this;
    toArray(array?: MutableNumberArray, offset?: number): MutableNumberArray;
    translate(v: Vector2): this;
    transpose(): this;
}

// @public
export class Matrix4 {
    constructor();
    add(a: Matrix4, b?: Matrix4): this;
    adjoint(m?: Matrix4): this;
    className: string;
    clone(): Matrix4;
    compose(q: Quaternion, v: Vector3, s: Vector3, p?: Vector3): this;
    copy(m: Matrix4): this;
    decompose(q: Quaternion, v: Vector3, s: Vector3, p?: Vector3): this;
    determinant(): number;
    // (undocumented)
    elements: mat4;
    equals(a: Matrix4, b?: Matrix4): boolean;
    exactEquals(a: Matrix4, b?: Matrix4): boolean;
    frob(): number;
    fromArray(array: ArrayLike<number>, offset?: number): this;
    fromQuat(q: Quaternion): this;
    fromRotation(rad: number, axis: Vector3): this;
    fromRotationTranslation(q: Quaternion, v: Vector3): this;
    fromRotationTranslationScale(q: Quaternion, v: Vector3, s: Vector3): this;
    fromRotationTranslationScaleOrigin(q: Quaternion, v: Vector3, s: Vector3, o: Vector3): this;
    fromScaling(v: Vector3): this;
    fromTranslation(v: Vector3): this;
    fromXRotation(rad: number): this;
    fromYRotation(rad: number): this;
    fromZRotation(rad: number): this;
    frustum(left: number, right: number, bottom: number, top: number, near: number, far: number): this;
    getRotation(out?: Quaternion): Quaternion;
    getScaling(out?: Vector3): Vector3;
    getTranslation(out?: Vector3): Vector3;
    identity(): this;
    invert(m?: Matrix4): this;
    // (undocumented)
    isMatrix4: boolean;
    lookAt(eye: XYZObject, center: XYZObject, up: Vector3): this;
    // (undocumented)
    mul(a: Matrix4, b?: Matrix4): this;
    multiply(a: Matrix4, b?: Matrix4): this;
    ortho(left: number, right: number, bottom: number, top: number, near: number, far: number): this;
    perspective(fovy: number, aspect: number, near: number, far: number): this;
    perspectiveFromFieldOfView(fov: unknown, near: number, far: number): this;
    premultiply(m: Matrix4): this;
    rotate(rad: number, axis: Vector3): this;
    rotateX(rad: number): this;
    rotateY(rad: number): this;
    rotateZ(rad: number): this;
    scale(v: Vector3): this;
    set(m00: number, m01: number, m02: number, m03: number, m10: number, m11: number, m12: number, m13: number, m20: number, m21: number, m22: number, m23: number, m30: number, m31: number, m32: number, m33: number): this;
    // (undocumented)
    sub(a: Matrix4, b?: Matrix4): this;
    subtract(a: Matrix4, b?: Matrix4): this;
    targetTo(eye: XYZObject, target: XYZObject, up: Vector3): this;
    toArray(array?: MutableNumberArray, offset?: number): MutableNumberArray;
    translate(v: Vector3): this;
    transpose(): this;
}

// @public
export class Matrix4Notifier extends Matrix4 {
    constructor();
    add(a: Matrix4, b?: Matrix4): this;
    adjoint(m?: Matrix4): this;
    className: string;
    compose(q: Quaternion, v: Vector3, s: Vector3, p?: Vector3): this;
    copy(m: Matrix4): this;
    decompose(q: Quaternion, v: Vector3, s: Vector3, p?: Vector3): this;
    determinant(): number;
    equals(a: Matrix4, b?: Matrix4): boolean;
    exactEquals(a: Matrix4, b?: Matrix4): boolean;
    frob(): number;
    fromArray(array: ArrayLike<number>, offset?: number): this;
    fromQuat(q: Quaternion): this;
    fromRotation(rad: number, axis: Vector3): this;
    fromRotationTranslation(q: Quaternion, v: Vector3): this;
    fromRotationTranslationScale(q: Quaternion, v: Vector3, s: Vector3): this;
    fromRotationTranslationScaleOrigin(q: Quaternion, v: Vector3, s: Vector3, o: Vector3, notCallUpdate?: boolean): this;
    fromScaling(v: Vector3): this;
    fromTranslation(v: Vector3): this;
    fromXRotation(rad: number): this;
    fromYRotation(rad: number): this;
    fromZRotation(rad: number): this;
    frustum(left: number, right: number, bottom: number, top: number, near: number, far: number): this;
    getRotation(out?: Quaternion): Quaternion;
    getScaling(out?: Vector3): Vector3;
    getTranslation(out?: Vector3): Vector3;
    identity(): this;
    invert(m?: Matrix4): this;
    // (undocumented)
    isMatrix4Notifier: boolean;
    lookAt(eye: XYZObject, center: XYZObject, up: Vector3): this;
    multiply(a: Matrix4, b?: Matrix4): this;
    onUpdate(): void;
    ortho(left: number, right: number, bottom: number, top: number, near: number, far: number): this;
    perspective(fovy: number, aspect: number, near: number, far: number): this;
    perspectiveFromFieldOfView(fov: unknown, near: number, far: number): this;
    premultiply(m: Matrix4): this;
    rotate(rad: number, axis: Vector3): this;
    rotateX(rad: number): this;
    rotateY(rad: number): this;
    rotateZ(rad: number): this;
    scale(v: Vector3): this;
    set(m00: number, m01: number, m02: number, m03: number, m10: number, m11: number, m12: number, m13: number, m20: number, m21: number, m22: number, m23: number, m30: number, m31: number, m32: number, m33: number): this;
    subtract(a: Matrix4, b?: Matrix4): this;
    targetTo(eye: XYZObject, target: XYZObject, up: Vector3): this;
    translate(v: Vector3): this;
    transpose(): this;
}

// @public
export class Mesh extends Node_2 {
    constructor(params?: MeshParameters);
    // (undocumented)
    className: string;
    clone(isChild?: boolean): Mesh;
    destroy(renderer?: Renderer, needDestroyTextures?: boolean): this;
    frustumTest: boolean;
    // (undocumented)
    geometry: Geometry | null;
    getRenderOption(opt?: ShaderOptions): ShaderOptions;
    get isDestroyed(): boolean;
    // (undocumented)
    protected _isDestroyed: boolean;
    // (undocumented)
    isMesh: boolean;
    // (undocumented)
    material: Material | null;
    raycast(ray: Ray, sort?: boolean): Vector3[] | null;
    // (undocumented)
    static readonly typeName: string;
    useInstanced: boolean;
}

// @public (undocumented)
export interface MeshParameters extends NodeParameters {
    // (undocumented)
    frustumTest?: boolean;
    // (undocumented)
    geometry?: Geometry | null;
    // (undocumented)
    material?: Material | null;
    // (undocumented)
    useInstanced?: boolean;
}

// @public
export class MeshPicker {
    constructor(params: MeshPickerParameters);
    readonly className = "MeshPicker";
    destroy(): void;
    getSelection(x: number, y: number, width?: number, height?: number): Promise<Mesh[]>;
    readonly isMeshPicker = true;
    readonly renderer: Renderer;
    readonly stage: Stage;
}

// @public
export interface MeshPickerParameters {
    stage: Stage;
}

// @public
export class MorphGeometry extends Geometry {
    constructor(params?: MorphGeometryParameters);
    // (undocumented)
    readonly className: string;
    // (undocumented)
    clone(): MorphGeometry;
    // (undocumented)
    getMorphTarget(name: string, slot: number): GeometryData | undefined;
    // (undocumented)
    getRenderOption(opt?: ShaderOptions): ShaderOptions;
    // (undocumented)
    readonly isMorphGeometry = true;
    // (undocumented)
    isStatic: boolean;
    targets: MorphTargets | null;
    // (undocumented)
    update(weights: number[] | Float32Array, originalWeightIndices: number[]): void;
    weights: number[] | Float32Array;
}

// @public (undocumented)
export interface MorphGeometryParameters extends GeometryParameters {
    // (undocumented)
    targets?: MorphTargets | null;
    // (undocumented)
    weights?: number[] | Float32Array;
}

// @public (undocumented)
export type MorphTargets = Record<string, GeometryData[]>;

// @public (undocumented)
export interface MutableArrayLike<Value> {
    // (undocumented)
    [index: number]: Value;
    // (undocumented)
    length: number;
}

// @public (undocumented)
export type MutableNumberArray = number[] | Float32Array | Float64Array | Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array;

// @public (undocumented)
export type NetworkResourceType = Exclude<BasicResourceType, 'img'>;

// @public
class Node_2 extends EventDispatcher {
    constructor(params?: NodeParameters);
    __forceUseParentWorldMatrix: boolean;
    addChild(child: Node_2): this;
    addTo(parent: Node_2): this;
    anim: Animation_2 | null;
    animationId: string;
    autoUpdateChildWorldMatrix: boolean;
    autoUpdateWorldMatrix: boolean;
    // (undocumented)
    children: Node_2[];
    // (undocumented)
    className: string;
    // (undocumented)
    clone(isChild?: boolean): Node_2;
    destroy(renderer?: Renderer, destroyTextures?: boolean): this;
    _firePointerEvent(event: NodePointerEvent): void;
    getBounds(parent?: Node_2, currentMatrix?: Matrix4, bounds?: Bounds): Bounds | undefined;
    getChildByFn(fn: NodeGetChildByCallback): Node_2 | null;
    getChildByFnBFS(fn: NodeGetChildByCallback): Node_2 | null;
    getChildById(id: string): Node_2 | null;
    getChildByName(name: string): Node_2 | null;
    getChildByNamePath(path: string[]): Node_2 | null;
    getChildrenByBaseClassName(className: string): Node_2[];
    getChildrenByClassName(className: string): Node_2[];
    getChildrenByFn(fn: NodeGetChildByCallback): Node_2[];
    getChildrenByName(name: string): Node_2[];
    getChildrenNameMap(): Record<string, Node_2>;
    getConcatenatedMatrix(ancestor?: Node_2): Matrix4;
    // (undocumented)
    id: string;
    // (undocumented)
    isCamera: boolean;
    // (undocumented)
    isMesh: boolean;
    // (undocumented)
    isNode: boolean;
    // (undocumented)
    isSkinnedMesh: boolean;
    jointName: string;
    lookAt(node: {
        x: number;
        y: number;
        z: number;
    }): this;
    get matrix(): Matrix4Notifier;
    // (undocumented)
    protected _matrix: Matrix4Notifier;
    // (undocumented)
    _matrixDirty: boolean;
    matrixVersion: number;
    name: string;
    needCallChildUpdate: boolean;
    onlySyncQuaternion: boolean;
    // (undocumented)
    _onMatrixUpdate(): void;
    // (undocumented)
    _onPivotUpdate(): void;
    // (undocumented)
    _onPositionUpdate(): void;
    // (undocumented)
    _onQuaternionUpdate(): void;
    // (undocumented)
    _onRotationUpdate(): void;
    // (undocumented)
    _onScaleUpdate(): void;
    onUpdate: ((deltaTime: number) => void) | null;
    // (undocumented)
    _originName?: string;
    parent: Node_2 | null;
    get pivot(): Vector3Notifier;
    // (undocumented)
    protected _pivot: Vector3Notifier;
    get pivotX(): number;
    set pivotX(value: number);
    get pivotY(): number;
    set pivotY(value: number);
    get pivotZ(): number;
    set pivotZ(value: number);
    pointerChildren: boolean;
    pointerEnabled: boolean;
    get position(): Vector3Notifier;
    // (undocumented)
    protected _position: Vector3Notifier;
    // (undocumented)
    _quatDirty: boolean;
    get quaternion(): Quaternion;
    // (undocumented)
    protected _quaternion: QuaternionNotifier;
    raycast(ray: Ray, sort?: boolean, eventMode?: boolean): NodeRaycastInfo[] | Vector3[] | null;
    removeChild(child: Node_2): this;
    removeFromParent(): this;
    resetSkinnedMeshRootNode(): void;
    get rotation(): EulerNotifier;
    // (undocumented)
    protected _rotation: EulerNotifier;
    get rotationX(): number;
    set rotationX(value: number);
    get rotationY(): number;
    set rotationY(value: number);
    get rotationZ(): number;
    set rotationZ(value: number);
    get scale(): Vector3Notifier;
    // (undocumented)
    protected _scale: Vector3Notifier;
    get scaleX(): number;
    set scaleX(value: number);
    get scaleY(): number;
    set scaleY(value: number);
    get scaleZ(): number;
    set scaleZ(value: number);
    setAnim(anim: Animation_2): this;
    setPivot(x: number, y: number, z: number): this;
    setPosition(x: number, y: number, z: number): this;
    setRotation(x: number, y: number, z: number): this;
    setScale(x: number, y?: number, z?: number): this;
    traverse(callback: NodeTraverseCallback, onlyChild?: boolean): this;
    static readonly TRAVERSE_STOP_ALL: 2;
    static readonly TRAVERSE_STOP_CHILDREN: 1;
    static readonly TRAVERSE_STOP_NONE: 0;
    traverseBFS(callback: NodeTraverseCallback, onlyChild?: boolean): this;
    traverseUpdate(dt: number): this;
    // (undocumented)
    static readonly typeName: string;
    // (undocumented)
    up: Vector3;
    updateMatrix(): this;
    updateMatrixWorld(force?: boolean): this;
    updateQuaternion(): this;
    updateTransform(): this;
    useHandCursor: boolean;
    userData: unknown;
    visible: boolean;
    // (undocumented)
    worldMatrix: Matrix4;
    worldMatrixVersion: number;
    get x(): number;
    set x(value: number);
    get y(): number;
    set y(value: number);
    get z(): number;
    set z(value: number);
}
export { Node_2 as Node }

// @public (undocumented)
export type NodeGetChildByCallback = (node: Node_2) => boolean;

// @public (undocumented)
export interface NodeParameters {
    // (undocumented)
    anim?: Animation_2 | null;
    // (undocumented)
    animationId?: string;
    // (undocumented)
    autoUpdateChildWorldMatrix?: boolean;
    // (undocumented)
    autoUpdateWorldMatrix?: boolean;
    // (undocumented)
    jointName?: string;
    // (undocumented)
    name?: string;
    // (undocumented)
    needCallChildUpdate?: boolean;
    // (undocumented)
    onlySyncQuaternion?: boolean;
    // (undocumented)
    onUpdate?: ((deltaTime: number) => void) | null;
    // (undocumented)
    parent?: Node_2 | null;
    // (undocumented)
    pivotX?: number;
    // (undocumented)
    pivotY?: number;
    // (undocumented)
    pivotZ?: number;
    // (undocumented)
    pointerChildren?: boolean;
    // (undocumented)
    pointerEnabled?: boolean;
    // (undocumented)
    rotationX?: number;
    // (undocumented)
    rotationY?: number;
    // (undocumented)
    rotationZ?: number;
    // (undocumented)
    scaleX?: number;
    // (undocumented)
    scaleY?: number;
    // (undocumented)
    scaleZ?: number;
    // (undocumented)
    up?: Vector3;
    // (undocumented)
    useHandCursor?: boolean;
    // (undocumented)
    userData?: unknown;
    // (undocumented)
    visible?: boolean;
    // (undocumented)
    x?: number;
    // (undocumented)
    y?: number;
    // (undocumented)
    z?: number;
}

// @public (undocumented)
export interface NodePointerEvent extends DispatchEvent {
    // (undocumented)
    altKey?: boolean;
    // (undocumented)
    button?: number;
    // (undocumented)
    buttons?: number;
    // (undocumented)
    clientX?: number;
    // (undocumented)
    clientY?: number;
    // (undocumented)
    ctrlKey?: boolean;
    // (undocumented)
    eventCurrentTarget?: Node_2;
    // (undocumented)
    eventTarget?: Node_2;
    // (undocumented)
    height?: number;
    // (undocumented)
    hitPoint?: Vector3;
    // (undocumented)
    isPrimary?: boolean;
    // (undocumented)
    metaKey?: boolean;
    // (undocumented)
    pageX?: number;
    // (undocumented)
    pageY?: number;
    // (undocumented)
    pointerId?: number;
    // (undocumented)
    pointerType?: string;
    // (undocumented)
    pressure?: number;
    // (undocumented)
    shiftKey?: boolean;
    // (undocumented)
    stageX?: number;
    // (undocumented)
    stageY?: number;
    // (undocumented)
    _stopPropagationed?: boolean;
    // (undocumented)
    width?: number;
}

// @public (undocumented)
export interface NodeRaycastInfo {
    // (undocumented)
    mesh: Node_2;
    // (undocumented)
    point: Vector3;
}

// @public (undocumented)
export type NodeTraverseCallback = (node: Node_2) => NodeTraverseResult | undefined;

// @public (undocumented)
export type NodeTraverseResult = 0 | 1 | 2;

// @public (undocumented)
const NORMAL = "NORMAL";

// @public
export type NormalizedComputeWorkgroupSize = readonly [number, number, number];

// @public
export class OrthographicCamera extends Camera {
    constructor(params?: OrthographicCameraParameters);
    // (undocumented)
    get bottom(): number;
    set bottom(value: number);
    // (undocumented)
    className: string;
    // (undocumented)
    get far(): number;
    set far(value: number);
    // (undocumented)
    getGeometry(forceUpdate?: boolean): Geometry;
    // (undocumented)
    isOrthographicCamera: boolean;
    // (undocumented)
    get left(): number;
    set left(value: number);
    // (undocumented)
    get near(): number;
    set near(value: number);
    // (undocumented)
    get right(): number;
    set right(value: number);
    // (undocumented)
    get top(): number;
    set top(value: number);
    // (undocumented)
    static readonly typeName: string;
    updateProjectionMatrix(): void;
}

// @public (undocumented)
export interface OrthographicCameraParameters extends CameraParameters {
    // (undocumented)
    bottom?: number;
    // (undocumented)
    far?: number;
    // (undocumented)
    left?: number;
    // (undocumented)
    near?: number;
    // (undocumented)
    right?: number;
    // (undocumented)
    top?: number;
}

// @public
export function parseRadianceHDR(input: ArrayBuffer | Uint8Array): RadianceHDRImage;

// @public
export class PBRMaterial extends Material {
    constructor(params?: PBRMaterialParameters);
    baseColor: Color;
    baseColorMap: Texture | null;
    brdfLUT: Texture | null;
    // (undocumented)
    readonly className: string;
    clearcoatFactor: number;
    clearcoatMap: Texture | null;
    clearcoatNormalMap: Texture | null;
    clearcoatRoughnessFactor: number;
    clearcoatRoughnessMap: Texture | null;
    diffuseEnvIntensity: number;
    diffuseEnvMap: MaterialTexture | null;
    diffuseEnvSphereHarmonics3: SphericalHarmonics3 | null;
    emission: MaterialTextureValue;
    emissionFactor: Color;
    gammaCorrection: boolean;
    // (undocumented)
    getRenderOption(option?: ShaderOptions): ShaderOptions;
    glossiness: number;
    isOcclusionInMetallicRoughnessMap: boolean;
    // (undocumented)
    isPBRMaterial: boolean;
    isSpecularEnvMapIncludeMipmaps: boolean;
    isSpecularGlossiness: boolean;
    // (undocumented)
    lightMap: Texture | null;
    lightType: 'PBR' | 'NONE';
    metallic: number;
    metallicMap: Texture | null;
    metallicRoughnessMap: Texture | null;
    occlusionMap: Texture | null;
    occlusionStrength: number;
    roughness: number;
    roughnessMap: Texture | null;
    specular: Color;
    specularEnvIntensity: number;
    specularEnvMap: MaterialTexture | null;
    specularGlossinessMap: Texture | null;
    // (undocumented)
    usedUniformVectors: number;
    usePhysicsLight: boolean;
}

// @public (undocumented)
export interface PBRMaterialParameters extends MaterialParameters {
    // (undocumented)
    baseColor?: Color;
    // (undocumented)
    baseColorMap?: Texture | null;
    // (undocumented)
    brdfLUT?: Texture | null;
    // (undocumented)
    clearcoatFactor?: number;
    // (undocumented)
    clearcoatMap?: Texture | null;
    // (undocumented)
    clearcoatNormalMap?: Texture | null;
    // (undocumented)
    clearcoatRoughnessFactor?: number;
    // (undocumented)
    clearcoatRoughnessMap?: Texture | null;
    // (undocumented)
    diffuseEnvIntensity?: number;
    // (undocumented)
    diffuseEnvMap?: MaterialTexture | null;
    // (undocumented)
    diffuseEnvSphereHarmonics3?: SphericalHarmonics3 | null;
    // (undocumented)
    emission?: MaterialTextureValue;
    // (undocumented)
    emissionFactor?: Color;
    // (undocumented)
    glossiness?: number;
    // (undocumented)
    isOcclusionInMetallicRoughnessMap?: boolean;
    // (undocumented)
    isSpecularEnvMapIncludeMipmaps?: boolean;
    // (undocumented)
    isSpecularGlossiness?: boolean;
    // (undocumented)
    lightMap?: Texture | null;
    // (undocumented)
    lightType?: 'PBR' | 'NONE';
    // (undocumented)
    metallic?: number;
    // (undocumented)
    metallicMap?: Texture | null;
    // (undocumented)
    metallicRoughnessMap?: Texture | null;
    // (undocumented)
    occlusionMap?: Texture | null;
    // (undocumented)
    occlusionStrength?: number;
    // (undocumented)
    roughness?: number;
    // (undocumented)
    roughnessMap?: Texture | null;
    // (undocumented)
    specular?: Color;
    // (undocumented)
    specularEnvIntensity?: number;
    // (undocumented)
    specularEnvMap?: MaterialTexture | null;
    // (undocumented)
    specularGlossinessMap?: Texture | null;
}

// @public
export class PerspectiveCamera extends Camera {
    constructor(params?: PerspectiveCameraParameters);
    get aspect(): number;
    set aspect(value: number);
    // (undocumented)
    className: string;
    get far(): number | null;
    set far(value: number | null);
    get fov(): number;
    set fov(value: number);
    // (undocumented)
    getGeometry(forceUpdate?: boolean): Geometry;
    // (undocumented)
    isPerspectiveCamera: boolean;
    get near(): number;
    set near(value: number);
    // (undocumented)
    static readonly typeName: string;
    updateProjectionMatrix(): void;
}

// @public (undocumented)
export interface PerspectiveCameraParameters extends CameraParameters {
    // (undocumented)
    aspect?: number;
    // (undocumented)
    far?: number | null;
    // (undocumented)
    fov?: number;
    // (undocumented)
    near?: number;
}

// @public
export class Plane {
    constructor(normal?: Vector3, distance?: number);
    className: string;
    clone(): Plane;
    copy(plane: Plane): this;
    // (undocumented)
    distance: number;
    distanceToPoint(point: Vector3): number;
    // (undocumented)
    isPlane: boolean;
    // (undocumented)
    normal: Vector3;
    normalize(): this;
    projectPoint(point: Vector3): Vector3;
    set(x: number, y: number, z: number, w: number): this;
}

// @public
export class PlaneGeometry extends Geometry {
    constructor(params?: PlaneGeometryParameters);
    // (undocumented)
    readonly className: string;
    height: number;
    heightSegments: number;
    // (undocumented)
    isPlaneGeometry: boolean;
    // (undocumented)
    _raycast(ray: Ray, side: GLenum): Vector3[] | null;
    width: number;
    widthSegments: number;
}

// @public (undocumented)
export interface PlaneGeometryParameters extends GeometryParameters {
    // (undocumented)
    height?: number;
    // (undocumented)
    heightSegments?: number;
    // (undocumented)
    width?: number;
    // (undocumented)
    widthSegments?: number;
}

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

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

// @public
export class PointLight extends Light {
    constructor(params?: PointLightParameters);
    // (undocumented)
    className: string;
    // (undocumented)
    isPointLight: boolean;
    // (undocumented)
    static readonly typeName = "PointLight";
}

// @public (undocumented)
export interface PointLightInfo extends ShadowInfo {
    // (undocumented)
    cameras?: Float32Array;
    // (undocumented)
    colors: Float32Array;
    // (undocumented)
    infos: Float32Array;
    // (undocumented)
    poses: Float32Array;
    // (undocumented)
    ranges: Float32Array;
}

// @public (undocumented)
export type PointLightParameters = Omit<ShadowCastingLightParameters, 'shadow'> & {
    shadow?: PointLightShadowOptions | null;
};

// @public (undocumented)
export interface PointLightShadowOptions extends Omit<LightShadowOptions, 'cameraInfo'> {
    cameraInfo?: PointShadowCameraParameters;
}

// @public (undocumented)
export type PointShadowCameraParameters = Pick<ShadowCameraParameters, 'near' | 'far'>;

// @public (undocumented)
const POSITION = "POSITION";

// @public
export class PresentRenderPass extends FullscreenRenderPass {
    constructor(name?: string);
}

// @public (undocumented)
export interface ProgramBindingInfo {
    // (undocumented)
    name?: string;
    // (undocumented)
    textureIndex?: number;
}

// @public (undocumented)
export class Quaternion {
    constructor(x?: number, y?: number, z?: number, w?: number);
    add(q: Quaternion): this;
    calculateW(): this;
    className: string;
    clone(): Quaternion;
    conjugate(): this;
    copy(q: Quaternion): this;
    dot(q: Quaternion): number;
    // (undocumented)
    elements: quat;
    equals(q: Quaternion): boolean;
    exactEquals(q: Quaternion): boolean;
    fromArray(array: ArrayLike<number>, offset?: number): this;
    fromEuler(euler: Euler): this;
    fromMat3(mat: Matrix3): this;
    fromMat4(mat: Matrix4): this;
    getAxisAngle(axis: Vector3): number;
    identity(): this;
    invert(): this;
    // (undocumented)
    isQuaternion: boolean;
    // (undocumented)
    len(): number;
    length(): number;
    lerp(q: Quaternion, t: number): this;
    // (undocumented)
    mul(q: Quaternion): this;
    multiply(q: Quaternion): this;
    normalize(): this;
    premultiply(q: Quaternion): this;
    rotateX(rad: number): this;
    rotateY(rad: number): this;
    rotateZ(rad: number): this;
    rotationTo(a: Vector3, b: Vector3): this;
    scale(scale: number): this;
    set(x: number, y: number, z: number, w: number): this;
    setAxes(view: Vector3, right: Vector3, up: Vector3): this;
    setAxisAngle(axis: Vector3, rad: number): this;
    slerp(q: Quaternion, t: number): this;
    sqlerp(qa: Quaternion, qb: Quaternion, qc: Quaternion, qd: Quaternion, t: number): this;
    // (undocumented)
    sqrLen(): number;
    squaredLength(): number;
    toArray(array?: MutableNumberArray, offset?: number): MutableNumberArray;
    get w(): number;
    set w(value: number);
    get x(): number;
    set x(value: number);
    get y(): number;
    set y(value: number);
    get z(): number;
    set z(value: number);
}

// @public
export class QuaternionNotifier extends Quaternion {
    constructor(x?: number, y?: number, z?: number, w?: number);
    add(q: Quaternion): this;
    calculateW(): this;
    className: string;
    clone(): Quaternion;
    conjugate(): this;
    copy(q: Quaternion /**
    * Copy the values from one quat to this
    * @param q -
    * @returns this
    */): this;
    dot(q: Quaternion): number;
    equals(q: Quaternion): boolean;
    exactEquals(q: Quaternion): boolean;
    fromArray(array: ArrayLike<number>, offset?: number): this;
    fromEuler(euler: Euler, notCallUpdate?: boolean): this;
    fromMat3(mat: Matrix3): this;
    fromMat4(mat: Matrix4): this;
    getAxisAngle(axis: Vector3): number;
    identity(): this;
    invert(): this;
    // (undocumented)
    isQuaternion: boolean;
    // (undocumented)
    isQuaternionNotifier: boolean;
    length(): number;
    lerp(q: Quaternion, t: number): this;
    multiply(q: Quaternion): this;
    normalize(): this;
    onUpdate(): void;
    premultiply(q: Quaternion): this;
    rotateX(rad: number): this;
    rotateY(rad: number): this;
    rotateZ(rad: number): this;
    rotationTo(a: Vector3, b: Vector3): this;
    scale(scale: number): this;
    set(x: number, y: number, z: number, w: number): this;
    setAxes(view: Vector3, right: Vector3, up: Vector3): this;
    setAxisAngle(axis: Vector3, rad: number): this;
    slerp(q: Quaternion, t: number): this;
    sqlerp(qa: Quaternion, qb: Quaternion, qc: Quaternion, qd: Quaternion, t: number): this;
    squaredLength(): number;
    toArray(array?: MutableNumberArray, offset?: number): MutableNumberArray;
    get w(): number;
    set w(value: number);
    get x(): number;
    set x(value: number);
    get y(): number;
    set y(value: number);
    get z(): number;
    set z(value: number);
}

// @public (undocumented)
export interface RadianceHDRImage {
    // (undocumented)
    readonly data: Float32Array;
    // (undocumented)
    readonly exposure: number;
    // (undocumented)
    readonly gamma: number;
    // (undocumented)
    readonly shape: readonly [width: number, height: number];
}

// @public
export class Ray {
    constructor(params?: RayParameters);
    className: string;
    clone(): Ray;
    copy(other: Ray): this;
    get direction(): Vector3;
    set direction(value: Vector3);
    distance(point: Vector3): number;
    fromCamera(camera: RayCamera, x: number, y: number, width: number, height: number): void;
    intersectsBox(aabb: AxisAlignedBox): Vector3 | null;
    intersectsPlane(normal: ArrayLike<number>, distance: number): Vector3 | null;
    intersectsSphere(center: ArrayLike<number>, radius: number): Vector3 | null;
    intersectsTriangle(triangle: Triangle): Vector3 | null;
    intersectsTriangleCell(cell: readonly [number, number, number], positions: readonly ArrayLike<number>[]): Vector3 | null;
    isRay: boolean;
    get origin(): Vector3;
    set origin(value: Vector3);
    set(origin: Vector3, direction: Vector3): this;
    sortPoints(points: (Vector3 | object)[], pointName?: PropertyKey): void;
    squaredDistance(point: Vector3): number;
    transformMat4(mat4: Matrix4): void;
}

// @public (undocumented)
export interface RayCamera {
    // (undocumented)
    far?: number | null;
    // (undocumented)
    isOrthographicCamera?: boolean;
    // (undocumented)
    isPerspectiveCamera?: boolean;
    // (undocumented)
    near?: number;
    // (undocumented)
    unprojectVector(vector: Vector3, width: number, height: number): Vector3;
    // (undocumented)
    worldMatrix: Matrix4;
}

// @public (undocumented)
export interface RayParameters {
    // (undocumented)
    direction?: Vector3;
    // (undocumented)
    origin?: Vector3;
}

// @public
export function registerUniformBlockBinding(name: string, bindingPoint?: number): number;

// @public (undocumented)
type RegistryLoadMethod = {
    load(data: LoaderRequest): Promise<unknown>;
}['load'];

// @public
export class Renderer<Backend extends RendererBackend = RendererBackend> implements RendererContract {
    // (undocumented)
    static [Symbol.hasInstance](value: unknown): boolean;
    // (undocumented)
    readonly backend: Backend;
    // (undocumented)
    readonly className: 'Renderer';
    // (undocumented)
    clearColor: RendererContract['clearColor'];
    static create(options?: RendererAutoOptions): Promise<Renderer>;
    // (undocumented)
    static create(options: RendererWebGL2Options): Promise<Renderer<'webgl2'>>;
    // (undocumented)
    static create(options: RendererWebGPUOptions): Promise<Renderer<'webgpu'>>;
    // (undocumented)
    static create<Backend extends RendererBackend>(options: RendererOptions<Backend>): Promise<Renderer<Backend>>;
    // (undocumented)
    readonly createRenderTarget: RendererContract['createRenderTarget'];
    // (undocumented)
    readonly createStorageBuffer: RendererContract['createStorageBuffer'];
    // (undocumented)
    readonly destroy: RendererContract['destroy'];
    // (undocumented)
    domElement: RendererContract['domElement'];
    // (undocumented)
    forceMaterial: RendererContract['forceMaterial'];
    // (undocumented)
    readonly getExtension: RendererContract['getExtension'];
    // (undocumented)
    readonly getViewport: RendererContract['getViewport'];
    // (undocumented)
    height: RendererContract['height'];
    static isBackendSupported(backend: 'webgl2', options?: RendererWebGL2Options): Promise<boolean>;
    // (undocumented)
    static isBackendSupported(backend: 'webgpu', options?: RendererSupportOptions): Promise<boolean>;
    // (undocumented)
    readonly isReady: RendererContract['isReady'];
    // (undocumented)
    readonly lightManager: RendererContract['lightManager'];
    // (undocumented)
    readonly off: (...args: Parameters<RendererContract['off']>) => this;
    // (undocumented)
    readonly on: (...args: Parameters<RendererContract['on']>) => this;
    // (undocumented)
    readonly onInit: (callback: (renderer: this) => void) => void;
    // (undocumented)
    pixelRatio: RendererContract['pixelRatio'];
    // (undocumented)
    readonly present: RendererContract['present'];
    // (undocumented)
    readonly ready: RendererContract['ready'];
    // (undocumented)
    readonly releaseGPUResources: RendererContract['releaseGPUResources'];
    // (undocumented)
    readonly render: RendererContract['render'];
    // (undocumented)
    readonly renderFrame: RendererContract['renderFrame'];
    // (undocumented)
    readonly renderInfo: RendererContract['renderInfo'];
    // (undocumented)
    readonly renderTarget: RendererContract['renderTarget'];
    // (undocumented)
    readonly renderToTarget: RendererContract['renderToTarget'];
    // (undocumented)
    readonly resize: RendererContract['resize'];
    // (undocumented)
    readonly resourceManager: RendererContract['resourceManager'];
    // (undocumented)
    readonly setOffset: RendererContract['setOffset'];
    // (undocumented)
    readonly setRenderTarget: (...args: Parameters<RendererContract['setRenderTarget']>) => this;
    // (undocumented)
    readonly supportsTextureCompression: RendererContract['supportsTextureCompression'];
    // (undocumented)
    useInstanced: RendererContract['useInstanced'];
    // (undocumented)
    readonly waitForIdle: RendererContract['waitForIdle'];
    // (undocumented)
    width: RendererContract['width'];
}

// @public
export type RendererAdapterPowerPreference = 'low-power' | 'high-performance';

// @public
export interface RendererAutoOptions extends RendererCommonOptions, RendererSupportOptions {
    // (undocumented)
    backend?: 'auto';
    preserveDrawingBuffer?: boolean;
}

// @public (undocumented)
export type RendererBackend = 'webgl2' | 'webgpu';

// @public
export interface RendererCommonOptions {
    // (undocumented)
    alpha?: boolean;
    // (undocumented)
    antialias?: boolean;
    // (undocumented)
    clearColor?: Color;
    // (undocumented)
    depth?: boolean;
    // (undocumented)
    domElement?: HTMLCanvasElement | null;
    // (undocumented)
    failIfMajorPerformanceCaveat?: boolean;
    // (undocumented)
    fog?: Fog | null;
    // (undocumented)
    forceMaterial?: Material | null;
    // (undocumented)
    fragmentPrecision?: ShaderPrecision;
    // (undocumented)
    height?: number;
    // (undocumented)
    offsetX?: number;
    // (undocumented)
    offsetY?: number;
    // (undocumented)
    pixelRatio?: number;
    // (undocumented)
    premultipliedAlpha?: boolean;
    renderPipeline?: RenderPipelineFactory;
    // (undocumented)
    stencil?: boolean;
    // (undocumented)
    useInstanced?: boolean;
    // (undocumented)
    useLogDepth?: boolean;
    // (undocumented)
    vertexPrecision?: ShaderPrecision;
    // (undocumented)
    width?: number;
}

// @public
export type RendererContextPowerPreference = 'default' | RendererAdapterPowerPreference;

// @public
export interface RendererContract {
    // (undocumented)
    readonly backend: RendererBackend;
    // (undocumented)
    readonly className: string;
    // (undocumented)
    clearColor: Color;
    // (undocumented)
    createRenderTarget(parameters: RenderTargetParameters): RenderTarget;
    createStorageBuffer(descriptor: Readonly<StorageBufferDescriptor>): StorageBuffer;
    // (undocumented)
    destroy(): void;
    // (undocumented)
    domElement: HTMLCanvasElement | null;
    // (undocumented)
    forceMaterial: Material | null;
    getExtension(name: string): object | null;
    getViewport(): RendererViewport;
    // (undocumented)
    height: number;
    // (undocumented)
    readonly isReady: boolean;
    // (undocumented)
    readonly lightManager: LightManager;
    // (undocumented)
    off(type?: string, listener?: EventListener_2): this;
    // (undocumented)
    on(type: string, listener: EventListener_2, once?: boolean): this;
    // (undocumented)
    onInit(callback: (renderer: this) => void): void;
    // (undocumented)
    pixelRatio: number;
    present(target?: RenderTarget): void;
    // (undocumented)
    readonly ready: Promise<void>;
    // (undocumented)
    releaseGPUResources(): void;
    // (undocumented)
    render(stage: RendererScene, camera: Camera, fireEvent?: boolean): void;
    renderFrame(callback: RendererFrameCallback): void;
    // (undocumented)
    readonly renderInfo: RenderInfo;
    // (undocumented)
    readonly renderTarget: RenderTarget | null;
    // (undocumented)
    renderToTarget(target: RenderTarget, stage: RendererScene, camera: Camera, fireEvent?: boolean): void;
    // (undocumented)
    resize(width: number, height: number, force?: boolean): void;
    // (undocumented)
    readonly resourceManager: RendererResourceManager;
    // (undocumented)
    setOffset(x: number, y: number): void;
    // (undocumented)
    setRenderTarget(target: RenderTarget | null, options?: RenderTargetSelectionOptions): this;
    // (undocumented)
    supportsTextureCompression(format: TextureCompressionFormat): boolean;
    // (undocumented)
    useInstanced: boolean;
    waitForIdle(): Promise<void>;
    // (undocumented)
    width: number;
}

// @public
export type RendererCreateOptions = RendererExplicitOptions | RendererAutoOptions;

// @public (undocumented)
export type RendererExplicitOptions = RendererOptions;

// @public
export type RendererFeatureName = 'texture-compression-bc' | 'texture-compression-etc2' | 'texture-compression-astc' | 'timestamp-query' | 'shader-f16' | 'depth32float-stencil8' | 'float32-filterable' | 'float32-blendable';

// @public
export interface RendererFrame {
    // (undocumented)
    readonly backend: RendererBackend;
    // (undocumented)
    present(target?: RenderTarget): void;
    // (undocumented)
    render(stage: RendererScene, camera: Camera, fireEvent?: boolean): void;
    // (undocumented)
    renderToTarget(target: RenderTarget, stage: RendererScene, camera: Camera, fireEvent?: boolean): void;
}

// @public
export type RendererFrameCallback = (frame: RendererFrame) => unknown;

// @public
export interface RendererListDescriptor {
    readonly castShadowsOnly?: boolean;
    readonly cullingResults: CullingResultsHandle;
    readonly overrideMaterial?: Material;
    readonly queue: RendererListQueue;
    readonly sorting: RendererListSorting;
}

// @public
export type RendererListHandle = number & {
    readonly [rendererListHandleBrand]: true;
};

// @public (undocumented)
const rendererListHandleBrand: unique symbol;

// @public
export type RendererListQueue = 'opaque' | 'transparent' | 'all';

// @public
export type RendererListSorting = 'material-front-to-back' | 'back-to-front' | 'none';

// @public
export type RendererOptions<Backend extends RendererBackend = RendererBackend> = RendererOptionsMap[Backend];

// @public (undocumented)
export interface RendererOptionsMap {
    // (undocumented)
    readonly webgl2: RendererWebGL2Options;
    // (undocumented)
    readonly webgpu: RendererWebGPUOptions;
}

// @public
export interface RendererResourceDiagnostics {
    // (undocumented)
    readonly frameActive: boolean;
    // (undocumented)
    readonly pendingDestroyCount: number;
    // (undocumented)
    readonly trackedMeshCount: number;
    // (undocumented)
    readonly trackedResourceCount: number;
    // (undocumented)
    readonly usedResourceCount: number;
}

// @public
export interface RendererResourceManager {
    // (undocumented)
    destroyIfNoRef(resource: Resource): void;
    // (undocumented)
    destroyMesh(mesh: Mesh): void;
    // (undocumented)
    getDiagnostics(rootNode?: Node_2): RendererResourceDiagnostics;
}

// @public (undocumented)
export type RendererScene = Node_2 & {
    readonly fog?: Fog | null;
};

// @public
export interface RendererSupportOptions {
    // (undocumented)
    failIfMajorPerformanceCaveat?: boolean;
    // (undocumented)
    forceFallbackAdapter?: boolean;
    // (undocumented)
    powerPreference?: RendererAdapterPowerPreference;
    // (undocumented)
    requiredFeatures?: readonly RendererFeatureName[];
    // (undocumented)
    requiredLimits?: Readonly<Record<string, number>>;
}

// @public
export type RendererViewport = readonly [x: number, y: number, width: number, height: number];

// @public
export interface RendererWebGL2Options extends RendererCommonOptions {
    // (undocumented)
    backend?: 'webgl2';
    // (undocumented)
    powerPreference?: RendererContextPowerPreference;
    // (undocumented)
    preserveDrawingBuffer?: boolean;
}

// @public
export interface RendererWebGPUOptions extends RendererCommonOptions, RendererSupportOptions {
    // (undocumented)
    backend: 'webgpu';
    preserveDrawingBuffer?: never;
}

// @public
export type RenderGraphBufferHandle = number & {
    readonly [renderGraphBufferHandleBrand]: true;
};

// @public (undocumented)
const renderGraphBufferHandleBrand: unique symbol;

// @public
export type RenderGraphBufferReadUse = 'storage' | 'vertex' | 'index' | 'copy-source' | 'indirect';

// @public
export type RenderGraphBufferWriteUse = 'storage' | 'copy-destination';

// @public
export interface RenderGraphFramePlan {
    // (undocumented)
    readonly lights: readonly Light[];
    // (undocumented)
    readonly meshes: readonly Mesh[];
    // (undocumented)
    readonly shadowLights: ReadonlySet<Light>;
}

// @public
export type RenderGraphPassHandle = number & {
    readonly [renderGraphPassHandleBrand]: true;
};

// @public (undocumented)
const renderGraphPassHandleBrand: unique symbol;

// @public
export type RenderGraphTextureHandle = number & {
    readonly [renderGraphTextureHandleBrand]: true;
};

// @public (undocumented)
const renderGraphTextureHandleBrand: unique symbol;

// @public
export class RenderInfo {
    constructor();
    addDrawCount(num: number): void;
    addFaceCount(num: number): void;
    // (undocumented)
    readonly className = "RenderInfo";
    // (undocumented)
    drawCount: number;
    // (undocumented)
    faceCount: number;
    // (undocumented)
    readonly isRenderInfo = true;
    reset(): void;
}

// @public
export type RenderPassParameterFactory<P extends object> = () => P;

// @public
export class RenderPassParameterPool<P extends object> {
    constructor(
    factory: RenderPassParameterFactory<P>,
    reset?: RenderPassParameterReset<P>);
    get capacity(): number;
}

// @public
export type RenderPassParameterReset<P extends object> = (parameters: P) => void;

// @public
export interface RenderPipeline {
    destroy(): void;
    readonly name: string;
    record(context: RenderPipelineContext): unknown;
}

// @public
export interface RenderPipelineBufferDescriptor {
    readonly byteLength: number;
    readonly label?: string;
}

// @public
export interface RenderPipelineCapabilities {
    readonly limits: Readonly<RenderPipelineLimits>;
    supportsCapability(capability: RenderPipelineCapabilityName): boolean;
    supportsTextureFormat(format: RenderTargetColorFormat | RenderTargetDepthStencilFormat, use: RenderPipelineTextureUse, sampleCount?: RenderTargetSampleCount): boolean;
}

// @public
export type RenderPipelineCapabilityName = 'storage-buffer' | 'storage-texture' | 'compute-pass' | 'indirect-draw';

// @public
export interface RenderPipelineColorAttachment {
    readonly clearValue?: RenderTargetColor;
    readonly loadOp: RenderTargetLoadOp;
    readonly resolveTarget?: RenderGraphTextureHandle;
    readonly storeOp: RenderTargetStoreOp;
    readonly texture: RenderGraphTextureHandle;
}

// @public
export interface RenderPipelineContext {
    acquirePassParameters<P extends object>(pool: RenderPassParameterPool<P>): P;
    readonly camera: Camera;
    readonly capabilities: RenderPipelineCapabilities;
    readonly clearColor: Readonly<RenderTargetColor>;
    createRendererList(descriptor: Readonly<RendererListDescriptor>): RendererListHandle;
    cull(options?: Readonly<CullingOptions>): CullingResultsHandle;
    readonly frameIndex: number;
    readonly graph: ScriptableRenderGraph;
    readonly output: RenderPipelineOutput;
    recordShadows(cullingResults: CullingResultsHandle): void;
    readonly scene: RendererScene;
    readonly viewport: RendererViewport;
}

// @public
export interface RenderPipelineCreateContext {
    readonly capabilities: RenderPipelineCapabilities;
}

// @public
export interface RenderPipelineDepthStencilAttachment {
    readonly depthClearValue?: number;
    readonly depthLoadOp?: RenderTargetLoadOp;
    readonly depthReadOnly?: boolean;
    readonly depthStoreOp?: RenderTargetStoreOp;
    readonly stencilClearValue?: number;
    readonly stencilLoadOp?: RenderTargetLoadOp;
    readonly stencilReadOnly?: boolean;
    readonly stencilStoreOp?: RenderTargetStoreOp;
    readonly texture: RenderGraphTextureHandle;
}

// @public
export type RenderPipelineExtent = Readonly<{
    width: number;
    height: number;
}> | Readonly<{
    relativeTo: 'output';
    scale: number;
    minWidth?: number;
    minHeight?: number;
}>;

// @public
export interface RenderPipelineFactory {
    create(context: RenderPipelineCreateContext): RenderPipeline | Promise<RenderPipeline>;
    readonly name: string;
    readonly requirements?: Readonly<RenderPipelineRequirements>;
}

// @public
export interface RenderPipelineLimits {
    readonly maxBindGroups: number;
    readonly maxBindingsPerBindGroup: number;
    readonly maxBufferSize: number;
    readonly maxColorAttachments: number;
    readonly maxComputeInvocationsPerWorkgroup?: number;
    readonly maxComputeWorkgroupSizeX?: number;
    readonly maxComputeWorkgroupSizeY?: number;
    readonly maxComputeWorkgroupSizeZ?: number;
    readonly maxComputeWorkgroupsPerDimension?: number;
    readonly maxComputeWorkgroupStorageSize?: number;
    readonly maxDynamicStorageBuffersPerPipelineLayout?: number;
    readonly maxSampledTexturesPerShaderStage: number;
    readonly maxStorageBufferBindingSize?: number;
    readonly maxStorageBuffersPerShaderStage?: number;
    readonly maxStorageTexturesPerShaderStage?: number;
    readonly maxTextureDimension2D: number;
    readonly minStorageBufferOffsetAlignment?: number;
}

// @public
export interface RenderPipelineOutput {
    colorAttachment(index: number): Readonly<RenderPipelineOutputColorAttachment>;
    readonly colorAttachmentCount: number;
    colorFormat(index: number): RenderTargetColorFormat;
    readonly depthStencilAttachment: Readonly<RenderPipelineOutputDepthStencilAttachment> | null;
    readonly depthStencilFormat: RenderTargetDepthStencilFormat | null;
    readonly height: number;
    readonly kind: 'surface' | 'render-target';
    readonly sampleCount: RenderTargetSampleCount;
    readonly width: number;
}

// @public
export interface RenderPipelineOutputColorAttachment {
    readonly clearValue: Readonly<RenderTargetColor>;
    readonly loadOp: RenderTargetLoadOp;
    readonly storeOp: RenderTargetStoreOp;
}

// @public
export interface RenderPipelineOutputDepthStencilAttachment {
    readonly depthClearValue: number;
    readonly depthLoadOp: RenderTargetLoadOp;
    readonly depthStoreOp: RenderTargetStoreOp;
    readonly stencilClearValue: number;
    readonly stencilLoadOp: RenderTargetLoadOp;
    readonly stencilStoreOp: RenderTargetStoreOp;
}

// @public
export type RenderPipelineOutputResources = RenderPipelineTargetResources;

// @public
export interface RenderPipelinePersistentTargetDescriptor {
    readonly colorFormats: readonly RenderTargetColorFormat[];
    readonly depthStencilFormat?: RenderTargetDepthStencilFormat;
    readonly extent: RenderPipelineExtent;
    readonly label?: string;
    readonly sampleCount?: RenderTargetSampleCount;
}

// @public
export interface RenderPipelineRequirements {
    readonly requiredCapabilities?: readonly RenderPipelineCapabilityName[];
    readonly requiredFeatures?: readonly RendererFeatureName[];
    readonly requiredLimits?: Readonly<Record<string, number>>;
    readonly requiredTextureFormats?: readonly Readonly<RenderPipelineTextureRequirement>[];
}

// @public
export interface RenderPipelineTargetResources {
    color(index: number): RenderGraphTextureHandle;
    readonly colorAttachmentCount: number;
    readonly depthStencil: RenderGraphTextureHandle | null;
    readonly height: number;
    readonly sampleCount: RenderTargetSampleCount;
    readonly width: number;
}

// @public
export interface RenderPipelineTextureDescriptor {
    readonly extent: RenderPipelineExtent;
    readonly format: RenderTargetColorFormat | RenderTargetDepthStencilFormat;
    readonly mipLevelCount?: number;
    readonly sampleCount?: RenderTargetSampleCount;
}

// @public
export interface RenderPipelineTextureRequirement {
    readonly format: RenderTargetColorFormat | RenderTargetDepthStencilFormat;
    readonly sampleCount?: RenderTargetSampleCount;
    readonly use: RenderPipelineTextureUse;
}

// @public
export type RenderPipelineTextureUse = 'sampled' | 'filterable-sampled' | 'color-attachment' | 'depth-stencil-attachment' | 'storage' | 'copy-source' | 'copy-destination';

// @public
export interface RenderTarget {
    // (undocumented)
    readonly backend: RendererBackend;
    // (undocumented)
    readonly colorAttachmentCount: number;
    // (undocumented)
    readonly colorFormats: readonly RenderTargetColorFormat[];
    // (undocumented)
    readonly depthStencilFormat: RenderTargetDepthStencilFormat | null;
    // (undocumented)
    destroy(): void;
    getColorTexture(index?: number): Texture<unknown>;
    getDepthTexture(): Texture<unknown> | null;
    // (undocumented)
    readonly height: number;
    // (undocumented)
    readonly isDestroyed: boolean;
    // (undocumented)
    readonly label: string;
    // (undocumented)
    readColorAttachment(options?: RenderTargetReadColorAttachmentOptions): Promise<RenderTargetColorAttachmentReadback>;
    // (undocumented)
    resize(width: number, height: number): void;
    // (undocumented)
    readonly sampleCount: RenderTargetSampleCount;
    // (undocumented)
    readonly width: number;
}

// @public
export interface RenderTargetColor {
    // (undocumented)
    readonly a: number;
    // (undocumented)
    readonly b: number;
    // (undocumented)
    readonly g: number;
    // (undocumented)
    readonly r: number;
}

// @public (undocumented)
export interface RenderTargetColorAttachmentOptions {
    // (undocumented)
    readonly clearValue?: RenderTargetColor;
    // (undocumented)
    readonly format?: RenderTargetColorFormat;
    // (undocumented)
    readonly label?: string;
    // (undocumented)
    readonly loadOp?: RenderTargetLoadOp;
    // (undocumented)
    readonly storeOp?: RenderTargetStoreOp;
}

// @public
export interface RenderTargetColorAttachmentReadback {
    // (undocumented)
    readonly bytesPerPixel: number;
    // (undocumented)
    readonly bytesPerRow: number;
    // (undocumented)
    readonly data: Uint8Array;
    // (undocumented)
    readonly format: RenderTargetColorFormat;
    // (undocumented)
    readonly height: number;
    // (undocumented)
    readonly width: number;
}

// @public (undocumented)
export type RenderTargetColorFormat = 'rgba8unorm' | 'rgba8unorm-srgb' | 'rgba16float' | 'rgba32float';

// @public (undocumented)
export type RenderTargetCompareFunction = 'never' | 'less' | 'equal' | 'less-equal' | 'greater' | 'not-equal' | 'greater-equal' | 'always';

// @public (undocumented)
export interface RenderTargetDepthStencilAttachmentOptions {
    // (undocumented)
    readonly compare?: RenderTargetCompareFunction;
    // (undocumented)
    readonly depthClearValue?: number;
    // (undocumented)
    readonly depthLoadOp?: RenderTargetLoadOp;
    // (undocumented)
    readonly depthStoreOp?: RenderTargetStoreOp;
    // (undocumented)
    readonly format?: RenderTargetDepthStencilFormat;
    // (undocumented)
    readonly label?: string;
    readonly sampled?: boolean;
    // (undocumented)
    readonly stencilClearValue?: number;
    // (undocumented)
    readonly stencilLoadOp?: RenderTargetLoadOp;
    // (undocumented)
    readonly stencilStoreOp?: RenderTargetStoreOp;
}

// @public (undocumented)
export type RenderTargetDepthStencilFormat = 'depth16unorm' | 'depth24plus' | 'depth24plus-stencil8' | 'depth32float' | 'depth32float-stencil8';

// @public (undocumented)
export type RenderTargetLoadOp = 'clear' | 'load';

// @public
export interface RenderTargetParameters {
    readonly colorAttachments?: readonly RenderTargetColorAttachmentOptions[];
    readonly depthStencilAttachment?: RenderTargetDepthStencilAttachmentOptions | false;
    // (undocumented)
    readonly height: number;
    // (undocumented)
    readonly label?: string;
    readonly sampleCount?: RenderTargetSampleCount;
    // (undocumented)
    readonly width: number;
}

// @public (undocumented)
export interface RenderTargetReadColorAttachmentOptions {
    // (undocumented)
    readonly attachmentIndex?: number;
    // (undocumented)
    readonly height?: number;
    // (undocumented)
    readonly width?: number;
    readonly x?: number;
    // (undocumented)
    readonly y?: number;
}

// @public (undocumented)
export type RenderTargetSampleCount = 1 | 4;

// @public (undocumented)
export interface RenderTargetSelectionOptions {
    readonly present?: boolean;
    readonly takeOwnership?: boolean;
}

// @public (undocumented)
export type RenderTargetStoreOp = 'store' | 'discard';

// @public (undocumented)
export type ResizableTextureImage = HTMLImageElement | HTMLCanvasElement | ImageBitmap | OffscreenCanvas | HTMLVideoElement;

// @public (undocumented)
export interface Resource {
    // (undocumented)
    destroy(): unknown;
    // (undocumented)
    destroyIfNoRef?(renderer: object): unknown;
}

// @public (undocumented)
export interface ResourceLoader {
    // Warning: (ae-forgotten-export) The symbol "RegistryLoadMethod" needs to be exported by the entry point Hilo3d.d.ts
    //
    // (undocumented)
    load: RegistryLoadMethod;
}

// @public (undocumented)
export type ResourceLoaderConstructor = new () => ResourceLoader;

// @public (undocumented)
export interface ResourceRequestOptions {
    // (undocumented)
    body?: BodyInit | null;
    // (undocumented)
    credentials?: RequestCredentials;
    // (undocumented)
    headers?: Readonly<Record<string, string>>;
    // (undocumented)
    method?: string;
    // (undocumented)
    signal?: AbortSignal;
    // (undocumented)
    type?: NetworkResourceType;
    // (undocumented)
    url: string;
}

// @public
export const SCENE_STORAGE_BIND_GROUP = 3;

// @public
export class SceneRenderPass implements ScriptableRenderPass<SceneRenderPassParameters> {
    constructor(name?: string);
    execute(context: ScriptableRenderPassContext, parameters: SceneRenderPassParameters): void;
    readonly name: string;
    setup(builder: ScriptableRenderPassBuilder, parameters: SceneRenderPassParameters): void;
}

// @public
export interface SceneRenderPassParameters {
    readonly colorAttachments: readonly Readonly<RenderPipelineColorAttachment>[];
    readonly depthStencilAttachment?: Readonly<RenderPipelineDepthStencilAttachment>;
    readonly rendererList: RendererListHandle;
    readonly scissor?: RendererViewport;
    readonly stencilReference?: number;
    readonly storageShaderVariant?: Readonly<SceneStorageShaderVariant>;
    readonly viewport?: RendererViewport;
}

// @public
export interface SceneStorageBufferBinding {
    readonly buffer: RenderGraphBufferHandle;
    readonly byteLength?: number;
    readonly byteOffset?: number;
}

// @public
export interface SceneStorageShaderVariant {
    readonly buffers: readonly Readonly<SceneStorageBufferBinding>[];
    readonly shader: StorageGraphicsShader;
}

// @public
export interface ScriptableRenderCommands {
    clearBuffer(buffer: RenderGraphBufferHandle, byteOffset?: number, byteLength?: number): void;
    copyBuffer(source: RenderGraphBufferHandle, destination: RenderGraphBufferHandle): void;
    copyTexture(source: RenderGraphTextureHandle, destination: RenderGraphTextureHandle): void;
    drawRendererList(list: RendererListHandle): void;
    setScissor(rect: RendererViewport): void;
    setStencilReference(reference: number): void;
    setViewport(viewport: RendererViewport): void;
}

// @public
export interface ScriptableRenderGraph {
    acquirePersistentTarget(key: object, descriptor: Readonly<RenderPipelinePersistentTargetDescriptor>): RenderPipelineTargetResources;
    addPass<P extends object>(pass: ScriptableRenderPass<P>, parameters: P): RenderGraphPassHandle;
    createBuffer(name: string, descriptor: Readonly<RenderPipelineBufferDescriptor>): RenderGraphBufferHandle;
    createTexture(name: string, descriptor: Readonly<RenderPipelineTextureDescriptor>): RenderGraphTextureHandle;
    importOutput(): RenderPipelineOutputResources;
    importRenderTarget(target: RenderTarget): RenderPipelineTargetResources;
    importStorageBuffer(buffer: StorageBuffer): RenderGraphBufferHandle;
    releasePersistentTarget(key: object): boolean;
}

// @public
export interface ScriptableRenderPass<P extends object> {
    execute(context: ScriptableRenderPassContext, parameters: P): unknown;
    readonly name: string;
    prepare?(context: ScriptableRenderPrepareContext, parameters: P): unknown;
    setup(builder: ScriptableRenderPassBuilder, parameters: P): unknown;
}

// @public
export interface ScriptableRenderPassBuilder {
    clearBuffer(buffer: RenderGraphBufferHandle, byteOffset?: number, byteLength?: number): void;
    copyBuffer(source: RenderGraphBufferHandle, destination: RenderGraphBufferHandle): void;
    copyTexture(source: RenderGraphTextureHandle, destination: RenderGraphTextureHandle): void;
    dependsOn(pass: RenderGraphPassHandle): void;
    markSideEffect(): void;
    readBuffer(buffer: RenderGraphBufferHandle, use: RenderGraphBufferReadUse): void;
    readTexture(texture: RenderGraphTextureHandle): void;
    readWriteBuffer(buffer: RenderGraphBufferHandle): void;
    useColorAttachment(options: Readonly<RenderPipelineColorAttachment>): void;
    useDepthStencilAttachment(options: Readonly<RenderPipelineDepthStencilAttachment>): void;
    useRendererList(list: RendererListHandle): void;
    writeBuffer(buffer: RenderGraphBufferHandle, use: RenderGraphBufferWriteUse): void;
    writeStorageTexture(texture: RenderGraphTextureHandle): void;
}

// @public
export interface ScriptableRenderPassContext {
    readonly commands: ScriptableRenderCommands;
}

// @public
export interface ScriptableRenderPrepareContext {
    readonly capabilities: RenderPipelineCapabilities;
}

// @public
export const semantic: {
    camera: Camera | null;
    lightManager: LightManager | null;
    fog: Fog | null;
    renderer: SemanticRenderer | null;
    blankInfo: {
        get(_mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): undefined;
    };
    init(_renderer: SemanticRenderer, _camera: Camera, _lightManager: LightManager, _fog: Fog | null): void;
    setCamera(_camera: Camera): void;
    setViewport(viewport: RendererViewport): void;
    handlerColorOrTexture(value: MaterialTextureValue): Float32Array | TextureBinding;
    handlerTexture(value: TextureBinding | null): TextureBinding;
    handlerUV(texture: unknown): number;
    _blankTexture: DataTexture | null;
    getBlankTexture(): DataTexture;
    POSITION: {
        get(mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    NORMAL: {
        get(mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    TANGENT: {
        get(mesh: SemanticMesh, material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    TEXCOORD_0: {
        get(mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    TEXCOORD_1: {
        get(mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    UVMATRIX_0: {
        get(mesh: SemanticMesh, material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    UVMATRIX_1: {
        get(mesh: SemanticMesh, material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    CAMERAFAR: {
        get(_mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    CAMERANEAR: {
        get(_mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    CAMERATYPE: {
        get(_mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    CAMERAPOSITION: {
        get(_mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    COLOR_0: {
        get(mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    SKININDICES: {
        get(mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    JOINT: {
        get(mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    WEIGHT: {
        get(mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    SKINWEIGHTS: {
        get(mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    RENDERERSIZE: {
        get(_mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    LOCAL: {
        get(mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
        isDependMesh: boolean;
    };
    MODEL: {
        get(mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
        isDependMesh: boolean;
    };
    OBJECTIDCOLOR: {
        get(mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): Float32Array;
        isDependMesh: boolean;
        notSupportInstanced: boolean;
    };
    VIEW: {
        get(_mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    PROJECTION: {
        get(_mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    VIEWPROJECTION: {
        get(_mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    MODELVIEW: {
        get(mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
        isDependMesh: boolean;
    };
    MODELVIEWPROJECTION: {
        get(mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
        isDependMesh: boolean;
    };
    MODELINVERSE: {
        get(mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
        isDependMesh: boolean;
    };
    VIEWINVERSE: {
        get(_mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    VIEWINVERSEINVERSETRANSPOSE: {
        get(_mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    PROJECTIONINVERSE: {
        get(_mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    MODELVIEWINVERSE: {
        get(mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
        isDependMesh: boolean;
    };
    MODELVIEWPROJECTIONINVERSE: {
        get(mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
        isDependMesh: boolean;
    };
    MODELINVERSETRANSPOSE: {
        get(mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
        isDependMesh: boolean;
    };
    MODELVIEWINVERSETRANSPOSE: {
        get(mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
        isDependMesh: boolean;
    };
    VIEWPORT: {
        get(_mesh?: SemanticMesh, _material?: SemanticMaterial, _programInfo?: ProgramBindingInfo): Float32Array;
    };
    JOINTMATRIX: {
        get(mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
        isDependMesh: boolean;
        notSupportInstanced: boolean;
    };
    NORMALMAPSCALE: {
        get(mesh: SemanticMesh, material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    OCCLUSIONSTRENGTH: {
        get(mesh: SemanticMesh, material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    SHININESS: {
        get(mesh: SemanticMesh, material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    SPECULARENVMATRIX: {
        get(mesh: SemanticMesh, material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    REFLECTIVITY: {
        get(mesh: SemanticMesh, material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    REFRACTRATIO: {
        get(mesh: SemanticMesh, material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    REFRACTIVITY: {
        get(mesh: SemanticMesh, material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    LOGDEPTH: {
        get(_mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    AMBIENTLIGHTSCOLOR: {
        get(_mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    DIRECTIONALLIGHTSCOLOR: {
        get(_mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    SHADOWATLAS: {
        get(_mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    SHADOWATLASSIZE: {
        get(): unknown;
    };
    SHADOWATLASRECTS: {
        get(): unknown;
    };
    POINTSHADOWMATRICES: {
        get(): unknown;
    };
    DIRECTIONALLIGHTSINFO: {
        get(_mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    DIRECTIONALLIGHTSSHADOWMAP: {
        get(_mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    DIRECTIONALLIGHTSSHADOWMAPSIZE: {
        get(_mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    DIRECTIONALLIGHTSSHADOWBIAS: {
        get(_mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    DIRECTIONALLIGHTSPACEMATRIX: {
        get(_mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    POINTLIGHTSPOS: {
        get(_mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    POINTLIGHTSCOLOR: {
        get(_mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    POINTLIGHTSINFO: {
        get(_mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    POINTLIGHTSRANGE: {
        get(_mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    POINTLIGHTSSHADOWMAP: {
        get(_mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    POINTLIGHTSSHADOWBIAS: {
        get(_mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    POINTLIGHTSPACEMATRIX: {
        get(_mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    POINTLIGHTCAMERA: {
        get(_mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    SPOTLIGHTSPOS: {
        get(_mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    SPOTLIGHTSDIR: {
        get(_mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    SPOTLIGHTSCOLOR: {
        get(_mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    SPOTLIGHTSCUTOFFS: {
        get(_mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    SPOTLIGHTSINFO: {
        get(_mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    SPOTLIGHTSRANGE: {
        get(_mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    SPOTLIGHTSSHADOWMAP: {
        get(_mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    SPOTLIGHTSSHADOWMAPSIZE: {
        get(_mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    SPOTLIGHTSSHADOWBIAS: {
        get(_mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    SPOTLIGHTSPACEMATRIX: {
        get(_mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    AREALIGHTSCOLOR: {
        get(_mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    AREALIGHTSPOS: {
        get(_mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    AREALIGHTSWIDTH: {
        get(_mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    AREALIGHTSHEIGHT: {
        get(_mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    AREALIGHTSLTCTEXTURE1: {
        get(_mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    AREALIGHTSLTCTEXTURE2: {
        get(_mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    FOGCOLOR: {
        get(_mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    FOGINFO: {
        get(_mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    POSITIONDECODEMAT: {
        get(mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
        isDependMesh: boolean;
    };
    NORMALDECODEMAT: {
        get(mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
        isDependMesh: boolean;
    };
    UVDECODEMAT: {
        get(mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
        isDependMesh: boolean;
    };
    UV1DECODEMAT: {
        get(mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
        isDependMesh: boolean;
    };
    BASECOLOR: {
        get(mesh: SemanticMesh, material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    EMISSIONFACTOR: {
        get(mesh: SemanticMesh, material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    METALLIC: {
        get(mesh: SemanticMesh, material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    ROUGHNESS: {
        get(mesh: SemanticMesh, material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    DIFFUSEENVMAP: {
        get(_mesh: SemanticMesh, material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    DIFFUSEENVINTENSITY: {
        get(mesh: SemanticMesh, material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    DIFFUSEENVSPHEREHARMONICS3: {
        get(mesh: SemanticMesh, material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    BRDFLUT: {
        get(_mesh: SemanticMesh, material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    SPECULARENVMAP: {
        get(_mesh: SemanticMesh, material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    SPECULARENVINTENSITY: {
        get(mesh: SemanticMesh, material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    SPECULARENVMAPMIPCOUNT: {
        get(mesh: SemanticMesh, material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    GLOSSINESS: {
        get(mesh: SemanticMesh, material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    ALPHACUTOFF: {
        get(mesh: SemanticMesh, material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    EXPOSURE: {
        get(mesh: SemanticMesh, material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    GAMMAFACTOR: {
        get(mesh: SemanticMesh, material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    MORPHWEIGHTS: {
        isDependMesh: boolean;
        notSupportInstanced: boolean;
        get(mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    CLEARCOATFACTOR: {
        isDependMesh: boolean;
        notSupportInstanced: boolean;
        get(mesh: SemanticMesh, material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
    CLEARCOATROUGHNESSFACTOR: {
        isDependMesh: boolean;
        notSupportInstanced: boolean;
        get(mesh: SemanticMesh, material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
    };
};

// @public (undocumented)
export interface SemanticMaterial extends Material {
    // (undocumented)
    [property: string]: unknown;
    // (undocumented)
    ambient: MaterialTextureValue;
    // (undocumented)
    baseColor: Color;
    // (undocumented)
    baseColorMap: Texture | null;
    // (undocumented)
    brdfLUT: Texture | null;
    // (undocumented)
    clearcoatFactor: number;
    // (undocumented)
    clearcoatMap: Texture | null;
    // (undocumented)
    clearcoatNormalMap: Texture | null;
    // (undocumented)
    clearcoatRoughnessFactor: number;
    // (undocumented)
    clearcoatRoughnessMap: Texture | null;
    // (undocumented)
    diffuse: MaterialTextureValue;
    // (undocumented)
    diffuseEnvIntensity: number;
    // (undocumented)
    diffuseEnvMap: MaterialTexture | null;
    // (undocumented)
    diffuseEnvSphereHarmonics3: SphericalHarmonics3 | null;
    // (undocumented)
    emissionFactor: Color;
    // (undocumented)
    glossiness: number;
    // (undocumented)
    lightMap: Texture | null;
    // (undocumented)
    metallic: number;
    // (undocumented)
    metallicMap: Texture | null;
    // (undocumented)
    metallicRoughnessMap: Texture | null;
    // (undocumented)
    occlusionMap: Texture | null;
    // (undocumented)
    occlusionStrength: number;
    // (undocumented)
    reflectivity: number;
    // (undocumented)
    refractivity: number;
    // (undocumented)
    refractRatio: number;
    // (undocumented)
    roughness: number;
    // (undocumented)
    roughnessMap: Texture | null;
    // (undocumented)
    shininess: number;
    // (undocumented)
    specular: MaterialTextureValue;
    // (undocumented)
    specularEnvIntensity: number;
    // (undocumented)
    specularEnvMap: MaterialTexture | null;
    // (undocumented)
    specularEnvMatrix: Matrix4 | null;
    // (undocumented)
    specularGlossinessMap: Texture | null;
}

// @public (undocumented)
export interface SemanticMesh extends Mesh {
    // (undocumented)
    geometry: Geometry;
    // (undocumented)
    getJointMat(): Float32Array;
    // (undocumented)
    isSkinnedMesh: boolean;
}

// @public (undocumented)
export interface SemanticRenderer {
    // (undocumented)
    getViewport(): RendererViewport;
    // (undocumented)
    height: number;
    // (undocumented)
    width: number;
}

// @public
export class Shader {
    constructor(params?: ShaderParameters);
    alwaysUse: boolean;
    static get cache(): Cache_2<Shader>;
    // (undocumented)
    readonly className = "Shader";
    // (undocumented)
    static commonOptions: Record<string, number>;
    destroy(): this;
    destroyIfNoRef(renderer: ShaderRenderer): this;
    fs: string;
    static getBasicShader(material: Material, isUseInstance: boolean, header: string, renderer?: ShaderPrecisionProvider): Shader;
    static getCustomShader(vs: string, fs: string, header?: string, cacheKey?: string, useHeaderCache?: boolean, renderer?: ShaderPrecisionProvider): Shader;
    static getHeader(mesh: Mesh, material: Material, lightManager: LightManager, fog: Fog | null, useLogDepth: boolean): string;
    static getHeaderKey(mesh: Mesh, material: Material, lightManager: LightManager, fog: Fog | null, useLogDepth: boolean): string;
    static getShader(mesh: Mesh, material: Material, isUseInstance: boolean, lightManager: LightManager, fog: Fog | null, useLogDepth: boolean, renderer?: ShaderPrecisionProvider): Shader | null;
    static get headerCache(): Cache_2<string>;
    // (undocumented)
    readonly id: string;
    static init(renderer: ShaderPrecisionProvider): void;
    // (undocumented)
    readonly isShader = true;
    static reset(): void;
    static shaders: {
        [k: string]: string;
    };
    vs: string;
}

// @public (undocumented)
export type ShaderDefineValue = string | number | boolean | undefined;

// @public
export class ShaderMaterial extends Material {
    constructor(params?: ShaderMaterialParameters);
    // (undocumented)
    readonly className: string;
    fs: string;
    getCustomRenderOption: CustomRenderOptionProvider | null;
    // (undocumented)
    getRenderOption(option?: ShaderOptions): ShaderOptions;
    // (undocumented)
    isShaderMaterial: boolean;
    useHeaderCache: boolean;
    vs: string;
}

// @public
export class ShaderMaterialLoader {
    // (undocumented)
    readonly className = "ShaderMaterialLoader";
    // (undocumented)
    readonly isShaderMaterialLoader = true;
    // (undocumented)
    load(params: ShaderMaterialLoadRequest): Promise<ShaderMaterial>;
}

// @public (undocumented)
export type ShaderMaterialLoadRequest = Omit<ShaderMaterialParameters, 'fs' | 'vs'> & {
    fs: string;
    vs: string;
};

// @public (undocumented)
export interface ShaderMaterialParameters extends MaterialParameters {
    // (undocumented)
    fs?: string;
    // (undocumented)
    getCustomRenderOption?: CustomRenderOptionProvider | null;
    // (undocumented)
    useHeaderCache?: boolean;
    // (undocumented)
    vs?: string;
}

// @public (undocumented)
export type ShaderOptions = Record<string, ShaderDefineValue>;

// @public (undocumented)
export interface ShaderParameters {
    // (undocumented)
    alwaysUse?: boolean;
    // (undocumented)
    fs?: string;
    // (undocumented)
    vs?: string;
}

// @public (undocumented)
export type ShaderPrecision = 'highp' | 'mediump' | 'lowp';

// @public (undocumented)
export interface ShaderPrecisionProvider {
    // (undocumented)
    fragmentPrecision: ShaderPrecision;
    // (undocumented)
    vertexPrecision: ShaderPrecision;
}

// @public
export type ShaderReadBinding = Readonly<{
    name: string;
    group: number;
    binding: number;
    kind: 'uniform-buffer' | 'read-only-storage-buffer';
    minBindingSize?: number;
    dynamicOffset?: boolean;
}> | Readonly<{
    name: string;
    group: number;
    binding: number;
    kind: 'sampled-texture';
    sampleType: ShaderTextureSampleType;
    viewDimension?: ShaderTextureViewDimension;
}> | Readonly<{
    name: string;
    group: number;
    binding: number;
    kind: 'sampler' | 'comparison-sampler';
}>;

// @public (undocumented)
export interface ShaderRenderer extends ShaderPrecisionProvider {
    // (undocumented)
    resourceManager: RendererResourceManager;
}

// @public
export type ShaderTextureSampleType = ComputeTextureSampleType | 'sint' | 'uint';

// @public
export type ShaderTextureViewDimension = ComputeTextureViewDimension | '2d-array' | '3d' | 'cube';

// @public (undocumented)
export interface ShadowCameraParameters {
    // (undocumented)
    aspect?: number;
    // (undocumented)
    bottom?: number;
    // (undocumented)
    far?: number;
    // (undocumented)
    fov?: number;
    // (undocumented)
    left?: number;
    // (undocumented)
    near?: number;
    // (undocumented)
    right?: number;
    // (undocumented)
    rotationX?: number;
    // (undocumented)
    rotationY?: number;
    // (undocumented)
    rotationZ?: number;
    // (undocumented)
    top?: number;
    // (undocumented)
    x?: number;
    // (undocumented)
    y?: number;
    // (undocumented)
    z?: number;
}

// @public
export interface ShadowCastingLightParameters extends LightParameters {
    // (undocumented)
    shadow?: LightShadowOptions | null;
}

// @public (undocumented)
interface ShadowInfo {
    // (undocumented)
    lightSpaceMatrix?: Float32Array;
    // (undocumented)
    shadowBias?: Float32Array;
    // (undocumented)
    shadowMap?: TextureBinding[];
    // (undocumented)
    shadowMapSize?: Float32Array;
}

// @public
export class ShadowRenderPass {
    constructor(name?: string);
    readonly name: string;
    record(context: RenderPipelineContext, parameters: Readonly<ShadowRenderPassParameters>): void;
}

// @public
export interface ShadowRenderPassParameters {
    readonly cullingResults: CullingResultsHandle;
}

// @public (undocumented)
export interface Size {
    // (undocumented)
    height: number;
    // (undocumented)
    width: number;
}

// @public
export class Skeleton {
    constructor(params?: SkeletonParameters);
    // (undocumented)
    className: string;
    clone(rootNode?: Node_2): Skeleton;
    copy(skeleton: Skeleton, rootNode?: Node_2): this;
    // (undocumented)
    readonly id: string;
    // (undocumented)
    inverseBindMatrices: Matrix4[];
    // (undocumented)
    isSkeleton: boolean;
    get jointCount(): number;
    // (undocumented)
    jointNames: string[];
    // (undocumented)
    jointNodeList: Node_2[];
    resetJointNamesByNodeName(skeleton: Skeleton): void;
    get rootNode(): Node_2 | null;
    set rootNode(rootNode: Node_2 | null);
    userData: unknown;
}

// @public (undocumented)
export interface SkeletonParameters {
    // (undocumented)
    inverseBindMatrices?: Matrix4[];
    // (undocumented)
    jointNames?: string[];
    // (undocumented)
    jointNodeList?: Node_2[];
    // (undocumented)
    rootNode?: Node_2 | null;
    // (undocumented)
    userData?: unknown;
}

// @public
export class SkinnedMesh extends Mesh {
    constructor(params?: SkinnedMeshParameters);
    // (undocumented)
    className: string;
    // (undocumented)
    clone(isChild?: boolean): SkinnedMesh;
    frustumTest: boolean;
    getJointMat(): Float32Array;
    // (undocumented)
    getRenderOption(opt?: ShaderOptions): ShaderOptions;
    // (undocumented)
    isSkinnedMesh: boolean;
    resetJointNamesByNodeName(skeleton: Skeleton): void;
    resetSkinIndices(skeleton: Skeleton): void;
    skeleton: Skeleton | null;
    // (undocumented)
    static readonly typeName: string;
    useInstanced: boolean;
}

// @public (undocumented)
export interface SkinnedMeshParameters extends MeshParameters {
    // (undocumented)
    skeleton?: Skeleton | null;
}

// @public (undocumented)
export class Sphere {
    constructor(params?: {
        center?: Vector3;
        radius?: number;
    });
    // (undocumented)
    center: Vector3;
    className: string;
    clone(): Sphere;
    copy(sphere: Sphere): this;
    fromGeometryData(geometryData: GeometryData): this;
    fromPoints(points: ArrayLike<number>): this;
    // (undocumented)
    isSphere: boolean;
    radius: number;
    transformMat4(mat4: Matrix4): this;
}

// @public
export class SphereGeometry extends Geometry {
    constructor(params?: SphereGeometryParameters);
    // (undocumented)
    readonly className: string;
    heightSegments: number;
    // (undocumented)
    isSphereGeometry: boolean;
    radius: number;
    // (undocumented)
    _raycast(ray: Ray, side: GLenum): Vector3[] | null;
    widthSegments: number;
}

// @public (undocumented)
export interface SphereGeometryParameters extends GeometryParameters {
    // (undocumented)
    heightSegments?: number;
    // (undocumented)
    radius?: number;
    // (undocumented)
    widthSegments?: number;
}

// @public
export class SphericalHarmonics3 {
    constructor();
    className: string;
    clone(): SphericalHarmonics3;
    // (undocumented)
    coefficients: Vector3[];
    copy(other: SphericalHarmonics3): this;
    fromArray(data: number[][] | number[]): this;
    // (undocumented)
    isSphericalHarmonics3: boolean;
    scale(scale: number): this;
    scaleForRender(): this;
    // (undocumented)
    static readonly SH3_SCALE: number[];
    toArray(): Float32Array;
}

// @public
export class SpotLight extends Light {
    constructor(params?: SpotLightParameters);
    // (undocumented)
    className: string;
    get cutoff(): number;
    set cutoff(value: number);
    // (undocumented)
    get cutoffCos(): number;
    // (undocumented)
    direction: Vector3;
    // (undocumented)
    getViewDirection(camera: Camera): Vector3;
    // (undocumented)
    getWorldDirection(): Vector3;
    // (undocumented)
    isSpotLight: boolean;
    get outerCutoff(): number;
    set outerCutoff(value: number);
    // (undocumented)
    get outerCutoffCos(): number;
    // (undocumented)
    static readonly typeName = "SpotLight";
}

// @public (undocumented)
export interface SpotLightInfo extends DirectionalLightInfo {
    // (undocumented)
    cutoffs: Float32Array;
    // (undocumented)
    dirs: Float32Array;
    // (undocumented)
    poses: Float32Array;
    // (undocumented)
    ranges: Float32Array;
}

// @public (undocumented)
export interface SpotLightParameters extends ShadowCastingLightParameters {
    // (undocumented)
    cutoff?: number;
    // (undocumented)
    direction?: Vector3;
    // (undocumented)
    outerCutoff?: number;
}

// @public
export class Stage<Backend extends RendererBackend = RendererBackend> extends Node_2 {
    camera: Camera | null;
    canvas: HTMLCanvasElement;
    // (undocumented)
    className: string;
    static create(params?: StageParameters): Promise<Stage>;
    static create<Backend extends RendererBackend>(params: StageParameters<Backend>): Promise<Stage<Backend>>;
    static create(params: StageParameters<StageBackend>): Promise<Stage>;
    destroy(): this;
    // Warning: (ae-forgotten-export) The symbol "DOMViewport" needs to be exported by the entry point Hilo3d.d.ts
    //
    // (undocumented)
    domViewport: DOMViewport | null;
    enableDOMEvent(types: string | readonly string[], enabled?: boolean): this;
    fog: Fog | null;
    getMeshResultAtPoint(x: number, y: number, eventMode?: boolean): NodeRaycastInfo | null;
    height: number;
    // (undocumented)
    isStage: boolean;
    offsetX: number;
    offsetY: number;
    pixelRatio: number;
    readonly ready: Promise<void>;
    releaseGPUResources(): this;
    renderer: Renderer<Backend>;
    // (undocumented)
    rendererHeight: number;
    // (undocumented)
    rendererWidth: number;
    resize(width: number, height: number, pixelRatio?: number, force?: boolean): this;
    setOffset(x: number, y: number): this;
    tick(dt: number): this;
    // (undocumented)
    static readonly typeName: string;
    updateDomViewport(): DOMViewport;
    viewport(x: number, y: number, width: number, height: number): this;
    width: number;
}

// @public
export type StageBackend = RendererBackend | 'auto';

// @public (undocumented)
export type StageBackendParameters<Backend extends StageBackend> = [StageBackend] extends [Backend] ? RendererSupportOptions & {
    backend?: StageBackend;
    preserveDrawingBuffer?: boolean;
} : [RendererBackend] extends [Backend] ? RendererSupportOptions & {
    backend: RendererBackend;
    preserveDrawingBuffer?: boolean;
} : Backend extends 'webgpu' ? RendererSupportOptions & {
    backend: 'webgpu';
    preserveDrawingBuffer?: never;
} : Backend extends 'auto' ? RendererSupportOptions & {
    backend?: 'auto';
    preserveDrawingBuffer?: boolean;
} : {
    backend?: 'webgl2';
    preserveDrawingBuffer?: boolean;
};

// @public (undocumented)
export interface StageCommonParameters extends NodeParameters {
    // (undocumented)
    alpha?: boolean;
    // (undocumented)
    antialias?: boolean;
    // (undocumented)
    camera?: Camera | null;
    // (undocumented)
    canvas?: HTMLCanvasElement;
    // (undocumented)
    clearColor?: Color;
    // (undocumented)
    container?: HTMLElement;
    // (undocumented)
    depth?: boolean;
    // (undocumented)
    failIfMajorPerformanceCaveat?: boolean;
    // (undocumented)
    fog?: Fog | null;
    // (undocumented)
    gameMode?: boolean;
    // (undocumented)
    height?: number;
    // (undocumented)
    pixelRatio?: number;
    // (undocumented)
    premultipliedAlpha?: boolean;
    renderPipeline?: RenderPipelineFactory;
    // (undocumented)
    stencil?: boolean;
    // (undocumented)
    useInstanced?: boolean;
    // (undocumented)
    useLogDepth?: boolean;
    // (undocumented)
    width?: number;
}

// @public (undocumented)
export type StageParameters<Backend extends StageBackend = 'auto'> = StageCommonParameters & {
    backend?: Backend;
} & StageBackendParameters<Backend>;

// @public (undocumented)
export interface StagePointerEvent extends NodePointerEvent {
    // (undocumented)
    lastEventTarget?: Node_2;
    // (undocumented)
    originalEvent: Event;
    // (undocumented)
    preventDefault(): void;
    // (undocumented)
    stageX: number;
    // (undocumented)
    stageY: number;
    // (undocumented)
    stopPropagation(): void;
}

// @public (undocumented)
export const STATE_TYPES: Readonly<{
    TRANSLATE: "Translation";
    POSITION: "Translation";
    TRANSLATION: "Translation";
    SCALE: "Scale";
    ROTATE: "Rotation";
    ROTATION: "Rotation";
    QUATERNION: "Quaternion";
    WEIGHTS: "Weights";
}>;

// @public (undocumented)
export type Std140ArrayValue = ArrayLike<number | boolean>;

// @public (undocumented)
export interface Std140FieldDefinition {
    // (undocumented)
    arrayLength?: number;
    // (undocumented)
    type: Std140Type;
}

// @public (undocumented)
export interface Std140FieldLayout {
    // (undocumented)
    readonly alignment: number;
    // (undocumented)
    readonly arrayLength: number;
    // (undocumented)
    readonly arrayStride: number;
    // (undocumented)
    readonly byteLength: number;
    // (undocumented)
    readonly componentCount: number;
    // (undocumented)
    readonly matrixStride: number;
    // (undocumented)
    readonly name: string;
    // (undocumented)
    readonly offset: number;
    // (undocumented)
    readonly type: Std140Type;
}

// @public (undocumented)
export type Std140FieldValue<Definition> = Definition extends {
    readonly arrayLength: number;
} ? Std140ArrayValue : Definition extends {
    readonly type: infer Type;
} ? Std140FieldValue<Type> : Definition extends 'bool' ? boolean : Definition extends Std140ScalarType ? number : Std140ArrayValue;

// @public
export class Std140Layout<Schema extends Std140Schema = Std140Schema> {
    constructor(schema: Schema);
    // (undocumented)
    readonly byteLength: number;
    // (undocumented)
    createBuffer(values?: Partial<Std140Values<Schema>>): ArrayBuffer;
    // (undocumented)
    readonly fields: Readonly<Record<keyof Schema & string, Std140FieldLayout>>;
    // (undocumented)
    readonly schema: Schema;
    write<Name extends keyof Schema & string>(target: ArrayBuffer, name: Name, value: Std140FieldValue<Schema[Name]>): {
        byteOffset: number;
        byteLength: number;
    };
    // @internal
    writeInto<Name extends keyof Schema & string>(target: ArrayBuffer, name: Name, value: Std140FieldValue<Schema[Name]>, result: {
        byteOffset: number;
        byteLength: number;
    }): {
        byteOffset: number;
        byteLength: number;
    };
}

// @public (undocumented)
export type Std140MatrixType = 'mat2' | 'mat3' | 'mat4' | 'mat2x3' | 'mat2x4' | 'mat3x2' | 'mat3x4' | 'mat4x2' | 'mat4x3';

// @public (undocumented)
export type Std140ScalarType = 'float' | 'int' | 'uint' | 'bool';

// @public (undocumented)
export type Std140Schema = Readonly<Record<string, Std140Type | Std140FieldDefinition>>;

// @public (undocumented)
export type Std140Type = Std140ScalarType | Std140VectorType | Std140MatrixType;

// @public (undocumented)
export type Std140Value = number | boolean | Std140ArrayValue;

// @public (undocumented)
export type Std140Values<Schema extends Std140Schema> = {
    [Name in keyof Schema]: Std140FieldValue<Schema[Name]>;
};

// @public (undocumented)
export type Std140VectorType = 'vec2' | 'vec3' | 'vec4' | 'ivec2' | 'ivec3' | 'ivec4' | 'uvec2' | 'uvec3' | 'uvec4' | 'bvec2' | 'bvec3' | 'bvec4';

// @public
export interface StorageArrayDefinition<Element extends StorageType = StorageType> {
    readonly element: Element;
    readonly length: number;
    readonly type: 'array';
}

// @public
export interface StorageBuffer {
    readonly backend: RendererBackend;
    readonly byteLength: number;
    destroy(): void;
    readonly isDestroyed: boolean;
    readonly label: string;
    range(byteOffset: number, byteLength: number): StorageBufferRange;
    read(byteOffset?: number, byteLength?: number): Promise<StorageBufferReadback>;
    readonly recovery: StorageBufferRecoveryPolicy;
    readonly usage: ReadonlySet<StorageBufferUsage>;
    write(byteOffset: number, data: ArrayBufferView): void;
}

// @public
export interface StorageBufferDescriptor {
    readonly byteLength: number;
    readonly initialData?: ArrayBuffer | ArrayBufferView;
    readonly label?: string;
    readonly recovery?: StorageBufferRecoveryPolicy;
    readonly usage: readonly StorageBufferUsage[];
}

// @public
export interface StorageBufferRange {
    readonly buffer: StorageBuffer;
    readonly byteLength: number;
    readonly byteOffset: number;
}

// @public
export interface StorageBufferReadback {
    readonly byteLength: number;
    readonly byteOffset: number;
    readonly data: Uint8Array;
}

// @public
export type StorageBufferRecoveryPolicy = 'cpu-shadow' | 'reinitialize';

// @public
export type StorageBufferUsage = 'storage' | 'vertex' | 'index' | 'indirect' | 'copy-source' | 'copy-destination';

// @public
export interface StorageFieldLayout {
    readonly alignment: number;
    readonly byteLength: number;
    readonly name: string;
    readonly offset: number;
    readonly type: StorageType;
}

// @public
export class StorageGraphicsShader {
    constructor(descriptor: Readonly<StorageGraphicsShaderDescriptor>);
    readonly bindings: readonly ShaderReadBinding[];
    readonly fragmentSource: string;
    readonly label: string;
    readonly vertexSource: string;
}

// @public
export interface StorageGraphicsShaderDescriptor {
    readonly bindings: readonly ShaderReadBinding[];
    readonly fragmentSource: string;
    readonly label?: string;
    readonly vertexSource: string;
}

// @public
export class StorageLayout<Schema extends StorageSchema = StorageSchema> {
    constructor(schema: Schema);
    readonly alignment: number;
    readonly byteLength: number;
    createBuffer(values?: Partial<StorageValues<Schema>>): ArrayBuffer;
    readonly fields: Readonly<Record<keyof Schema & string, StorageFieldLayout>>;
    readonly schema: Schema;
    write<Name extends keyof Schema & string>(target: ArrayBuffer, name: Name, value: StorageValue<Schema[Name]>): StorageWriteResult;
    writeInto<Name extends keyof Schema & string>(target: ArrayBuffer, name: Name, value: StorageValue<Schema[Name]>, result: StorageWriteResult): StorageWriteResult;
}

// @public
export type StorageMatrixType = 'mat2x2<f32>' | 'mat2x3<f32>' | 'mat2x4<f32>' | 'mat3x2<f32>' | 'mat3x3<f32>' | 'mat3x4<f32>' | 'mat4x2<f32>' | 'mat4x3<f32>' | 'mat4x4<f32>';

// @public
export type StoragePrimitiveType = StorageScalarType | StorageVectorType | StorageMatrixType;

// @public
export type StoragePrimitiveValue<Type extends StoragePrimitiveType> = Type extends StorageScalarType ? number : ArrayLike<number>;

// @public
export type StorageScalarType = 'f32' | 'i32' | 'u32' | 'atomic<i32>' | 'atomic<u32>';

// @public
export type StorageSchema = Readonly<Record<string, StorageType>>;

// @public
export interface StorageStructDefinition<Fields extends StorageSchema = StorageSchema> {
    readonly fields: Fields;
    readonly type: 'struct';
}

// @public
export type StorageType = StoragePrimitiveType | StorageArrayDefinition | StorageStructDefinition;

// @public
export type StorageValue<Definition> = Definition extends StoragePrimitiveType ? StoragePrimitiveValue<Definition> : Definition extends StorageArrayDefinition<infer Element> ? Element extends StorageScalarType ? ArrayLike<number> : readonly StorageValue<Element>[] : Definition extends StorageStructDefinition<infer Fields> ? StorageValues<Fields> : never;

// @public
export type StorageValues<Schema extends StorageSchema> = {
    readonly [Name in keyof Schema]: StorageValue<Schema[Name]>;
};

// @public
export type StorageVectorType = 'vec2<f32>' | 'vec3<f32>' | 'vec4<f32>' | 'vec2<i32>' | 'vec3<i32>' | 'vec4<i32>' | 'vec2<u32>' | 'vec3<u32>' | 'vec4<u32>';

// @public
export interface StorageWriteResult {
    byteLength: number;
    byteOffset: number;
}

// @public (undocumented)
export interface SubDataUpdate {
    // (undocumented)
    readonly byteOffset: number;
    // (undocumented)
    readonly data: TypedArray;
    // (undocumented)
    readonly revision: number;
}

// @public
export class Texture<Image = TextureImageSource> extends EventDispatcher {
    constructor(params?: TextureParameters<Image>);
    anisotropic: number;
    autoUpdate: boolean;
    // (undocumented)
    readonly border = 0;
    // (undocumented)
    readonly className: string;
    clone(): Texture<Image>;
    compressed: boolean;
    depth: number;
    destroy(): this;
    flipY: boolean;
    format: number;
    getSupportSize(img: ResizableTextureImage, maxTextureSize?: number): Size;
    getTextureUpdatesSince(revision: number): TextureUpdateSnapshot;
    // (undocumented)
    height: number;
    // (undocumented)
    readonly id: string;
    get image(): Image | null;
    set image(_img: Image | null);
    internalFormat: number;
    isImageCanRelease: boolean;
    get isImageReleased(): boolean;
    // (undocumented)
    readonly isTexture = true;
    magFilter: number;
    minFilter: number;
    get mipmapCount(): number;
    mipmaps: TextureMipmap[] | null;
    // (undocumented)
    name: string;
    needDestroy: boolean;
    get needUpdate(): boolean;
    set needUpdate(value: boolean);
    get origHeight(): number;
    get origWidth(): number;
    // (undocumented)
    premultiplyAlpha: boolean;
    // (undocumented)
    protected _releaseImage(): void;
    releaseImageIfAllowed(): boolean;
    resizeImg(img: ResizableTextureImage, width: number, height: number): ResizableTextureImage | HTMLCanvasElement;
    target: number;
    type: number;
    get updateRevision(): number;
    updateSubTexture(descriptor: TextureSubImage): void;
    get useMipmap(): boolean;
    uv: TextureUVChannel;
    // (undocumented)
    width: number;
    wrapR: number;
    wrapS: number;
    wrapT: number;
}

// @public
export type TextureBinding = Texture<unknown>;

// @public
export type TextureCompressionFormat = 'bc' | 'etc1' | 'etc2' | 'astc-4x4' | 'pvrtc';

// @public
export class TextureCopyPass implements ScriptableRenderPass<TextureCopyPassParameters> {
    constructor(name?: string);
    execute(context: ScriptableRenderPassContext, parameters: TextureCopyPassParameters): void;
    readonly name: string;
    setup(builder: ScriptableRenderPassBuilder, parameters: TextureCopyPassParameters): void;
}

// @public
export interface TextureCopyPassParameters {
    readonly destination: RenderGraphTextureHandle;
    readonly source: RenderGraphTextureHandle;
}

// @public
export type TextureCubeFace = 0 | 1 | 2 | 3 | 4 | 5;

// @public (undocumented)
export type TextureImageSource = HTMLImageElement | HTMLCanvasElement | ImageBitmap | ImageData | OffscreenCanvas | HTMLVideoElement | TexturePixelData;

// @public (undocumented)
export class TextureLoader {
    // (undocumented)
    readonly className = "TextureLoader";
    // (undocumented)
    readonly isTextureLoader = true;
    // (undocumented)
    load(params: TextureLoadRequest): Promise<Texture<HTMLImageElement>>;
}

// @public (undocumented)
export type TextureLoadRequest = BasicLoadRequest & Omit<TextureParameters<HTMLImageElement>, 'image' | 'type'> & {
    src: string;
};

// @public
export interface TextureMipmap {
    // (undocumented)
    data: TexturePixelData;
    depth?: number;
    face?: TextureCubeFace;
    // (undocumented)
    height: number;
    // (undocumented)
    width: number;
}

// @public (undocumented)
class TextureOptionBuilder {
    // (undocumented)
    add(texture: unknown, optionName: string, callback?: () => void): this;
    // (undocumented)
    reset(option: ShaderOptions): this;
    // (undocumented)
    update(): this;
}

// @public (undocumented)
export interface TextureParameters<Image = TextureImageSource> {
    // (undocumented)
    anisotropic?: number;
    // (undocumented)
    autoUpdate?: boolean;
    // (undocumented)
    compressed?: boolean;
    depth?: number;
    // (undocumented)
    flipY?: boolean;
    // (undocumented)
    format?: GLenum;
    // (undocumented)
    height?: number;
    // (undocumented)
    image?: Image | null;
    // (undocumented)
    internalFormat?: GLenum;
    // (undocumented)
    isImageCanRelease?: boolean;
    // (undocumented)
    magFilter?: GLenum;
    // (undocumented)
    minFilter?: GLenum;
    // (undocumented)
    mipmaps?: TextureMipmap[] | null;
    // (undocumented)
    name?: string;
    // (undocumented)
    needDestroy?: boolean;
    // (undocumented)
    needUpdate?: boolean;
    // (undocumented)
    premultiplyAlpha?: boolean;
    // (undocumented)
    target?: GLenum;
    // (undocumented)
    type?: GLenum;
    // (undocumented)
    uv?: TextureUVChannel;
    // (undocumented)
    width?: number;
    wrapR?: GLenum;
    // (undocumented)
    wrapS?: GLenum;
    // (undocumented)
    wrapT?: GLenum;
}

// @public
export type TexturePixelData = TypedArray | DataView;

// @public (undocumented)
export type TextureSource = TexImageSource | TexturePixelData;

// @public
export interface TextureSubImage {
    readonly depth?: number;
    readonly face?: TextureCubeFace;
    readonly height: number;
    readonly image: TextureSource;
    readonly layer?: number;
    readonly mipLevel: number;
    readonly width: number;
    readonly x: number;
    readonly y: number;
    readonly z?: number;
}

// @public
export interface TextureUpdateSnapshot {
    readonly requiresFullUpload: boolean;
    readonly revision: number;
    readonly subTextures: readonly TextureSubImage[];
}

// @public (undocumented)
export type TextureUVChannel = 0 | 1;

// @public (undocumented)
export interface Tickable {
    // (undocumented)
    tick(deltaTime: number): void;
}

// @public
export class Ticker {
    constructor(fps?: number);
    // (undocumented)
    addTick(tickObject: Tickable): void;
    // (undocumented)
    getMeasuredFPS(): number;
    // (undocumented)
    interval(callback: () => void, duration: number): Tickable;
    // (undocumented)
    nextTick(callback: (deltaTime: number) => void): Tickable;
    // (undocumented)
    pause(): void;
    // (undocumented)
    removeTick(tickObject: Tickable): void;
    // (undocumented)
    resume(): void;
    // (undocumented)
    start(): void;
    // (undocumented)
    stop(): void;
    // (undocumented)
    get targetFPS(): number;
    set targetFPS(value: number);
    // (undocumented)
    timeout(callback: () => void, duration: number): Tickable;
}

// @public (undocumented)
export type Triangle = readonly [ArrayLike<number>, ArrayLike<number>, ArrayLike<number>];

// @public
export class Tween {
    constructor(target: object, toProperties: TweenProperties, params?: TweenParameters);
    constructor(target: object, fromProperties: TweenProperties | null, toProperties: TweenProperties, params?: TweenParameters);
    // (undocumented)
    static add(tween: Tween): typeof Tween;
    // (undocumented)
    delay: number | string;
    // (undocumented)
    duration: number;
    // (undocumented)
    static readonly Ease: TweenEaseCollection;
    // (undocumented)
    ease: TweenEaseFunction | null;
    // (undocumented)
    static from(target: object, fromProperties: TweenProperties, params?: TweenParameters): Tween;
    // (undocumented)
    static from(target: readonly object[], fromProperties: TweenProperties, params?: TweenParameters): Tween[];
    // (undocumented)
    static fromTo(target: object, fromProperties: TweenProperties | null, toProperties: TweenProperties, params?: TweenParameters): Tween;
    // (undocumented)
    static fromTo(target: readonly object[], fromProperties: TweenProperties | null, toProperties: TweenProperties, params?: TweenParameters): Tween[];
    // (undocumented)
    isComplete: boolean;
    // (undocumented)
    isStart: boolean;
    // (undocumented)
    link(tween: Tween): Tween;
    // (undocumented)
    loop: boolean;
    // (undocumented)
    onComplete: TweenCompleteCallback | null;
    // (undocumented)
    onStart: TweenStartCallback | null;
    // (undocumented)
    onUpdate: TweenUpdateCallback | null;
    // (undocumented)
    pause(): this;
    // (undocumented)
    paused: boolean;
    // (undocumented)
    static remove(tweenOrTarget: Tween | object | readonly (Tween | object)[]): typeof Tween;
    // (undocumented)
    static removeAll(): typeof Tween;
    // (undocumented)
    repeat: number;
    // (undocumented)
    repeatDelay: number;
    // (undocumented)
    resume(): this;
    // (undocumented)
    reverse: boolean;
    // (undocumented)
    seek(time: number, pause?: boolean): this;
    // (undocumented)
    setProps(fromProperties?: TweenProperties | null, toProperties?: TweenProperties | null): this;
    // (undocumented)
    start(): this;
    // (undocumented)
    stop(): this;
    // (undocumented)
    readonly target: object;
    // (undocumented)
    static tick(): typeof Tween;
    // (undocumented)
    time: number;
    // (undocumented)
    static to(target: object, toProperties: TweenProperties, params?: TweenParameters): Tween;
    // (undocumented)
    static to(target: readonly object[], toProperties: TweenProperties, params?: TweenParameters): Tween[];
    // (undocumented)
    static readonly _tweens: Tween[];
}

// @public (undocumented)
export type TweenCompleteCallback = (this: Tween, tween: Tween) => void;

// @public (undocumented)
export interface TweenEaseCollection {
    // (undocumented)
    Back: BackEaseObject;
    // (undocumented)
    Bounce: TweenEaseObject;
    // (undocumented)
    Circ: TweenEaseObject;
    // (undocumented)
    Cubic: TweenEaseObject;
    // (undocumented)
    Elastic: ElasticEaseObject;
    // (undocumented)
    Expo: TweenEaseObject;
    // (undocumented)
    Linear: TweenEaseNoneObject;
    // (undocumented)
    Quad: TweenEaseObject;
    // (undocumented)
    Quart: TweenEaseObject;
    // (undocumented)
    Quint: TweenEaseObject;
    // (undocumented)
    Sine: TweenEaseObject;
}

// @public (undocumented)
export type TweenEaseFunction = (ratio: number) => number;

// @public (undocumented)
export interface TweenEaseNoneObject {
    // (undocumented)
    EaseNone: TweenEaseFunction;
}

// @public (undocumented)
export interface TweenEaseObject {
    // (undocumented)
    EaseIn: TweenEaseFunction;
    // (undocumented)
    EaseInOut: TweenEaseFunction;
    // (undocumented)
    EaseOut: TweenEaseFunction;
}

// @public (undocumented)
export interface TweenParameters {
    // (undocumented)
    delay?: number | string;
    // (undocumented)
    duration?: number;
    // (undocumented)
    ease?: TweenEaseFunction | null;
    // (undocumented)
    loop?: boolean;
    // (undocumented)
    onComplete?: TweenCompleteCallback | null;
    // (undocumented)
    onStart?: TweenStartCallback | null;
    // (undocumented)
    onUpdate?: TweenUpdateCallback | null;
    // (undocumented)
    paused?: boolean;
    // (undocumented)
    repeat?: number;
    // (undocumented)
    repeatDelay?: number;
    // (undocumented)
    reverse?: boolean;
    // (undocumented)
    stagger?: number;
    // (undocumented)
    time?: number;
}

// @public (undocumented)
export type TweenProperties = Readonly<Record<string, number>>;

// @public (undocumented)
export type TweenStartCallback = (this: Tween, tween: Tween) => void;

// @public (undocumented)
export type TweenUpdateCallback = (this: Tween, ratio: number, tween: Tween) => void;

// @public (undocumented)
export type TypedArray = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array;

// @public (undocumented)
export interface TypedArrayConstructor {
    // (undocumented)
    new (values: number | ArrayLike<number>): TypedArray;
    // (undocumented)
    readonly BYTES_PER_ELEMENT: number;
}

// @public (undocumented)
export const UNIFORM_BLOCK_BINDINGS: Readonly<{
    readonly FrameBlock: 0;
    readonly CameraBlock: 1;
    readonly SceneBlock: 2;
    readonly LightBlock: 3;
    readonly MaterialBlock: 4;
    readonly ModelBlock: 5;
    readonly GeometryBlock: 6;
    readonly SkinningBlock: 7;
    readonly MorphBlock: 8;
}>;

// @public
export class UniformBuffer<Schema extends Std140Schema = Std140Schema> {
    constructor(layout: Std140Layout<Schema>, values?: Partial<Std140Values<Schema>>);
    // (undocumented)
    get byteLength(): number;
    // (undocumented)
    readonly className = "UniformBuffer";
    get data(): ArrayBuffer;
    set data(data: ArrayBuffer);
    // (undocumented)
    static fromSchema<const Schema extends Std140Schema>(layout: Std140Layout<Schema>, values?: Partial<Std140Values<Schema>>): UniformBuffer<Schema>;
    getDirtyRangesSince(revision: number): readonly UniformBufferDirtyRange[] | null;
    // @internal
    getDirtySpanSince(revision: number, result: {
        byteOffset: number;
        byteLength: number;
    }): boolean;
    // (undocumented)
    readonly isUniformBuffer = true;
    // (undocumented)
    readonly layout: Std140Layout<Schema>;
    markDirty(byteOffset?: number, byteLength?: number): this;
    // (undocumented)
    range(byteOffset: number, byteLength: number): UniformBufferRange;
    get revision(): number;
    set<Name extends keyof Schema & string>(name: Name, value: Std140FieldValue<Schema[Name]>): this;
    write(byteOffset: number, data: TypedArray): this;
}

// @public
export interface UniformBufferDirtyRange {
    // (undocumented)
    readonly byteLength: number;
    // (undocumented)
    readonly byteOffset: number;
    // (undocumented)
    readonly revision: number;
}

// @public (undocumented)
export interface UniformBufferRange {
    // (undocumented)
    readonly byteLength: number;
    // (undocumented)
    readonly byteOffset: number;
    // (undocumented)
    readonly uniformBuffer: UniformBuffer;
}

// @public (undocumented)
export namespace util {
    export { util_d_convertUint8ArrayToString as convertUint8ArrayToString, util_d_copyArrayData as copyArrayData, util_d_each as each, util_d_getBlobUrl as getBlobUrl, util_d_getElementRect as getElementRect, util_d_getExtension as getExtension, util_d_getIndexFromSortedArray as getIndexFromSortedArray, util_d_getRelativePath as getRelativePath, util_d_getTypedArrayClass as getTypedArrayClass, util_d_getTypedArrayGLType as getTypedArrayGLType, util_d_hasOwnProperty as hasOwnProperty, util_d_insertToSortedArray as insertToSortedArray, util_d_isArrayLike as isArrayLike, util_d_isBlobUrl as isBlobUrl, util_d_isStrOrNumber as isStrOrNumber, util_d_padLeft as padLeft, util_d_revokeBlobUrl as revokeBlobUrl, util_d_serialRun as serialRun };
    export export type { util_d_GeometryDataLike as GeometryDataLike, util_d_MutableArrayLike as MutableArrayLike, util_d_TypedArray as TypedArray, util_d_TypedArrayConstructor as TypedArrayConstructor };
}

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

// @public
export class Vector2 {
    constructor(x?: number, y?: number);
    add(a: Vector2, b?: Vector2): this;
    ceil(): this;
    className: string;
    clone(): Vector2;
    copy(v: Vector2): this;
    cross(a: Vector2, b?: Vector2): this;
    // (undocumented)
    dist(a: Vector2, b?: Vector2): number;
    distance(a: Vector2, b?: Vector2): number;
    // (undocumented)
    div(a: Vector2, b?: Vector2): this;
    divide(a: Vector2, b?: Vector2): this;
    dot(a: Vector2, b?: Vector2): number;
    // (undocumented)
    elements: vec2;
    equals(a: Vector2, b?: Vector2): boolean;
    exactEquals(a: Vector2, b?: Vector2): boolean;
    floor(): this;
    fromArray(array: ArrayLike<number>, offset?: number): this;
    inverse(a?: Vector2): this;
    // (undocumented)
    isVector2: boolean;
    // (undocumented)
    len(): number;
    length(): number;
    lerp(v: Vector2, t: number): this;
    max(a: Vector2, b?: Vector2): this;
    min(a: Vector2, b?: Vector2): this;
    // (undocumented)
    mul(a: Vector2, b?: Vector2): this;
    multiply(a: Vector2, b?: Vector2): this;
    negate(): this;
    normalize(): this;
    random(scale?: number): this;
    round(): this;
    scale(scale: number): this;
    scaleAndAdd(scale: number, a: Vector2, b?: Vector2): this;
    set(x: number, y: number): this;
    // (undocumented)
    sqrDist(a: Vector2, b?: Vector2): number;
    // (undocumented)
    sqrLen(): number;
    squaredDistance(a: Vector2, b?: Vector2): number;
    squaredLength(): number;
    // (undocumented)
    sub(a: Vector2, b?: Vector2): this;
    subtract(a: Vector2, b?: Vector2): this;
    toArray(array?: MutableNumberArray, offset?: number): MutableNumberArray;
    transformMat3(m: Matrix3): this;
    transformMat4(m: Matrix4): this;
    get x(): number;
    set x(value: number);
    get y(): number;
    set y(value: number);
}

// @public
export class Vector3 {
    constructor(x?: number, y?: number, z?: number);
    add(a: Vector3, b?: Vector3): this;
    bezier(a: Vector3, b: Vector3, c: Vector3, d: Vector3, t: number): this;
    ceil(): this;
    className: string;
    clone(): Vector3;
    copy(v: Vector3): this;
    cross(a: Vector3, b?: Vector3): this;
    // (undocumented)
    dist(a: Vector3, b?: Vector3): number;
    distance(a: Vector3, b?: Vector3): number;
    // (undocumented)
    div(a: Vector3, b?: Vector3): this;
    divide(a: Vector3, b?: Vector3): this;
    dot(a: Vector3, b?: Vector3): number;
    // (undocumented)
    elements: vec3;
    equals(a: Vector3, b?: Vector3): boolean;
    exactEquals(a: Vector3, b?: Vector3): boolean;
    floor(): this;
    fromArray(array: ArrayLike<number>, offset?: number): this;
    hermite(a: Vector3, b: Vector3, c: Vector3, d: Vector3, t: number): this;
    inverse(a?: Vector3): this;
    // (undocumented)
    isVector3: boolean;
    // (undocumented)
    len(): number;
    length(): number;
    lerp(v: Vector3, t: number): this;
    max(a: Vector3, b?: Vector3): this;
    min(a: Vector3, b?: Vector3): this;
    // (undocumented)
    mul(a: Vector3, b?: Vector3): this;
    multiply(a: Vector3, b?: Vector3): this;
    negate(): this;
    normalize(): this;
    random(scale?: number): this;
    rotateX(origin: Vector3, rotation: number): this;
    rotateY(origin: Vector3, rotation: number): this;
    rotateZ(origin: Vector3, rotation: number): this;
    round(): this;
    scale(scale: number): this;
    scaleAndAdd(scale: number, a: Vector3, b?: Vector3): this;
    set(x: number, y: number, z: number): this;
    // (undocumented)
    sqrDist(a: Vector3, b?: Vector3): number;
    // (undocumented)
    sqrLen(): number;
    squaredDistance(a: Vector3, b?: Vector3): number;
    squaredLength(): number;
    // (undocumented)
    sub(a: Vector3, b?: Vector3): this;
    subtract(a: Vector3, b?: Vector3): this;
    toArray(array?: MutableNumberArray, offset?: number): MutableNumberArray;
    transformDirection(m: Matrix4): this;
    transformMat3(m: Matrix3): this;
    transformMat4(m: Matrix4): this;
    transformQuat(q: Quaternion): this;
    get x(): number;
    set x(value: number);
    get y(): number;
    set y(value: number);
    get z(): number;
    set z(value: number);
}

// @public
export class Vector3Notifier extends Vector3 {
    constructor(x?: number, y?: number, z?: number);
    add(a: Vector3, b?: Vector3): this;
    bezier(a: Vector3, b: Vector3, c: Vector3, d: Vector3, t: number): this;
    ceil(): this;
    className: string;
    clone(): Vector3;
    copy(v: Vector3): this;
    cross(a: Vector3, b?: Vector3): this;
    distance(a: Vector3, b?: Vector3): number;
    divide(a: Vector3, b?: Vector3): this;
    dot(a: Vector3, b?: Vector3): number;
    equals(a: Vector3, b?: Vector3): boolean;
    exactEquals(a: Vector3, b?: Vector3): boolean;
    floor(): this;
    fromArray(array: ArrayLike<number>, offset?: number): this;
    hermite(a: Vector3, b: Vector3, c: Vector3, d: Vector3, t: number): this;
    inverse(a?: Vector3): this;
    // (undocumented)
    isVector3Notifier: boolean;
    length(): number;
    lerp(v: Vector3, t: number): this;
    max(a: Vector3, b?: Vector3): this;
    min(a: Vector3, b?: Vector3): this;
    multiply(a: Vector3, b?: Vector3): this;
    negate(): this;
    normalize(): this;
    onUpdate(): void;
    random(scale?: number): this;
    rotateX(origin: Vector3, rotation: number): this;
    rotateY(origin: Vector3, rotation: number): this;
    rotateZ(origin: Vector3, rotation: number): this;
    round(): this;
    scale(scale: number): this;
    scaleAndAdd(scale: number, a: Vector3, b?: Vector3): this;
    set(x: number, y: number, z: number): this;
    squaredDistance(a: Vector3, b?: Vector3): number;
    squaredLength(): number;
    subtract(a: Vector3, b?: Vector3): this;
    toArray(array?: MutableNumberArray, offset?: number): MutableNumberArray;
    transformDirection(m: Matrix4): this;
    transformMat3(m: Matrix3): this;
    transformMat4(m: Matrix4): this;
    transformQuat(q: Quaternion): this;
    get x(): number;
    set x(value: number);
    get y(): number;
    set y(value: number);
    get z(): number;
    set z(value: number);
}

// @public
export class Vector4 {
    constructor(x?: number, y?: number, z?: number, w?: number);
    add(a: Vector4, b?: Vector4): this;
    ceil(): this;
    className: string;
    clone(): Vector4;
    copy(v: Vector4): this;
    // (undocumented)
    dist(a: Vector4, b?: Vector4): number;
    distance(a: Vector4, b?: Vector4): number;
    // (undocumented)
    div(a: Vector4, b?: Vector4): this;
    divide(a: Vector4, b?: Vector4): this;
    dot(a: Vector4, b?: Vector4): number;
    // (undocumented)
    elements: vec4;
    equals(a: Vector4, b?: Vector4): boolean;
    exactEquals(a: Vector4, b?: Vector4): boolean;
    floor(): this;
    fromArray(array: ArrayLike<number>, offset?: number): this;
    inverse(a?: Vector4): this;
    // (undocumented)
    isVector4: boolean;
    // (undocumented)
    len(): number;
    length(): number;
    lerp(v: Vector4, t: number): this;
    max(a: Vector4, b?: Vector4): this;
    min(a: Vector4, b?: Vector4): this;
    // (undocumented)
    mul(a: Vector4, b?: Vector4): this;
    multiply(a: Vector4, b?: Vector4): this;
    negate(): this;
    normalize(): this;
    random(scale?: number): this;
    round(): this;
    scale(scale: number): this;
    scaleAndAdd(scale: number, a: Vector4, b?: Vector4): this;
    set(x: number, y: number, z: number, w: number): this;
    // (undocumented)
    sqrDist(a: Vector4, b?: Vector4): number;
    // (undocumented)
    sqrLen(): number;
    squaredDistance(a: Vector4, b?: Vector4): number;
    squaredLength(): number;
    // (undocumented)
    sub(a: Vector4, b?: Vector4): this;
    subtract(a: Vector4, b?: Vector4): this;
    toArray(array?: MutableNumberArray, offset?: number): MutableNumberArray;
    transformMat4(m: Matrix4): this;
    transformQuat(q: Quaternion): this;
    get w(): number;
    set w(value: number);
    get x(): number;
    set x(value: number);
    get y(): number;
    set y(value: number);
    get z(): number;
    set z(value: number);
}

// @public (undocumented)
export const version: string;

// @public (undocumented)
export namespace webgl2Constants {
    export {
        webgl2_ACTIVE_UNIFORM_BLOCKS as ACTIVE_UNIFORM_BLOCKS,
        webgl2_ALREADY_SIGNALED as ALREADY_SIGNALED,
        webgl2_ANY_SAMPLES_PASSED as ANY_SAMPLES_PASSED,
        webgl2_ANY_SAMPLES_PASSED_CONSERVATIVE as ANY_SAMPLES_PASSED_CONSERVATIVE,
        webgl2_COLOR as COLOR,
        webgl2_COLOR_ATTACHMENT1 as COLOR_ATTACHMENT1,
        webgl2_COLOR_ATTACHMENT10 as COLOR_ATTACHMENT10,
        webgl2_COLOR_ATTACHMENT11 as COLOR_ATTACHMENT11,
        webgl2_COLOR_ATTACHMENT12 as COLOR_ATTACHMENT12,
        webgl2_COLOR_ATTACHMENT13 as COLOR_ATTACHMENT13,
        webgl2_COLOR_ATTACHMENT14 as COLOR_ATTACHMENT14,
        webgl2_COLOR_ATTACHMENT15 as COLOR_ATTACHMENT15,
        webgl2_COLOR_ATTACHMENT2 as COLOR_ATTACHMENT2,
        webgl2_COLOR_ATTACHMENT3 as COLOR_ATTACHMENT3,
        webgl2_COLOR_ATTACHMENT4 as COLOR_ATTACHMENT4,
        webgl2_COLOR_ATTACHMENT5 as COLOR_ATTACHMENT5,
        webgl2_COLOR_ATTACHMENT6 as COLOR_ATTACHMENT6,
        webgl2_COLOR_ATTACHMENT7 as COLOR_ATTACHMENT7,
        webgl2_COLOR_ATTACHMENT8 as COLOR_ATTACHMENT8,
        webgl2_COLOR_ATTACHMENT9 as COLOR_ATTACHMENT9,
        webgl2_COMPARE_REF_TO_TEXTURE as COMPARE_REF_TO_TEXTURE,
        webgl2_COMPRESSED_R11_EAC as COMPRESSED_R11_EAC,
        webgl2_COMPRESSED_RG11_EAC as COMPRESSED_RG11_EAC,
        webgl2_COMPRESSED_RGB8_ETC2 as COMPRESSED_RGB8_ETC2,
        webgl2_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 as COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2,
        webgl2_COMPRESSED_RGBA8_ETC2_EAC as COMPRESSED_RGBA8_ETC2_EAC,
        webgl2_COMPRESSED_SIGNED_R11_EAC as COMPRESSED_SIGNED_R11_EAC,
        webgl2_COMPRESSED_SIGNED_RG11_EAC as COMPRESSED_SIGNED_RG11_EAC,
        webgl2_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC as COMPRESSED_SRGB8_ALPHA8_ETC2_EAC,
        webgl2_COMPRESSED_SRGB8_ETC2 as COMPRESSED_SRGB8_ETC2,
        webgl2_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 as COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2,
        webgl2_CONDITION_SATISFIED as CONDITION_SATISFIED,
        webgl2_COPY_READ_BUFFER as COPY_READ_BUFFER,
        webgl2_COPY_READ_BUFFER_BINDING as COPY_READ_BUFFER_BINDING,
        webgl2_COPY_WRITE_BUFFER as COPY_WRITE_BUFFER,
        webgl2_COPY_WRITE_BUFFER_BINDING as COPY_WRITE_BUFFER_BINDING,
        webgl2_DEPTH as DEPTH,
        webgl2_DEPTH24_STENCIL8 as DEPTH24_STENCIL8,
        webgl2_DEPTH32F_STENCIL8 as DEPTH32F_STENCIL8,
        webgl2_DEPTH_COMPONENT24 as DEPTH_COMPONENT24,
        webgl2_DEPTH_COMPONENT32F as DEPTH_COMPONENT32F,
        webgl2_DEPTH_STENCIL as DEPTH_STENCIL,
        webgl2_DEPTH_STENCIL_ATTACHMENT as DEPTH_STENCIL_ATTACHMENT,
        webgl2_DRAW_BUFFER0 as DRAW_BUFFER0,
        webgl2_DRAW_BUFFER1 as DRAW_BUFFER1,
        webgl2_DRAW_BUFFER10 as DRAW_BUFFER10,
        webgl2_DRAW_BUFFER11 as DRAW_BUFFER11,
        webgl2_DRAW_BUFFER12 as DRAW_BUFFER12,
        webgl2_DRAW_BUFFER13 as DRAW_BUFFER13,
        webgl2_DRAW_BUFFER14 as DRAW_BUFFER14,
        webgl2_DRAW_BUFFER15 as DRAW_BUFFER15,
        webgl2_DRAW_BUFFER2 as DRAW_BUFFER2,
        webgl2_DRAW_BUFFER3 as DRAW_BUFFER3,
        webgl2_DRAW_BUFFER4 as DRAW_BUFFER4,
        webgl2_DRAW_BUFFER5 as DRAW_BUFFER5,
        webgl2_DRAW_BUFFER6 as DRAW_BUFFER6,
        webgl2_DRAW_BUFFER7 as DRAW_BUFFER7,
        webgl2_DRAW_BUFFER8 as DRAW_BUFFER8,
        webgl2_DRAW_BUFFER9 as DRAW_BUFFER9,
        webgl2_DRAW_FRAMEBUFFER as DRAW_FRAMEBUFFER,
        webgl2_DRAW_FRAMEBUFFER_BINDING as DRAW_FRAMEBUFFER_BINDING,
        webgl2_DYNAMIC_COPY as DYNAMIC_COPY,
        webgl2_DYNAMIC_READ as DYNAMIC_READ,
        webgl2_FLOAT_32_UNSIGNED_INT_24_8_REV as FLOAT_32_UNSIGNED_INT_24_8_REV,
        webgl2_FLOAT_MAT2x3 as FLOAT_MAT2x3,
        webgl2_FLOAT_MAT2x4 as FLOAT_MAT2x4,
        webgl2_FLOAT_MAT3x2 as FLOAT_MAT3x2,
        webgl2_FLOAT_MAT3x4 as FLOAT_MAT3x4,
        webgl2_FLOAT_MAT4x2 as FLOAT_MAT4x2,
        webgl2_FLOAT_MAT4x3 as FLOAT_MAT4x3,
        webgl2_FRAGMENT_SHADER_DERIVATIVE_HINT as FRAGMENT_SHADER_DERIVATIVE_HINT,
        webgl2_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE as FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE,
        webgl2_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE as FRAMEBUFFER_ATTACHMENT_BLUE_SIZE,
        webgl2_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING as FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING,
        webgl2_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE as FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE,
        webgl2_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE as FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE,
        webgl2_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE as FRAMEBUFFER_ATTACHMENT_GREEN_SIZE,
        webgl2_FRAMEBUFFER_ATTACHMENT_RED_SIZE as FRAMEBUFFER_ATTACHMENT_RED_SIZE,
        webgl2_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE as FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE,
        webgl2_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER as FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER,
        webgl2_FRAMEBUFFER_DEFAULT as FRAMEBUFFER_DEFAULT,
        webgl2_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE as FRAMEBUFFER_INCOMPLETE_MULTISAMPLE,
        webgl2_HALF_FLOAT as HALF_FLOAT,
        webgl2_INTERLEAVED_ATTRIBS as INTERLEAVED_ATTRIBS,
        webgl2_INT_2_10_10_10_REV as INT_2_10_10_10_REV,
        webgl2_INT_SAMPLER_2D as INT_SAMPLER_2D,
        webgl2_INT_SAMPLER_2D_ARRAY as INT_SAMPLER_2D_ARRAY,
        webgl2_INT_SAMPLER_3D as INT_SAMPLER_3D,
        webgl2_INT_SAMPLER_CUBE as INT_SAMPLER_CUBE,
        webgl2_INVALID_INDEX as INVALID_INDEX,
        webgl2_MAX as MAX,
        webgl2_MAX_3D_TEXTURE_SIZE as MAX_3D_TEXTURE_SIZE,
        webgl2_MAX_ARRAY_TEXTURE_LAYERS as MAX_ARRAY_TEXTURE_LAYERS,
        webgl2_MAX_CLIENT_WAIT_TIMEOUT_WEBGL as MAX_CLIENT_WAIT_TIMEOUT_WEBGL,
        webgl2_MAX_COLOR_ATTACHMENTS as MAX_COLOR_ATTACHMENTS,
        webgl2_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS as MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS,
        webgl2_MAX_COMBINED_UNIFORM_BLOCKS as MAX_COMBINED_UNIFORM_BLOCKS,
        webgl2_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS as MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS,
        webgl2_MAX_DRAW_BUFFERS as MAX_DRAW_BUFFERS,
        webgl2_MAX_ELEMENTS_INDICES as MAX_ELEMENTS_INDICES,
        webgl2_MAX_ELEMENTS_VERTICES as MAX_ELEMENTS_VERTICES,
        webgl2_MAX_ELEMENT_INDEX as MAX_ELEMENT_INDEX,
        webgl2_MAX_FRAGMENT_INPUT_COMPONENTS as MAX_FRAGMENT_INPUT_COMPONENTS,
        webgl2_MAX_FRAGMENT_UNIFORM_BLOCKS as MAX_FRAGMENT_UNIFORM_BLOCKS,
        webgl2_MAX_FRAGMENT_UNIFORM_COMPONENTS as MAX_FRAGMENT_UNIFORM_COMPONENTS,
        webgl2_MAX_PROGRAM_TEXEL_OFFSET as MAX_PROGRAM_TEXEL_OFFSET,
        webgl2_MAX_SAMPLES as MAX_SAMPLES,
        webgl2_MAX_SERVER_WAIT_TIMEOUT as MAX_SERVER_WAIT_TIMEOUT,
        webgl2_MAX_TEXTURE_LOD_BIAS as MAX_TEXTURE_LOD_BIAS,
        webgl2_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS as MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS,
        webgl2_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS as MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS,
        webgl2_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS as MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS,
        webgl2_MAX_UNIFORM_BLOCK_SIZE as MAX_UNIFORM_BLOCK_SIZE,
        webgl2_MAX_UNIFORM_BUFFER_BINDINGS as MAX_UNIFORM_BUFFER_BINDINGS,
        webgl2_MAX_VARYING_COMPONENTS as MAX_VARYING_COMPONENTS,
        webgl2_MAX_VERTEX_OUTPUT_COMPONENTS as MAX_VERTEX_OUTPUT_COMPONENTS,
        webgl2_MAX_VERTEX_UNIFORM_BLOCKS as MAX_VERTEX_UNIFORM_BLOCKS,
        webgl2_MAX_VERTEX_UNIFORM_COMPONENTS as MAX_VERTEX_UNIFORM_COMPONENTS,
        webgl2_MIN as MIN,
        webgl2_MIN_PROGRAM_TEXEL_OFFSET as MIN_PROGRAM_TEXEL_OFFSET,
        webgl2_OBJECT_TYPE as OBJECT_TYPE,
        webgl2_PACK_ROW_LENGTH as PACK_ROW_LENGTH,
        webgl2_PACK_SKIP_PIXELS as PACK_SKIP_PIXELS,
        webgl2_PACK_SKIP_ROWS as PACK_SKIP_ROWS,
        webgl2_PIXEL_PACK_BUFFER as PIXEL_PACK_BUFFER,
        webgl2_PIXEL_PACK_BUFFER_BINDING as PIXEL_PACK_BUFFER_BINDING,
        webgl2_PIXEL_UNPACK_BUFFER as PIXEL_UNPACK_BUFFER,
        webgl2_PIXEL_UNPACK_BUFFER_BINDING as PIXEL_UNPACK_BUFFER_BINDING,
        webgl2_QUERY_RESULT as QUERY_RESULT,
        webgl2_QUERY_RESULT_AVAILABLE as QUERY_RESULT_AVAILABLE,
        webgl2_R11F_G11F_B10F as R11F_G11F_B10F,
        webgl2_R16F as R16F,
        webgl2_R16I as R16I,
        webgl2_R16UI as R16UI,
        webgl2_R32F as R32F,
        webgl2_R32I as R32I,
        webgl2_R32UI as R32UI,
        webgl2_R8 as R8,
        webgl2_R8I as R8I,
        webgl2_R8UI as R8UI,
        webgl2_R8_SNORM as R8_SNORM,
        webgl2_RASTERIZER_DISCARD as RASTERIZER_DISCARD,
        webgl2_READ_BUFFER as READ_BUFFER,
        webgl2_READ_FRAMEBUFFER as READ_FRAMEBUFFER,
        webgl2_READ_FRAMEBUFFER_BINDING as READ_FRAMEBUFFER_BINDING,
        webgl2_RED as RED,
        webgl2_RED_INTEGER as RED_INTEGER,
        webgl2_RENDERBUFFER_SAMPLES as RENDERBUFFER_SAMPLES,
        webgl2_RG as RG,
        webgl2_RG16F as RG16F,
        webgl2_RG16I as RG16I,
        webgl2_RG16UI as RG16UI,
        webgl2_RG32F as RG32F,
        webgl2_RG32I as RG32I,
        webgl2_RG32UI as RG32UI,
        webgl2_RG8 as RG8,
        webgl2_RG8I as RG8I,
        webgl2_RG8UI as RG8UI,
        webgl2_RG8_SNORM as RG8_SNORM,
        webgl2_RGB10_A2 as RGB10_A2,
        webgl2_RGB10_A2UI as RGB10_A2UI,
        webgl2_RGB16F as RGB16F,
        webgl2_RGB16I as RGB16I,
        webgl2_RGB16UI as RGB16UI,
        webgl2_RGB32F as RGB32F,
        webgl2_RGB32I as RGB32I,
        webgl2_RGB32UI as RGB32UI,
        webgl2_RGB8 as RGB8,
        webgl2_RGB8I as RGB8I,
        webgl2_RGB8UI as RGB8UI,
        webgl2_RGB8_SNORM as RGB8_SNORM,
        webgl2_RGB9_E5 as RGB9_E5,
        webgl2_RGBA16F as RGBA16F,
        webgl2_RGBA16I as RGBA16I,
        webgl2_RGBA16UI as RGBA16UI,
        webgl2_RGBA32F as RGBA32F,
        webgl2_RGBA32I as RGBA32I,
        webgl2_RGBA32UI as RGBA32UI,
        webgl2_RGBA8 as RGBA8,
        webgl2_RGBA8I as RGBA8I,
        webgl2_RGBA8UI as RGBA8UI,
        webgl2_RGBA8_SNORM as RGBA8_SNORM,
        webgl2_RGBA_INTEGER as RGBA_INTEGER,
        webgl2_RGB_INTEGER as RGB_INTEGER,
        webgl2_RG_INTEGER as RG_INTEGER,
        webgl2_SAMPLER_2D_ARRAY as SAMPLER_2D_ARRAY,
        webgl2_SAMPLER_2D_ARRAY_SHADOW as SAMPLER_2D_ARRAY_SHADOW,
        webgl2_SAMPLER_2D_SHADOW as SAMPLER_2D_SHADOW,
        webgl2_SAMPLER_3D as SAMPLER_3D,
        webgl2_SAMPLER_BINDING as SAMPLER_BINDING,
        webgl2_SAMPLER_CUBE_SHADOW as SAMPLER_CUBE_SHADOW,
        webgl2_SEPARATE_ATTRIBS as SEPARATE_ATTRIBS,
        webgl2_SIGNALED as SIGNALED,
        webgl2_SIGNED_NORMALIZED as SIGNED_NORMALIZED,
        webgl2_SRGB as SRGB,
        webgl2_SRGB8 as SRGB8,
        webgl2_SRGB8_ALPHA8 as SRGB8_ALPHA8,
        webgl2_STATIC_COPY as STATIC_COPY,
        webgl2_STATIC_READ as STATIC_READ,
        webgl2_STENCIL as STENCIL,
        webgl2_STREAM_COPY as STREAM_COPY,
        webgl2_STREAM_READ as STREAM_READ,
        webgl2_SYNC_CONDITION as SYNC_CONDITION,
        webgl2_SYNC_FENCE as SYNC_FENCE,
        webgl2_SYNC_FLAGS as SYNC_FLAGS,
        webgl2_SYNC_FLUSH_COMMANDS_BIT as SYNC_FLUSH_COMMANDS_BIT,
        webgl2_SYNC_GPU_COMMANDS_COMPLETE as SYNC_GPU_COMMANDS_COMPLETE,
        webgl2_SYNC_STATUS as SYNC_STATUS,
        webgl2_TEXTURE_2D_ARRAY as TEXTURE_2D_ARRAY,
        webgl2_TEXTURE_3D as TEXTURE_3D,
        webgl2_TEXTURE_BASE_LEVEL as TEXTURE_BASE_LEVEL,
        webgl2_TEXTURE_BINDING_2D_ARRAY as TEXTURE_BINDING_2D_ARRAY,
        webgl2_TEXTURE_BINDING_3D as TEXTURE_BINDING_3D,
        webgl2_TEXTURE_COMPARE_FUNC as TEXTURE_COMPARE_FUNC,
        webgl2_TEXTURE_COMPARE_MODE as TEXTURE_COMPARE_MODE,
        webgl2_TEXTURE_IMMUTABLE_FORMAT as TEXTURE_IMMUTABLE_FORMAT,
        webgl2_TEXTURE_IMMUTABLE_LEVELS as TEXTURE_IMMUTABLE_LEVELS,
        webgl2_TEXTURE_MAX_LEVEL as TEXTURE_MAX_LEVEL,
        webgl2_TEXTURE_MAX_LOD as TEXTURE_MAX_LOD,
        webgl2_TEXTURE_MIN_LOD as TEXTURE_MIN_LOD,
        webgl2_TEXTURE_WRAP_R as TEXTURE_WRAP_R,
        webgl2_TIMEOUT_EXPIRED as TIMEOUT_EXPIRED,
        webgl2_TIMEOUT_IGNO as TIMEOUT_IGNO,
        webgl2_TRANSFORM_FEEDBACK as TRANSFORM_FEEDBACK,
        webgl2_TRANSFORM_FEEDBACK_ACTIVE as TRANSFORM_FEEDBACK_ACTIVE,
        webgl2_TRANSFORM_FEEDBACK_BINDING as TRANSFORM_FEEDBACK_BINDING,
        webgl2_TRANSFORM_FEEDBACK_BUFFER as TRANSFORM_FEEDBACK_BUFFER,
        webgl2_TRANSFORM_FEEDBACK_BUFFER_BINDING as TRANSFORM_FEEDBACK_BUFFER_BINDING,
        webgl2_TRANSFORM_FEEDBACK_BUFFER_MODE as TRANSFORM_FEEDBACK_BUFFER_MODE,
        webgl2_TRANSFORM_FEEDBACK_BUFFER_SIZE as TRANSFORM_FEEDBACK_BUFFER_SIZE,
        webgl2_TRANSFORM_FEEDBACK_BUFFER_START as TRANSFORM_FEEDBACK_BUFFER_START,
        webgl2_TRANSFORM_FEEDBACK_PAUSED as TRANSFORM_FEEDBACK_PAUSED,
        webgl2_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN as TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN,
        webgl2_TRANSFORM_FEEDBACK_VARYINGS as TRANSFORM_FEEDBACK_VARYINGS,
        webgl2_UNIFORM_ARRAY_STRIDE as UNIFORM_ARRAY_STRIDE,
        webgl2_UNIFORM_BLOCK_ACTIVE_UNIFORMS as UNIFORM_BLOCK_ACTIVE_UNIFORMS,
        webgl2_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES as UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES,
        webgl2_UNIFORM_BLOCK_BINDING as UNIFORM_BLOCK_BINDING,
        webgl2_UNIFORM_BLOCK_DATA_SIZE as UNIFORM_BLOCK_DATA_SIZE,
        webgl2_UNIFORM_BLOCK_INDEX as UNIFORM_BLOCK_INDEX,
        webgl2_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER as UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER,
        webgl2_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER as UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER,
        webgl2_UNIFORM_BUFFER as UNIFORM_BUFFER,
        webgl2_UNIFORM_BUFFER_BINDING as UNIFORM_BUFFER_BINDING,
        webgl2_UNIFORM_BUFFER_OFFSET_ALIGNMENT as UNIFORM_BUFFER_OFFSET_ALIGNMENT,
        webgl2_UNIFORM_BUFFER_SIZE as UNIFORM_BUFFER_SIZE,
        webgl2_UNIFORM_BUFFER_START as UNIFORM_BUFFER_START,
        webgl2_UNIFORM_IS_ROW_MAJOR as UNIFORM_IS_ROW_MAJOR,
        webgl2_UNIFORM_MATRIX_STRIDE as UNIFORM_MATRIX_STRIDE,
        webgl2_UNIFORM_OFFSET as UNIFORM_OFFSET,
        webgl2_UNIFORM_SIZE as UNIFORM_SIZE,
        webgl2_UNIFORM_TYPE as UNIFORM_TYPE,
        webgl2_UNPACK_IMAGE_HEIGHT as UNPACK_IMAGE_HEIGHT,
        webgl2_UNPACK_ROW_LENGTH as UNPACK_ROW_LENGTH,
        webgl2_UNPACK_SKIP_IMAGES as UNPACK_SKIP_IMAGES,
        webgl2_UNPACK_SKIP_PIXELS as UNPACK_SKIP_PIXELS,
        webgl2_UNPACK_SKIP_ROWS as UNPACK_SKIP_ROWS,
        webgl2_UNSIGNALED as UNSIGNALED,
        webgl2_UNSIGNED_INT_10F_11F_11F_REV as UNSIGNED_INT_10F_11F_11F_REV,
        webgl2_UNSIGNED_INT_24_8 as UNSIGNED_INT_24_8,
        webgl2_UNSIGNED_INT_2_10_10_10_REV as UNSIGNED_INT_2_10_10_10_REV,
        webgl2_UNSIGNED_INT_5_9_9_9_REV as UNSIGNED_INT_5_9_9_9_REV,
        webgl2_UNSIGNED_INT_SAMPLER_2D as UNSIGNED_INT_SAMPLER_2D,
        webgl2_UNSIGNED_INT_SAMPLER_2D_ARRAY as UNSIGNED_INT_SAMPLER_2D_ARRAY,
        webgl2_UNSIGNED_INT_SAMPLER_3D as UNSIGNED_INT_SAMPLER_3D,
        webgl2_UNSIGNED_INT_SAMPLER_CUBE as UNSIGNED_INT_SAMPLER_CUBE,
        webgl2_UNSIGNED_INT_VEC2 as UNSIGNED_INT_VEC2,
        webgl2_UNSIGNED_INT_VEC3 as UNSIGNED_INT_VEC3,
        webgl2_UNSIGNED_INT_VEC4 as UNSIGNED_INT_VEC4,
        webgl2_UNSIGNED_NORMALIZED as UNSIGNED_NORMALIZED,
        webgl2_URRENT_QUERY as URRENT_QUERY,
        webgl2_VERTEX_ARRAY_BINDING as VERTEX_ARRAY_BINDING,
        webgl2_VERTEX_ATTRIB_ARRAY_DIVISOR as VERTEX_ATTRIB_ARRAY_DIVISOR,
        webgl2_VERTEX_ATTRIB_ARRAY_INTEGER as VERTEX_ATTRIB_ARRAY_INTEGER,
        webgl2_WAIT_FAILED as WAIT_FAILED,
    };
}

// @public (undocumented)
export namespace webglConstants {
    export {
        webgl_ACTIVE_ATTRIBUTES as ACTIVE_ATTRIBUTES,
        webgl_ACTIVE_ATTRIBUTE_MAX_LENGTH as ACTIVE_ATTRIBUTE_MAX_LENGTH,
        webgl_ACTIVE_TEXTURE as ACTIVE_TEXTURE,
        webgl_ACTIVE_UNIFORMS as ACTIVE_UNIFORMS,
        webgl_ACTIVE_UNIFORM_MAX_LENGTH as ACTIVE_UNIFORM_MAX_LENGTH,
        webgl_ALIASED_LINE_WIDTH_RANGE as ALIASED_LINE_WIDTH_RANGE,
        webgl_ALIASED_POINT_SIZE_RANGE as ALIASED_POINT_SIZE_RANGE,
        webgl_ALPHA as ALPHA,
        webgl_ALPHA_BITS as ALPHA_BITS,
        webgl_ALWAYS as ALWAYS,
        webgl_ARRAY_BUFFER as ARRAY_BUFFER,
        webgl_ARRAY_BUFFER_BINDING as ARRAY_BUFFER_BINDING,
        webgl_ATTACHED_SHADERS as ATTACHED_SHADERS,
        webgl_BACK as BACK,
        webgl_BLEND as BLEND,
        webgl_BLEND_COLOR as BLEND_COLOR,
        webgl_BLEND_DST_ALPHA as BLEND_DST_ALPHA,
        webgl_BLEND_DST_RGB as BLEND_DST_RGB,
        webgl_BLEND_EQUATION as BLEND_EQUATION,
        webgl_BLEND_EQUATION_ALPHA as BLEND_EQUATION_ALPHA,
        webgl_BLEND_EQUATION_RGB as BLEND_EQUATION_RGB,
        webgl_BLEND_SRC_ALPHA as BLEND_SRC_ALPHA,
        webgl_BLEND_SRC_RGB as BLEND_SRC_RGB,
        webgl_BLUE_BITS as BLUE_BITS,
        webgl_BOOL as BOOL,
        webgl_BOOL_VEC2 as BOOL_VEC2,
        webgl_BOOL_VEC3 as BOOL_VEC3,
        webgl_BOOL_VEC4 as BOOL_VEC4,
        webgl_BROWSER_DEFAULT_WEBGL as BROWSER_DEFAULT_WEBGL,
        webgl_BUFFER_SIZE as BUFFER_SIZE,
        webgl_BUFFER_USAGE as BUFFER_USAGE,
        webgl_BYTE as BYTE,
        webgl_CCW as CCW,
        webgl_CLAMP_TO_EDGE as CLAMP_TO_EDGE,
        webgl_COLOR_ATTACHMENT0 as COLOR_ATTACHMENT0,
        webgl_COLOR_BUFFER_BIT as COLOR_BUFFER_BIT,
        webgl_COLOR_CLEAR_VALUE as COLOR_CLEAR_VALUE,
        webgl_COLOR_WRITEMASK as COLOR_WRITEMASK,
        webgl_COMPILE_STATUS as COMPILE_STATUS,
        webgl_COMPRESSED_TEXTURE_FORMATS as COMPRESSED_TEXTURE_FORMATS,
        webgl_CONSTANT_ALPHA as CONSTANT_ALPHA,
        webgl_CONSTANT_COLOR as CONSTANT_COLOR,
        webgl_CONTEXT_LOST_WEBGL as CONTEXT_LOST_WEBGL,
        webgl_CULL_FACE as CULL_FACE,
        webgl_CULL_FACE_MODE as CULL_FACE_MODE,
        webgl_CURRENT_PROGRAM as CURRENT_PROGRAM,
        webgl_CURRENT_VERTEX_ATTRIB as CURRENT_VERTEX_ATTRIB,
        webgl_CW as CW,
        webgl_DECR as DECR,
        webgl_DECR_WRAP as DECR_WRAP,
        webgl_DELETE_STATUS as DELETE_STATUS,
        webgl_DEPTH_ATTACHMENT as DEPTH_ATTACHMENT,
        webgl_DEPTH_BITS as DEPTH_BITS,
        webgl_DEPTH_BUFFER_BIT as DEPTH_BUFFER_BIT,
        webgl_DEPTH_CLEAR_VALUE as DEPTH_CLEAR_VALUE,
        webgl_DEPTH_COMPONENT as DEPTH_COMPONENT,
        webgl_DEPTH_COMPONENT16 as DEPTH_COMPONENT16,
        webgl_DEPTH_FUNC as DEPTH_FUNC,
        webgl_DEPTH_RANGE as DEPTH_RANGE,
        DEPTH_STENCIL$1 as DEPTH_STENCIL,
        DEPTH_STENCIL_ATTACHMENT$1 as DEPTH_STENCIL_ATTACHMENT,
        webgl_DEPTH_TEST as DEPTH_TEST,
        webgl_DEPTH_WRITEMASK as DEPTH_WRITEMASK,
        webgl_DITHER as DITHER,
        webgl_DONT_CARE as DONT_CARE,
        webgl_DST_ALPHA as DST_ALPHA,
        webgl_DST_COLOR as DST_COLOR,
        webgl_DYNAMIC_DRAW as DYNAMIC_DRAW,
        webgl_ELEMENT_ARRAY_BUFFER as ELEMENT_ARRAY_BUFFER,
        webgl_ELEMENT_ARRAY_BUFFER_BINDING as ELEMENT_ARRAY_BUFFER_BINDING,
        webgl_EQUAL as EQUAL,
        webgl_FASTEST as FASTEST,
        webgl_FLOAT as FLOAT,
        webgl_FLOAT_MAT2 as FLOAT_MAT2,
        webgl_FLOAT_MAT3 as FLOAT_MAT3,
        webgl_FLOAT_MAT4 as FLOAT_MAT4,
        webgl_FLOAT_VEC2 as FLOAT_VEC2,
        webgl_FLOAT_VEC3 as FLOAT_VEC3,
        webgl_FLOAT_VEC4 as FLOAT_VEC4,
        webgl_FRAGMENT_SHADER as FRAGMENT_SHADER,
        webgl_FRAMEBUFFER as FRAMEBUFFER,
        webgl_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME as FRAMEBUFFER_ATTACHMENT_OBJECT_NAME,
        webgl_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE as FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE,
        webgl_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE as FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE,
        webgl_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL as FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL,
        webgl_FRAMEBUFFER_BINDING as FRAMEBUFFER_BINDING,
        webgl_FRAMEBUFFER_COMPLETE as FRAMEBUFFER_COMPLETE,
        webgl_FRAMEBUFFER_INCOMPLETE_ATTACHMENT as FRAMEBUFFER_INCOMPLETE_ATTACHMENT,
        webgl_FRAMEBUFFER_INCOMPLETE_DIMENSIONS as FRAMEBUFFER_INCOMPLETE_DIMENSIONS,
        webgl_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT as FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT,
        webgl_FRAMEBUFFER_UNSUPPORTED as FRAMEBUFFER_UNSUPPORTED,
        webgl_FRONT as FRONT,
        webgl_FRONT_AND_BACK as FRONT_AND_BACK,
        webgl_FRONT_FACE as FRONT_FACE,
        webgl_FUNC_ADD as FUNC_ADD,
        webgl_FUNC_REVERSE_SUBTRACT as FUNC_REVERSE_SUBTRACT,
        webgl_FUNC_SUBTRACT as FUNC_SUBTRACT,
        webgl_GENERATE_MIPMAP_HINT as GENERATE_MIPMAP_HINT,
        webgl_GEQUAL as GEQUAL,
        webgl_GREATER as GREATER,
        webgl_GREEN_BITS as GREEN_BITS,
        webgl_HIGH_FLOAT as HIGH_FLOAT,
        webgl_HIGH_INT as HIGH_INT,
        webgl_INCR as INCR,
        webgl_INCR_WRAP as INCR_WRAP,
        webgl_INFO_LOG_LENGTH as INFO_LOG_LENGTH,
        webgl_INT as INT,
        webgl_INT_VEC2 as INT_VEC2,
        webgl_INT_VEC3 as INT_VEC3,
        webgl_INT_VEC4 as INT_VEC4,
        webgl_INVALID_ENUM as INVALID_ENUM,
        webgl_INVALID_FRAMEBUFFER_OPERATION as INVALID_FRAMEBUFFER_OPERATION,
        webgl_INVALID_OPERATION as INVALID_OPERATION,
        webgl_INVALID_VALUE as INVALID_VALUE,
        webgl_INVERT as INVERT,
        webgl_KEEP as KEEP,
        webgl_LEQUAL as LEQUAL,
        webgl_LESS as LESS,
        webgl_LINEAR as LINEAR,
        webgl_LINEAR_MIPMAP_LINEAR as LINEAR_MIPMAP_LINEAR,
        webgl_LINEAR_MIPMAP_NEAREST as LINEAR_MIPMAP_NEAREST,
        webgl_LINES as LINES,
        webgl_LINE_LOOP as LINE_LOOP,
        webgl_LINE_STRIP as LINE_STRIP,
        webgl_LINE_WIDTH as LINE_WIDTH,
        webgl_LINK_STATUS as LINK_STATUS,
        webgl_LOW_FLOAT as LOW_FLOAT,
        webgl_LOW_INT as LOW_INT,
        webgl_LUMINANCE as LUMINANCE,
        webgl_LUMINANCE_ALPHA as LUMINANCE_ALPHA,
        webgl_MAX_COMBINED_TEXTURE_IMAGE_UNITS as MAX_COMBINED_TEXTURE_IMAGE_UNITS,
        webgl_MAX_CUBE_MAP_TEXTURE_SIZE as MAX_CUBE_MAP_TEXTURE_SIZE,
        webgl_MAX_FRAGMENT_UNIFORM_VECTORS as MAX_FRAGMENT_UNIFORM_VECTORS,
        webgl_MAX_RENDERBUFFER_SIZE as MAX_RENDERBUFFER_SIZE,
        webgl_MAX_TEXTURE_IMAGE_UNITS as MAX_TEXTURE_IMAGE_UNITS,
        webgl_MAX_TEXTURE_SIZE as MAX_TEXTURE_SIZE,
        webgl_MAX_VARYING_VECTORS as MAX_VARYING_VECTORS,
        webgl_MAX_VERTEX_ATTRIBS as MAX_VERTEX_ATTRIBS,
        webgl_MAX_VERTEX_TEXTURE_IMAGE_UNITS as MAX_VERTEX_TEXTURE_IMAGE_UNITS,
        webgl_MAX_VERTEX_UNIFORM_VECTORS as MAX_VERTEX_UNIFORM_VECTORS,
        webgl_MAX_VIEWPORT_DIMS as MAX_VIEWPORT_DIMS,
        webgl_MEDIUM_FLOAT as MEDIUM_FLOAT,
        webgl_MEDIUM_INT as MEDIUM_INT,
        webgl_MIRRORED_REPEAT as MIRRORED_REPEAT,
        webgl_NEAREST as NEAREST,
        webgl_NEAREST_MIPMAP_LINEAR as NEAREST_MIPMAP_LINEAR,
        webgl_NEAREST_MIPMAP_NEAREST as NEAREST_MIPMAP_NEAREST,
        webgl_NEVER as NEVER,
        webgl_NICEST as NICEST,
        webgl_NONE as NONE,
        webgl_NOTEQUAL as NOTEQUAL,
        webgl_NO_ERROR as NO_ERROR,
        webgl_NUM_COMPRESSED_TEXTURE_FORMATS as NUM_COMPRESSED_TEXTURE_FORMATS,
        webgl_ONE as ONE,
        webgl_ONE_MINUS_CONSTANT_ALPHA as ONE_MINUS_CONSTANT_ALPHA,
        webgl_ONE_MINUS_CONSTANT_COLOR as ONE_MINUS_CONSTANT_COLOR,
        webgl_ONE_MINUS_DST_ALPHA as ONE_MINUS_DST_ALPHA,
        webgl_ONE_MINUS_DST_COLOR as ONE_MINUS_DST_COLOR,
        webgl_ONE_MINUS_SRC_ALPHA as ONE_MINUS_SRC_ALPHA,
        webgl_ONE_MINUS_SRC_COLOR as ONE_MINUS_SRC_COLOR,
        webgl_OUT_OF_MEMORY as OUT_OF_MEMORY,
        webgl_PACK_ALIGNMENT as PACK_ALIGNMENT,
        webgl_POINTS as POINTS,
        webgl_POLYGON_OFFSET_FACTOR as POLYGON_OFFSET_FACTOR,
        webgl_POLYGON_OFFSET_FILL as POLYGON_OFFSET_FILL,
        webgl_POLYGON_OFFSET_UNITS as POLYGON_OFFSET_UNITS,
        webgl_RED_BITS as RED_BITS,
        webgl_RENDERBUFFER as RENDERBUFFER,
        webgl_RENDERBUFFER_ALPHA_SIZE as RENDERBUFFER_ALPHA_SIZE,
        webgl_RENDERBUFFER_BINDING as RENDERBUFFER_BINDING,
        webgl_RENDERBUFFER_BLUE_SIZE as RENDERBUFFER_BLUE_SIZE,
        webgl_RENDERBUFFER_DEPTH_SIZE as RENDERBUFFER_DEPTH_SIZE,
        webgl_RENDERBUFFER_GREEN_SIZE as RENDERBUFFER_GREEN_SIZE,
        webgl_RENDERBUFFER_HEIGHT as RENDERBUFFER_HEIGHT,
        webgl_RENDERBUFFER_INTERNAL_FORMAT as RENDERBUFFER_INTERNAL_FORMAT,
        webgl_RENDERBUFFER_RED_SIZE as RENDERBUFFER_RED_SIZE,
        webgl_RENDERBUFFER_STENCIL_SIZE as RENDERBUFFER_STENCIL_SIZE,
        webgl_RENDERBUFFER_WIDTH as RENDERBUFFER_WIDTH,
        webgl_RENDERER as RENDERER,
        webgl_REPEAT as REPEAT,
        webgl_REPLACE as REPLACE,
        webgl_RGB as RGB,
        webgl_RGB565 as RGB565,
        webgl_RGB5_A1 as RGB5_A1,
        webgl_RGBA as RGBA,
        webgl_RGBA4 as RGBA4,
        webgl_SAMPLER_2D as SAMPLER_2D,
        webgl_SAMPLER_CUBE as SAMPLER_CUBE,
        webgl_SAMPLES as SAMPLES,
        webgl_SAMPLE_ALPHA_TO_COVERAGE as SAMPLE_ALPHA_TO_COVERAGE,
        webgl_SAMPLE_BUFFERS as SAMPLE_BUFFERS,
        webgl_SAMPLE_COVERAGE as SAMPLE_COVERAGE,
        webgl_SAMPLE_COVERAGE_INVERT as SAMPLE_COVERAGE_INVERT,
        webgl_SAMPLE_COVERAGE_VALUE as SAMPLE_COVERAGE_VALUE,
        webgl_SCISSOR_BOX as SCISSOR_BOX,
        webgl_SCISSOR_TEST as SCISSOR_TEST,
        webgl_SHADER_COMPILER as SHADER_COMPILER,
        webgl_SHADER_SOURCE_LENGTH as SHADER_SOURCE_LENGTH,
        webgl_SHADER_TYPE as SHADER_TYPE,
        webgl_SHADING_LANGUAGE_VERSION as SHADING_LANGUAGE_VERSION,
        webgl_SHORT as SHORT,
        webgl_SRC_ALPHA as SRC_ALPHA,
        webgl_SRC_ALPHA_SATURATE as SRC_ALPHA_SATURATE,
        webgl_SRC_COLOR as SRC_COLOR,
        webgl_STATIC_DRAW as STATIC_DRAW,
        webgl_STENCIL_ATTACHMENT as STENCIL_ATTACHMENT,
        webgl_STENCIL_BACK_FAIL as STENCIL_BACK_FAIL,
        webgl_STENCIL_BACK_FUNC as STENCIL_BACK_FUNC,
        webgl_STENCIL_BACK_PASS_DEPTH_FAIL as STENCIL_BACK_PASS_DEPTH_FAIL,
        webgl_STENCIL_BACK_PASS_DEPTH_PASS as STENCIL_BACK_PASS_DEPTH_PASS,
        webgl_STENCIL_BACK_REF as STENCIL_BACK_REF,
        webgl_STENCIL_BACK_VALUE_MASK as STENCIL_BACK_VALUE_MASK,
        webgl_STENCIL_BACK_WRITEMASK as STENCIL_BACK_WRITEMASK,
        webgl_STENCIL_BITS as STENCIL_BITS,
        webgl_STENCIL_BUFFER_BIT as STENCIL_BUFFER_BIT,
        webgl_STENCIL_CLEAR_VALUE as STENCIL_CLEAR_VALUE,
        webgl_STENCIL_FAIL as STENCIL_FAIL,
        webgl_STENCIL_FUNC as STENCIL_FUNC,
        webgl_STENCIL_INDEX as STENCIL_INDEX,
        webgl_STENCIL_INDEX8 as STENCIL_INDEX8,
        webgl_STENCIL_PASS_DEPTH_FAIL as STENCIL_PASS_DEPTH_FAIL,
        webgl_STENCIL_PASS_DEPTH_PASS as STENCIL_PASS_DEPTH_PASS,
        webgl_STENCIL_REF as STENCIL_REF,
        webgl_STENCIL_TEST as STENCIL_TEST,
        webgl_STENCIL_VALUE_MASK as STENCIL_VALUE_MASK,
        webgl_STENCIL_WRITEMASK as STENCIL_WRITEMASK,
        webgl_STREAM_DRAW as STREAM_DRAW,
        webgl_SUBPIXEL_BITS as SUBPIXEL_BITS,
        webgl_TEXTURE as TEXTURE,
        webgl_TEXTURE0 as TEXTURE0,
        webgl_TEXTURE1 as TEXTURE1,
        webgl_TEXTURE10 as TEXTURE10,
        webgl_TEXTURE11 as TEXTURE11,
        webgl_TEXTURE12 as TEXTURE12,
        webgl_TEXTURE13 as TEXTURE13,
        webgl_TEXTURE14 as TEXTURE14,
        webgl_TEXTURE15 as TEXTURE15,
        webgl_TEXTURE16 as TEXTURE16,
        webgl_TEXTURE17 as TEXTURE17,
        webgl_TEXTURE18 as TEXTURE18,
        webgl_TEXTURE19 as TEXTURE19,
        webgl_TEXTURE2 as TEXTURE2,
        webgl_TEXTURE20 as TEXTURE20,
        webgl_TEXTURE21 as TEXTURE21,
        webgl_TEXTURE22 as TEXTURE22,
        webgl_TEXTURE23 as TEXTURE23,
        webgl_TEXTURE24 as TEXTURE24,
        webgl_TEXTURE25 as TEXTURE25,
        webgl_TEXTURE26 as TEXTURE26,
        webgl_TEXTURE27 as TEXTURE27,
        webgl_TEXTURE28 as TEXTURE28,
        webgl_TEXTURE29 as TEXTURE29,
        webgl_TEXTURE3 as TEXTURE3,
        webgl_TEXTURE30 as TEXTURE30,
        webgl_TEXTURE31 as TEXTURE31,
        webgl_TEXTURE4 as TEXTURE4,
        webgl_TEXTURE5 as TEXTURE5,
        webgl_TEXTURE6 as TEXTURE6,
        webgl_TEXTURE7 as TEXTURE7,
        webgl_TEXTURE8 as TEXTURE8,
        webgl_TEXTURE9 as TEXTURE9,
        webgl_TEXTURE_2D as TEXTURE_2D,
        webgl_TEXTURE_BINDING_2D as TEXTURE_BINDING_2D,
        webgl_TEXTURE_BINDING_CUBE_MAP as TEXTURE_BINDING_CUBE_MAP,
        webgl_TEXTURE_CUBE_MAP as TEXTURE_CUBE_MAP,
        webgl_TEXTURE_CUBE_MAP_NEGATIVE_X as TEXTURE_CUBE_MAP_NEGATIVE_X,
        webgl_TEXTURE_CUBE_MAP_NEGATIVE_Y as TEXTURE_CUBE_MAP_NEGATIVE_Y,
        webgl_TEXTURE_CUBE_MAP_NEGATIVE_Z as TEXTURE_CUBE_MAP_NEGATIVE_Z,
        webgl_TEXTURE_CUBE_MAP_POSITIVE_X as TEXTURE_CUBE_MAP_POSITIVE_X,
        webgl_TEXTURE_CUBE_MAP_POSITIVE_Y as TEXTURE_CUBE_MAP_POSITIVE_Y,
        webgl_TEXTURE_CUBE_MAP_POSITIVE_Z as TEXTURE_CUBE_MAP_POSITIVE_Z,
        webgl_TEXTURE_MAG_FILTER as TEXTURE_MAG_FILTER,
        webgl_TEXTURE_MIN_FILTER as TEXTURE_MIN_FILTER,
        webgl_TEXTURE_WRAP_S as TEXTURE_WRAP_S,
        webgl_TEXTURE_WRAP_T as TEXTURE_WRAP_T,
        webgl_TRIANGLES as TRIANGLES,
        webgl_TRIANGLE_FAN as TRIANGLE_FAN,
        webgl_TRIANGLE_STRIP as TRIANGLE_STRIP,
        webgl_UNPACK_ALIGNMENT as UNPACK_ALIGNMENT,
        webgl_UNPACK_COLORSPACE_CONVERSION_WEBGL as UNPACK_COLORSPACE_CONVERSION_WEBGL,
        webgl_UNPACK_FLIP_Y_WEBGL as UNPACK_FLIP_Y_WEBGL,
        webgl_UNPACK_PREMULTIPLY_ALPHA_WEBGL as UNPACK_PREMULTIPLY_ALPHA_WEBGL,
        webgl_UNSIGNED_BYTE as UNSIGNED_BYTE,
        webgl_UNSIGNED_INT as UNSIGNED_INT,
        webgl_UNSIGNED_SHORT as UNSIGNED_SHORT,
        webgl_UNSIGNED_SHORT_4_4_4_4 as UNSIGNED_SHORT_4_4_4_4,
        webgl_UNSIGNED_SHORT_5_5_5_1 as UNSIGNED_SHORT_5_5_5_1,
        webgl_UNSIGNED_SHORT_5_6_5 as UNSIGNED_SHORT_5_6_5,
        webgl_VALIDATE_STATUS as VALIDATE_STATUS,
        webgl_VENDOR as VENDOR,
        webgl_VERSION as VERSION,
        webgl_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING as VERTEX_ATTRIB_ARRAY_BUFFER_BINDING,
        webgl_VERTEX_ATTRIB_ARRAY_ENABLED as VERTEX_ATTRIB_ARRAY_ENABLED,
        webgl_VERTEX_ATTRIB_ARRAY_NORMALIZED as VERTEX_ATTRIB_ARRAY_NORMALIZED,
        webgl_VERTEX_ATTRIB_ARRAY_POINTER as VERTEX_ATTRIB_ARRAY_POINTER,
        webgl_VERTEX_ATTRIB_ARRAY_SIZE as VERTEX_ATTRIB_ARRAY_SIZE,
        webgl_VERTEX_ATTRIB_ARRAY_STRIDE as VERTEX_ATTRIB_ARRAY_STRIDE,
        webgl_VERTEX_ATTRIB_ARRAY_TYPE as VERTEX_ATTRIB_ARRAY_TYPE,
        webgl_VERTEX_SHADER as VERTEX_SHADER,
        webgl_VIEWPORT as VIEWPORT,
        webgl_ZERO as ZERO,
    };
}

// @public (undocumented)
export namespace webglExtensionConstants {
    export {
        webglExtensions_COMPRESSED_RGBA_ASTC_4X4_KHR as COMPRESSED_RGBA_ASTC_4X4_KHR,
        webglExtensions_COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL as COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL,
        webglExtensions_COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL as COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL,
        webglExtensions_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG as COMPRESSED_RGBA_PVRTC_2BPPV1_IMG,
        webglExtensions_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG as COMPRESSED_RGBA_PVRTC_4BPPV1_IMG,
        webglExtensions_COMPRESSED_RGBA_S3TC_DXT1_EXT as COMPRESSED_RGBA_S3TC_DXT1_EXT,
        webglExtensions_COMPRESSED_RGBA_S3TC_DXT3_EXT as COMPRESSED_RGBA_S3TC_DXT3_EXT,
        webglExtensions_COMPRESSED_RGBA_S3TC_DXT5_EXT as COMPRESSED_RGBA_S3TC_DXT5_EXT,
        webglExtensions_COMPRESSED_RGB_ATC_WEBGL as COMPRESSED_RGB_ATC_WEBGL,
        webglExtensions_COMPRESSED_RGB_ETC1_WEBGL as COMPRESSED_RGB_ETC1_WEBGL,
        webglExtensions_COMPRESSED_RGB_PVRTC_2BPPV1_IMG as COMPRESSED_RGB_PVRTC_2BPPV1_IMG,
        webglExtensions_COMPRESSED_RGB_PVRTC_4BPPV1_IMG as COMPRESSED_RGB_PVRTC_4BPPV1_IMG,
        webglExtensions_COMPRESSED_RGB_S3TC_DXT1_EXT as COMPRESSED_RGB_S3TC_DXT1_EXT,
        webglExtensions_COMPRESSED_SRGB8_ALPHA8_ASTC_4X4_KHR as COMPRESSED_SRGB8_ALPHA8_ASTC_4X4_KHR,
        webglExtensions_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT as COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT,
        webglExtensions_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT as COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT,
        webglExtensions_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT as COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT,
        webglExtensions_COMPRESSED_SRGB_S3TC_DXT1_EXT as COMPRESSED_SRGB_S3TC_DXT1_EXT,
        webglExtensions_CURRENT_QUERY_EXT as CURRENT_QUERY_EXT,
        webglExtensions_GPU_DISJOINT_EXT as GPU_DISJOINT_EXT,
        webglExtensions_MAX_TEXTURE_MAX_ANISOTROPY_EXT as MAX_TEXTURE_MAX_ANISOTROPY_EXT,
        webglExtensions_QUERY_COUNTER_BITS_EXT as QUERY_COUNTER_BITS_EXT,
        webglExtensions_QUERY_RESULT_AVAILABLE_EXT as QUERY_RESULT_AVAILABLE_EXT,
        webglExtensions_QUERY_RESULT_EXT as QUERY_RESULT_EXT,
        webglExtensions_TEXTURE_MAX_ANISOTROPY_EXT as TEXTURE_MAX_ANISOTROPY_EXT,
        webglExtensions_TIMESTAMP_EXT as TIMESTAMP_EXT,
        webglExtensions_TIME_ELAPSED_EXT as TIME_ELAPSED_EXT,
        webglExtensions_UNMASKED_RENDERER_WEBGL as UNMASKED_RENDERER_WEBGL,
        webglExtensions_UNMASKED_VENDOR_WEBGL as UNMASKED_VENDOR_WEBGL,
    };
}

// @public
export const WebGLSupport: {
    readonly get: () => boolean;
};

// @public (undocumented)
export interface XYZObject {
    // (undocumented)
    x: number;
    // (undocumented)
    y: number;
    // (undocumented)
    z: number;
}

```
