import { S as ShadoConfig, F as FieldType, a as ShadoStructSchema, G as GPUBacking, B as BackendKind, b as Shado, V as VarArrayType, c as ScalarType, d as VectorType, M as MatrixType, e as StructRef, L as LazyCtor } from './types-oCidOW3T.cjs';
export { A as ASCExtension, q as DirtyEvent, r as DirtyHandler, D as DynamicMeta, f as FieldDef, w as FloatArena, I as InitializeConfig, m as LAZY_CTOR, P as PendingField, h as ScalarTy, i as SchemaSpec, g as Segment, p as ShadoAbstractCtor, l as ShadoBaseCtor, n as ShadoConcreteCtor, k as ShadoStatics, j as StorageSpec, o as StructArrayType, U as UboField, W as WasmInitializeMode, t as field, s as gpuStruct, u as readClassMeta, v as readFields } from './types-oCidOW3T.cjs';
export { I as InstanceNameSource, N as NameplateData, h as SHADO_ENTITY2D_MESH_INDEX_MOTION_COMPONENT, g as SHADO_ENTITY_HIGHLIGHTED, f as SHADO_ENTITY_SELECTED, e as SHADO_ENTITY_VISIBLE, S as ShadoActor, A as ShadoAsyncPickingBaseOptions, s as ShadoAtlasColor, q as ShadoAtlasEntry, p as ShadoAtlasRect, E as ShadoDynamicEntityAsyncPickingOptions, y as ShadoDynamicEntityContainer, v as ShadoDynamicEntityDestinationInput, w as ShadoDynamicEntityExpirationInput, x as ShadoDynamicEntityGeometryMode, u as ShadoDynamicEntityInput, C as ShadoDynamicEntityPickResult, o as ShadoEntity2D, l as ShadoEntity2DDestinationInput, k as ShadoEntity2DInput, D as ShadoInstanceAsyncPickingOptions, b as ShadoInstanceContainer, a as ShadoInstanceContainerOptions, B as ShadoInstancePickResult, d as ShadoMaterial, c as ShadoMaterialOptions, F as ShadoPickingHandle, z as ShadoPickingSchedule, j as ShadoRgba, r as ShadoTextureAtlas, i as ShadoUvRect, T as TestClass, t as createSolidColorAtlas, n as entityFlags, m as hashEntityId, O as installShadoDynamicEntityClickPicking, M as installShadoInstanceClickPicking, G as normalizePickingOptions, K as pickShadoDynamicEntityAtPointer, L as pickShadoDynamicEntityWithRay, H as pickShadoInstanceAtPointer, J as pickShadoInstanceWithRay } from './index-BW6UeJpA.cjs';
export { D as DQBuildOpts, a as DQClipInfo, S as SerializedDQVAT, V as VATBuilder, m as matrixToDualQuaternion } from './VATBuilder-DkNitwpU.cjs';
import { StorageBuffer, RawTexture } from '@babylonjs/core';
export * from '@babylonjs/core';
export { BABYLON, ensureBABYLON, peekBABYLON } from './babylon/index.cjs';
export { SHADO_DYNAMIC_ENTITY_DELTA_HEADER_BYTES, SHADO_DYNAMIC_ENTITY_DELTA_RECORD_BYTES, SHADO_DYNAMIC_ENTITY_EXPIRATION_BY_FRAME, SHADO_DYNAMIC_ENTITY_EXPIRATION_BY_SIMULATION_TIME, SHADO_DYNAMIC_ENTITY_EXPIRATION_RECORD_BYTES, SHADO_DYNAMIC_ENTITY_REDUCER_MAGIC, SHADO_DYNAMIC_ENTITY_REDUCER_VERSION, SHADO_DYNAMIC_ENTITY_VISIBLE, SHADO_ENTITY2D_REDUCER_LAYOUT, ShadoDynamicEntityDeltaRecord, ShadoDynamicEntityExpirationRecord, ShadoDynamicEntityMeshVariant, ShadoDynamicEntityMeshVariantRendererOptions, ShadoDynamicEntityNameplateInput, ShadoDynamicEntityNameplateLayer, ShadoDynamicEntityNameplateLayerOptions, ShadoDynamicEntityReducer, ShadoDynamicEntityReducerDeltaRecord, ShadoDynamicEntityReducerExports, ShadoDynamicEntityReducerInit, ShadoDynamicEntityReducerOp, ShadoDynamicEntityReducerOptions, ShadoDynamicEntityReducerResolvedInit, ShadoDynamicEntityRenderer, ShadoDynamicEntityRendererOptions, createShadoDynamicEntityReducer, defaultShadoDynamicEntityReducerDebugWasmBytes, defaultShadoDynamicEntityReducerWasmBytes, encodeShadoDynamicEntityReducerDelta, wrapShadoDynamicEntityReducerExports } from './render/index.cjs';

declare class ShadoSchemaBuilder {
    private _name;
    private fields;
    private built;
    private _config;
    constructor(name: string, config?: ShadoConfig);
    registerField(name: string, type: FieldType): this;
    build(): ShadoStructSchema;
}

declare function setIncludeChunkWGSL(name: string, wgsl: string): void;
declare function setIncludeChunkFX(name: string, fx: string): void;
declare function setIncludeChunkBoth(name: string, glsl: string, wgsl: string): void;
declare function registerIncludesOnEngine(schema: ShadoStructSchema, customName?: string): void;

declare class DataTexBacking implements GPUBacking {
    private engine;
    private schema;
    private owner;
    kind: BackendKind;
    private bufTex?;
    private texW;
    private texH;
    private capTexels;
    private capFloats;
    private staging?;
    private lastUsedFloats;
    constructor(engine: any, schema: any, owner: Shado);
    reserveFloats(minFloats: number): void;
    commit(): void;
    bind(effect: any, includeName: string): void;
    bindMaterial(material: any, includeName: string): void;
    private applyBindings;
    dispose(): void;
}

declare class StorageBacking implements GPUBacking {
    private engine;
    private schema;
    private owner;
    kind: BackendKind;
    private buf?;
    private bufCapBytes;
    private paramsBuf?;
    private paramsCapBytes;
    private paramsScratch;
    constructor(engine: any, schema: any, owner: any);
    commit(): void;
    private buildParams;
    bind(effect: any, includeName: string): void;
    bindMaterial(material: any, includeName: string): void;
    private applyBindings;
    dispose(): void;
}

declare function isVarArray(t: FieldType): t is VarArrayType;
declare function isScalar(t: any): t is ScalarType;
declare function isVector(t: any): t is VectorType;
declare function isMatrix(t: any): t is MatrixType;
declare function isVarArrayOfStruct(t: FieldType): t is VarArrayType;
declare function floatStrideOf(t: ScalarType | VectorType | MatrixType): number;
declare function isStructRef(t: any): t is StructRef;
declare const lazy: <T>(fn: () => T) => LazyCtor<T>;
declare function resolveCtor(x: any): any;

declare function createEmbeddedProxyFromArena(parent: Shado, childCtor: {
    getSchema(): ShadoStructSchema;
}, baseFloatOffset: number): any;

declare class BindingAlloc {
    private next;
    private used;
    constructor(startAt?: number);
    takeFor(symbol: string, count?: number): number;
    take(count?: number): number;
}
declare function safeTypeName(name: string): string;

declare function toWGSLType(t: ScalarType | VectorType | MatrixType): string;
declare function toGLSLType(t: ScalarType | VectorType | MatrixType): string;
declare const lc: (s: string) => string;
declare const roundUpFloats: (x: number, a: number) => number;

type DQClipInput = {
    name: string;
    bones: number;
    framesOut: number;
    fpsOut: number;
    dq: Float32Array;
};
type ClipTOC_SSBO = {
    name: string;
    bones: number;
    framesOut: number;
    fpsOut: number;
    baseF: number;
    frameStrideF: number;
};
type SSBOAtlas = {
    buffer: StorageBuffer;
    totalFloats: number;
    clips: ClipTOC_SSBO[];
};
type ClipTOC_Tex2D = {
    name: string;
    bones: number;
    framesOut: number;
    fpsOut: number;
    rowBase: number;
    rowWidthTex: number;
    atlasWidthTex: number;
};
type Tex2DAtlas = {
    texture: RawTexture;
    widthTex: number;
    heightTex: number;
    clips: ClipTOC_Tex2D[];
};

declare const VERSION = "";

export { BackendKind, BindingAlloc, type ClipTOC_SSBO, type ClipTOC_Tex2D, type DQClipInput, DataTexBacking, FieldType, GPUBacking, LazyCtor, MatrixType, type SSBOAtlas, ScalarType, Shado as ShaderObject, Shado, ShadoConfig, ShadoSchemaBuilder, ShadoStructSchema, StorageBacking, StructRef, type Tex2DAtlas, VERSION, VarArrayType, VectorType, createEmbeddedProxyFromArena, floatStrideOf, isMatrix, isScalar, isStructRef, isVarArray, isVarArrayOfStruct, isVector, lazy, lc, registerIncludesOnEngine, resolveCtor, roundUpFloats, safeTypeName, setIncludeChunkBoth, setIncludeChunkFX, setIncludeChunkWGSL, toGLSLType, toWGSLType };