getfloorplan-gltf-widget 1.11.29

package/build/types/three/GFPGLTFLoader/extensions/GLTFBinaryExtension.d.ts

@@ -0,0 +1,13 @@
+export declare const BINARY_EXTENSION_HEADER_MAGIC = "glTF";
+export declare const BINARY_EXTENSION_HEADER_LENGTH = 12;
+export declare const BINARY_EXTENSION_CHUNK_TYPES: {
+    JSON: number;
+    BIN: number;
+};
+export declare class GLTFBinaryExtension {
+    name: string;
+    content: any | null;
+    body: any | null;
+    header: any;
+    constructor(data: any);
+}

package/build/types/three/GFPGLTFLoader/extensions/GLTFDracoMeshCompressionExtension.d.ts

@@ -0,0 +1,16 @@
+import type { GLTFParser } from '../GLTFParser';
+import type { DRACOLoader } from 'three/examples/jsm/loaders/DRACOLoader';
+/**
+ * DRACO Mesh Compression Extension
+ *
+ * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_draco_mesh_compression
+ *
+ * @private
+ */
+export declare class GLTFDracoMeshCompressionExtension {
+    name: string;
+    json: any;
+    dracoLoader: DRACOLoader;
+    constructor(json: any, dracoLoader: DRACOLoader);
+    decodePrimitive(primitive: any, parser: GLTFParser): any;
+}

package/build/types/three/GFPGLTFLoader/extensions/GLTFMaterialsEmissiveStrengthExtension.d.ts

@@ -0,0 +1,14 @@
+import type { GLTFParser } from '../GLTFParser';
+/**
+ * Materials Emissive Strength Extension
+ *
+ * Specification: https://github.com/KhronosGroup/glTF/blob/5768b3ce0ef32bc39cdf1bef10b948586635ead3/extensions/2.0/Khronos/KHR_materials_emissive_strength/README.md
+ *
+ * @private
+ */
+export declare class GLTFMaterialsEmissiveStrengthExtension {
+    parser: GLTFParser;
+    name: string;
+    constructor(parser: GLTFParser);
+    extendMaterialParams(materialIndex: number, materialParams: Record<string, any>): Promise<void>;
+}

package/build/types/three/GFPGLTFLoader/extensions/GLTFMaterialsTransmissionExtension.d.ts

@@ -0,0 +1,17 @@
+import type { GLTFParser } from '../GLTFParser';
+import { UnrealMaterial } from 'three/UnrealMaterial';
+/**
+ * Transmission Materials Extension
+ *
+ * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_transmission
+ * Draft: https://github.com/KhronosGroup/glTF/pull/1698
+ *
+ * @private
+ */
+export declare class GLTFMaterialsTransmissionExtension {
+    parser: GLTFParser;
+    name: string;
+    constructor(parser: GLTFParser);
+    getMaterialType(materialIndex: number): typeof UnrealMaterial | null;
+    extendMaterialParams(materialIndex: number, materialParams: Record<string, any>): Promise<void> | Promise<import("three").Texture[]>;
+}

package/build/types/three/GFPGLTFLoader/extensions/GLTFMaterialsUnlitExtension.d.ts

@@ -0,0 +1,15 @@
+import type { GLTFParser } from '../GLTFParser';
+import { UnrealMaterial } from 'three/UnrealMaterial';
+/**
+ * Unlit Materials Extension
+ *
+ * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_unlit
+ *
+ * @private
+ */
+export declare class GLTFMaterialsUnlitExtension {
+    name: string;
+    constructor();
+    getMaterialType(): typeof UnrealMaterial;
+    extendParams(materialParams: Record<string, any>, materialDef: Record<string, any>, parser: GLTFParser): Promise<import("three").Texture[]>;
+}

package/build/types/three/GFPGLTFLoader/extensions/GLTFMeshGpuInstancing.d.ts

@@ -0,0 +1,14 @@
+import type { GLTFParser } from '../GLTFParser';
+/**
+ * GPU Instancing Extension
+ *
+ * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/EXT_mesh_gpu_instancing
+ *
+ * @private
+ */
+export declare class GLTFMeshGpuInstancing {
+    parser: GLTFParser;
+    name: string;
+    constructor(parser: GLTFParser);
+    createNodeMesh(nodeIndex: number): Promise<any> | null;
+}

package/build/types/three/GFPGLTFLoader/extensions/GLTFMeshQuantizationExtension.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Mesh Quantization Extension
+ *
+ * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_mesh_quantization
+ *
+ * @private
+ */
+export declare class GLTFMeshQuantizationExtension {
+    name: string;
+    constructor();
+}

package/build/types/three/GFPGLTFLoader/extensions/GLTFMeshoptCompression.d.ts

@@ -0,0 +1,14 @@
+import type { GLTFParser } from '../GLTFParser';
+/**
+ * meshopt BufferView Compression Extension
+ *
+ * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/EXT_meshopt_compression
+ *
+ * @private
+ */
+export declare class GLTFMeshoptCompression {
+    parser: GLTFParser;
+    name: string;
+    constructor(parser: GLTFParser);
+    loadBufferView(index: number): any;
+}

package/build/types/three/GFPGLTFLoader/extensions/GLTFTextureAVIFExtension.d.ts

@@ -0,0 +1,14 @@
+import type { GLTFParser } from '../GLTFParser';
+/**
+ * AVIF Texture Extension
+ *
+ * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/EXT_texture_avif
+ *
+ * @private
+ */
+export declare class GLTFTextureAVIFExtension {
+    parser: GLTFParser;
+    name: string;
+    constructor(parser: GLTFParser);
+    loadTexture(textureIndex: number): any;
+}

package/build/types/three/GFPGLTFLoader/extensions/GLTFTextureBasisUExtension.d.ts

@@ -0,0 +1,14 @@
+import type { GLTFParser } from '../GLTFParser';
+/**
+ * BasisU Texture Extension
+ *
+ * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_texture_basisu
+ *
+ * @private
+ */
+export declare class GLTFTextureBasisUExtension {
+    parser: GLTFParser;
+    name: string;
+    constructor(parser: GLTFParser);
+    loadTexture(textureIndex: number): any;
+}

package/build/types/three/GFPGLTFLoader/extensions/GLTFTextureTransformExtension.d.ts

@@ -0,0 +1,13 @@
+import type { Texture } from 'three';
+/**
+ * Texture Transform Extension
+ *
+ * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_texture_transform
+ *
+ * @private
+ */
+export declare class GLTFTextureTransformExtension {
+    name: string;
+    constructor();
+    extendTexture(texture: Texture, transform: any): Texture;
+}

package/build/types/three/GFPGLTFLoader/extensions/GLTFTextureWebPExtension.d.ts

@@ -0,0 +1,14 @@
+import type { GLTFParser } from '../GLTFParser';
+/**
+ * WebP Texture Extension
+ *
+ * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/EXT_texture_webp
+ *
+ * @private
+ */
+export declare class GLTFTextureWebPExtension {
+    parser: GLTFParser;
+    name: string;
+    constructor(parser: GLTFParser);
+    loadTexture(textureIndex: number): any;
+}

package/build/types/three/GFPGLTFLoader/index.d.ts

@@ -0,0 +1,24 @@
+import type { Store } from 'store';
+import type { LoadingManager } from 'three';
+import type { DRACOLoader } from 'three/examples/jsm/loaders/DRACOLoader';
+import type { GLTF } from 'three/examples/jsm/loaders/GLTFLoader';
+import type { KTX2Loader } from 'three/examples/jsm/loaders/KTX2Loader';
+import { Loader } from 'three';
+import { GLTFParser } from './GLTFParser';
+export declare class GFPGLTFLoader extends Loader {
+    dracoLoader: DRACOLoader | null;
+    ktx2Loader: KTX2Loader | null;
+    meshoptDecoder: any | null;
+    pluginCallbacks: ((parser: GLTFParser) => any)[];
+    private readonly _store;
+    constructor(store: Store, manager?: LoadingManager);
+    loadPlease(url: string, onLoad?: (gltf: GLTF) => void, onProgress?: (loaded: number, total: number) => void, onError?: (error: any) => void): void;
+    loadAsyncPlease(url: string, onProgress?: (loaded: number, total: number) => void): Promise<GLTF>;
+    setDRACOLoader(dracoLoader: DRACOLoader): this;
+    setKTX2Loader(ktx2Loader: KTX2Loader): this;
+    setMeshoptDecoder(meshoptDecoder: any): this;
+    register(callback: (parser: GLTFParser) => void): this;
+    unregister(callback: (parser: GLTFParser) => void): this;
+    parse(data: string | ArrayBuffer | object, path?: string, onLoad?: (gltf: GLTF) => void, onProgress?: (loaded: number, total: number) => void, onError?: (error: any) => void): void;
+    parseAsync(data: ArrayBuffer | string | object, path?: string): Promise<GLTF>;
+}

package/build/types/three/GFPGLTFLoader/lib/GLTFCubicSplineInterpolant.d.ts

@@ -0,0 +1,6 @@
+import { Interpolant } from 'three';
+export declare class GLTFCubicSplineInterpolant extends Interpolant {
+    constructor(parameterPositions: any, sampleValues: any, sampleSize: any, resultBuffer: any);
+    copySampleValue_(index: number): any;
+    interpolate_(i1: number, t0: number, t: number, t1: number): any;
+}

package/build/types/three/GFPGLTFLoader/lib/GLTFCubicSplineQuaternionInterpolant.d.ts

@@ -0,0 +1,4 @@
+import { GLTFCubicSplineInterpolant } from './GLTFCubicSplineInterpolant';
+export declare class GLTFCubicSplineQuaternionInterpolant extends GLTFCubicSplineInterpolant {
+    interpolate_(i1: number, t0: number, t: number, t1: number): any;
+}

package/build/types/three/GFPGLTFLoader/utils/addMorphTargets.d.ts

@@ -0,0 +1,12 @@
+import type { GLTFParser } from '../GLTFParser';
+import type { BufferGeometry } from 'three';
+/**
+ * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#morph-targets
+ *
+ * @private
+ * @param {BufferGeometry} geometry
+ * @param {Array<GLTF.Target>} targets
+ * @param {GLTFParser} parser
+ * @return {Promise<BufferGeometry>}
+ */
+export declare function addMorphTargets(geometry: BufferGeometry, targets: any[], parser: GLTFParser): Promise<BufferGeometry>;

package/build/types/three/GFPGLTFLoader/utils/addPrimitiveAttributes.d.ts

@@ -0,0 +1,9 @@
+/**
+ *
+ * @private
+ * @param {BufferGeometry} geometry
+ * @param {GLTF.Primitive} primitiveDef
+ * @param {GLTFParser} parser
+ * @return {Promise<BufferGeometry>}
+ */
+export declare function addPrimitiveAttributes(geometry: any, primitiveDef: any, parser: any): Promise<any>;

package/build/types/three/GFPGLTFLoader/utils/addUnknownExtensionsToUserData.d.ts

@@ -0,0 +1 @@
+export declare function addUnknownExtensionsToUserData(knownExtensions: Record<string, any>, object: any, objectDef: any): void;

package/build/types/three/GFPGLTFLoader/utils/assignExtrasToUserData.d.ts

@@ -0,0 +1,7 @@
+/**
+ *
+ * @private
+ * @param {Object3D|Material|BufferGeometry|Object} object
+ * @param {GLTF.definition} gltfDef
+ */
+export declare function assignExtrasToUserData(object: any, gltfDef: any): void;

package/build/types/three/GFPGLTFLoader/utils/computeBounds.d.ts

@@ -0,0 +1,8 @@
+/**
+ *
+ * @private
+ * @param {BufferGeometry} geometry
+ * @param {GLTF.Primitive} primitiveDef
+ * @param {GLTFParser} parser
+ */
+export declare function computeBounds(geometry: any, primitiveDef: any, parser: any): void;

package/build/types/three/GFPGLTFLoader/utils/createAttributesKey.d.ts

@@ -0,0 +1 @@
+export declare function createAttributesKey(attributes: any): string;

package/build/types/three/GFPGLTFLoader/utils/createDefaultMaterial.d.ts

@@ -0,0 +1,10 @@
+import type { Store } from 'store';
+import { UnrealMaterial } from 'three/UnrealMaterial';
+/**
+ * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#default-material
+ *
+ * @private
+ * @param {Object<string, Material>} cache
+ * @return {Material}
+ */
+export declare function createDefaultMaterial(store: Store): UnrealMaterial;

package/build/types/three/GFPGLTFLoader/utils/createPrimitiveKey.d.ts

@@ -0,0 +1 @@
+export declare function createPrimitiveKey(primitiveDef: any): string;

package/build/types/three/GFPGLTFLoader/utils/getImageURIMimeType.d.ts

@@ -0,0 +1 @@
+export declare function getImageURIMimeType(uri: string): "image/jpeg" | "image/webp" | "image/ktx2" | "image/png";

package/build/types/three/GFPGLTFLoader/utils/getNormalizedComponentScale.d.ts

@@ -0,0 +1 @@
+export declare function getNormalizedComponentScale(constructor: any): number;

package/build/types/three/GFPGLTFLoader/utils/updateMorphTargets.d.ts

@@ -0,0 +1,7 @@
+/**
+ *
+ * @private
+ * @param {Mesh} mesh
+ * @param {GLTF.Mesh} meshDef
+ */
+export declare function updateMorphTargets(mesh: any, meshDef: any): void;

package/build/types/three/SmartGLTFLoader.d.ts

@@ -0,0 +1,11 @@
+import type { Store } from 'store';
+import type { GLTF } from 'three/examples/jsm/loaders/GLTFLoader';
+export declare class SmartGLTFLoader {
+    private readonly _gltfLoader;
+    private readonly _customGLTFLoader;
+    private readonly _store;
+    constructor(store: Store);
+    loadAsync(url: string, path?: string, onProgress?: (loaded: number, total: number) => void): Promise<GLTF>;
+    private loadGlbAsync;
+    private loadGltfAsync;
+}

package/build/types/three/UnrealMaterial/index.d.ts

@@ -0,0 +1,91 @@
+import type { Store } from 'store';
+import type { ColorRepresentation, ShaderMaterialParameters, Texture, ToneMapping, Vector2Like } from 'three';
+import type { TGLTFEpicLightmap } from 'types/TGLTFJson';
+import { Color, RawShaderMaterial, Vector2, Vector4 } from 'three';
+type TUnrealMaterialOptions = ShaderMaterialParameters & {
+    color?: ColorRepresentation;
+    map?: Texture | null;
+    alphaMap?: Texture | null;
+    emissive?: ColorRepresentation;
+    emissiveIntensity?: number;
+    emissiveMap?: Texture | null;
+    metalness?: number;
+    roughness?: number;
+    transmission?: number;
+    ior?: number;
+    metalnessMap?: Texture | null;
+    roughnessMap?: Texture | null;
+    aoMap?: Texture | null;
+    normalScale?: Vector2Like;
+    normalMap?: Texture | null;
+    watermarkMap?: Texture | null;
+};
+export declare class UnrealMaterial extends RawShaderMaterial {
+    private readonly _store;
+    readonly isUnrealMaterial = true;
+    isDebugLightmapVisible: boolean;
+    isDebugMapVisible: boolean;
+    private _prevTime;
+    private _toneMapping;
+    private readonly _smoothness;
+    constructor(store: Store, { uniforms, color, opacity, transmission, map, alphaMap, alphaTest, emissive, emissiveMap, emissiveIntensity, metalness, roughness, ior, metalnessMap, roughnessMap, watermarkMap, aoMap, normalScale, normalMap, ...rest }: TUnrealMaterialOptions);
+    get config(): import("../../config/material/MaterialConfig").TMaterialConfig;
+    get color(): Color;
+    set color(value: Color);
+    get map(): Texture | null;
+    set map(value: Texture | null);
+    get alphaMap(): Texture | null;
+    set alphaMap(value: Texture | null);
+    get emissive(): Color;
+    set emissive(value: Color);
+    get emissiveMap(): Texture | null;
+    set emissiveMap(value: Texture | null);
+    get metalness(): number;
+    set metalness(value: number);
+    get roughness(): number;
+    set roughness(value: number);
+    get transmission(): number;
+    set transmission(value: number);
+    get ior(): number;
+    set ior(value: number);
+    get metalnessMap(): Texture | null;
+    set metalnessMap(value: Texture | null);
+    get roughnessMap(): Texture | null;
+    set roughnessMap(value: Texture | null);
+    get aoMap(): Texture | null;
+    set aoMap(value: Texture | null);
+    get normalScale(): Vector2;
+    set normalScale(value: Vector2);
+    get normalMap(): Texture | null;
+    set normalMap(value: Texture | null);
+    get epicLightMap(): Texture | null;
+    set epicLightMap(value: Texture | null);
+    get coordinateScaleBias(): Vector4;
+    set coordinateScaleBias(value: Vector4);
+    get lightmapAdd(): Vector4;
+    set lightmapAdd(value: Vector4);
+    get lightmapScale(): Vector4;
+    set lightmapScale(value: Vector4);
+    get lightmapIntensity(): number;
+    set lightmapIntensity(value: number);
+    get mapIntensity(): number;
+    set mapIntensity(value: number);
+    get watermarkMap(): Texture | null;
+    set watermarkMap(value: Texture | null);
+    get watermarkIntensity(): number;
+    set watermarkIntensity(value: number);
+    get toneMapping(): ToneMapping;
+    set toneMapping(value: ToneMapping);
+    get toneMappingExposure(): number;
+    set toneMappingExposure(value: number);
+    update: (time: number) => void;
+    private updateMap;
+    private updateLightmap;
+    setLightmapData(lightMap: Texture | null, lightMapData: TGLTFEpicLightmap | null): void;
+    private applyMapTransformUniform;
+    private getUniformTexture;
+    private getToneMappingFunction;
+    private getTexelEncodingFunction;
+    private updateShaders;
+}
+export {};

package/build/types/types/DeepPartial.d.ts

@@ -0,0 +1,3 @@
+export type DeepPartial<T extends object> = {
+    [K in keyof T]?: T[K] extends object ? Partial<DeepPartial<T[K]>> : T[K];
+};

package/build/types/types/DeepRequired.d.ts

@@ -0,0 +1,3 @@
+export type DeepRequired<T> = {
+    [K in keyof T]: Required<T[K] extends object ? DeepRequired<T[K]> : T[K]>;
+};

package/build/types/types/IStoreProps.d.ts

@@ -0,0 +1,4 @@
+import type { Store } from 'store';
+export interface IStoreProps {
+    store: Store;
+}

package/build/types/types/Nullable.d.ts

@@ -0,0 +1 @@
+export type Nullable<T> = T | null | undefined;

package/build/types/types/TBuilding.d.ts

@@ -0,0 +1,218 @@
+export type TUpperVector2 = {
+    X: number;
+    Y: number;
+};
+export type TUpperVector3 = {
+    X: number;
+    Y: number;
+    Z: number;
+};
+export type TUpperVector4 = {
+    X: number;
+    Y: number;
+    Z: number;
+    W: number;
+};
+export type TUpperBounds = {
+    Left: number;
+    Top: number;
+    Right: number;
+    Bottom: number;
+};
+export type TUpperRotator = {
+    Pitch: number;
+    Roll: number;
+    Yaw: number;
+};
+export type TUpperSize2 = {
+    Width: number;
+    Height: number;
+};
+export type TUpperColorRgba = {
+    R: number;
+    G: number;
+    B: number;
+    A: number;
+};
+export type TVector2 = {
+    x: number;
+    y: number;
+};
+export type TVector3 = {
+    x: number;
+    y: number;
+    z: number;
+};
+export type TVector4 = {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+};
+export type TRgb = {
+    r: number;
+    g: number;
+    b: number;
+};
+export type TRgba = {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+};
+export type TBoundsObject = {
+    Origin: TUpperVector3;
+    Extent: TUpperVector3;
+};
+export type TUpperMatrix4 = {
+    XPlane: TUpperVector4;
+    YPlane: TUpperVector4;
+    ZPlane: TUpperVector4;
+    WPlane: TUpperVector4;
+};
+export type TVertex = {
+    ID: string;
+    Location: TUpperVector3;
+};
+export type TControlPoint = {
+    ID: string;
+    Location: TUpperVector3;
+};
+export type TDecor = {
+    ID: string;
+    RoomID?: string | null;
+    Location: TUpperVector3;
+    Rotation: TUpperRotator;
+    Scale: TUpperVector3;
+    Extent: TUpperVector3;
+    Walls?: string[];
+    Model?: string;
+    Type?: string;
+};
+export type TRoom = {
+    ID: string;
+    Type: string;
+    TypeDisplayName?: string;
+    DisplayArea?: string;
+    Area: number;
+    Walls: string[];
+    FloorLayersMolding?: boolean;
+    FloorMoldingModel?: string;
+    CeilingMoldingModel?: string;
+    FloorOffsetZ: number;
+    FloorCutOutIDs?: string[];
+    CeilingCutOutIDs?: string[];
+    Furniture: TFurniture[];
+    FloorLayers?: any[];
+    ColorID?: TUpperColorRgba | null;
+    Width?: number;
+    Length?: number;
+    WallsState?: 'Flipped';
+    CeilingState?: 'Gap';
+    Numeric?: number;
+};
+export type TWall = {
+    ID: string;
+    Vertices: [string, string];
+    ControlPoint?: TControlPoint | null;
+    IsCurved?: boolean;
+    IsExterior?: boolean;
+    IsHidden?: boolean;
+    MaterialID?: number;
+    Model?: string;
+};
+export type TFurniture = Record<string, any> & {
+    ID: string;
+    Type: string;
+    Model: string;
+    RoomID: string;
+    Location: TUpperVector3;
+    Rotation: TUpperRotator;
+    Scale: TUpperVector3;
+    Extent: TUpperVector3;
+    HideWithCeiling?: boolean;
+};
+export type TCameraPoint = {
+    ID: string;
+    RoomID: string | null;
+    Location: TUpperVector3;
+    Rotation: TUpperRotator;
+};
+export type TPortal = {
+    ID: string;
+    Location: TUpperVector3;
+    RelativeLocation: TUpperVector3;
+    Rotation: TUpperRotator;
+    Scale: TUpperVector3;
+    Extent: TUpperVector3;
+    Icon: string;
+    FromID: string;
+    ToID: string;
+};
+export type TUnit = {
+    Location: TUpperVector3;
+    Rotation: TUpperRotator;
+    Scale: TUpperVector3;
+    Rooms: TRoom[];
+};
+export type TFloor = {
+    Number: number;
+    Entrance: number;
+    Height: number;
+    FloorOffsetZ: number;
+    MarginTop: number;
+    MarginBottom: number;
+    Location: TUpperVector3;
+    Rotation: TUpperRotator;
+    Scale: TUpperVector3;
+    Units: TUnit[];
+    Walls: TWall[];
+    CameraPoints: TCameraPoint[];
+    Apertures: any[];
+    Doors?: any[];
+    Decors: TDecor[];
+    RoofSlopes: any[];
+    RoofSlopeApertures: any[];
+    Portals?: TPortal[];
+    ExteriorWalls: string[];
+    GlassWalls: string[];
+    FenceWalls: string[];
+    VerandaWalls: string[];
+    CompanionWalls: string[];
+    Helpers: any[];
+    PrimaryCameraPointId: string | null;
+};
+export type TWidgetInfo = {
+    PlanBounds: TUpperBounds[];
+};
+export type TBackgroundTransform = {
+    Location: TUpperVector2;
+    Scale: TUpperVector2;
+    Rotation: number;
+    Modified: boolean;
+};
+export type TMeta = {
+    FloorsScales?: TUpperVector3[];
+    BackgroundsTransforms?: TBackgroundTransform[];
+    WidgetInfo?: TWidgetInfo;
+    PrimaryCameraPointId?: string;
+};
+export type TObjectType = 'Room' | 'Furniture' | 'Aperture';
+export type TObjectMaskColorPair = {
+    ObjectID: string;
+    Type: TObjectType;
+    MaskColorID: TUpperColorRgba;
+};
+export type TRoomColorIDPair = {
+    ObjectID: string;
+    Type: TObjectType;
+    ColorID: TUpperColorRgba;
+};
+export type TBuilding = {
+    Floors: TFloor[];
+    Vertices: TVertex[];
+    Scale: TUpperVector3;
+    Meta: TMeta;
+    RoomColorIDPairs?: TRoomColorIDPair[];
+    ObjectMaskColorPairs?: TObjectMaskColorPair[];
+};

package/build/types/types/TGLTF.d.ts

@@ -0,0 +1,14 @@
+import type { AnimationAction, AnimationMixer, Object3D } from 'three';
+import type { GLTF } from 'three/examples/jsm/loaders/GLTFLoader';
+import type { GLTFParser } from 'three/GFPGLTFLoader/GLTFParser';
+export type TGLTF = GLTF & {
+    parser: GLTFParser;
+    userData: {
+        mixer?: AnimationMixer;
+        animationAction?: AnimationAction;
+        objectsToRaycast?: Object3D[];
+        roomLinkObjectsToRaycast?: Object3D[];
+        doorLinkObjectsToRaycast?: Object3D[];
+        roofObjects: Object3D[];
+    };
+};