@pilotdev/pilot-web-3d 23.0.4 → 23.0.6-alpha.1

package/index.d.ts

@@ -1,5 +1,15 @@
 /// <reference types="@types/three" />
 declare namespace PilotWeb3D {
+export class InitializerOptions {
+    libList?: string[];
+    language?: string;
+}
+export class Localization {
+    static initialize(options: any): Promise<void>;
+    static translate(stringToTrans: string): string;
+    static setLanguage(language: string): Promise<void>;
+    static extendLocalization(locales: any): boolean;
+}
 export class LoadingSpinner {
     addToDOM(container: HTMLElement): void;
     removeFromDOM(container: HTMLElement): void;
@@ -13,7 +23,7 @@ export const theExtensionManager: ExtensionManager;
 export class ExtensionLoader {
     loadExtension(extensionId: string): Promise<ExtensionBase>;
     unloadExtension(extensionId: string): Promise<boolean>;
-    getExtensions(): ExtensionBase[];
+    getExtensions(): string[];
 }
 export interface ILayerManager {
     createLayer(name: string): ILayer;
@@ -74,44 +84,59 @@ export class InMemorySettingsStorage implements ISettingsStorage {
     getKeys(): string[];
 }
 export interface ISettings {
-    changeSetting<T>(name: string, value: T, notify?: boolean): void;
+    changeSetting<T>(name: string, value: T, notify?: boolean, providedData?: any): void;
     getSettingValue<T>(name: string): T;
 }
-
 export class BaseSettingsNames {
     static TOOLBAR: string;
+    static TOOLBAR_DIRECTION: string;
+    static TOOLBAR_CONTENT: string;
+    static THEME: string;
 }
 export class SettingChangedEvent extends Event {
     name: string;
     oldValue: any;
     newValue: any;
+    providedData: any;
 }
 export abstract class SettingsBase implements ISettings {
     protected _eventDispatcher: IEventsDispatcher;
     protected _storage: ISettingsStorage;
-    changeSetting<T>(name: string, value: T, notify?: boolean): void;
+    changeSetting<T>(name: string, value: T, notify?: boolean, providedData?: any): void;
     getSettingValue<T>(name: string): T;
     protected abstract getKeyWithPrefix(key: string): string;
 }
+export enum SettingsTheme {
+    LIGHT_THEME = "ascn-light",
+    DARK_THEME = "ascn-dark"
+}
+export const defaultThemeAppearance: string;
 export enum ToolbarDirection {
-    TOP_FIXED = "ascn-toolbar-fixed-top",
-    TOP_FLUENT = "ascn-toolbar-top",
-    BOTTOM_FIXED = "ascn-toolbar-fixed-bottom",
-    BOTTOM_FLUENT = "ascn-toolbar-bottom"
+    TOP_FIXED = "ascn-toolbar-direction-fixed-top",
+    TOP_FLUENT = "ascn-toolbar-direction-top",
+    BOTTOM_FIXED = "ascn-toolbar-direction-fixed-bottom",
+    BOTTOM_FLUENT = "ascn-toolbar-direction-bottom"
 }
 export enum ToolbarContent {
     CENTER = "ascn-toolbar-content-center",
     START = "ascn-toolbar-content-start",
     END = "ascn-toolbar-content-end"
 }
+export interface ToolbarOptions {
+    height: number;
+    direction: ToolbarDirection;
+}
 export interface ToolbarStyle {
     direction?: ToolbarDirection;
     content?: ToolbarContent;
 }
+export const defaultToolbarAppearance: ToolbarStyle;
 export type ViewerSettings = Record<string, any>;
 export class ViewerConfiguration {
+    settingsPrefix: string;
     appearance: ViewerSettings;
     createConfiguration(configuration: ViewerSettings, origin: ViewerSettings): void;
+    changeTheme(newTheme: string): void;
 }
 export type ErrorCallback = (message: string) => void;
 export type SuccessCallback = (modelId: any) => void;
@@ -126,11 +151,12 @@ export abstract class ViewerBase {
     protected _loadingSpinner: LoadingSpinner;
     protected _documentType: DocumentType;
     protected _configuration: ViewerConfiguration;
-    container: HTMLElement;
-    layerManagers: Map<number, ILayerManager>;
-    extensionsLoader: ExtensionLoader;
+    readonly container: HTMLElement;
+    readonly layerManagers: Map<number, ILayerManager>;
+    readonly extensionsLoader: ExtensionLoader;
     abstract settings: ISettings;
     abstract events: IEventsDispatcher;
+    get rootContainer(): HTMLElement;
     getConfiguration(): ViewerConfiguration;
     /**
      *
@@ -143,6 +169,7 @@ export abstract class ViewerBase {
     finish(): void;
     onPostExtensionLoad(extension: ExtensionBase): void;
     protected loadExtensions(): void;
+    protected setThemeFromSettings(): void;
 }
 export class Control {
     container: HTMLElement;
@@ -158,6 +185,8 @@ export class Toolbar extends Control {
     constructor(id: string, toolbarContainer: HTMLElement, options?: ToolbarStyle);
     addControl(control: Control): void;
     removeControl(id: string): void;
+    changeToolbarPosition(direction: string): void;
+    changeToolbarContent(content: string): void;
 }
 export class ExtensionBase {
     protected _viewer: ViewerBase;
@@ -220,6 +249,7 @@ export class Color {
     alpha(): number;
     fromArray(array: ArrayLike<number>, offset?: number): Color;
     toArray(array: Array<number>, offset?: number): Array<number>;
+    clone(): Color;
 }
 export abstract class ViewObject extends THREE.Object3D {
     protected _isDisposed: boolean;
@@ -289,79 +319,297 @@ export abstract class ViewObject extends THREE.Object3D {
      */
     protected riseOnUpdated(updateType?: UpdateType, object?: THREE.Object3D): void;
 }
-export class MeshLine extends THREE.BufferGeometry {
-    isMeshLine: boolean;
-    widthCallback: (t: number) => number;
-    positions: number[];
-    previous: number[];
-    next: number[];
-    side: number[];
-    width: number[];
-    indices_array: number[];
-    uvs: number[];
-    counters: number[];
-    _attributes: any;
-    get geometry(): THREE.BufferGeometry;
-    setPoints(points: THREE.Vector3[], widthCallback: (t: number) => number): void;
-    setPointsArray(points: Float32Array, widthCallback: (t: number) => number): void;
-    raycast(raycaster: THREE.Raycaster, intersects: THREE.Intersection[], lineWidth?: number, matrixWorld?: THREE.Matrix4): void;
-    /**
-     * Fast method to advance the line by one position.  The oldest position is removed.
-     * @param position
-     */
-    advance(position: THREE.Vector3): void;
-    computeBoundingBox(): void;
-    computeBoundingSphere(): void;
+export abstract class CustomMaterial extends THREE.ShaderMaterial {
+    
+    constructor();
+    copy(source: CustomMaterial): this;
+    protected customProgramCacheKeyCallback(): string;
+    protected onBeforeRender(renderer: THREE.WebGLRenderer, scene: THREE.Scene, camera: THREE.Camera, geometry: THREE.BufferGeometry, material: THREE.Material, group: THREE.Group): void;
+    protected onBeforeCompileCallback(shader: THREE.Shader): void;
+    protected refreshTransformUniform(map: THREE.Texture, uniform: THREE.IUniform): void;
+}
+export interface CustomMeshLambertMaterialParameters extends THREE.ShaderMaterialParameters, THREE.MeshLambertMaterialParameters {
+    instancing?: boolean | undefined;
+}
+export class CustomMeshLambertMaterial extends CustomMaterial {
+    type: string;
+    
+    constructor(parameters?: CustomMeshLambertMaterialParameters);
+    /**
+     * @default false
+     */
+    get instancing(): boolean;
+    set instancing(value: boolean);
+    /**
+     * @default new THREE.Color( 0xffffff )
+     */
+    color: THREE.Color;
+    /**
+     * @default null
+     */
+    bumpMap: THREE.Texture | null;
+    /**
+     * @default 1
+     */
+    bumpScale: number;
+    /**
+     * @default null
+     */
+    displacementMap: THREE.Texture | null;
+    /**
+     * @default 1
+     */
+    displacementScale: number;
+    /**
+     * @default 0
+     */
+    displacementBias: number;
+    /**
+     * @default new THREE.Color( 0x000000 )
+     */
+    emissive: THREE.Color;
+    /**
+     * @default 1
+     */
+    emissiveIntensity: number;
+    /**
+     * @default null
+     */
+    emissiveMap: THREE.Texture | null;
+    /**
+     * @default false
+     */
+    flatShading: boolean;
+    /**
+     * @default null
+     */
+    map: THREE.Texture | null;
+    /**
+     * @default null
+     */
+    lightMap: THREE.Texture | null;
+    /**
+     * @default 1
+     */
+    lightMapIntensity: number;
+    /**
+     * @default null
+     */
+    normalMap: THREE.Texture | null;
+    normalMapType: THREE.NormalMapTypes;
+    /**
+     * @default new THREE.Vector2( 1, 1 )
+     */
+    normalScale: THREE.Vector2;
+    /**
+     * @default null
+     */
+    aoMap: THREE.Texture | null;
+    /**
+     * @default 1
+     */
+    aoMapIntensity: number;
+    /**
+     * @default null
+     */
+    specularMap: THREE.Texture | null;
+    /**
+     * @default null
+     */
+    alphaMap: THREE.Texture | null;
+    /**
+     * @default null
+     */
+    envMap: THREE.Texture | null;
+    /**
+     * @default THREE.MultiplyOperation
+     */
+    combine: THREE.Combine;
+    /**
+     * @default 1
+     */
+    reflectivity: number;
+    /**
+     * @default 0.98
+     */
+    refractionRatio: number;
+    /**
+     * @default false
+     */
+    wireframe: boolean;
+    /**
+     * @default 1
+     */
+    wireframeLinewidth: number;
+    /**
+     * @default 'round'
+     */
+    wireframeLinecap: string;
+    /**
+     * @default 'round'
+     */
+    wireframeLinejoin: string;
+    /**
+     * Whether the material is affected by fog. Default is true.
+     * @default fog
+     */
+    fog: boolean;
+    protected refreshUniformsCommon(uniforms: {
+        [uniform: string]: THREE.IUniform;
+    }, material: CustomMeshLambertMaterial, renderer: THREE.WebGLRenderer): void;
+    protected onBeforeRender(renderer: THREE.WebGLRenderer, scene: THREE.Scene, camera: THREE.Camera, geometry: THREE.BufferGeometry, material: THREE.Material, group: THREE.Group): void;
+    copy(source: CustomMeshLambertMaterial): this;
+}
+export interface CustomLineMaterialParameters extends THREE.ShaderMaterialParameters, THREE.LineBasicMaterialParameters {
+    instancing?: boolean | undefined;
+}
+export class CustomLineMaterial extends CustomMaterial {
+    type: string;
+    
+    constructor(parameters?: CustomLineMaterialParameters);
+    /**
+     * @default false
+     */
+    get instancing(): boolean;
+    set instancing(value: boolean);
+    /**
+     * @default 0xffffff
+     */
+    color: THREE.Color;
+    /**
+     * Whether the material is affected by fog. Default is true.
+     * @default true
+     */
+    fog: boolean;
+    /**
+     * @default 1
+     */
+    linewidth: number;
+    /**
+     * @default 'round'
+     */
+    linecap: string;
+    /**
+     * @default 'round'
+     */
+    linejoin: string;
+    /**
+     * @default null
+     */
+    map: THREE.Texture | null;
+    protected refreshUniformsCommon(uniforms: {
+        [uniform: string]: THREE.IUniform;
+    }, material: CustomLineMaterial, renderer: THREE.WebGLRenderer): void;
+    protected onBeforeRender(renderer: THREE.WebGLRenderer, scene: THREE.Scene, camera: THREE.Camera, geometry: THREE.BufferGeometry, material: THREE.Material, group: THREE.Group): void;
+    copy(source: CustomLineMaterial): this;
 }
 export interface MeshLineMaterialParameters extends THREE.ShaderMaterialParameters {
-    lineWidth?: number;
-    map?: THREE.Texture;
-    useMap?: boolean;
-    alphaMap?: THREE.Texture;
-    useAlphaMap?: number;
-    color?: THREE.ColorRepresentation;
-    resolution?: THREE.Vector2;
-    sizeAttenuation?: boolean;
-    dashArray?: number;
-    dashOffset?: number;
-    dashRatio?: number;
-    useDash?: number;
-    alphaTest?: number;
-    repeat?: THREE.Vector2;
-}
-export class MeshLineMaterial extends THREE.ShaderMaterial {
-    isMeshLineMaterial: boolean;
+    alphaToCoverage?: boolean | undefined;
+    color?: THREE.ColorRepresentation | undefined;
+    dashed?: boolean | undefined;
+    dashScale?: number | undefined;
+    dashSize?: number | undefined;
+    dashOffset?: number | undefined;
+    gapSize?: number | undefined;
+    linewidth?: number | undefined;
+    resolution?: THREE.Vector2 | undefined;
+    wireframe?: boolean | undefined;
+    worldUnits?: boolean | undefined;
+}
+export class MeshLineMaterial extends CustomMaterial {
+    type: string;
     
     constructor(parameters: MeshLineMaterialParameters);
-    get lineWidth(): number;
-    set lineWidth(value: number);
-    get map(): THREE.Texture;
-    set map(value: THREE.Texture);
-    get useMap(): number;
-    set useMap(value: number);
-    get alphaMap(): THREE.Texture;
-    set alphaMap(value: THREE.Texture);
-    get useAlphaMap(): number;
-    set useAlphaMap(value: number);
     get color(): THREE.Color;
-    set color(value: THREE.Color);
-    get resolution(): THREE.Vector2;
-    set resolution(value: THREE.Vector2);
-    get sizeAttenuation(): number;
-    set sizeAttenuation(value: number);
-    get dashArray(): number;
-    set dashArray(value: number);
+    set color(value: THREE.ColorRepresentation);
+    get worldUnits(): boolean;
+    set worldUnits(value: boolean);
+    get dashed(): boolean;
+    set dashed(value: boolean);
+    get dashScale(): number;
+    set dashScale(value: number);
+    get dashSize(): number;
+    set dashSize(value: number);
     get dashOffset(): number;
     set dashOffset(value: number);
-    get dashRatio(): number;
-    set dashRatio(value: number);
-    get useDash(): number;
-    set useDash(value: number);
-    get repeat(): THREE.Vector2;
-    set repeat(value: THREE.Vector2);
-    copy(source: MeshLineMaterial): this;
-    clone(): this;
-    dispose(): void;
+    get gapSize(): number;
+    set gapSize(value: number);
+    get resolution(): THREE.Vector2;
+    set resolution(value: THREE.Vector2);
+    onBeforeRender(renderer: THREE.WebGLRenderer, scene: THREE.Scene, camera: THREE.Camera, geometry: THREE.BufferGeometry, material: THREE.Material, group: THREE.Group): void;
+}
+export interface CustomPointMaterialParameters extends THREE.ShaderMaterialParameters, THREE.PointsMaterialParameters {
+}
+export class CustomPointMaterial extends CustomMaterial {
+    type: string;
+    
+    constructor(parameters?: CustomPointMaterialParameters);
+    /**
+     * @default new THREE.Color( 0xffffff )
+     */
+    color: THREE.Color;
+    /**
+     * @default null
+     */
+    map: THREE.Texture | null;
+    /**
+     * @default null
+     */
+    alphaMap: THREE.Texture | null;
+    /**
+     * @default 1
+     */
+    size: number;
+    /**
+     * @default true
+     */
+    sizeAttenuation: boolean;
+    /**
+     * Whether the material is affected by fog. Default is true.
+     * @default fog
+     */
+    fog: boolean;
+    protected refreshUniformsCommon(uniforms: {
+        [uniform: string]: THREE.IUniform;
+    }, material: CustomPointMaterial, renderer: THREE.WebGLRenderer): void;
+    protected onBeforeRender(renderer: THREE.WebGLRenderer, scene: THREE.Scene, camera: THREE.Camera, geometry: THREE.BufferGeometry, material: THREE.Material, group: THREE.Group): void;
+    copy(source: CustomPointMaterial): this;
+}
+export class MeshLineGeometry extends THREE.InstancedBufferGeometry {
+    type: string;
+    instanceStart: THREE.BufferAttribute;
+    instanceEnd: THREE.BufferAttribute;
+    instanceColorStart: THREE.BufferAttribute;
+    instanceColorEnd: THREE.BufferAttribute;
+    
+    constructor();
+    applyMatrix4(matrix: THREE.Matrix4): this;
+    updatePoint(index: number, point: THREE.Vector3): void;
+    updateColor(index: number, color: THREE.Color): void;
+    setPoints(points: THREE.Vector3[]): this;
+    setPositions(array: ArrayLike<number>): this;
+    setColors(array: ArrayLike<number>): this;
+    computeLineDistances(): this;
+    toBufferGeometry(): THREE.BufferGeometry;
+    toWireframeGeometry(): THREE.BufferGeometry;
+    fromWireframeGeometry(geometry: THREE.WireframeGeometry): this;
+    fromEdgesGeometry(geometry: THREE.EdgesGeometry): this;
+    fromMesh(mesh: THREE.Mesh): this;
+    fromLineSegments(lineSegments: THREE.LineSegments): this;
+    computeBoundingBox(): void;
+    computeBoundingSphere(): void;
+}
+export class MeshLine extends THREE.Mesh {
+    type: string;
+    material: MeshLineMaterial;
+    geometry: MeshLineGeometry;
+    
+    constructor(geometry?: MeshLineGeometry, material?: MeshLineMaterial);
+    raycast(raycaster: THREE.Raycaster, intersects: THREE.Intersection[]): void;
+}
+export class TPair<TKey, TValue> {
+    get key(): TKey;
+    get value(): TValue;
 }
 export type Point3 = {
     x: number;
@@ -470,6 +718,31 @@ export interface IEventSigner<Data> {
         allowMissing?: boolean;
     }): boolean;
 }
+
+export interface EventEmitter<Data> {
+    emit(data?: Data, options?: object): void;
+}
+export class EventListener<Data> implements IEventListener<Data>, Disposable {
+    
+    constructor(event: IEventSigner<Data>, func: EventFunction<Data>, options: {
+        bind?: object;
+    });
+    dispose(): void;
+}
+export class EventDispatcher<Data> implements IEventSigner<Data>, EventEmitter<Data> {
+    listen(func: EventFunction<Data>, options?: {
+        bind?: object;
+    }): EventListener<Data>;
+    unlisten(func: EventFunction<Data>, options?: {
+        bind?: object;
+        allowMissing?: boolean;
+    }): boolean;
+    emit(data?: Data): void;
+    emitR(data?: Data): any[];
+    asSigner(): IEventSigner<Data>;
+    asEmitter(): EventEmitter<Data>;
+    removeAllListeners(): void;
+}
 export interface IModelIntersectionChecker {
     /** Gets the center of the model*/
     get modelCenter(): THREE.Vector3;
@@ -482,13 +755,15 @@ export interface IModelIntersectionChecker {
     /**
      * Gets {@link THREE.Intersection} between a casted {@link ray} and model object.
      * @param ray
+     * @param camera
      */
-    getIntersectionByRay(ray: THREE.Ray): THREE.Intersection<THREE.Object3D> | undefined;
+    getIntersectionByRay(ray: THREE.Ray, camera: THREE.Camera): THREE.Intersection<THREE.Object3D> | undefined;
     /**
      * Gets ID of the model object intersected by {@link ray}
      * @param ray
+     * @param camera
      */
-    getIntersectionIDByRay(ray: THREE.Ray): {
+    getIntersectionIDByRay(ray: THREE.Ray, camera: THREE.Camera): {
         modelId: string;
         guid: string;
     } | undefined;
@@ -519,10 +794,6 @@ export interface IModelIntersectionChecker {
         guid: string;
     }[];
 }
-export class TPair<TKey, TValue> {
-    get key(): TKey;
-    get value(): TValue;
-}
 export class RenderViewSettings {
     telemetry?: boolean;
     hideEdgesWhenNavigation?: boolean;
@@ -611,6 +882,10 @@ export interface IUserScene {
     get intersectionChecker(): IModelIntersectionChecker | null;
     /** Gets the THREE.Object3D representation of the scene */
     get threeObjectRepresentation(): THREE.Object3D | null;
+    /** Sets clipping enable */
+    set clippingEnable(value: boolean);
+    /** Indicates whether the scene should be clipped */
+    get clippingEnable(): boolean;
     /** Place objects on scene */
     addRange(objects: THREE.Object3D[]): void;
     /** Update objects on scene */
@@ -634,6 +909,7 @@ export interface IUserScene {
 }
 export interface I3DRenderer {
     clear(color?: boolean, depth?: boolean, stencil?: boolean): void;
+    setClearColor(color: ColorRepresentation, alpha?: number): void;
     clearDepth(): void;
     render(scene: THREE.Object3D, camera: THREE.Camera): void;
     getSize(target: THREE.Vector2): THREE.Vector2;
@@ -673,6 +949,17 @@ export interface IRenderViewer3D {
      * Gets all render scenes.
      */
     getScenes(): IUserScene[];
+    /**
+     *
+     * @param name
+     * @param isClippable
+     */
+    addScene(name: string, isClippable: boolean): IUserScene;
+    /**
+     *
+     * @param scene
+     */
+    removeScene(scene: IUserScene): void;
 }
 export class ModelElement {
     get id(): string;
@@ -682,7 +969,8 @@ export class ModelElement {
     get name(): string;
     get children(): ModelElement[];
     get hasGeometry(): boolean;
-    get boundingBoxCenter(): Point3;
+    get viewObject(): ViewObject | undefined;
+    get boundingBoxCenter(): Point3 | null;
 }
 export class ModelElementTree {
     /**
@@ -2315,7 +2603,7 @@ export class Viewer3D extends ViewerBase {
     settings: Readonly<ISettings>;
     get navigation(): INavigation;
     events: Readonly<IEventsDispatcher>;
-    baseConfiguration(): import("@core/index").ViewerConfiguration;
+    getConfiguration(): Viewer3DConfiguration;
     start(): Promise<number>;
     finish(): void;
     /**
@@ -2345,6 +2633,7 @@ export class Viewer3D extends ViewerBase {
      * @returns Blob object representing render image.
      */
     makeScreenshot(mimeType?: string, quality?: number): Promise<Blob>;
+    setThemeFromSettings(): void;
 }
 export class GuiViewer3D extends Viewer3D {
     loadModelPart(buffer: ArrayBuffer, options: ModelLoadingOptions, onSuccessCallback: SuccessCallback, onErrorCallback: ErrorCallback): void;
@@ -2472,6 +2761,123 @@ export class GizmoBuilder {
     static buildRotationAxis(axisDir: THREE.Vector3, handleBaseMatrial?: THREE.Material, handleHoveredMaterial?: THREE.Material, handleSelectedMaterial?: THREE.Material, pickerBaseMatrial?: THREE.Material, pickerHoveredMaterial?: THREE.Material, pickerSelectedMaterial?: THREE.Material): GizmoAxis;
     static buildScaleAxis(axisDir: THREE.Vector3, handleBaseMatrial?: THREE.Material, handleHoveredMaterial?: THREE.Material, handleSelectedMaterial?: THREE.Material): GizmoAxis;
 }
+export interface LabelSpriteParameters {
+    text?: string | undefined;
+    sizeAttenuation?: boolean | undefined;
+    fontFace?: string | FontFace | undefined;
+    fontSize?: number | undefined;
+    borderColor?: Color | undefined;
+    backgroundColor?: Color | undefined;
+    borderThickness?: number | undefined;
+    borderRadius?: number | undefined;
+    textColor?: Color | undefined;
+    textPadding?: THREE.Vector4Tuple | undefined;
+}
+export class LabelSprite extends THREE.Sprite {
+    readonly extraHeightFactor = 1.4;
+    
+    constructor(parameters: LabelSpriteParameters);
+    get sizeAttenuation(): boolean;
+    set sizeAttenuation(value: boolean);
+    /**
+     * @default ''
+     */
+    get text(): string;
+    set text(value: string);
+    /**
+    * @default 'Roboto, sans-serif'
+    */
+    get fontFace(): string | FontFace;
+    set fontFace(value: string | FontFace);
+    /**
+    * @default 12
+    */
+    get fontSize(): number;
+    set fontSize(value: number);
+    /**
+    * @default 2
+    */
+    get borderThickness(): number;
+    set borderThickness(value: number);
+    /**
+    * @default new Color(0, 0, 0, 1.0)
+    */
+    get borderColor(): Color;
+    set borderColor(value: Color);
+    /**
+    * @default 1
+    */
+    get borderRadius(): number;
+    set borderRadius(value: number);
+    /**
+    * @default new Color(1.0, 1.0, 1.0, 1.0)
+    */
+    get backgroundColor(): Color;
+    set backgroundColor(value: Color);
+    /**
+    * @default new Color(0, 0, 0, 1.0)
+    */
+    get textColor(): Color;
+    set textColor(value: Color);
+    /**
+     * Label text padding: left, top, right, bottom
+     * @default [0, 0, 0, 0]
+     */
+    get textPadding(): THREE.Vector4Tuple;
+    set textPadding(value: THREE.Vector4Tuple);
+    dispose(): void;
+}
+export interface IWindowStyle {
+    width: string;
+    height: string;
+    left: string;
+    right: string;
+    top: string;
+}
+export interface IWindowStateOptions {
+    saveKey: string;
+    restoreWindowSize: boolean;
+}
+export class WindowStater {
+    get windowStylesState(): IWindowStyle;
+    get windowOptionsState(): IWindowStateOptions;
+    restore(): void;
+    saveWindowState(): void;
+}
+export class Resizer {
+    
+    constructor(resizableContainer: HTMLElement, containerToRestriction: HTMLElement, elementAnchor?: HTMLElement, windowStater?: WindowStater);
+    get windowState(): IWindowStyle | null;
+}
+export class Dragger {
+    
+    constructor(allowedDraggableElement: HTMLElement, draggableContainer: HTMLElement, containerToRestriction: HTMLElement, windowStater?: WindowStater);
+    get windowState(): IWindowStyle | null;
+}
+export namespace Viewer3DIcons {
+    const VIEWER_SETTINGS_ICON: string;
+    const VIEWER_MODEL_BROWSER_ICON: string;
+    const VIEWER_FULL_SCREEN_ICON: string;
+    const VIEWER_COLLAPSE_ICON: string;
+    const VIEWER_ELEMENT_PROPERTIES_ICON: string;
+    const VIEWER_ADD_CLIPPING_PLANE_ICON: string;
+    const VIEWER_CLIPPING_FLIP_ICON: string;
+    const VIEWER_DELETE_CLIPPING_PLANE_ICON: string;
+    const VIEWER_CLIPPING_CUBE_ICON: string;
+    const VIEWER_DISABLED_DELETE_CLIPPING_PLANE_ICON: string;
+    const VIEWER_DISABLED_CLIPPING_FLIP_ICON: string;
+    const VIEWER_ADD_REMARK_ICON: string;
+}
+export namespace ViewerGeneralIcons {
+    const ZOOM_IN: string;
+    const ZOOM_OUT: string;
+    const CLOSE: string;
+    const STRETCH_WINDOW: string;
+    const EXPAND_TREE: string;
+    const COLLAPSE_TREE: string;
+    const ARROW_DROP_DOWN: string;
+    const ARROW_DROP_RIGHT: string;
+}
 export class Button extends Control {
     
     constructor(id: string);
@@ -2479,6 +2885,7 @@ export class Button extends Control {
     setState(state: Button.State): boolean;
     getState(): Button.State;
     setIcon(iconClassName: string): void;
+    setFromSvgTemlate(template: string): void;
     /**
      * Override this method to be notified when the user clicks on the button.
      * @param {MouseEvent} event
@@ -2514,14 +2921,23 @@ interface ElementClass {
 export class Dialog extends Control {
     responseDialog: (state?: boolean) => void;
     
-    constructor(id: string, panelToAttach: HTMLElement, contentPassed?: HTMLElement, header?: HTMLElement, classNames?: ElementClass);
+    constructor(id: string, panelToAttach: HTMLElement);
     get dialog(): HTMLElement;
+    get dialogContent(): HTMLElement;
+    get resizable(): boolean;
+    setDialogContent(value: HTMLElement): Dialog;
+    setHeader(value: HTMLElement): Dialog;
+    setCaption(value: string): Dialog;
+    setIcon(iconClassName: string): Dialog;
+    setFooter(value: HTMLElement): Dialog;
+    setDialogElementClassNames(value: ElementClass): Dialog;
+    setResizable(value: boolean): Dialog;
+    setWindowOptions(value: IWindowStateOptions): Dialog;
+    setDraggable(value: boolean): Dialog;
     openDialog(): HTMLElement;
     destroyDialog(): void;
     isDialogShown(): boolean;
     subscribe(fn: (state: boolean) => void): void;
-    addCheckBox(value: boolean, caption: string, id: string, action: (isChecked: boolean) => void): void;
-    addComboBox(index: number, caption: string, id: string, values: string[], action: (selectedIndex: number) => void): void;
 }
 export {};
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pilotdev/pilot-web-3d",
-  "version": "23.0.4",
+  "version": "23.0.6-alpha.1",
   "description": "TypeScript definitions for ASCON PilotWeb3D component",
   "main": "",
   "types": "index.d.ts",
@@ -8,8 +8,8 @@
   "author": "JSC Ascon",
   "license": "MIT",
   "typeScriptVersion": "4.9.4",
-  "devDependencies": {
-    "@types/three": "0.135.0"
+  "dependencies": {
+    "@types/three": "0.148.0"
   },
   "keywords": [
     "pilotdev",

package/.script.py

@@ -1,15 +0,0 @@
-text = '''
-; good config
-;@myorg:registry=https://somewhere-else.com/myorg
-;@another:registry=https://somewhere-else.com/another
-//registry.npmjs.org/:_authToken=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
-; would apply to both @myorg and @another
-; //somewhere-else.com/:_authToken=MYTOKEN
-; would apply only to @myorg
-;//somewhere-else.com/myorg/:_authToken=MYTOKEN1
-; would apply only to @another
-;//somewhere-else.com/another/:_authToken=MYTOKEN2
-'''
-file = open("/home/teamcityagent/.BuildAgent/work/3abf6afd0f88818/3d_view/types/.npmrc","w")
-file.write(text)
-file.close()