@combeenation/3d-viewer 0.0.1-types

package/dist/types/node_modules/@babylonjs/procedural-textures/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./brick/index.js";
+export * from "./cloud/index.js";
+export * from "./fire/index.js";
+export * from "./grass/index.js";
+export * from "./marble/index.js";
+export * from "./normalMap/index.js";
+export * from "./perlinNoise/index.js";
+export * from "./road/index.js";
+export * from "./starfield/index.js";
+export * from "./wood/index.js";

package/dist/types/node_modules/@babylonjs/procedural-textures/legacy/legacy-brick.d.ts

@@ -0,0 +1 @@
+export * from "../brick/index.js";

package/dist/types/node_modules/@babylonjs/procedural-textures/legacy/legacy-cloud.d.ts

@@ -0,0 +1 @@
+export * from "../cloud/index.js";

package/dist/types/node_modules/@babylonjs/procedural-textures/legacy/legacy-fire.d.ts

@@ -0,0 +1 @@
+export * from "../fire/index.js";

package/dist/types/node_modules/@babylonjs/procedural-textures/legacy/legacy-grass.d.ts

@@ -0,0 +1 @@
+export * from "../grass/index.js";

package/dist/types/node_modules/@babylonjs/procedural-textures/legacy/legacy-marble.d.ts

@@ -0,0 +1 @@
+export * from "../marble/index.js";

package/dist/types/node_modules/@babylonjs/procedural-textures/legacy/legacy-normalMap.d.ts

@@ -0,0 +1 @@
+export * from "../normalMap/index.js";

package/dist/types/node_modules/@babylonjs/procedural-textures/legacy/legacy-perlinNoise.d.ts

@@ -0,0 +1 @@
+export * from "../perlinNoise/index.js";

package/dist/types/node_modules/@babylonjs/procedural-textures/legacy/legacy-road.d.ts

@@ -0,0 +1 @@
+export * from "../road/index.js";

package/dist/types/node_modules/@babylonjs/procedural-textures/legacy/legacy-starfield.d.ts

@@ -0,0 +1 @@
+export * from "../starfield/index.js";

package/dist/types/node_modules/@babylonjs/procedural-textures/legacy/legacy-wood.d.ts

@@ -0,0 +1 @@
+export * from "../wood/index.js";

package/dist/types/node_modules/@babylonjs/procedural-textures/legacy/legacy.d.ts

@@ -0,0 +1 @@
+export * from "../index.js";

package/dist/types/node_modules/@babylonjs/procedural-textures/marble/index.d.ts

@@ -0,0 +1 @@
+export * from "./marbleProceduralTexture.js";

package/dist/types/node_modules/@babylonjs/procedural-textures/marble/marbleProceduralTexture.d.ts

@@ -0,0 +1,26 @@
+export class MarbleProceduralTexture extends ProceduralTexture {
+    /**
+     * Creates a Marble Procedural Texture from parsed marble procedural texture data
+     * @param parsedTexture defines parsed texture data
+     * @param scene defines the current scene
+     * @param rootUrl defines the root URL containing marble procedural texture information
+     * @returns a parsed Marble Procedural Texture
+     */
+    static Parse(parsedTexture: any, scene: any, rootUrl: any): MarbleProceduralTexture;
+    constructor(name: any, size: any, scene: null | undefined, fallbackTexture: any, generateMipMaps: any);
+    _numberOfTilesHeight: number;
+    _numberOfTilesWidth: number;
+    _amplitude: number;
+    _jointColor: Color3;
+    updateShaderUniforms(): void;
+    set numberOfTilesHeight(arg: number);
+    get numberOfTilesHeight(): number;
+    set amplitude(arg: number);
+    get amplitude(): number;
+    set numberOfTilesWidth(arg: number);
+    get numberOfTilesWidth(): number;
+    set jointColor(arg: Color3);
+    get jointColor(): Color3;
+}
+import { ProceduralTexture } from "@babylonjs/core/Materials/Textures/Procedurals/proceduralTexture.js";
+import { Color3 } from "@babylonjs/core/Maths/math.color.js";

package/dist/types/node_modules/@babylonjs/procedural-textures/marble/marbleProceduralTexture.fragment.d.ts

@@ -0,0 +1,7 @@
+export namespace marbleProceduralTexturePixelShader {
+    export { name };
+    export { shader };
+}
+declare const name: "marbleProceduralTexturePixelShader";
+declare const shader: "precision highp float;\nvarying vec2 vPosition;\nvarying vec2 vUV;\nuniform float numberOfTilesHeight;\nuniform float numberOfTilesWidth;\nuniform float amplitude;\nuniform vec3 marbleColor;\nuniform vec3 jointColor;\nconst vec3 tileSize=vec3(1.1,1.0,1.1);\nconst vec3 tilePct=vec3(0.98,1.0,0.98);\nfloat rand(vec2 n) {\nreturn fract(cos(dot(n,vec2(12.9898,4.1414)))*43758.5453);\n}\nfloat noise(vec2 n) {\nconst vec2 d=vec2(0.0,1.0);\nvec2 b=floor(n),f=smoothstep(vec2(0.0),vec2(1.0),fract(n));\nreturn mix(mix(rand(b),rand(b+d.yx),f.x),mix(rand(b+d.xy),rand(b+d.yy),f.x),f.y);\n}\nfloat turbulence(vec2 P)\n{\nfloat val=0.0;\nfloat freq=1.0;\nfor (int i=0; i<4; i++)\n{\nval+=abs(noise(P*freq)/freq);\nfreq*=2.07;\n}\nreturn val;\n}\nfloat roundF(float number){\nreturn sign(number)*floor(abs(number)+0.5);\n}\nvec3 marble_color(float x)\n{\nvec3 col;\nx=0.5*(x+1.);\nx=sqrt(x); \nx=sqrt(x);\nx=sqrt(x);\ncol=vec3(.2+.75*x); \ncol.b*=0.95; \nreturn col;\n}\nvoid main()\n{\nfloat brickW=1.0/numberOfTilesWidth;\nfloat brickH=1.0/numberOfTilesHeight;\nfloat jointWPercentage=0.01;\nfloat jointHPercentage=0.01;\nvec3 color=marbleColor;\nfloat yi=vUV.y/brickH;\nfloat nyi=roundF(yi);\nfloat xi=vUV.x/brickW;\nif (mod(floor(yi),2.0)==0.0){\nxi=xi-0.5;\n}\nfloat nxi=roundF(xi);\nvec2 brickvUV=vec2((xi-floor(xi))/brickH,(yi-floor(yi))/brickW);\nif (yi<nyi+jointHPercentage && yi>nyi-jointHPercentage){\ncolor=mix(jointColor,vec3(0.37,0.25,0.25),(yi-nyi)/jointHPercentage+0.2);\n}\nelse if (xi<nxi+jointWPercentage && xi>nxi-jointWPercentage){\ncolor=mix(jointColor,vec3(0.44,0.44,0.44),(xi-nxi)/jointWPercentage+0.2);\n}\nelse {\nfloat t=6.28*brickvUV.x/(tileSize.x+noise(vec2(vUV)*6.0));\nt+=amplitude*turbulence(brickvUV.xy);\nt=sin(t);\ncolor=marble_color(t);\n}\ngl_FragColor=vec4(color,0.0);\n}";
+export {};

package/dist/types/node_modules/@babylonjs/procedural-textures/normalMap/index.d.ts

@@ -0,0 +1 @@
+export * from "./normalMapProceduralTexture.js";

package/dist/types/node_modules/@babylonjs/procedural-textures/normalMap/normalMapProceduralTexture.d.ts

@@ -0,0 +1,18 @@
+export class NormalMapProceduralTexture extends ProceduralTexture {
+    /**
+     * Creates a Normal Map Procedural Texture from parsed normal map procedural texture data
+     * @param parsedTexture defines parsed texture data
+     * @param scene defines the current scene
+     * @param rootUrl defines the root URL containing normal map procedural texture information
+     * @returns a parsed Normal Map Procedural Texture
+     */
+    static Parse(parsedTexture: any, scene: any, rootUrl: any): NormalMapProceduralTexture;
+    constructor(name: any, size: any, scene: null | undefined, fallbackTexture: any, generateMipMaps: any);
+    updateShaderUniforms(): void;
+    render(useCameraPostProcess: any): void;
+    resize(size: any, generateMipMaps: any): void;
+    set baseTexture(arg: any);
+    get baseTexture(): any;
+    _baseTexture: any;
+}
+import { ProceduralTexture } from "@babylonjs/core/Materials/Textures/Procedurals/proceduralTexture.js";

package/dist/types/node_modules/@babylonjs/procedural-textures/normalMap/normalMapProceduralTexture.fragment.d.ts

@@ -0,0 +1,7 @@
+export namespace normalMapProceduralTexturePixelShader {
+    export { name };
+    export { shader };
+}
+declare const name: "normalMapProceduralTexturePixelShader";
+declare const shader: "precision highp float;uniform sampler2D baseSampler;uniform float size;varying vec2 vUV;const vec3 LUMA_COEFFICIENT=vec3(0.2126,0.7152,0.0722);float lumaAtCoord(vec2 coord)\n{vec3 pixel=texture2D(baseSampler,coord).rgb;float luma=dot(pixel,LUMA_COEFFICIENT);return luma;}\nvoid main()\n{float lumaU0=lumaAtCoord(vUV+vec2(-1.0, 0.0)/size);float lumaU1=lumaAtCoord(vUV+vec2( 1.0, 0.0)/size);float lumaV0=lumaAtCoord(vUV+vec2( 0.0,-1.0)/size);float lumaV1=lumaAtCoord(vUV+vec2( 0.0, 1.0)/size);vec2 slope=(vec2(lumaU0-lumaU1,lumaV0-lumaV1)+1.0)*0.5;gl_FragColor=vec4(slope,1.0,1.0);}\n";
+export {};

package/dist/types/node_modules/@babylonjs/procedural-textures/perlinNoise/index.d.ts

@@ -0,0 +1 @@
+export * from "./perlinNoiseProceduralTexture.js";

package/dist/types/node_modules/@babylonjs/procedural-textures/perlinNoise/perlinNoiseProceduralTexture.d.ts

@@ -0,0 +1,19 @@
+export class PerlinNoiseProceduralTexture extends ProceduralTexture {
+    /**
+     * Creates a Perlin Noise Procedural Texture from parsed perlin noise procedural texture data
+     * @param parsedTexture defines parsed texture data
+     * @param scene defines the current scene
+     * @param rootUrl defines the root URL containing perlin noise procedural texture information
+     * @returns a parsed Perlin Noise Procedural Texture
+     */
+    static Parse(parsedTexture: any, scene: any, rootUrl: any): PerlinNoiseProceduralTexture;
+    constructor(name: any, size: any, scene: null | undefined, fallbackTexture: any, generateMipMaps: any);
+    time: number;
+    timeScale: number;
+    translationSpeed: number;
+    _currentTranslation: number;
+    updateShaderUniforms(): void;
+    render(useCameraPostProcess: any): void;
+    resize(size: any, generateMipMaps: any): void;
+}
+import { ProceduralTexture } from "@babylonjs/core/Materials/Textures/Procedurals/proceduralTexture.js";

package/dist/types/node_modules/@babylonjs/procedural-textures/perlinNoise/perlinNoiseProceduralTexture.fragment.d.ts

@@ -0,0 +1,7 @@
+export namespace perlinNoiseProceduralTexturePixelShader {
+    export { name };
+    export { shader };
+}
+declare const name: "perlinNoiseProceduralTexturePixelShader";
+declare const shader: "precision highp float;uniform float size;uniform float time;uniform float translationSpeed;varying vec2 vUV;float r(float n)\n{return fract(cos(n*89.42)*343.42);}\nvec2 r(vec2 n)\n{return vec2(r(n.x*23.62-300.0+n.y*34.35),r(n.x*45.13+256.0+n.y*38.89)); }\nfloat worley(vec2 n,float s)\n{float dis=1.0;for(int x=-1; x<=1; x++)\n{for(int y=-1; y<=1; y++)\n{vec2 p=floor(n/s)+vec2(x,y);float d=length(r(p)+vec2(x,y)-fract(n/s));if (dis>d)\ndis=d;}}\nreturn 1.0-dis;}\nvec3 hash33(vec3 p3)\n{p3=fract(p3*vec3(0.1031,0.11369,0.13787));p3+=dot(p3,p3.yxz+19.19);return -1.0+2.0*fract(vec3((p3.x+p3.y)*p3.z,(p3.x+p3.z)*p3.y,(p3.y+p3.z)*p3.x));}\nfloat perlinNoise(vec3 p)\n{vec3 pi=floor(p);vec3 pf=p-pi;vec3 w=pf*pf*(3.0-2.0*pf);return mix(\nmix(\nmix(\ndot(pf-vec3(0,0,0),hash33(pi+vec3(0,0,0))),\ndot(pf-vec3(1,0,0),hash33(pi+vec3(1,0,0))),w.x\n),mix(\ndot(pf-vec3(0,0,1),hash33(pi+vec3(0,0,1))),\ndot(pf-vec3(1,0,1),hash33(pi+vec3(1,0,1))),w.x\n),w.z\n),mix(\nmix(\ndot(pf-vec3(0,1,0),hash33(pi+vec3(0,1,0))),\ndot(pf-vec3(1,1,0),hash33(pi+vec3(1,1,0))),w.x\n),mix(\ndot(pf-vec3(0,1,1),hash33(pi+vec3(0,1,1))),\ndot(pf-vec3(1,1,1),hash33(pi+vec3(1,1,1))),w.x\n),w.z\n),w.y\n);}\n#define CUSTOM_FRAGMENT_DEFINITIONS\nvoid main(void)\n{vec2 uv=gl_FragCoord.xy+translationSpeed;float dis=(\n1.0+perlinNoise(vec3(uv/vec2(size,size),time*0.05)*8.0))\n* (1.0+(worley(uv,32.0)+ 0.5*worley(2.0*uv,32.0)+0.25*worley(4.0*uv,32.0))\n);gl_FragColor=vec4(vec3(dis/4.0),1.0);}\n";
+export {};

package/dist/types/node_modules/@babylonjs/procedural-textures/road/index.d.ts

@@ -0,0 +1 @@
+export * from "./roadProceduralTexture.js";

package/dist/types/node_modules/@babylonjs/procedural-textures/road/roadProceduralTexture.d.ts

@@ -0,0 +1,17 @@
+export class RoadProceduralTexture extends ProceduralTexture {
+    /**
+     * Creates a Road Procedural Texture from parsed road procedural texture data
+     * @param parsedTexture defines parsed texture data
+     * @param scene defines the current scene
+     * @param rootUrl defines the root URL containing road procedural texture information
+     * @returns a parsed Road Procedural Texture
+     */
+    static Parse(parsedTexture: any, scene: any, rootUrl: any): RoadProceduralTexture;
+    constructor(name: any, size: any, scene: null | undefined, fallbackTexture: any, generateMipMaps: any);
+    _roadColor: Color3;
+    updateShaderUniforms(): void;
+    set roadColor(arg: Color3);
+    get roadColor(): Color3;
+}
+import { ProceduralTexture } from "@babylonjs/core/Materials/Textures/Procedurals/proceduralTexture.js";
+import { Color3 } from "@babylonjs/core/Maths/math.color.js";

package/dist/types/node_modules/@babylonjs/procedural-textures/road/roadProceduralTexture.fragment.d.ts

@@ -0,0 +1,7 @@
+export namespace roadProceduralTexturePixelShader {
+    export { name };
+    export { shader };
+}
+declare const name: "roadProceduralTexturePixelShader";
+declare const shader: "precision highp float;varying vec2 vUV; \nuniform vec3 roadColor;float rand(vec2 n) {return fract(cos(dot(n,vec2(12.9898,4.1414)))*43758.5453);}\nfloat noise(vec2 n) {const vec2 d=vec2(0.0,1.0);vec2 b=floor(n),f=smoothstep(vec2(0.0),vec2(1.0),fract(n));return mix(mix(rand(b),rand(b+d.yx),f.x),mix(rand(b+d.xy),rand(b+d.yy),f.x),f.y);}\nfloat fbm(vec2 n) {float total=0.0,amplitude=1.0;for (int i=0; i<4; i++) {total+=noise(n)*amplitude;n+=n;amplitude*=0.5;}\nreturn total;}\n#define CUSTOM_FRAGMENT_DEFINITIONS\nvoid main(void) {\n#define CUSTOM_FRAGMENT_MAIN_BEGIN\nfloat ratioy=mod(gl_FragCoord.y*100.0 ,fbm(vUV*2.0));vec3 color=roadColor*ratioy;gl_FragColor=vec4(color,1.0);\n#define CUSTOM_FRAGMENT_MAIN_END\n}";
+export {};

package/dist/types/node_modules/@babylonjs/procedural-textures/starfield/index.d.ts

@@ -0,0 +1 @@
+export * from "./starfieldProceduralTexture.js";

package/dist/types/node_modules/@babylonjs/procedural-textures/starfield/starfieldProceduralTexture.d.ts

@@ -0,0 +1,46 @@
+export class StarfieldProceduralTexture extends ProceduralTexture {
+    /**
+     * Creates a Starfield Procedural Texture from parsed startfield procedural texture data
+     * @param parsedTexture defines parsed texture data
+     * @param scene defines the current scene
+     * @param rootUrl defines the root URL containing startfield procedural texture information
+     * @returns a parsed Starfield Procedural Texture
+     */
+    static Parse(parsedTexture: any, scene: any, rootUrl: any): StarfieldProceduralTexture;
+    constructor(name: any, size: any, scene: null | undefined, fallbackTexture: any, generateMipMaps: any);
+    _time: number;
+    _alpha: number;
+    _beta: number;
+    _zoom: number;
+    _formuparam: number;
+    _stepsize: number;
+    _tile: number;
+    _brightness: number;
+    _darkmatter: number;
+    _distfading: number;
+    _saturation: number;
+    updateShaderUniforms(): void;
+    set time(arg: number);
+    get time(): number;
+    set alpha(arg: number);
+    get alpha(): number;
+    set beta(arg: number);
+    get beta(): number;
+    set formuparam(arg: number);
+    get formuparam(): number;
+    set stepsize(arg: number);
+    get stepsize(): number;
+    set zoom(arg: number);
+    get zoom(): number;
+    set tile(arg: number);
+    get tile(): number;
+    set brightness(arg: number);
+    get brightness(): number;
+    set darkmatter(arg: number);
+    get darkmatter(): number;
+    set distfading(arg: number);
+    get distfading(): number;
+    set saturation(arg: number);
+    get saturation(): number;
+}
+import { ProceduralTexture } from "@babylonjs/core/Materials/Textures/Procedurals/proceduralTexture.js";

package/dist/types/node_modules/@babylonjs/procedural-textures/starfield/starfieldProceduralTexture.fragment.d.ts

@@ -0,0 +1,7 @@
+export namespace starfieldProceduralTexturePixelShader {
+    export { name };
+    export { shader };
+}
+declare const name: "starfieldProceduralTexturePixelShader";
+declare const shader: "precision highp float;\n#define volsteps 20\n#define iterations 15\nvarying vec2 vPosition;varying vec2 vUV;uniform float time;uniform float alpha;uniform float beta;uniform float zoom;uniform float formuparam;uniform float stepsize;uniform float tile;uniform float brightness;uniform float darkmatter;uniform float distfading;uniform float saturation;void main()\n{vec3 dir=vec3(vUV*zoom,1.);float localTime=time*0.0001;mat2 rot1=mat2(cos(alpha),sin(alpha),-sin(alpha),cos(alpha));mat2 rot2=mat2(cos(beta),sin(beta),-sin(beta),cos(beta));dir.xz*=rot1;dir.xy*=rot2;vec3 from=vec3(1.,.5,0.5);from+=vec3(-2.,localTime*2.,localTime);from.xz*=rot1;from.xy*=rot2;float s=0.1,fade=1.;vec3 v=vec3(0.);for (int r=0; r<volsteps; r++) {vec3 p=from+s*dir*.5;p=abs(vec3(tile)-mod(p,vec3(tile*2.))); \nfloat pa,a=pa=0.;for (int i=0; i<iterations; i++) {p=abs(p)/dot(p,p)-formuparam; \na+=abs(length(p)-pa); \npa=length(p);}\nfloat dm=max(0.,darkmatter-a*a*.001); \na*=a*a; \nif (r>6) fade*=1.-dm; \nv+=fade;v+=vec3(s,s*s,s*s*s*s)*a*brightness*fade; \nfade*=distfading; \ns+=stepsize;}\nv=mix(vec3(length(v)),v,saturation); \ngl_FragColor=vec4(v*.01,1.);}";
+export {};

package/dist/types/node_modules/@babylonjs/procedural-textures/wood/index.d.ts

@@ -0,0 +1 @@
+export * from "./woodProceduralTexture.js";

package/dist/types/node_modules/@babylonjs/procedural-textures/wood/woodProceduralTexture.d.ts

@@ -0,0 +1,20 @@
+export class WoodProceduralTexture extends ProceduralTexture {
+    /**
+     * Creates a Wood Procedural Texture from parsed wood procedural texture data
+     * @param parsedTexture defines parsed texture data
+     * @param scene defines the current scene
+     * @param rootUrl defines the root URL containing wood procedural texture information
+     * @returns a parsed Wood Procedural Texture
+     */
+    static Parse(parsedTexture: any, scene: any, rootUrl: any): WoodProceduralTexture;
+    constructor(name: any, size: any, scene: null | undefined, fallbackTexture: any, generateMipMaps: any);
+    _ampScale: number;
+    _woodColor: Color3;
+    updateShaderUniforms(): void;
+    set ampScale(arg: number);
+    get ampScale(): number;
+    set woodColor(arg: Color3);
+    get woodColor(): Color3;
+}
+import { ProceduralTexture } from "@babylonjs/core/Materials/Textures/Procedurals/proceduralTexture.js";
+import { Color3 } from "@babylonjs/core/Maths/math.color.js";

package/dist/types/node_modules/@babylonjs/procedural-textures/wood/woodProceduralTexture.fragment.d.ts

@@ -0,0 +1,7 @@
+export namespace woodProceduralTexturePixelShader {
+    export { name };
+    export { shader };
+}
+declare const name: "woodProceduralTexturePixelShader";
+declare const shader: "precision highp float;varying vec2 vPosition;varying vec2 vUV;uniform float ampScale;uniform vec3 woodColor;float rand(vec2 n) {return fract(cos(dot(n,vec2(12.9898,4.1414)))*43758.5453);}\nfloat noise(vec2 n) {const vec2 d=vec2(0.0,1.0);vec2 b=floor(n),f=smoothstep(vec2(0.0),vec2(1.0),fract(n));return mix(mix(rand(b),rand(b+d.yx),f.x),mix(rand(b+d.xy),rand(b+d.yy),f.x),f.y);}\nfloat fbm(vec2 n) {float total=0.0,amplitude=1.0;for (int i=0; i<4; i++) {total+=noise(n)*amplitude;n+=n;amplitude*=0.5;}\nreturn total;}\n#define CUSTOM_FRAGMENT_DEFINITIONS\nvoid main(void) {\n#define CUSTOM_FRAGMENT_MAIN_BEGIN\nfloat ratioy=mod(vUV.x*ampScale,2.0+fbm(vUV*0.8));vec3 wood=woodColor*ratioy;gl_FragColor=vec4(wood,1.0);\n#define CUSTOM_FRAGMENT_MAIN_END\n}";
+export {};

package/dist/types/node_modules/@babylonjs/serializers/OBJ/index.d.ts

@@ -0,0 +1 @@
+export * from "./objSerializer.js";

package/dist/types/node_modules/@babylonjs/serializers/OBJ/objSerializer.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Class for generating OBJ data from a Babylon scene.
+ */
+export class OBJExport {
+    /**
+     * Exports the geometry of a Mesh array in .OBJ file format (text)
+     * @param mesh defines the list of meshes to serialize
+     * @param materials defines if materials should be exported
+     * @param matlibname defines the name of the associated mtl file
+     * @param globalposition defines if the exported positions are globals or local to the exported mesh
+     * @returns the OBJ content
+     */
+    static OBJ(mesh: any, materials: any, matlibname: any, globalposition: any): string;
+    /**
+     * Exports the material(s) of a mesh in .MTL file format (text)
+     * @param mesh defines the mesh to extract the material from
+     * @returns the mtl content
+     */
+    static MTL(mesh: any): string;
+}

package/dist/types/node_modules/@babylonjs/serializers/glTF/2.0/Extensions/EXT_mesh_gpu_instancing.d.ts

@@ -0,0 +1,19 @@
+/**
+ * [Specification](https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Vendor/EXT_mesh_gpu_instancing/README.md)
+ */
+export class EXT_mesh_gpu_instancing {
+    constructor(exporter: any);
+    /** Name of this extension */
+    name: string;
+    /** Defines whether this extension is enabled */
+    enabled: boolean;
+    /** Defines whether this extension is required */
+    required: boolean;
+    _wasUsed: boolean;
+    _exporter: any;
+    dispose(): void;
+    /** @internal */
+    get wasUsed(): boolean;
+    postExportNodeAsync(context: any, node: any, babylonNode: any, nodeMap: any, binaryWriter: any): Promise<any>;
+    _buildAccessor(buffer: any, type: any, count: any, binaryWriter: any, componentType: any): any;
+}

package/dist/types/node_modules/@babylonjs/serializers/glTF/2.0/Extensions/KHR_lights_punctual.d.ts

@@ -0,0 +1,34 @@
+/**
+ * [Specification](https://github.com/KhronosGroup/glTF/blob/master/extensions/2.0/Khronos/KHR_lights_punctual/README.md)
+ */
+export class KHR_lights_punctual {
+    /**
+     * @internal
+     */
+    constructor(exporter: any);
+    /** The name of this extension. */
+    name: string;
+    /** Defines whether this extension is enabled. */
+    enabled: boolean;
+    /** Defines whether this extension is required */
+    required: boolean;
+    _exporter: any;
+    /** @internal */
+    dispose(): void;
+    _lights: {
+        lights: never[];
+    } | null | undefined;
+    /** @internal */
+    get wasUsed(): boolean;
+    /** @internal */
+    onExporting(): void;
+    /**
+     * Define this method to modify the default behavior when exporting a node
+     * @param context The context when exporting the node
+     * @param node glTF node
+     * @param babylonNode BabylonJS node
+     * @param nodeMap Node mapping of unique id to glTF node index
+     * @returns nullable INode promise
+     */
+    postExportNodeAsync(context: any, node: any, babylonNode: any, nodeMap: any): Promise<any>;
+}

package/dist/types/node_modules/@babylonjs/serializers/glTF/2.0/Extensions/KHR_materials_clearcoat.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @internal
+ */
+export class KHR_materials_clearcoat {
+    constructor(exporter: any);
+    /** Name of this extension */
+    name: string;
+    /** Defines whether this extension is enabled */
+    enabled: boolean;
+    /** Defines whether this extension is required */
+    required: boolean;
+    _wasUsed: boolean;
+    _exporter: any;
+    dispose(): void;
+    /** @internal */
+    get wasUsed(): boolean;
+    postExportMaterialAdditionalTextures(context: any, node: any, babylonMaterial: any): import("@babylonjs/core").BaseTexture[];
+    postExportMaterialAsync(context: any, node: any, babylonMaterial: any): Promise<any>;
+}

package/dist/types/node_modules/@babylonjs/serializers/glTF/2.0/Extensions/KHR_materials_ior.d.ts

@@ -0,0 +1,17 @@
+/**
+ * [Specification](https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_materials_ior/README.md)
+ */
+export class KHR_materials_ior {
+    /** Name of this extension */
+    name: string;
+    /** Defines whether this extension is enabled */
+    enabled: boolean;
+    /** Defines whether this extension is required */
+    required: boolean;
+    _wasUsed: boolean;
+    dispose(): void;
+    /** @internal */
+    get wasUsed(): boolean;
+    _isExtensionEnabled(mat: any): boolean;
+    postExportMaterialAsync(context: any, node: any, babylonMaterial: any): Promise<any>;
+}

package/dist/types/node_modules/@babylonjs/serializers/glTF/2.0/Extensions/KHR_materials_iridescence.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @internal
+ */
+export class KHR_materials_iridescence {
+    constructor(exporter: any);
+    /** Name of this extension */
+    name: string;
+    /** Defines whether this extension is enabled */
+    enabled: boolean;
+    /** Defines whether this extension is required */
+    required: boolean;
+    _wasUsed: boolean;
+    _exporter: any;
+    dispose(): void;
+    /** @internal */
+    get wasUsed(): boolean;
+    postExportMaterialAdditionalTextures(context: any, node: any, babylonMaterial: any): import("@babylonjs/core").BaseTexture[];
+    postExportMaterialAsync(context: any, node: any, babylonMaterial: any): Promise<any>;
+}

package/dist/types/node_modules/@babylonjs/serializers/glTF/2.0/Extensions/KHR_materials_sheen.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @internal
+ */
+export class KHR_materials_sheen {
+    constructor(exporter: any);
+    /** Name of this extension */
+    name: string;
+    /** Defines whether this extension is enabled */
+    enabled: boolean;
+    /** Defines whether this extension is required */
+    required: boolean;
+    _wasUsed: boolean;
+    _exporter: any;
+    dispose(): void;
+    /** @internal */
+    get wasUsed(): boolean;
+    postExportMaterialAdditionalTextures(context: any, node: any, babylonMaterial: any): import("@babylonjs/core").BaseTexture[];
+    postExportMaterialAsync(context: any, node: any, babylonMaterial: any): Promise<any>;
+}

package/dist/types/node_modules/@babylonjs/serializers/glTF/2.0/Extensions/KHR_materials_specular.d.ts

@@ -0,0 +1,21 @@
+/**
+ * [Specification](https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_materials_specular/README.md)
+ */
+export class KHR_materials_specular {
+    constructor(exporter: any);
+    /** Name of this extension */
+    name: string;
+    /** Defines whether this extension is enabled */
+    enabled: boolean;
+    /** Defines whether this extension is required */
+    required: boolean;
+    _wasUsed: boolean;
+    _exporter: any;
+    dispose(): void;
+    /** @internal */
+    get wasUsed(): boolean;
+    postExportMaterialAdditionalTextures(context: any, node: any, babylonMaterial: any): any[];
+    _isExtensionEnabled(mat: any): boolean;
+    _hasTexturesExtension(mat: any): boolean;
+    postExportMaterialAsync(context: any, node: any, babylonMaterial: any): Promise<any>;
+}

package/dist/types/node_modules/@babylonjs/serializers/glTF/2.0/Extensions/KHR_materials_transmission.d.ts

@@ -0,0 +1,21 @@
+/**
+ * [Specification](https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_materials_transmission/README.md)
+ */
+export class KHR_materials_transmission {
+    constructor(exporter: any);
+    /** Name of this extension */
+    name: string;
+    /** Defines whether this extension is enabled */
+    enabled: boolean;
+    /** Defines whether this extension is required */
+    required: boolean;
+    _wasUsed: boolean;
+    _exporter: any;
+    dispose(): void;
+    /** @internal */
+    get wasUsed(): boolean;
+    postExportMaterialAdditionalTextures(context: any, node: any, babylonMaterial: any): any[];
+    _isExtensionEnabled(mat: any): any;
+    _hasTexturesExtension(mat: any): boolean;
+    postExportMaterialAsync(context: any, node: any, babylonMaterial: any): Promise<any>;
+}

package/dist/types/node_modules/@babylonjs/serializers/glTF/2.0/Extensions/KHR_materials_unlit.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @internal
+ */
+export class KHR_materials_unlit {
+    /** Name of this extension */
+    name: string;
+    /** Defines whether this extension is enabled */
+    enabled: boolean;
+    /** Defines whether this extension is required */
+    required: boolean;
+    _wasUsed: boolean;
+    /** @internal */
+    get wasUsed(): boolean;
+    dispose(): void;
+    postExportMaterialAsync(context: any, node: any, babylonMaterial: any): Promise<any>;
+}

package/dist/types/node_modules/@babylonjs/serializers/glTF/2.0/Extensions/KHR_materials_volume.d.ts

@@ -0,0 +1,21 @@
+/**
+ * [Specification](https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_materials_volume/README.md)
+ */
+export class KHR_materials_volume {
+    constructor(exporter: any);
+    /** Name of this extension */
+    name: string;
+    /** Defines whether this extension is enabled */
+    enabled: boolean;
+    /** Defines whether this extension is required */
+    required: boolean;
+    _wasUsed: boolean;
+    _exporter: any;
+    dispose(): void;
+    /** @internal */
+    get wasUsed(): boolean;
+    postExportMaterialAdditionalTextures(context: any, node: any, babylonMaterial: any): any[];
+    _isExtensionEnabled(mat: any): boolean;
+    _hasTexturesExtension(mat: any): boolean;
+    postExportMaterialAsync(context: any, node: any, babylonMaterial: any): Promise<any>;
+}

package/dist/types/node_modules/@babylonjs/serializers/glTF/2.0/Extensions/KHR_texture_transform.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @internal
+ */
+export class KHR_texture_transform {
+    _recordedTextures: any[];
+    /** Name of this extension */
+    name: string;
+    /** Defines whether this extension is enabled */
+    enabled: boolean;
+    /** Defines whether this extension is required */
+    required: boolean;
+    /** Reference to the glTF exporter */
+    _wasUsed: boolean;
+    dispose(): void;
+    /** @internal */
+    get wasUsed(): boolean;
+    postExportTexture(context: any, textureInfo: any, babylonTexture: any): void;
+    preExportTextureAsync(context: any, babylonTexture: any): Promise<any>;
+    /**
+     * Transform the babylon texture by the offset, rotation and scale parameters using a procedural texture
+     * @param babylonTexture
+     * @param scene
+     */
+    _textureTransformTextureAsync(babylonTexture: any, scene: any): Promise<any>;
+}

package/dist/types/node_modules/@babylonjs/serializers/glTF/2.0/Extensions/index.d.ts

@@ -0,0 +1,11 @@
+export * from "./KHR_texture_transform.js";
+export * from "./KHR_lights_punctual.js";
+export * from "./KHR_materials_clearcoat.js";
+export * from "./KHR_materials_iridescence.js";
+export * from "./KHR_materials_sheen.js";
+export * from "./KHR_materials_unlit.js";
+export * from "./KHR_materials_ior.js";
+export * from "./KHR_materials_specular.js";
+export * from "./KHR_materials_volume.js";
+export * from "./KHR_materials_transmission.js";
+export * from "./EXT_mesh_gpu_instancing.js";