archiyou 0.7.0

package/dist/src/types.d.ts

@@ -0,0 +1,944 @@
+import { Point, Vector, Shape, Vertex, Edge, Wire, Face, Shell, Solid, ShapeCollection, VertexCollection, Bbox, BaseAnnotation, ParamManager, Obj, Script, ScriptParam, ScriptData, Brep, Doc, Beams, Container, DimensionLine, CodeParser, Exporter, Make, Calc, Db as CalcDb, View, Runner, Services, ScriptParamData } from './internal';
+import { Console } from './Console';
+export declare const ALL_SHAPE_NAMES: string[];
+export declare const AXIS_TO_VECS: {
+    x: number[];
+    '-x': number[];
+    y: number[];
+    '-y': number[];
+    z: number[];
+    '-z': number[];
+    xy: number[];
+    xz: number[];
+    yz: number[];
+};
+export declare const SIDES: string[];
+export declare const SIDE_TO_AXIS: {
+    [key: string]: string;
+};
+export declare const ALIGNMENTS_ADD_TO_SIDES: string[];
+export type ModelUnits = 'mm' | 'cm' | 'dm' | 'm' | 'km' | 'in' | 'ft' | 'yd' | 'mi';
+export type Units = DocUnits | ModelUnits;
+export type UnitsWithPerc = Units | '%';
+export type Coord = number | string;
+export type MainAxis = 'x' | 'y' | 'z';
+export type Plane = 'xy' | 'xz' | 'yz';
+export type Axis = 'x' | '-x' | 'y' | '-y' | 'z' | '-z' | Plane;
+export type SideX = 'left' | 'right';
+export type SideY = 'front' | 'back';
+export type SideZ = 'top' | 'bottom';
+export type Side = SideX | SideY | SideZ;
+export type SketchPlaneName = Plane | Side;
+export type CoordArray = [Coord, Coord, Coord];
+export type PointLike = Coord | Array<Coord> | Vector | Point | Vertex;
+export type PointLikeSequence = Array<PointLike> | ShapeCollection;
+export type ShapeType = 'Vertex' | 'Edge' | 'Wire' | 'Face' | 'Shell' | 'Solid';
+export type ShapeTypes = Array<ShapeType>;
+export type LinearShape = Edge | Wire;
+export type PointLikeOrAnyShape = PointLike | AnyShape;
+export type AnyShape = Shape | Vertex | Edge | Wire | Face | Shell | Solid;
+export type AnyTypedShape = Vertex | Edge | Wire | Face | Shell | Solid;
+export type AnyShapeCollection = ShapeCollection | VertexCollection;
+export type AnyShapeSequence = AnyShapeCollection | Array<AnyShape>;
+export type AnyShapeOrCollection = AnyShape | AnyShapeCollection;
+export type AnyShapeOrSequence = AnyShape | AnyShapeSequence;
+export type PointLikeOrVertexCollection = PointLike | VertexCollection;
+export type PointLikeOrAnyShapeOrCollection = PointLike | AnyShape | AnyShapeCollection;
+export type ColorInput = string | number;
+export type Pivot = PointLike | string;
+export type Alignment = string | PointLike;
+export type BboxAlignment = Array<number> | Alignment;
+export type LinearShapeTail = 'start' | 'end';
+export type ThickenDirection = 'all' | 'center' | PointLike | Side;
+export type OrientationXY = 'horizontal' | 'vertical';
+export type SelectionString = string;
+export type AnyShapeOrCollectionOrSelectionString = AnyShape | AnyShapeCollection | SelectionString;
+export type PointLikeOrAnyShapeOrCollectionOrSelectionString = PointLikeOrAnyShapeOrCollection | SelectionString;
+export type MakeShapeCollectionInput = PointLikeOrAnyShapeOrCollection | PointLikeSequence | Array<PointLikeOrAnyShapeOrCollection | PointLikeSequence>;
+export type MakeWireInput = PointLikeSequence | AnyShapeOrCollection | Array<PointLikeSequence | AnyShapeOrCollection>;
+export type MakeFaceInput = Wire | PointLikeSequence | AnyShapeSequence;
+export type MakeShellInput = Array<Face | Edge> | ShapeCollection;
+export type MakeSolidInput = Array<Shell> | ShapeCollection;
+/** Pipelines are calculations that need to run to generate certain outputs */
+export type PipelineType = 'docs' | '3dprint' | 'cnc' | 'techdraw' | 'laser';
+/** Saved Scripts by Version */
+export interface ScriptVersion {
+    id?: string;
+    file_id?: string;
+    user_id?: string;
+    user_name?: string;
+    file_name?: string;
+    prev_version_id?: string;
+    created_at?: string;
+    updated_at?: string;
+    params?: Array<ScriptParam>;
+    code: string;
+    shared?: boolean;
+    shared_version_tag?: string;
+    shared_auto_sync?: boolean;
+    shared_category?: string;
+    shared_description?: string;
+}
+/** After execution of the script (on client or server) we fill in some metadata */
+export interface ScriptMeta {
+    units: ModelUnits;
+    pipelines: Array<string>;
+    metrics: Array<string>;
+    tables: Array<string>;
+    docs: Array<string>;
+    numShapes?: number;
+    bbox?: Array<number | number | number | number | number | number>;
+}
+/** Information on how the Script is published
+ *  If null then the script is not published
+ *  Before publishing the script is executed and validated, so here we also add information
+ *  that comes out of execution
+*/
+export interface ScriptPublished {
+    title?: string;
+    version: string;
+    libraryUrl?: string;
+    url?: string;
+    published?: Date;
+    description?: string;
+    public?: boolean;
+    params?: Record<string, any>;
+    presets?: Array<string>;
+}
+/** A group of all modules of Archiyou for easy access  */
+export interface ArchiyouApp {
+    oc?: any;
+    worker?: any;
+    runner?: Runner;
+    scope?: any;
+    brep?: Brep;
+    doc?: Doc;
+    console?: Console;
+    executor?: CodeParser;
+    exporter?: Exporter;
+    calc?: Calc;
+    make?: Make;
+    services?: Services;
+    gizmos?: Array<Gizmo>;
+    beams?: Beams;
+    paramManager?: ParamManager;
+    config?: Record<string, any>;
+}
+export interface ArchiyouAppInfoBbox {
+    min: Array<number | number | number>;
+    max: Array<number | number | number>;
+    width: number;
+    height: number;
+}
+export type ArchiyouOutputFormatType = 'step' | 'stl' | 'gltf';
+export interface ArchiyouOutputSettings {
+    metrics?: boolean;
+    tables?: boolean;
+    docs?: boolean | Array<string>;
+    pipelines?: boolean | Array<string>;
+    formats?: boolean | Array<ArchiyouOutputFormatType>;
+    messages?: boolean | Array<ConsoleMessageType>;
+}
+export type ConsoleMessageType = 'info' | 'geom' | 'user' | 'warn' | 'error' | 'exec';
+/** A console Message */
+export interface ConsoleMessage {
+    type: ConsoleMessageType;
+    time: string;
+    from: string;
+    message: string;
+}
+/** Special Archiyou data inserted into asset.archiyou
+    TODO: We use RunnerScriptExecutionResult internally - which has a lot of overlap with this
+    When we start using GLB format internally these types will merge
+*/
+export interface ArchiyouData {
+    scenegraph: SceneGraphNode;
+    gizmos: Array<Gizmo>;
+    annotations: Array<DimensionLineData>;
+    docs: {
+        [key: string]: DocData;
+    };
+    errors?: Array<StatementResult>;
+    messages?: Array<ConsoleMessage>;
+    metrics?: Record<string, Metric>;
+    tables?: {
+        [key: string]: any;
+    };
+    managedParams?: Record<ParamOperation, Array<ScriptParamData>>;
+}
+/** TODO */
+export interface ExportSVGOptions {
+}
+export interface ExportGLTFOptions {
+    binary?: boolean;
+    quality?: MeshingQualitySettings;
+    archiyouFormat?: boolean;
+    archiyouOutput?: ArchiyouOutputSettings;
+    includePointsAndLines?: boolean;
+    extraShapesAsPointLines?: boolean;
+}
+/** Archiyou-specific information in GLTF */
+export interface ArchiyouData {
+    scenegraph: SceneGraphNode;
+    gizmos: Array<Gizmo>;
+    annotations: Array<DimensionLineData>;
+    docs: {
+        [key: string]: DocData;
+    };
+    errors?: Array<StatementResult>;
+    messages?: Array<ConsoleMessage>;
+    tables?: {
+        [key: string]: any;
+    };
+}
+export type EngineStateStatus = 'init' | 'loaded' | 'executing' | 'executed';
+export interface EngineState {
+    engine: 'cloud' | 'local';
+    status?: EngineStateStatus;
+    executionTime?: number | undefined;
+    statements?: Array<StatementResult>;
+}
+export interface MeshingQuality {
+}
+export interface ComputeTask {
+    uuid?: string;
+    type: string;
+    user_id?: string;
+    broker_id?: string;
+    client_id?: string;
+    created_at?: Date;
+    params?: Array<ScriptParam>;
+    code: string;
+}
+export interface RunnerScriptExecutionResult {
+    created_at: Date;
+    status: 'success' | 'error';
+    duration: number;
+    request: RunnerScriptExecutionRequest;
+    scenegraph?: SceneGraphNode;
+    gizmos?: Array<Gizmo>;
+    annotations?: Array<any>;
+    managedParams?: Record<ParamOperation, Array<ScriptParamData>>;
+    statements?: Array<StatementResult>;
+    errors?: Array<StatementResult>;
+    warnings?: Array<string>;
+    messages?: Array<ConsoleMessage>;
+    meta?: ScriptMeta;
+    outputs?: Array<ScriptOutputData>;
+}
+/** Results of component execution
+ *  This is a flattened version of RunnerScriptExecutionResult for direct use in execution scope
+ *  Any output is in internal format
+ *   - models -> Obj (which contains Shapes)
+ *   - metrics -> Record<string,Metric>
+ *   - tables -> CalcTable (or CalcDb?)
+ *   - docs -> Doc
+ *
+*/
+export type ImportComponentOutput = Obj | Record<string, Metric> | Calc | Doc | null;
+export interface ImportComponentResultPipeline {
+    model?: Obj | null;
+    metrics?: Record<string, Metric> | null;
+    tables?: CalcDb | null;
+    docs?: Doc | null;
+}
+/** Result with multiple pipelines */
+export type ImportComponentResultPipelines = Record<string, ImportComponentResultPipeline>;
+/** Combined type: direct output, per pipeline or multiple pipelines */
+export type ImportComponentResult = ImportComponentOutput | ImportComponentResultPipeline | ImportComponentResultPipelines;
+export type ParamType = 'number' | 'boolean' | 'text' | 'options' | 'list' | 'object';
+export type ParamOperation = 'new' | 'updated' | 'deleted';
+/** Target of a Param behaviour  */
+export type ParamBehaviourTarget = 'visible' | 'enable' | 'value' | 'values' | 'start' | 'end' | 'options';
+/** A way to define nested ParamObjects, either user in a single entry or list
+ *  NOTE: For now we don't allow nested structures (so no ParamObj containing other ParamObj field)
+*/
+export type ParamObjectSchema = Record<string, ScriptParam>;
+/** All possible attributes for Shapes */
+export interface ShapeAttributes {
+    hidden?: boolean;
+    outline?: boolean;
+    visible?: boolean;
+    dashed?: boolean;
+}
+/** A cursor in a coordinate system. Used in Sketcher and others in the future */
+export interface Cursor {
+    point: Point;
+    direction?: Vector;
+}
+export interface PolarCoord {
+    length: number;
+    angle: number;
+    relativeAngle?: boolean;
+}
+/** Represents a link between two Shapes */
+export interface Link {
+    from: Point;
+    to: Point;
+    fromSupport: Vertex | Edge | Face;
+    toSupport: Vertex | Edge | Face;
+    fromParams: Array<number>;
+    toParams: Array<number>;
+    distance: number;
+}
+export interface SceneGraphNode {
+    name: string;
+    type: string;
+    nodes: Array<SceneGraphNode>;
+    details?: SceneGraphNodeDetails;
+}
+export interface SceneGraphNodeDetails {
+    visible?: boolean;
+    color?: number;
+    subType?: string;
+    numVertices?: number;
+    numEdges?: number;
+    numWires?: number;
+}
+export interface BaseStyle {
+    color?: number | string;
+    opacity?: number;
+    size?: number;
+    dashed?: boolean;
+    width?: number;
+}
+export interface ObjStyle {
+    point?: BaseStyle;
+    line?: BaseStyle;
+    fill?: BaseStyle;
+}
+export interface Gizmo {
+    name: string;
+    _id?: string;
+    axis: string;
+    position: Array<number>;
+    domains: Array<number>;
+    step: number;
+    toParams: Object;
+    _curPosition?: Array<number>;
+    _index?: number;
+    _obj?: any;
+    _dummy?: any;
+    _domainBounds?: Array<Array<any>>;
+    _paramValues: Object;
+}
+/** For applying select strings */
+export interface Selection {
+    string: SelectionString;
+    targetShape: string;
+    singleResult?: boolean;
+    paramValue?: any;
+    selectorMethod?: any;
+    selectedShapes?: Shape | ShapeCollection;
+}
+export interface SelectionShapeTargetSetting {
+    single?: boolean;
+    targetShapeType: string;
+    ignoreCase?: boolean;
+}
+export interface SelectorSetting {
+    testLong: string;
+    testShort: string;
+    params: Array<string>;
+    worksOn: Array<string>;
+    selectorMethod: string;
+}
+export interface SelectorPointRange {
+    point?: Array<number>;
+    operator?: string;
+    range?: number;
+}
+export interface SelectorAxisCoord {
+    axis?: 'x' | 'y' | 'z';
+    coord?: number;
+    tolerance: number;
+}
+export interface SelectorBbox {
+    from?: Array<number>;
+    to?: Array<number>;
+}
+export interface SelectorIndex {
+    indices?: Array<number>;
+}
+export interface ShapeClone {
+    from: AnyShape;
+    transformations: Array<any>;
+}
+/** The Script seperated into statements */
+export interface Statement {
+    code: string;
+    startIndex?: number;
+    endIndex?: number;
+    lineStart?: number;
+    lineEnd?: number;
+    columnStartIndex?: number;
+    columnEndIndex?: number;
+}
+export interface StatementResult extends Statement {
+    status: 'error' | 'success';
+    message?: string;
+    duration?: number;
+    durationPerc?: number;
+}
+/** Bring all annotations in one type */
+export type AnnotationType = 'base' | 'dimensionLine' | 'label';
+export type Annotation = BaseAnnotation | DimensionLine;
+export type AnnotationData = DimensionLineData;
+export type AnnotationAutoDimStrategy = 'part' | 'levels';
+/** Exporting DimensionLine instances as data */
+export interface DimensionLineData {
+    _id?: string;
+    _type?: AnnotationType;
+    start: [number, number, number];
+    end: [number, number, number];
+    targetStart: [number, number, number];
+    targetEnd: [number, number, number];
+    targetDir: [number, number, number];
+    dir: [number, number, number];
+    value: number;
+    static?: boolean;
+    units?: string;
+    offsetVec?: [number, number, number];
+    offsetLength?: number;
+    offset?: Array<number | number | number>;
+    interactive: boolean;
+    round?: boolean;
+    roundDecimals?: number;
+    param: string;
+    _labelPosition?: Array<number | number | number>;
+    showUnits?: boolean;
+}
+/** Used with Shape.dimension() as options
+ *  NOTE: update typeguards when adding fields to this
+*/
+export interface DimensionOptions {
+    units?: ModelUnits;
+    offset?: number;
+    offsetVec?: Vector;
+    ortho?: boolean | MainAxis;
+    roundDecimals?: number;
+}
+export interface DimensionLevel {
+    axis: MainAxis;
+    at: number;
+    coordType?: 'relative' | 'absolute';
+    align?: 'min' | 'auto' | 'max' | false | true;
+    minDistance?: number;
+    offset?: number;
+    showLine?: boolean;
+}
+export interface DimensionLevelSettings {
+    levels: Array<DimensionLevel>;
+}
+export type DocUnits = 'mm' | 'cm' | 'inch' | 'pnt';
+export type DocUnitsWithPerc = DocUnits | '%';
+export type PercentageString = string;
+export type ValueWithUnitsString = number | string;
+export type WidthHeightInput = number | PercentageString | ValueWithUnitsString;
+export type ContainerTableInput = string | DataRows;
+export interface DocSettings {
+    proxy: string;
+}
+export interface DocData {
+    name: string;
+    units: DocUnits;
+    pages: Array<PageData>;
+    modelUnits: ModelUnits;
+}
+export interface DocPipeline {
+    fn: () => any;
+    done: boolean;
+}
+export type PageSize = 'A0' | 'A1' | 'A2' | 'A3' | 'A4' | 'A5' | 'A6' | 'A7';
+export type PageOrientation = 'landscape' | 'portrait';
+export type PageSide = 'width' | 'height';
+export type AnyPageContainer = Container | View;
+export interface PageData {
+    _entity: 'page';
+    name: string;
+    size: PageSize;
+    width: number;
+    height: number;
+    orientation: PageOrientation;
+    padding: Array<number | number>;
+    containers: Array<ContainerData>;
+    variables?: {
+        [key: string]: any;
+    };
+    docUnits: DocUnits;
+}
+export type ContainerType = 'view' | 'image' | 'text' | 'textarea' | 'table' | 'graphic';
+export type ContainerHAlignment = 'left' | 'center' | 'right';
+export type ContainerVAlignment = 'top' | 'center' | 'bottom';
+export type ContainerAlignment = [ContainerHAlignment, ContainerVAlignment];
+export type ContainerSide = 'width' | 'height';
+export type ZoomRelativeTo = 'container' | 'world';
+export type ScaleInput = 'auto' | number;
+export type ContainerSizeRelativeTo = 'page' | 'page-content-area';
+export type ContainerPositionCoordRel = number;
+export type ContainerPositionCoordAbs = number | string;
+export type ContainerPositionRel = Array<number | number>;
+export type ContainerPositionAbs = Array<string | string>;
+export type ContainerPositionLike = ContainerPositionRel | ContainerAlignment | ContainerPositionAbs;
+export type ContainerData = {
+    _entity: string;
+    name: string;
+    parent?: string;
+    type: ContainerType;
+    width: number;
+    widthRelativeTo: ContainerSizeRelativeTo;
+    widthAbs?: number;
+    height: number;
+    heightRelativeTo: ContainerSizeRelativeTo;
+    heightAbs?: number;
+    position: ContainerPositionRel;
+    pivot: ContainerPositionRel;
+    border?: boolean;
+    borderStyle?: DocPathStyle;
+    frame?: any;
+    index?: number;
+    contentAlign: ContainerAlignment;
+    content: any;
+    zoomLevel?: ScaleInput;
+    zoomRelativeTo?: ZoomRelativeTo;
+    docUnits: DocUnits;
+    modelUnits: ModelUnits;
+    caption?: string;
+    title?: string;
+    _domElem?: HTMLDivElement;
+};
+export interface Frame {
+    color: string;
+    thickness: number;
+    shape: 'rect' | 'circle';
+}
+export interface ContainerContent {
+    source?: string;
+    format?: 'jpg' | 'svg' | 'png';
+    data: any;
+    settings: {
+        [key: string]: any;
+    };
+}
+export type ImageOptionsFit = 'fill' | 'contain' | 'cover';
+export declare function isImageOptionsFit(o: any): o is ImageOptionsFit;
+export interface ImageOptions {
+    fit?: ImageOptionsFit;
+    align?: ContainerAlignment;
+    opacity?: number;
+    brightness?: number;
+    contrast?: number;
+    saturation?: number;
+    grayscale?: number;
+}
+export interface TableContainerOptions {
+    fontsize?: number;
+    fontcolor?: string;
+}
+export type TextAreaAlign = 'left' | 'right' | 'center' | 'fill';
+export type TextBaseline = 'alphabetic' | 'ideographic' | 'bottom' | 'top' | 'middle' | 'hanging';
+export interface TextOptions {
+    size?: number | string;
+    color?: string;
+    width?: number;
+    height?: number;
+    bold?: boolean;
+    underline?: boolean;
+    strike?: boolean;
+    oblique?: boolean;
+    align?: TextAreaAlign;
+    baseline?: TextBaseline;
+    angle?: number;
+}
+export type DocGraphicType = 'rect' | 'circle' | 'ellipse' | 'line' | 'hline' | 'vline' | 'triangle';
+export interface DocGraphicInputBase {
+    type?: DocGraphicType;
+    units?: DocUnitsWithPerc;
+    style?: DocPathStyle;
+    data?: any;
+}
+export interface DocGraphicInputRect extends DocGraphicInputBase {
+    width: number;
+    height: number;
+    round?: number;
+}
+export interface DocGraphicInputCircle extends DocGraphicInputBase {
+    radius: number;
+}
+export interface DocGraphicInputLine extends DocGraphicInputBase {
+    start: [number, number];
+    end: [number, number];
+}
+export interface DocGraphicInputOrthoLine extends DocGraphicInputBase {
+    length: number | string;
+    thickness: number | string;
+    color: string;
+}
+export interface toSVGOptions {
+    all?: boolean;
+    only2D?: boolean;
+    annotations?: boolean;
+    fills?: boolean;
+    outlines?: boolean;
+}
+export interface SVGtoPDFtransform {
+    svgUnits: string;
+    scale: number;
+    translateX: number;
+    translateY: number;
+    containerTranslateX: number;
+    containerTranslateY: number;
+    boundBy: 'width' | 'height';
+    contentOffsetX: number;
+    contentOffsetY: number;
+}
+export interface toDXFOptions {
+    all?: boolean;
+    annotations?: boolean;
+}
+export interface TextAreaOptions {
+    size?: number | string;
+    color?: string;
+    align?: TextAreaAlign;
+}
+/** Important data of created ContainerBlock */
+export interface ContainerBlock {
+    width: number;
+    height: number;
+    x: number;
+    y: number;
+    pivot: [number, number];
+    bbox?: [number, number, number, number];
+}
+export interface TitleBlockInput {
+    title?: string;
+    designer?: string;
+    logoUrl?: string;
+    designLicense?: PublishLicense;
+    manualLicense?: PublishLicense;
+}
+export interface LabelBlockOptions {
+    x?: string | number;
+    y?: string | number;
+    width?: string | number;
+    pivot?: [number, number];
+    textSize?: string | number;
+    secondaryTextSize?: string | number;
+    labelSize?: string | number;
+    numTextLines?: number;
+    margin?: number | string;
+    line?: boolean;
+}
+export interface VertexMesh {
+    objId: string;
+    ocId: string;
+    vertices: Array<number>;
+    indexInShape: number;
+}
+export interface EdgeMesh {
+    objId: string;
+    ocId: string;
+    vertices: Array<number>;
+    indexInShape: number;
+}
+export interface FaceMesh {
+    objId: string;
+    ocId: string;
+    numTriangles: number;
+    vertices: Array<number>;
+    normals: Array<number>;
+    uvCoords: Array<number>;
+    triangleIndices: Array<number>;
+    indexInShape: number;
+}
+export interface MeshCache {
+    vertices: Array<VertexMesh> | null;
+    edges: Array<EdgeMesh> | null;
+    faces: Array<FaceMesh> | null;
+}
+/** MeshShape is a very verbose format in which to save Shape Mesh data
+ *  Inclusing for every Vertex, Edge and Face:
+ *      - objId
+ *      - ocId
+ *      - vertex or vertices
+ *
+ *  NOTE: is it really needed?
+ */
+export interface MeshShape {
+    objId: string;
+    vertices: Array<VertexMesh>;
+    edges: Array<EdgeMesh>;
+    faces: Array<FaceMesh>;
+    style?: ObjStyle;
+}
+export interface MeshInfo {
+    objId: string;
+    shapeId: number;
+    subShapeType: 'Face' | 'Edge' | 'Vertex';
+    indexInShape: number;
+    color?: number;
+    faceGroupVertexIndices?: number;
+    edgeGroupLineSegmentsRange?: Array<number>;
+}
+export interface MeshShapeBufferStats {
+    numVertices: number;
+    numEdges: number;
+    numLines?: number;
+    numTriangles: number;
+    numFaces: number;
+    numShapes: number;
+}
+/** New optimized Mesh buffer: combines all Vertices, Edges and Face triangles in one buffer  */
+export interface MeshShapeBuffer {
+    verticesBuffer: Array<number>;
+    verticesInfo: Array<MeshInfo>;
+    edgesBuffer: Array<number>;
+    lineEdgesInfo: Array<MeshInfo>;
+    trianglesVertices: Array<number>;
+    trianglesVertexColors: Array<number>;
+    triangleIndices: Array<number>;
+    triangleNormals: Array<number>;
+    triangleUVs: Array<number>;
+    trianglesInfo: Array<MeshInfo>;
+    stats: MeshShapeBufferStats;
+}
+export interface MeshingQualitySettings {
+    linearDeflection: number;
+    angularDeflection: number;
+    tolerance: number;
+    edgeMinimalPoints: number;
+    edgeMinimalLength: number;
+}
+export interface SelectedMeshShapeInfo {
+    meshInfo: MeshInfo;
+    stats: MeshShapeBufferStats;
+}
+export interface Obbox {
+    center: Point;
+    width: number;
+    depth: number;
+    height: number;
+    xDirection: Vector;
+    yDirection: Vector;
+    zDirection: Vector;
+}
+export interface BeamLikeDims {
+    small: number;
+    mid: number;
+    length: number;
+}
+/** Configurator on how to draw shapes on documents (HTML or PDF)
+ *  These settings correspond to the style functions of jsPDF (with some exceptions!)
+*/
+export interface DocPathStyle {
+    lineWidth?: number;
+    lineCap?: 'butt' | 'round' | 'bevel';
+    lineJoin?: 'butt' | 'round' | 'bevel';
+    lineDashPattern?: Array<number | number>;
+    strokeColor?: string;
+    strokeOpacity?: number;
+    fillColor?: string;
+    fillOpacity?: number;
+    dash?: Array<number>;
+}
+export interface PDFLinePath {
+    path: string;
+    style: DocPathStyle;
+}
+export type LayoutOrderType = 'line' | 'grid' | 'binpack' | 'nest';
+export interface LayoutOptions {
+    autoRotate?: boolean;
+    flatten?: boolean;
+    stockWidth?: number;
+    stockHeight?: number;
+    groupSame?: boolean;
+    margin?: number;
+    center?: boolean;
+    algo?: any;
+    drawStock?: boolean;
+}
+export interface Layout {
+    type?: LayoutOrderType;
+    options: LayoutOptions;
+    flatten: boolean;
+}
+export type DataRowColumnValue = {
+    [key: string]: any;
+};
+export type DataRowValues = Array<any>;
+export type DataRowsColumnValue = Array<DataRowColumnValue>;
+export type DataRowsValues = Array<DataRowValues>;
+export type DataRows = DataRowsColumnValue | DataRowsValues;
+export type MetricName = 'cost_material' | 'cost_labor' | 'production_time' | 'price_est' | 'price' | 'weight' | 'volume' | 'size' | 'r-value';
+/** Metric is a element that outputs data in some way */
+export interface Metric {
+    name: MetricName;
+    label: string;
+    type: 'text' | 'bar' | 'line' | 'radar';
+    data: number | string | Array<number | string>;
+    options: TextMetricOptions;
+    _component: string;
+}
+export interface MetricOptionsBase {
+    label: string;
+}
+/** Options for TextMetric */
+export interface TextMetricOptions extends MetricOptionsBase {
+    label: string;
+    icon: string;
+    color: any;
+    pre: string;
+    unit: string;
+}
+export type MetricOptions = TextMetricOptions;
+/** Get data from table location  */
+export interface TableLocation {
+    location: string;
+    table: any;
+    column?: string;
+    row?: number;
+    data: any | Array<any>;
+}
+export interface CalcData {
+    tables: Object;
+    metrics: Object;
+}
+export type PublishLicense = 'unknown' | 'copyright' | 'trademarked' | 'CC BY' | 'CC BY-SA' | 'CC BY-ND' | 'CC BY-NC' | 'CC BY-NC-SA' | 'CC BY-NC-ND' | 'CC0';
+export interface PublishScriptSettings extends ArchiyouOutputSettings {
+    fulFillments: Array<any>;
+}
+export type PublishScript = {
+    id?: string;
+    name: string;
+    title?: string;
+    author?: string;
+    org?: string;
+    url?: string;
+    description?: string;
+    created_at?: Date;
+    updated_at?: Date;
+    version?: string;
+    prev_version?: string;
+    safe?: boolean;
+    published?: boolean;
+    units?: string;
+    params?: {
+        [key: string]: ScriptParamData;
+    };
+    param_presets?: {
+        [key: string]: {
+            [key: string]: Record<string, any>;
+        };
+    };
+    public_code?: boolean;
+    public_code_url?: string;
+    code: string;
+    cad_engine?: string;
+    cad_engine_version?: string;
+    cad_engine_config?: PublishScriptSettings;
+    meta?: {
+        [key: string]: any;
+    };
+};
+export type RunnerExecutionContext = 'local' | 'worker';
+export type RunnerRole = 'manager' | 'worker' | 'single';
+export type ModelFormat = 'buffer' | 'glb' | 'svg';
+export interface RunnerOptions {
+    context?: RunnerExecutionContext;
+}
+export interface RunnerActiveScope {
+    name: string;
+    context: RunnerExecutionContext;
+}
+/** Basic structure of scope */
+export interface RunnerScriptScopeState extends ProxyConstructor {
+    _scope: string;
+    _main: boolean;
+    ay: ArchiyouApp;
+    console: Console;
+    brep: Brep;
+    doc: Doc;
+    calc: Calc;
+    exporter: Exporter;
+    make: Make;
+    Vector: typeof Vector;
+    Point: typeof Point;
+    Bbox: typeof Bbox;
+    Edge: typeof Edge;
+    Vertex: typeof Vertex;
+    Wire: typeof Wire;
+    Face: typeof Face;
+    Shell: typeof Shell;
+    Solid: typeof Solid;
+    ShapeCollection: typeof ShapeCollection;
+    Obj: typeof Obj;
+}
+/** Simplified version of Script(Version) */
+export interface RunnerScript {
+    code: string;
+    params?: Record<string, ScriptParamData>;
+}
+/** Request results from executing a script */
+export interface RunnerScriptExecutionRequest {
+    script: Script | ScriptData;
+    component?: string;
+    params?: Record<string, any>;
+    preset?: string;
+    variantId?: string;
+    mode?: 'main' | 'component';
+    outputs?: Array<string>;
+    cache?: boolean;
+    messages?: Array<ConsoleMessageType>;
+    forceFileResponse?: boolean;
+    _onDone?: ((result: RunnerScriptExecutionResult) => any);
+}
+export type ScriptOutputCategory = 'model' | 'metrics' | 'tables' | 'docs';
+export type ScriptOutputFormatInternal = 'internal';
+export type ScriptOutputFormatModel = 'buffer' | 'glb' | 'step' | 'stl' | 'svg' | 'dae' | 'obj' | 'dxf';
+export type ScriptOutputFormatMetric = 'json' | 'xlsx';
+export type ScriptOutputFormatTable = 'json' | 'xlsx' | 'gsheets';
+export type ScriptOutputFormatDoc = 'json' | 'pdf';
+export type ScriptOutputFormat = ScriptOutputFormatInternal | ScriptOutputFormatModel | ScriptOutputFormatMetric | ScriptOutputFormatTable | ScriptOutputFormatDoc;
+/** Data only representation of ScriptOutputPath class */
+export interface ScriptOutputPathData {
+    requestedPath: string;
+    resolvedPath: string;
+    pipeline: string | null;
+    category: ScriptOutputCategory | null;
+    entityName: string | null;
+    format: ScriptOutputFormat | null;
+    formatOptions: Record<string, any>;
+}
+/** Data output of a script based on given path */
+export interface ScriptOutputData {
+    path: ScriptOutputPathData;
+    output: string | ArrayBuffer | Record<string, any> | ScriptOutputDataWrapper;
+}
+/** Wraps different output data with information
+ *  When we apply an encoding (like base64) we apply extra data to the wrapper
+*/
+export interface ScriptOutputDataWrapper {
+    type?: string;
+    encoding?: 'base64';
+    data: any | string | ArrayBuffer;
+    length?: number;
+}
+export interface ExecutionRequestOutputFormatGLTFOptions {
+    binary?: boolean;
+    data?: boolean;
+    metrics?: boolean;
+    tables?: boolean;
+    docs?: boolean;
+    pointAndLines?: boolean;
+    shapesAsPointAndLines?: boolean;
+}
+/** Message from Worker to Manager */
+export interface RunnerWorkerMessage {
+    type: 'init' | 'loaded' | 'executing' | 'stopped' | 'executed' | 'console' | 'save-step' | 'save-stl' | 'save-gltf' | 'save-svg' | 'save-svg-2d';
+    payload: any;
+}
+/** Message from Manager to Worker */
+export interface RunnerManagerMessage {
+    type: 'init' | 'load' | 'execute' | 'stop' | 'export-to-step' | 'export-to-stl' | 'export-to-gltf' | 'export-to-svg' | 'export-to-svg-2d';
+    payload?: any;
+}