/**
 * pacem v0.51.10-faraday (https://js.pacem.it)
 * Copyright 2025 Pacem (https://pacem.it)
 * Licensed under Apache-2.0
 */
declare namespace Pacem.Drawing3D {
    const Point3DConverter: Pacem.PropertyConverter;
    const Point3DOrNumberConverter: Pacem.PropertyConverter;
    const QuaternionConverter: Pacem.PropertyConverter;
    const BooleanOrNumberConverter: Pacem.PropertyConverter;
}
declare namespace Pacem.Drawing3D {
    function NotifyChange(callback: (property?: string, old?: any, val?: any) => void): (target: any, prop: string, descriptor?: PropertyDescriptor) => void;
}
declare namespace Pacem.Components.Drawing3D {
    /** @deprecated*/
    class Pacem3DDetector {
        private _detected;
        constructor();
        get info(): {
            main?: any;
            bits?: any;
            shader?: any;
            tex?: any;
            misc?: any;
        };
        get supported(): boolean;
    }
}
declare namespace Pacem.Drawing3D {
    interface NodeGeometry {
        positions: Vector3D[];
        boundingBox?: Box3D;
        barycenter?: Vector3D;
        boundingSphere?: Sphere3D;
        flags: StalePropertyFlag[];
        key?: string;
    }
    interface MeshGeometry extends NodeGeometry {
        triangleIndices: number[];
        textureCoordinates: UVMap;
        normals: Vector3D[];
    }
    abstract class NodeGeometry {
        constructor(positions?: Vector3D[]);
        static barycenter(positions: Vector3D[]): Vector3D;
        static boundingBox(positions: Vector3D[]): Box3D;
        protected setAsDirty(): void;
    }
    class LineGeometry extends NodeGeometry {
        positions: Vector3D[];
    }
    class MeshGeometry extends NodeGeometry {
        #private;
        get barycenter(): Vector3D;
        set barycenter(point: Vector3D);
        get boundingBox(): Box3D;
        set boundingBox(bbox: Box3D);
        get boundingSphere(): Sphere3D;
        set boundingSphere(sphere: Sphere3D);
        constructor(positions: Vector3D[], triangleIndices: number[], textureCoordinates?: UVMap, normals?: Vector3D[]);
        positions: Vector3D[];
        triangleIndices: number[];
        textureCoordinates: UVMap;
        normals: Vector3D[];
    }
}
declare namespace Pacem.Drawing3D {
    type Vector3D = Pacem.Geometry.LinearAlgebra.Vector3D;
    type Matrix3D = Pacem.Geometry.LinearAlgebra.Matrix3D;
    type Quaternion = Pacem.Geometry.LinearAlgebra.Quaternion;
    type UVMap = Pacem.Point[];
    interface Box3D {
        minX: number;
        minY: number;
        minZ: number;
        maxX: number;
        maxY: number;
        maxZ: number;
    }
    interface Sphere3D {
        center: Vector3D;
        radius: number;
    }
    interface Stage extends EventTarget {
        render(item?: Renderable): any;
        readonly stage: HTMLElement;
        readonly scene: any;
        readonly size: Size;
        transparent?: boolean;
        background?: string | Rgba;
    }
    interface Renderable {
        stage?: Stage;
        position: Vector3D;
        /** Gets or sets whether the drawable is hit-testable. */
        inert?: boolean;
        hide?: boolean;
        tag?: any;
        flags: StalePropertyFlag[];
        key?: string;
        /** @deprecated will be likely removed sooner or later to be handled outside the stage/adapter. */
        draggable?: boolean;
    }
    function isStage(object: any): object is Stage;
    function isRenderable(object: any): object is Renderable;
    interface Ui3DObject extends Renderable {
        rotate?: Quaternion;
        scale?: Vector3D;
        offset?: Vector3D;
        transformMatrix: Matrix3D;
        /** Gets the plain (untransformed via {@link transformMatrix}) bounding sphere. */
        readonly boundingSphere?: Sphere3D;
        /** Gets the plain (untransformed via {@link transformMatrix}) bounding box. */
        readonly boundingBox?: Box3D;
    }
    function isUi3DObject(object: any): object is Ui3DObject;
    interface Camera extends Renderable {
        /** Target in world coordinates. */
        lookAt: Vector3D;
        /** Up vector in world coordinates. */
        up: Vector3D;
        near: number;
        far: number;
    }
    interface OrthographicCamera extends Camera {
        type: "orthographic";
        /** Top frustum coordinate (e.g. 1). */
        top: number;
        /** Left frustum coordinate (e.g. -1). */
        left: number;
        /** Bottom frustum coordinate (e.g. -1). */
        bottom: number;
        /** Right frustum coordinate (e.g. 1). */
        right: number;
    }
    interface PerspectiveCamera extends Camera {
        type: "perspective";
        /** Vertical field of view in degrees. */
        fov: number;
        aspectRatio: number;
    }
    function isCamera(object: any): object is Camera;
    function isPerspectiveCamera(object: any): object is PerspectiveCamera;
    function isOrthographicCamera(object: any): object is OrthographicCamera;
    interface Light extends Renderable {
        intensity: number;
        target?: Vector3D;
        color: string;
        type: 'spot' | 'direction' | 'omni' | 'ambient';
        attenuationStart?: number;
        attenuationEnd?: number;
        angle?: number;
    }
    function isLight(object: any): object is Light;
    interface Mesh extends Ui3DObject {
        geometry: NodeGeometry;
        material?: Material;
        backMaterial?: Material;
    }
    function isMesh(object: any): object is Mesh;
    function isGeometry(object: any): object is NodeGeometry;
    function isMeshGeometry(object: any): object is MeshGeometry;
    interface Group extends Ui3DObject {
        childRenderables: Renderable[];
    }
    function isGroup(object: any): object is Group;
    interface DragEventArgs {
        readonly offset: Point;
        readonly item: Renderable;
    }
    /**
     * Sets the normals to a mesh geometry by computing each face's unit orthogonal vector.
     * @param geometry
     */
    function computeSharpVertexNormals(geometry: MeshGeometry): void;
    /**
     * Computes the unit vector orthogonal to the plane identified by 3 points.
     * @param a
     * @param b
     * @param c
     */
    function computePlaneNormal(a: Vector3D, b: Vector3D, c: Vector3D): Vector3D;
    abstract class UI3DEvent<T> extends CustomUIEvent<T> {
        #private;
        constructor(type: string, eventInit: CustomEventInit<T>, originalEvent: MouseEvent | TouchEvent | KeyboardEvent, point: Vector3D);
        /** Gets the event's source position in 3d coordinates. */
        get point(): Vector3D;
    }
    class DragEvent extends UI3DEvent<DragEventArgs> {
    }
    class RenderableEvent extends UI3DEvent<Renderable> {
        constructor(type: string, args: Renderable, originalEvent: MouseEvent | TouchEvent | KeyboardEvent, p: Vector3D);
    }
    type RaycastResult = {
        object: Renderable;
        point: Vector3D;
    };
    enum StalePropertyFlag {
        Position = "position",
        Transform = "transform",
        Geometry = "geometry",
        Children = "children",
        Material = "material",
        Light = "light",
        Camera = "camera",
        Visibility = "visibility"
    }
}
declare namespace Pacem.Components.Drawing3D {
    export const TAG_MIDDLE_NAME = "3d";
    export const DEG2RAD: number;
    type StalePropertyFlag = Pacem.Drawing3D.StalePropertyFlag;
    const StalePropertyFlag: typeof Pacem.Drawing3D.StalePropertyFlag;
    export abstract class RenderableElement extends PacemCrossItemsContainerElement<RenderableElement> implements Pacem.Drawing3D.Renderable {
        #private;
        validate(_: RenderableElement): boolean;
        protected findContainer(): RenderableElement | Pacem3DElement;
        get stage(): Pacem3DElement;
        get parent(): RenderableElement;
        position: Pacem.Drawing3D.Vector3D;
        tag: string;
        inert: boolean;
        disconnectedCallback(): void;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        get flags(): StalePropertyFlag[];
        /** Calls for a redraw of the current element in the next rendering process. */
        protected setAsDirty(...flags: StalePropertyFlag[]): void;
    }
    export abstract class Ui3DElement extends RenderableElement implements Pacem.Drawing3D.Ui3DObject {
        rotate: Geometry.LinearAlgebra.Quaternion;
        scale: Geometry.LinearAlgebra.Point3D;
        offset: Geometry.LinearAlgebra.Point3D;
        /** Gets the local transform 3D matrix (4x4). */
        transformMatrix: Geometry.LinearAlgebra.Matrix3D;
        /** @deprecated*/
        scaleX: number;
        /** @deprecated*/
        scaleY: number;
        /** @deprecated*/
        scaleZ: number;
        /** @deprecated*/
        translateX: number;
        /** @deprecated*/
        translateY: number;
        /** @deprecated*/
        translateZ: number;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        private _computeTransformMatrix;
    }
    export class Pacem3DGroupElement extends Ui3DElement implements Pacem.Drawing3D.Group {
        #private;
        validate(child: RenderableElement): boolean;
        datasource: Pacem.Drawing3D.Renderable[];
        get childRenderables(): Pacem.Drawing3D.Renderable[];
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
    }
    export class Pacem3DMeshElement extends Ui3DElement implements Pacem.Drawing3D.Mesh {
        geometry: Pacem.Drawing3D.NodeGeometry;
        material: Pacem.Drawing3D.Material;
        backMaterial: Pacem.Drawing3D.Material;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
    }
    export class Pacem3DObjectElement extends Ui3DElement {
        content: any;
        type: string | "obj" | "fbx" | "native";
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
    }
    export class Pacem3DLightElement extends RenderableElement implements Pacem.Drawing3D.Light {
        intensity: number;
        target: Pacem.Drawing3D.Vector3D;
        color: string;
        type: 'spot' | 'direction' | 'omni';
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
    }
    export abstract class Pacem3DCameraElement extends RenderableElement implements Pacem.Drawing3D.Camera {
        #private;
        near: number;
        far: number;
        up: Pacem.Drawing3D.Vector3D;
        lookAt: Pacem.Drawing3D.Vector3D;
        private _resetBoundingSphere;
        get boundingSphere(): Pacem.Drawing3D.Sphere3D;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
    }
    export class Pacem3DPerspectiveCameraElement extends Pacem3DCameraElement implements Pacem.Drawing3D.PerspectiveCamera {
        fov: number;
        aspect: number;
        get type(): "perspective";
        get aspectRatio(): number;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
    }
    export class Pacem3DOrthographicCameraElement extends Pacem3DCameraElement implements Pacem.Drawing3D.OrthographicCamera {
        top: number;
        left: number;
        bottom: number;
        right: number;
        get type(): "orthographic";
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
    }
    export abstract class Pacem3DAdapterElement extends PacemEventTarget {
        /**
         * When implemented in a derived class, resizes the stage.
         */
        abstract invalidateSize(scene: Pacem3DElement, size: Size): void;
        /**
         * Initializes the 3d scene and returns its corresponding DOM element.
         * @param scene {Pacem3DElement} Container for the stage/scene
         */
        abstract initialize(scene: Pacem3DElement): Promise<HTMLElement>;
        /**
         * When implemented in a derived class, renders the scene.
         */
        abstract render(scene: Pacem3DElement): void;
        /**
         * Processes the stage content and returns an image accordingly.
         * */
        abstract snapshot(scene: Pacem3DElement, bgColor?: string, type?: string, quality?: number): PromiseLike<Blob>;
        /**
         * When implemented in a derived class, retrieves the element casting the ray through the provided point (if any).
         * @param point {Object} 2D to check.
         */
        abstract raycast(scene: Pacem3DElement, point: Point, size: Size, callback: (result: Pacem.Drawing3D.RaycastResult) => void): void;
        /**
         * When implemented in a derived class, adds a 3d element.
         * @param item {Pacem3DObject} item to be added
         */
        abstract addItem(scene: Pacem3DElement, item: Pacem.Drawing3D.Renderable): void;
        /**
         * When implemented in a derived class, removes a 3d element.
         * @param item {Pacem3DObject} item to be removed
         */
        abstract removeItem(scene: Pacem3DElement, item: Pacem.Drawing3D.Renderable): void;
        /**
         * Updates the object before the next rendering.
         * @param item
         * @param redraw Whether to completely redraw the object (not just its 3d transform) or not
         */
        abstract updateItem(scene: Pacem3DElement, item: Pacem.Drawing3D.Renderable): void;
        /**
         * Adjusts the camera to zoom-fit specific objects in the viewport.
         * @param items
         */
        abstract zoomFit(scene: Pacem3DElement, ...items: Pacem.Drawing3D.Ui3DObject[]): Promise<void>;
        abstract project(scene: Pacem3DElement, point3D: Pacem.Drawing3D.Vector3D): Point;
        /** Gets the native scene instance */
        abstract getScene(scene: Pacem3DElement): any;
        /**
         * Disposes the 2d scene resources.
         * @param scene {Pacem3DElement} The stage/scene
         */
        abstract dispose(scene: Pacem3DElement): void;
    }
    export {};
}
declare namespace Pacem.Components.Drawing3D {
    class Pacem3DElement extends PacemItemsContainerElement<RenderableElement> implements Pacem.Drawing3D.Stage {
        #private;
        validate(item: RenderableElement): boolean;
        private _container;
        private _resizer;
        interactive: boolean;
        transparent: boolean;
        background: string;
        /** @deprecated */
        orbit: boolean;
        adapter: Pacem3DAdapterElement;
        datasource: Pacem.Drawing3D.Renderable[];
        get stage(): HTMLElement;
        get scene(): any;
        register(item: RenderableElement): boolean;
        unregister(item: RenderableElement): boolean;
        private _buildUpDatasourceFromDOM;
        private _itemPropertyChangeHandler;
        private _add;
        private _erase;
        private _initializeAdapter;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        private _lastHitResult;
        viewActivatedCallback(): void;
        private _itemDispatch;
        private _clickHandler;
        private _hitTestCallback;
        private _moveHandler;
        disconnectedCallback(): void;
        get size(): Size;
        private _resizeHandler;
        render(item?: Pacem.Drawing3D.Renderable, deepUpdate?: boolean, now?: number): void;
        private _doRender;
    }
}
declare namespace Pacem.Components.Drawing3D {
    type PointerEventLike = MouseEvent | PointerEvent | TouchEvent;
    export class AdapterUtils {
        static isMeshGeometry(obj: any): obj is Pacem.Drawing3D.MeshGeometry;
        static isVector3D(obj: any): obj is Pacem.Drawing3D.Vector3D;
        static isRgba(obj: any): obj is Pacem.Rgba;
        static flattenVectorArray(array: Pacem.Drawing3D.Vector3D[] | Pacem.Drawing3D.UVMap | Pacem.Rgba[]): number[];
        static findCamera(items: Pacem.Drawing3D.Renderable[]): Pacem.Drawing3D.Camera;
        clipPixel(viewportPoint: Point): Point;
        clipPixel(evt: PointerEventLike, canvas: HTMLCanvasElement): Point;
        clipPixel(evt: PointerEventLike, viewport: Rect): Point;
    }
    export {};
}
declare namespace Pacem.Drawing3D {
    enum KnownShader {
        Basic = "basic",
        Lambert = "lambert",
        Phong = "phong",
        Standard = "standard",
        Line = "line",
        Custom = "custom"
    }
    interface Material {
        opacity?: number;
        wireframe?: boolean;
        /** Object color. */
        color?: string | Rgba;
        visible?: boolean;
        /** Texture map. */
        map?: string;
        texture?: ImageBitmap;
        /** Renders each face as flat. */
        flatShading?: boolean;
        readonly shader: KnownShader;
        flags: StalePropertyFlag[];
    }
    function isMaterial(obj: any): obj is Material;
    interface BasicMaterial extends Material {
        readonly shader: KnownShader.Basic;
    }
    function isBasicMaterial(obj: any): obj is BasicMaterial;
    interface LineMaterial extends Material {
        readonly shader: KnownShader.Line;
        lineWidth: number;
        lineJoin?: CanvasLineJoin;
        lineCap?: CanvasLineCap;
        dashArray?: number[];
    }
    function isLineMaterial(obj: any): obj is LineMaterial;
    interface DiffuseMaterial extends Material {
        /** Diffuse color, albedo. */
        emissiveColor?: string;
        /** Percentage of reflected light. */
        reflectivity?: number;
        /** Index of refraction. */
        refractionRatio?: number;
    }
    interface LambertMaterial extends DiffuseMaterial {
        readonly shader: KnownShader.Lambert;
    }
    function isLambertMaterial(obj: any): obj is LambertMaterial;
    interface SpecularMaterial extends DiffuseMaterial {
        /** Specular color, defines the color of reflections. */
        specularColor?: string;
        /** Specular exponent, glossiness. */
        shininess?: number;
    }
    interface PhongMaterial extends SpecularMaterial {
        readonly shader: KnownShader.Phong;
    }
    function isPhongMaterial(obj: any): obj is PhongMaterial;
    interface StandardMaterial extends DiffuseMaterial {
        readonly shader: KnownShader.Phong;
        roughness?: number;
        metalness?: number;
        /** Percentage of reflected light at grazing angles. */
        fresnel?: number;
    }
    function isStandardMaterial(obj: any): obj is StandardMaterial;
    interface ShaderMaterial extends Material {
        readonly shader: KnownShader.Custom;
        vertexShader?: string;
        fragmentShader?: string;
    }
    function isShaderMaterial(obj: any): obj is ShaderMaterial;
}
declare namespace Pacem.Components.Drawing3D {
    abstract class MaterialElement extends PacemEventTarget {
        #private;
        constructor(shader: Pacem.Drawing3D.KnownShader);
        get shader(): Pacem.Drawing3D.KnownShader;
        private _loadMap;
        material: Pacem.Drawing3D.Material;
        opacity: number;
        wireframe: boolean;
        color: string;
        hide: boolean;
        map?: string;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        viewActivatedCallback(): void;
        protected updateMaterial(): void;
        protected createMaterial(): Promise<Pacem.Drawing3D.Material>;
    }
}
declare namespace Pacem.Components.Drawing3D {
    class Pacem3DThreeAdapterElement extends Pacem3DAdapterElement {
        private _assertMonoStage;
        dispose(scene: Pacem3DElement): void;
        snapshot(scene: Pacem3DElement, background?: string, type?: string, quality?: number): PromiseLike<Blob>;
        project(scene: Pacem3DElement, point3D: Pacem.Drawing3D.Vector3D): Point;
        zoomFit(scene: Pacem3DElement, ...items: Pacem.Drawing3D.Ui3DObject[]): Promise<void>;
        private _3d;
        private _stage;
        private _renderer;
        private _camera;
        private _scene;
        private _orbitCtrls;
        private _objects;
        private _dict;
        orbit: boolean;
        getScene(scene: Pacem3DElement): any;
        raycast(scene: Pacem3DElement, point: Point, size: Size, callback: (result: Pacem.Drawing3D.RaycastResult) => void): void;
        initialize(container: Pacem3DElement): Promise<HTMLCanvasElement>;
        private _setCamera;
        private _orbitControlsDelegate;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        private _initOrbitControls;
        private _disposeOrbitControls;
        private _updateRenderer;
        invalidateSize(scene: Pacem3DElement, size?: Size): void;
        removeItem(scene: Pacem3DElement, item: RenderableElement): void;
        updateItem(scene: Pacem3DElement, item: RenderableElement): void;
        addItem(scene: Pacem3DElement, item: RenderableElement): void;
        private _ensureAndRefresh;
        private _addOrUpdateItem;
        render(): void;
    }
}
declare namespace Pacem.Drawing3D.WebGPU {
    interface Context {
        readonly canvas: HTMLCanvasElement;
        readonly context: GPUCanvasContext;
        readonly adapter: GPUAdapter;
        readonly device: GPUDevice;
        readonly format: GPUTextureFormat;
    }
    type RenderPassEncoderBindDelegate = (pass: GPURenderPassEncoder, ...buffers: RenderableBuffer[]) => void;
    type RenderableBufferKey = 'u32id' | 'cameraViewTransform' | 'objectWorldTransform' | 'geometryPositions' | 'light' | 'geometryNormals' | 'geometryTexCoords' | 'material' | 'geometry' | 'line';
    type MaterialKey = 'texture' | 'sampler' | 'normalTexture' | '';
    type Texture = {
        texture?: GPUTexture;
        view?: GPUTextureView;
        source?: ImageBitmap;
    };
    type Buffer = {
        buffer: GPUBuffer;
        value: Uint32Array<ArrayBufferLike> | Float32Array<ArrayBufferLike>;
        version: number;
    };
    type RenderableBufferSet = Record<'meshes' | 'cameras' | 'lights' | 'groups', RenderableBuffer[]>;
    interface ManagedBuffer<T> {
        readonly item: T;
        buffer(context: Context, key: RenderableBufferKey): Buffer & {
            fresh: boolean;
        };
        version?: (key: RenderableBufferKey) => number;
        texture(context: Context, key?: MaterialKey): Texture & {
            fresh: boolean;
        };
        lock(): void;
        unlock(): void;
        destroy(): any;
        readonly disposed: boolean;
    }
    interface RenderableBuffer extends ManagedBuffer<Renderable> {
        readonly id: number;
    }
    interface WGSLFragmentExtra {
        definitions?: string[];
        bindings?: string[];
        modifiers?: string[];
    }
    type BindGroupDefinition = {
        key: RenderableBufferKey | MaterialKey;
        group: number;
        binding?: number;
        type: 'buffer' | 'texture';
    };
    enum WGSLBindingType {
        Mesh = "mesh",
        Camera = "camera",
        Texture = "texture",
        Light = "light"
    }
    interface WGSL<TMetadata extends {
        [key: string]: any;
    }> {
        readonly vertex: string;
        readonly fragment: string;
        readonly key: string;
        /**
         * Returns the allocated bindgroup coordinates (group + binding).
         * @param obj Involved object.
         */
        bindings(type: WGSLBindingType): BindGroupDefinition[];
        bindings(type: WGSLBindingType, key: RenderableBufferKey | MaterialKey): BindGroupDefinition[];
        bindings(type: WGSLBindingType, key: RenderableBufferKey | MaterialKey, index: number): BindGroupDefinition;
        readonly metadata: TMetadata;
    }
    interface Raycaster {
        begin(): void;
        frame: (...buffers: RenderableBuffer[]) => void;
        end: (pixel?: Point) => Promise<Iterable<Renderable>>;
        destroy(): void;
    }
    interface RenderPipeline {
        frame: RenderPassEncoderBindDelegate;
        /** @deprecated*/
        set?: RenderPassEncoderBindDelegate;
        /** @deprecated*/
        bind?: RenderPassEncoderBindDelegate;
        /** @deprecated*/
        draw?: RenderPassEncoderBindDelegate;
    }
    /**
     * Meant to be the delegate of the adapter per-stage.
     * It should be able to generate, manage, explot and dispose the necessary pipelines
     */
    interface Renderer {
        render(): void;
        raycast(pixel: Point): Promise<Iterable<Renderable>>;
        dispose(): void;
        update(...items: Renderable[]): void;
        resize(size: Size): void;
        readonly canvas: HTMLCanvasElement | OffscreenCanvas;
    }
    interface Camera {
        view(): Matrix3D;
        projection(size?: Size): Matrix3D;
    }
    type WGSLDefinitionDelegate = (wgsl: string) => string;
    type WGSLBindingLayoutDelegate = (group: number, binding: number) => string;
    type WGSLModifierDelegate = (positionReference?: string, normalReference?: string, vertexReference?: string, vertexColorReference?: string, uvReference?: string) => string;
    type WGSLDelegates = {
        definitions?: WGSLDefinitionDelegate;
        bindings?: WGSLBindingLayoutDelegate;
        modifiers?: WGSLModifierDelegate;
    };
    interface Material {
        /** Returns the omni-comprehensive buffer for the material WGSL struct. */
        buffer(ctx: Context, key?: RenderableBufferKey): Buffer;
        wgsl: WGSLDelegates;
        texture(ctx: Context, key?: MaterialKey): Texture;
    }
    interface Light {
        wgsl: WGSLDelegates;
        buffer(context: Context): GPUBuffer;
    }
}
declare namespace Pacem.Drawing3D.WebGPU {
    class Buffers {
        static create(device: GPUDevice, data: Float32Array, label?: string): GPUBuffer;
        static createUniform(device: GPUDevice, data: Float32Array, label?: string): GPUBuffer;
        static createUniform(device: GPUDevice, data: Uint32Array, label?: string): GPUBuffer;
        static createStorage(device: GPUDevice, data: Float32Array, label?: string): GPUBuffer;
        static createStorage(device: GPUDevice, data: Uint32Array, label?: string): GPUBuffer;
        static createIndexed(device: GPUDevice, data: Uint16Array, label?: string): GPUBuffer;
    }
    class BufferLayouts {
        /**
         * Create one {@link GPUVertexBufferLayout} at the provided {@param shaderLocation} having the spcified {@param size}.
         * @param shaderLocation {Number} Shader location index.
         * @param size {Number} Float32Array size (defaults to 3 assuming a flattened array of 3D vectors as the most common case).
         */
        static createVertex(shaderLocation: number, size?: number): GPUVertexBufferLayout;
        /**
         * Create one {@link GPUVertexBufferLayout} having the first defined shaderLocation at the provided {@param shaderLocationStart} index and the offsets obeying to the spcified {@param sizes}.
         * @param shaderLocationStart {Number} First shader location index.
         * @param sizes {Array} Ordered Float32Array sizes.
         */
        static createVertex(shaderLocationStart: number, ...sizes: number[]): GPUVertexBufferLayout;
    }
}
declare namespace Pacem.Drawing3D.WebGPU {
    const Matrix3D: typeof Geometry.LinearAlgebra.Matrix3D;
    type Matrix3D = Pacem.Geometry.LinearAlgebra.Matrix3D;
    export class Camera {
        /**
         * Creates a new webgpu {@link Camera} given a canonic one.
         * @param camera
         * @returns
         */
        static create(camera: Pacem.Drawing3D.Camera): Camera;
    }
    export class OrthographicCamera implements Camera {
        private _camera;
        constructor(_camera: Pacem.Drawing3D.OrthographicCamera);
        static view(camera: Pacem.Drawing3D.OrthographicCamera): Matrix3D;
        static projection(camera: Pacem.Drawing3D.OrthographicCamera, size?: Size): Matrix3D;
        view(): Matrix3D;
        projection(size?: Size): Matrix3D;
    }
    export class PerspectiveCamera implements Camera {
        private _camera;
        constructor(_camera: Pacem.Drawing3D.PerspectiveCamera);
        static view(camera: Pacem.Drawing3D.PerspectiveCamera): Matrix3D;
        static projection(camera: Pacem.Drawing3D.PerspectiveCamera, size?: Size): Matrix3D;
        view(): Matrix3D;
        projection(size?: Size): Matrix3D;
    }
    export {};
}
declare namespace Pacem.Drawing3D.WebGPU {
    const LABEL_PREFIX = "pacem-3d-";
    const U32_MAX = 4294967295;
    const VERTEX_BUFFER_INDEX_MESH_POSITION = 0;
    const VERTEX_BUFFER_INDEX_MESH_NORMAL = 1;
    const VERTEX_BUFFER_INDEX_MESH_UV = 2;
    const VERTEX_OUTPUT_LOCATION_NORMAL = 0;
    const VERTEX_OUTPUT_LOCATION_VERTEX = 1;
    const VERTEX_OUTPUT_LOCATION_UV = 2;
    const VERTEX_OUTPUT_LOCATION_INDEX = 3;
    const VERTEX_OUTPUT_LOCATION_RAY = 4;
    const UNIFORM_GROUP_INDEX_TRANSFORM = 0;
    const UNIFORM_GROUP_INDEX_CAMERA = 1;
    const STORAGE_GROUP_INDEX_LINE = 2;
    const UNIFORM_GROUP_INDEX_COLORPICKING = 2;
    const UNIFORM_BINDING_INDEX_TRANSFORM = 0;
    const UNIFORM_BINDING_INDEX_CAMERA = 0;
    const MATERIAL_GROUP_INDEX = 2;
    const UNIFORM_GROUP_INDEX_LIGHTING: number;
    const STORAGE_MATERIAL_INDEX = 0;
    const SAMPLER_BINDING_INDEX = 1;
    const TEXTURE_BINDING_INDEX = 2;
    const MATERIAL_REFERENCE = "material";
    const VERTEX_COLOR_REFERENCE = "color";
    const AMBIENT_COLOR_REFERENCE = "ambient";
    const LIGHTING_COLOR_REFERENCE = "lighting";
}
declare namespace Pacem.Drawing3D.WebGPU {
    type BasicMaterialFragmentOptions = {
        /** Output location for normal vector (vec3f). */
        outputNormalLocation?: number;
        /** Output location for vertex vector (vec3f). */
        outputVertexLocation?: number;
        /** Output location for uv vector (vec2f). */
        outputUvLocation?: number;
        /** Output location for vertex index (u32). */
        outputVertexIndexLocation?: number;
        /** Output location for ray vector (vec3f). */
        outputRayIndexLocation?: number;
        storageMaterialGroupIndex?: number;
        storageMaterialBindingIndex?: number;
    };
    function getBasicMaterialFragmentWgsl(extensions?: WGSLFragmentExtra, options?: Partial<BasicMaterialFragmentOptions>): string;
}
declare namespace Pacem.Drawing3D.WebGPU {
    type LineMaterialFragmentOptions = {
        /** Output location for instance index (u32). */
        outputInstanceIndexLocation?: number;
        /** Output location for vertex index (u32). */
        outputVertexIndexLocation?: number;
        storageMaterialGroupIndex?: number;
        storageMaterialBindingIndex?: number;
    };
    function getLineMaterialFragmentWgsl(extensions?: WGSLFragmentExtra, options?: Partial<LineMaterialFragmentOptions>): string;
}
declare namespace Pacem.Drawing3D.WebGPU {
    export class Material {
        static create(material: Pacem.Drawing3D.Material): Material;
    }
    abstract class MaterialBase implements Material {
        #private;
        constructor(material: Pacem.Drawing3D.Material);
        protected get material(): Pacem.Drawing3D.Material;
        abstract texture(ctx: Context, key: MaterialKey): Texture;
        abstract readonly shader: string;
        get wgsl(): WGSLDelegates;
        buffer({ device }: Context, label?: string): Buffer;
        private _diffuseColor;
    }
    export class BasicMaterial extends MaterialBase {
        get shader(): string;
        constructor(material: Pacem.Drawing3D.BasicMaterial);
        texture({ device }: Context, key?: MaterialKey): Texture;
        static fragment: typeof getBasicMaterialFragmentWgsl;
    }
    export class LineMaterial extends MaterialBase {
        get shader(): string;
        constructor(material: Pacem.Drawing3D.LineMaterial);
        buffer(ctx: Context, key?: RenderableBufferKey): Buffer;
        texture(_: Context): Texture;
        static fragment: typeof getLineMaterialFragmentWgsl;
    }
    export {};
}
declare namespace Pacem.Drawing3D.WebGPU {
    type TextureMapReferences = {
        /** Name of the input UVMap vector parameter. */
        uv: string;
        inputColor: string;
        outputColors?: string[];
    };
    export function textureMap(references: Partial<TextureMapReferences>, group: number, binding?: number): WGSLFragmentExtra;
    export {};
}
declare namespace Pacem.Drawing3D.WebGPU {
    type MeshVertexOptions = {
        /** Output location for normal vector (vec3f). */
        outputNormalLocation?: number;
        /** Output location for vertex vector (vec3f). */
        outputVertexLocation?: number;
        /** Output location for uv vector (vec2f). */
        outputUvLocation?: number;
        /** Output location for uv vector (u32). */
        outputVertexIndexLocation?: number;
        /** Output location for ray vector (vec3f). */
        outputRayLocation?: number;
        /** Uniform group index for world transform matrix (mat4x4f). */
        uniformWorldGroupIndex?: number;
        /** Uniform group index for camera view matrix (mat4x4f). */
        uniformViewGroupIndex?: number;
        /** Uniform group index for camera view-projection matrix (mat4x4f). */
        uniformViewProjectionGroupIndex?: number;
        /** Uniform binding index for world transform matrix (mat4x4f). */
        uniformWorldBindingIndex?: number;
        /** Uniform binding index for camera view matrix (mat4x4f). */
        uniformViewBindingIndex?: number;
        /** Uniform binding index for camera view-projection matrix (mat4x4f). */
        uniformViewProjectionBindingIndex?: number;
        /** Input location for position vector (vec3f). */
        inputPositionLocation?: number;
        /** Input location for normal vector (vec3f). */
        inputNormalLocation?: number;
        /** Input location for uv vector (vec2f). */
        inputUvLocation?: number;
    };
    function getMeshVertexWgsl(options?: MeshVertexOptions): string;
}
declare namespace Pacem.Drawing3D.WebGPU {
    type LineVertexOptions = {
        inputPositionLocation?: number;
        /** Output location for instance index (u32). */
        outputInstanceIndexLocation?: number;
        /** Output location for vertex index (u32). */
        outputVertexIndexLocation?: number;
        /** Uniform group index for world transform matrix (mat4x4f). */
        uniformWorldGroupIndex?: number;
        /** Uniform group index for camera view matrix (mat4x4f). */
        uniformViewGroupIndex?: number;
        /** Uniform binding index for world transform matrix (mat4x4f). */
        uniformWorldBindingIndex?: number;
        /** Uniform binding index for camera view matrix (mat4x4f). */
        uniformViewBindingIndex?: number;
        /** Storage group index for positions (array<f32>). */
        storagePositionsGroupIndex?: number;
        storagePositionsBindingIndex?: number;
        uniformDimensionsGroupIndex?: number;
        uniformDimensionsBindingIndex?: number;
    };
    function getDefaultLineVertexWgsl(options?: LineVertexOptions): string;
    function getFatLineVertexWgsl(options?: LineVertexOptions): string;
}
declare namespace Pacem.Drawing3D.WebGPU {
    type PipelineOptions = {
        primitive: GPUPrimitiveState;
        multisample: boolean;
        packedVertices: boolean;
    };
    class RenderPipeline {
        private static _memoizer;
        static dispose(ctx: Context): void;
        static createColorPicking(ctx: Context, items: RenderableBuffer[]): RenderPipeline | null;
        static create(ctx: Context, [mesh, camera, ...lights]: RenderableBuffer[], pipelineOptions?: Partial<PipelineOptions>): RenderPipeline;
    }
}
declare namespace Pacem.Drawing3D.WebGPU {
    class Raycaster {
        private static _memoizer;
        static dispose(ctx: Context): void;
        /** Creates a raycaster that uses color picking as a strategy to hit-test objects. */
        static createColorPicking(ctx: Context): Raycaster;
    }
}
declare namespace Pacem.Drawing3D.WebGPU {
    class RenderLooper {
        private _set;
        constructor(_set: RenderableBufferSet);
        /** @internal */
        get items(): RenderableBufferSet;
        loop(render: (mesh: RenderableBuffer, camera: RenderableBuffer, lights: RenderableBuffer[]) => boolean): void;
    }
    class ManagedBuffer<T> {
        static create(item: any): ManagedBuffer<any>;
    }
    class RenderableBuffer {
        static create(item: Renderable, ...args: any[]): RenderableBuffer;
        static clearFlags(buffer: RenderableBuffer, includeParent?: boolean): void;
        static allFlags(buffer: RenderableBuffer): StalePropertyFlag[];
    }
}
declare namespace Pacem.Drawing3D.WebGPU {
    type RendererConfiguration = {
        enableValidation: boolean;
    };
    export enum WebGPUIssueCause {
        NotSupported = 0,
        Disabled = 1
    }
    export type WebGPUIssue = {
        message: string;
        cause: WebGPUIssueCause;
    };
    export class Renderer {
        static create(stage: Pacem.Components.Drawing3D.Pacem3DElement, config: RendererConfiguration): Promise<Renderer>;
    }
    export {};
}
declare namespace Pacem.Components.Drawing3D {
    class Pacem3DWebgpuAdapterElement extends Pacem3DAdapterElement {
        #private;
        invalidateSize(stage: Pacem3DElement, size?: Size): void;
        get supported(): boolean;
        get active(): boolean;
        private _webGPUNotSupported;
        initialize(scene: Pacem3DElement): Promise<HTMLCanvasElement | null>;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        disconnectedCallback(): void;
        dispose(scene: Pacem3DElement): void;
        enableValidation: boolean;
        private _ensureRenderer;
        private _updatePipeline;
        /**
         * Called when scene datasource changes.
         * @param scene
         */
        render(scene: Pacem3DElement): void;
        snapshot(scene: Pacem3DElement, background?: string, type?: string, quality?: number): PromiseLike<Blob>;
        raycast(stage: Pacem3DElement, point: Point, size: Size, callback: (result: Pacem.Drawing3D.RaycastResult) => void): void;
        private _itemsChangedExec;
        private _itemsChanged;
        addItem(stage: Pacem3DElement, item: Pacem.Drawing3D.Renderable): void;
        removeItem(stage: Pacem3DElement, item: Pacem.Drawing3D.Renderable): void;
        updateItem(stage: Pacem3DElement, item: Pacem.Drawing3D.Renderable): void;
        zoomFit(stage: Pacem3DElement, ...items: Pacem.Drawing3D.Ui3DObject[]): Promise<void>;
        project(stage: Pacem3DElement, point3D: Geometry.LinearAlgebra.Vector3D): Point;
        getScene(stage: Pacem3DElement): any;
    }
}
declare namespace Pacem.Components.Drawing3D {
    type OrbitCameraConfiguration = {
        maxAzimuth: number;
        minAzimuth: number;
        minPolar: number;
        maxPolar: number;
        inertia: boolean | number;
        pan: OrbitCameraControl;
        rotation: OrbitCameraControl;
        zoom: OrbitCameraControl;
    };
    type OrbitCameraControl = {
        enabled: boolean;
        button?: number;
        modifiers?: EventKeyModifier[];
    };
    export class OrbitCameraBehavior {
        #private;
        private _config;
        private readonly _canvas;
        private readonly _camera;
        private readonly _scene;
        private readonly _initialState;
        private _currentState;
        private constructor();
        private static _buildState;
        /**
         * Tries to attach a new {@link OrbitCameraBehavior} to the provided element, if the element is a proper renderable and it is ready.
         * @param element
         * @returns
         */
        static tryAttach(element: any, config?: OrbitCameraConfiguration): OrbitCameraBehavior | null;
        /** State of the current configuration, obtained from the interaction inputs. */
        private _input;
        /** Sibling state of {@link _input} that comes helpful when inertia is involved. */
        private _progress;
        get configuration(): OrbitCameraConfiguration;
        set configuration(v: OrbitCameraConfiguration);
        private _startHandler;
        private _avoidHandler;
        private _endHandler;
        private _zoomHandler;
        private _moveHandler;
        private _getSafeAzimuth;
        private _getSafePolar;
        private static _modAngle;
        private static _getViewXYZ;
        private _update;
        private _renderHandler;
        /** Detaches and removes handlers and resources. */
        dispose(): void;
    }
    export class PacemOrbitCameraBehaviorElement extends Pacem.Behaviors.PacemBehavior {
        #private;
        maxAzimuth: number;
        maxPolar: number;
        minAzimuth: number;
        minPolar: number;
        zoomControl: OrbitCameraControl;
        rotationControl: OrbitCameraControl;
        panControl: OrbitCameraControl;
        inertia: boolean | number;
        private _readyHandler;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        disconnectedCallback(): void;
        private _buildConfig;
        private _decorateCore;
        protected decorate(element: Element): void;
        protected undecorate(element: Element): void;
    }
    export {};
}
declare namespace Pacem.Drawing3D.WebGPU {
    type AmbientLightReferences = {
        /** Name of the input vertex color variable/constant. */
        inputColor: string;
        /** Name of the input vertex color variable/constant. */
        outputColor: string;
    };
    export function ambientLight(references: Partial<AmbientLightReferences>, group: number, binding: number): WGSLFragmentExtra;
    export {};
}
declare namespace Pacem.Drawing3D.WebGPU {
    type DirectionalLightReferences = {
        /** Name of the input vertex color variable/constant. */
        inputColor?: string;
        /** Name of the output vertex color variable. */
        outputColor?: string;
        /** Name of the input normal vector parameter. */
        normal: string;
    };
    export function directionalLight(references: Partial<DirectionalLightReferences>, group: number, binding: number): WGSLFragmentExtra;
    export {};
}
declare namespace Pacem.Drawing3D.WebGPU {
    /**
     * Generate a WGSL piece of code that eases 3D picking using color strategy.
     */
    function getColorPickingFragmentWgsl(groupIndex?: number): string;
}
declare namespace Pacem.Drawing3D.WebGPU {
    type OmniLightReferences = {
        /** Name of the input vertex color variable/constant. */
        inputColor?: string;
        /** Name of the output vertex color variable. */
        outputColor?: string;
        /** Name of the specular color variable. */
        specularColor?: string;
        /** Name of the shininess variable. */
        shininess?: string;
        /** Name of the input normal vector parameter. */
        normal: string;
        /** Name of the input vertex position parameter. */
        position: string;
        /** Name of the input ray (eye-to-vertex) vector parameter. */
        ray: string;
    };
    export function omniLight(references: Partial<OmniLightReferences>, group: number, binding: number): WGSLFragmentExtra;
    export {};
}
declare namespace Pacem.Drawing3D.WebGPU {
    type StandardMaterialFragmentOptions = {
        /** Output location for normal vector (vec3f). */
        outputNormalLocation?: number;
        /** Output location for vertex vector (vec3f). */
        outputVertexLocation?: number;
        /** Output location for uv vector (vec2f). */
        outputUvLocation?: number;
        /** Output location for vertex index (u32). */
        outputVertexIndexLocation?: number;
        /** Output location for ray vector (vec3f). */
        outputRayIndexLocation?: number;
        storageMaterialGroupIndex?: number;
        storageMaterialBindingIndex?: number;
    };
    function getStandardMaterialFragmentWgsl(extensions?: WGSLFragmentExtra, options?: Partial<StandardMaterialFragmentOptions>): string;
}
declare namespace Pacem.Components.Drawing3D {
    class BasicMaterialElement extends MaterialElement {
        constructor();
    }
}
declare namespace Pacem.Components.Drawing3D {
    class LambertMaterialElement extends MaterialElement {
        constructor();
        protected createMaterial(): Promise<Pacem.Drawing3D.LambertMaterial>;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        emissiveColor: string;
        reflectivity: number;
        refractionRatio: number;
    }
}
declare namespace Pacem.Components.Drawing3D {
    class LineMaterialElement extends MaterialElement {
        constructor();
        lineWidth: number;
        lineJoin?: CanvasLineJoin;
        lineCap?: CanvasLineCap;
        dashArray?: number[];
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        protected createMaterial(): Promise<Pacem.Drawing3D.LineMaterial>;
    }
}
declare namespace Pacem.Components.Drawing3D {
    class PhongMaterialElement extends MaterialElement {
        constructor();
        protected createMaterial(): Promise<Pacem.Drawing3D.PhongMaterial>;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        emissiveColor: string;
        reflectivity: number;
        refractionRatio: number;
        specularColor: string;
        shininess: number;
        flatShading: boolean;
    }
}
declare namespace Pacem.Components.Drawing3D {
    class StandardMaterialElement extends MaterialElement {
        constructor();
        protected createMaterial(): Promise<Pacem.Drawing3D.PhongMaterial>;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        emissiveColor: string;
        refractionRatio: number;
        roughness: number;
        metalness: number;
        flatShading: boolean;
    }
}
declare namespace Pacem.Drawing3D {
}
declare namespace Pacem.Components.Drawing3D {
    abstract class Pacem3DPrimitiveElement extends PacemEventTarget {
        geometry: Pacem.Drawing3D.NodeGeometry;
        viewActivatedCallback(): void;
        protected abstract createDefaultGeometry(): Pacem.Drawing3D.NodeGeometry;
    }
}
declare namespace Pacem.Components.Drawing3D {
    class PacemBoxElement extends Pacem3DPrimitiveElement {
        width: number;
        height: number;
        depth: number;
        widthSegments: number;
        heightSegments: number;
        depthSegments: number;
        static createMeshGeometry(width?: number, height?: number, depth?: number, widthSegments?: number, heightSegments?: number, depthSegments?: number): Pacem.Drawing3D.MeshGeometry;
        protected createDefaultGeometry(): Pacem.Drawing3D.MeshGeometry;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
    }
}
declare namespace Pacem.Components.Drawing3D {
    class PacemConeElement extends Pacem3DPrimitiveElement {
        radius: number;
        height: number;
        sides: number;
        heightSegments: number;
        capSegments: number;
        static createMeshGeometry(radius?: number, height?: number, sides?: number, heightSegments?: number, capSegments?: number): Pacem.Drawing3D.MeshGeometry;
        protected createDefaultGeometry(): Pacem.Drawing3D.MeshGeometry;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
    }
}
declare namespace Pacem.Components.Drawing3D {
    class PacemCylinderElement extends Pacem3DPrimitiveElement {
        radius: number;
        height: number;
        sides: number;
        heightSegments: number;
        capSegments: number;
        static createMeshGeometry(radius?: number, height?: number, sides?: number, heightSegments?: number, capSegments?: number): Pacem.Drawing3D.MeshGeometry;
        protected createDefaultGeometry(): Pacem.Drawing3D.MeshGeometry;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
    }
}
declare namespace Pacem.Components.Drawing3D {
    class PacemLineElement extends Pacem3DPrimitiveElement {
        positions: Pacem.Drawing3D.Vector3D[];
        static createLineGeometry(positions?: Pacem.Drawing3D.Vector3D[]): Pacem.Drawing3D.LineGeometry;
        protected createDefaultGeometry(): Pacem.Drawing3D.LineGeometry;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
    }
}
declare namespace Pacem.Components.Drawing3D {
    class PacemPlaneElement extends Pacem3DPrimitiveElement {
        width: number;
        length: number;
        widthSegments: number;
        lengthSegments: number;
        static createMeshGeometry(width?: number, length?: number, widthSegments?: number, lengthSegments?: number): Pacem.Drawing3D.MeshGeometry;
        protected createDefaultGeometry(): Pacem.Drawing3D.MeshGeometry;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
    }
}
declare namespace Pacem.Components.Drawing3D {
    abstract class PolyhedronElement extends Pacem3DPrimitiveElement {
        radius: number;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        private _assignMeshGeometry;
        protected createDefaultGeometry(): Pacem.Drawing3D.MeshGeometry;
        protected abstract createMeshGeometry(radius: number): Pacem.Drawing3D.MeshGeometry;
    }
    class PacemTetrahedronElement extends PolyhedronElement {
        static createMeshGeometry(radius?: number): Pacem.Drawing3D.MeshGeometry;
        protected createMeshGeometry(radius?: number): Pacem.Drawing3D.MeshGeometry;
    }
    class PacemOctahedronElement extends PolyhedronElement {
        static createMeshGeometry(radius?: number): Pacem.Drawing3D.MeshGeometry;
        protected createMeshGeometry(radius?: number): Pacem.Drawing3D.MeshGeometry;
    }
    class PacemHexahedronElement extends PolyhedronElement {
        static createMeshGeometry(radius?: number): Pacem.Drawing3D.MeshGeometry;
        protected createMeshGeometry(radius?: number): Pacem.Drawing3D.MeshGeometry;
    }
    class PacemIcosahedronElement extends PolyhedronElement {
        static createMeshGeometry(radius?: number): Pacem.Drawing3D.MeshGeometry;
        protected createMeshGeometry(radius?: number): Pacem.Drawing3D.MeshGeometry;
    }
    class PacemDodecahedronElement extends PolyhedronElement {
        static createMeshGeometry(radius?: number): Pacem.Drawing3D.MeshGeometry;
        protected createMeshGeometry(radius?: number): Pacem.Drawing3D.MeshGeometry;
    }
}
declare namespace Pacem.Components.Drawing3D {
    class PacemSphereElement extends Pacem3DPrimitiveElement {
        radius: number;
        segments: number;
        static createMeshGeometry(radius?: number, segs?: number): Pacem.Drawing3D.MeshGeometry;
        protected createDefaultGeometry(): Pacem.Drawing3D.MeshGeometry;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
    }
}
declare namespace Pacem.Components.Drawing3D {
    class PacemTorusElement extends Pacem3DPrimitiveElement {
        radius: number;
        innerRadius: number;
        segments: number;
        sides: number;
        static createMeshGeometry(radius?: number, innerRadius?: number, segments?: number, sides?: number): Pacem.Drawing3D.MeshGeometry;
        protected createDefaultGeometry(): Pacem.Drawing3D.MeshGeometry;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
    }
}
