dragonfly-schema 1.12.1-v10

package/models/ContextShadeRadiancePropertiesAbridged.ts

@@ -0,0 +1,63 @@
+import { IsString, IsOptional, Matches, validate, ValidationError as TsValidationError } from 'class-validator';
+import { Type, plainToClass, instanceToPlain } from 'class-transformer';
+import { _OpenAPIGenBaseModel } from "./_OpenAPIGenBaseModel";
+
+/** Base class for all objects that are not extensible with additional keys.\n\nThis effectively includes all objects except for the Properties classes\nthat are assigned to geometry objects. */
+export class ContextShadeRadiancePropertiesAbridged extends _OpenAPIGenBaseModel {
+    @IsString()
+    @IsOptional()
+    @Matches(/^ContextShadeRadiancePropertiesAbridged$/)
+    type?: string;
+	
+    @IsString()
+    @IsOptional()
+    /** Name of a Modifier to set the reflectance and specularity of the ContextShade. If None, the the default of 0.2 diffuse reflectance will be used. */
+    modifier?: string;
+	
+
+    constructor() {
+        super();
+        this.type = "ContextShadeRadiancePropertiesAbridged";
+    }
+
+
+    override init(_data?: any) {
+        super.init(_data);
+        if (_data) {
+            const obj = plainToClass(ContextShadeRadiancePropertiesAbridged, _data);
+            this.type = obj.type;
+            this.modifier = obj.modifier;
+        }
+    }
+
+
+    static override fromJS(data: any): ContextShadeRadiancePropertiesAbridged {
+        data = typeof data === 'object' ? data : {};
+
+        let result = new ContextShadeRadiancePropertiesAbridged();
+        result.init(data);
+        return result;
+    }
+
+	override toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        for (var property in this) {
+            if (this.hasOwnProperty(property))
+                data[property] = this[property];
+        }
+
+        data["type"] = this.type;
+        data["modifier"] = this.modifier;
+        data = super.toJSON(data);
+        return instanceToPlain(data);
+    }
+
+	async validate(): Promise<boolean> {
+        const errors = await validate(this);
+        if (errors.length > 0){
+			const errorMessages = errors.map((error: TsValidationError) => Object.values(error.constraints || [error]).join(', ')).join('; ');
+      		throw new Error(`Validation failed: ${errorMessages}`);
+		}
+        return true;
+    }
+}

package/models/DetailedSkylights.ts

@@ -0,0 +1,73 @@
+import { IsArray, IsDefined, IsString, IsOptional, Matches, IsBoolean, validate, ValidationError as TsValidationError } from 'class-validator';
+import { Type, plainToClass, instanceToPlain } from 'class-transformer';
+import { IsNestedNumberArray } from "./../helpers/class-validator";
+import { _OpenAPIGenBaseModel } from "./_OpenAPIGenBaseModel";
+
+/** Several detailed skylights defined by 2D Polygons (lists of 2D vertices). */
+export class DetailedSkylights extends _OpenAPIGenBaseModel {
+    @IsArray()
+    @IsNestedNumberArray()
+    @IsDefined()
+    /** An array of arrays with each sub-array representing a polygonal boundary of a skylight. Each sub-array should consist of arrays representing points, which contain 2 values for 2D coordinates in the world XY system. These coordinate values should lie within the parent Room2D Polygon. */
+    polygons!: number [] [] [];
+	
+    @IsString()
+    @IsOptional()
+    @Matches(/^DetailedSkylights$/)
+    type?: string;
+	
+    @IsArray()
+    @IsBoolean({ each: true })
+    @IsOptional()
+    /** An array of booleans that align with the polygons and note whether each of the polygons represents an overhead door (True) or a skylight (False). If None, it will be assumed that all polygons represent skylights and they will be translated to Apertures in any resulting Honeybee model. */
+    are_doors?: boolean [];
+	
+
+    constructor() {
+        super();
+        this.type = "DetailedSkylights";
+    }
+
+
+    override init(_data?: any) {
+        super.init(_data);
+        if (_data) {
+            const obj = plainToClass(DetailedSkylights, _data);
+            this.polygons = obj.polygons;
+            this.type = obj.type;
+            this.are_doors = obj.are_doors;
+        }
+    }
+
+
+    static override fromJS(data: any): DetailedSkylights {
+        data = typeof data === 'object' ? data : {};
+
+        let result = new DetailedSkylights();
+        result.init(data);
+        return result;
+    }
+
+	override toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        for (var property in this) {
+            if (this.hasOwnProperty(property))
+                data[property] = this[property];
+        }
+
+        data["polygons"] = this.polygons;
+        data["type"] = this.type;
+        data["are_doors"] = this.are_doors;
+        data = super.toJSON(data);
+        return instanceToPlain(data);
+    }
+
+	async validate(): Promise<boolean> {
+        const errors = await validate(this);
+        if (errors.length > 0){
+			const errorMessages = errors.map((error: TsValidationError) => Object.values(error.constraints || [error]).join(', ')).join('; ');
+      		throw new Error(`Validation failed: ${errorMessages}`);
+		}
+        return true;
+    }
+}

package/models/DetailedWindows.ts

@@ -0,0 +1,73 @@
+import { IsArray, IsDefined, IsString, IsOptional, Matches, IsBoolean, validate, ValidationError as TsValidationError } from 'class-validator';
+import { Type, plainToClass, instanceToPlain } from 'class-transformer';
+import { IsNestedNumberArray } from "./../helpers/class-validator";
+import { _WindowParameterBase } from "./_WindowParameterBase";
+
+/** Several detailed windows defined by 2D Polygons (lists of 2D vertices). */
+export class DetailedWindows extends _WindowParameterBase {
+    @IsArray()
+    @IsNestedNumberArray()
+    @IsDefined()
+    /** An array of arrays with each sub-array representing a polygonal boundary of a window. Each sub-array should consist of arrays representing points, which can either contain 2 values (indicating they are 2D vertices within the plane of a parent wall segment) or they can contain 3 values (indicating they are 3D world coordinates). For 2D points, the wall plane is assumed to have an origin at the first point of the wall segment and an X-axis extending along the length of the segment. The wall plane Y-axis always points upwards. Therefore, both X and Y values of each point in the polygon should always be positive. Some sample code to convert from 2D vertices to 2D vertices in the plane of the wall can be found here: https://www.ladybug.tools/dragonfly-core/docs/dragonfly.windowparameter.html#dragonfly.windowparameter.DetailedWindows */
+    polygons!: number [] [] [];
+	
+    @IsString()
+    @IsOptional()
+    @Matches(/^DetailedWindows$/)
+    type?: string;
+	
+    @IsArray()
+    @IsBoolean({ each: true })
+    @IsOptional()
+    /** An array of booleans that align with the polygons and note whether each of the polygons represents a door (True) or a window (False). If None, it will be assumed that all polygons represent windows and they will be translated to Apertures in any resulting Honeybee model. */
+    are_doors?: boolean [];
+	
+
+    constructor() {
+        super();
+        this.type = "DetailedWindows";
+    }
+
+
+    override init(_data?: any) {
+        super.init(_data);
+        if (_data) {
+            const obj = plainToClass(DetailedWindows, _data);
+            this.polygons = obj.polygons;
+            this.type = obj.type;
+            this.are_doors = obj.are_doors;
+        }
+    }
+
+
+    static override fromJS(data: any): DetailedWindows {
+        data = typeof data === 'object' ? data : {};
+
+        let result = new DetailedWindows();
+        result.init(data);
+        return result;
+    }
+
+	override toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        for (var property in this) {
+            if (this.hasOwnProperty(property))
+                data[property] = this[property];
+        }
+
+        data["polygons"] = this.polygons;
+        data["type"] = this.type;
+        data["are_doors"] = this.are_doors;
+        data = super.toJSON(data);
+        return instanceToPlain(data);
+    }
+
+	async validate(): Promise<boolean> {
+        const errors = await validate(this);
+        if (errors.length > 0){
+			const errorMessages = errors.map((error: TsValidationError) => Object.values(error.constraints || [error]).join(', ')).join('; ');
+      		throw new Error(`Validation failed: ${errorMessages}`);
+		}
+        return true;
+    }
+}

package/models/ExteriorApertureGridParameter.ts

@@ -0,0 +1,74 @@
+import { IsString, IsOptional, Matches, IsNumber, IsEnum, validate, ValidationError as TsValidationError } from 'class-validator';
+import { Type, plainToClass, instanceToPlain } from 'class-transformer';
+import { _GridParameterBase } from "./_GridParameterBase";
+import { ExteriorApertureType } from "./ExteriorApertureType";
+
+/** Instructions for a SensorGrid generated from exterior Aperture. */
+export class ExteriorApertureGridParameter extends _GridParameterBase {
+    @IsString()
+    @IsOptional()
+    @Matches(/^ExteriorApertureGridParameter$/)
+    type?: string;
+	
+    @IsNumber()
+    @IsOptional()
+    /** A number for how far to offset the grid from the Apertures. (Default: 0.1, suitable for Models in Meters). */
+    offset?: number;
+	
+    @IsEnum(ExteriorApertureType)
+    @Type(() => String)
+    @IsOptional()
+    /** Text to specify the type of Aperture that will be used to generate grids. Window indicates Apertures in Walls. Skylights are in parent Roof faces. */
+    aperture_type?: ExteriorApertureType;
+	
+
+    constructor() {
+        super();
+        this.type = "ExteriorApertureGridParameter";
+        this.offset = 0.1;
+        this.aperture_type = ExteriorApertureType.All;
+    }
+
+
+    override init(_data?: any) {
+        super.init(_data);
+        if (_data) {
+            const obj = plainToClass(ExteriorApertureGridParameter, _data);
+            this.type = obj.type;
+            this.offset = obj.offset;
+            this.aperture_type = obj.aperture_type;
+        }
+    }
+
+
+    static override fromJS(data: any): ExteriorApertureGridParameter {
+        data = typeof data === 'object' ? data : {};
+
+        let result = new ExteriorApertureGridParameter();
+        result.init(data);
+        return result;
+    }
+
+	override toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        for (var property in this) {
+            if (this.hasOwnProperty(property))
+                data[property] = this[property];
+        }
+
+        data["type"] = this.type;
+        data["offset"] = this.offset;
+        data["aperture_type"] = this.aperture_type;
+        data = super.toJSON(data);
+        return instanceToPlain(data);
+    }
+
+	async validate(): Promise<boolean> {
+        const errors = await validate(this);
+        if (errors.length > 0){
+			const errorMessages = errors.map((error: TsValidationError) => Object.values(error.constraints || [error]).join(', ')).join('; ');
+      		throw new Error(`Validation failed: ${errorMessages}`);
+		}
+        return true;
+    }
+}

package/models/ExteriorApertureType.ts

@@ -0,0 +1,8 @@
+// Auto-generated
+
+/** An enumeration. */
+export enum ExteriorApertureType {
+    Window = "Window",
+    Skylight = "Skylight",
+    All = "All",
+}

package/models/ExteriorFaceGridParameter.ts

@@ -0,0 +1,82 @@
+import { IsString, IsOptional, Matches, IsNumber, IsEnum, IsBoolean, validate, ValidationError as TsValidationError } from 'class-validator';
+import { Type, plainToClass, instanceToPlain } from 'class-transformer';
+import { _GridParameterBase } from "./_GridParameterBase";
+import { ExteriorFaceType } from "./ExteriorFaceType";
+
+/** Instructions for a SensorGrid generated from exterior Faces. */
+export class ExteriorFaceGridParameter extends _GridParameterBase {
+    @IsString()
+    @IsOptional()
+    @Matches(/^ExteriorFaceGridParameter$/)
+    type?: string;
+	
+    @IsNumber()
+    @IsOptional()
+    /** A number for how far to offset the grid from the Faces. (Default: 0.1, suitable for Models in Meters). */
+    offset?: number;
+	
+    @IsEnum(ExteriorFaceType)
+    @Type(() => String)
+    @IsOptional()
+    /** Text to specify the type of face that will be used to generate grids. Note that only Faces with Outdoors boundary conditions will be used, meaning that most Floors will typically be excluded unless they represent the underside of a cantilever. */
+    face_type?: ExteriorFaceType;
+	
+    @IsBoolean()
+    @IsOptional()
+    /** A boolean to note whether the punched_geometry of the faces should be used (True) with the areas of sub-faces removed from the grid or the full geometry should be used (False). */
+    punched_geometry?: boolean;
+	
+
+    constructor() {
+        super();
+        this.type = "ExteriorFaceGridParameter";
+        this.offset = 0.1;
+        this.face_type = ExteriorFaceType.Wall;
+        this.punched_geometry = false;
+    }
+
+
+    override init(_data?: any) {
+        super.init(_data);
+        if (_data) {
+            const obj = plainToClass(ExteriorFaceGridParameter, _data);
+            this.type = obj.type;
+            this.offset = obj.offset;
+            this.face_type = obj.face_type;
+            this.punched_geometry = obj.punched_geometry;
+        }
+    }
+
+
+    static override fromJS(data: any): ExteriorFaceGridParameter {
+        data = typeof data === 'object' ? data : {};
+
+        let result = new ExteriorFaceGridParameter();
+        result.init(data);
+        return result;
+    }
+
+	override toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        for (var property in this) {
+            if (this.hasOwnProperty(property))
+                data[property] = this[property];
+        }
+
+        data["type"] = this.type;
+        data["offset"] = this.offset;
+        data["face_type"] = this.face_type;
+        data["punched_geometry"] = this.punched_geometry;
+        data = super.toJSON(data);
+        return instanceToPlain(data);
+    }
+
+	async validate(): Promise<boolean> {
+        const errors = await validate(this);
+        if (errors.length > 0){
+			const errorMessages = errors.map((error: TsValidationError) => Object.values(error.constraints || [error]).join(', ')).join('; ');
+      		throw new Error(`Validation failed: ${errorMessages}`);
+		}
+        return true;
+    }
+}

package/models/ExteriorFaceType.ts

@@ -0,0 +1,9 @@
+// Auto-generated
+
+/** An enumeration. */
+export enum ExteriorFaceType {
+    Wall = "Wall",
+    Roof = "Roof",
+    Floor = "Floor",
+    All = "All",
+}

package/models/ExtrudedBorder.ts

@@ -0,0 +1,63 @@
+import { IsNumber, IsDefined, IsString, IsOptional, Matches, validate, ValidationError as TsValidationError } from 'class-validator';
+import { Type, plainToClass, instanceToPlain } from 'class-transformer';
+import { _OpenAPIGenBaseModel } from "./_OpenAPIGenBaseModel";
+
+/** Extruded borders over all windows in the wall. */
+export class ExtrudedBorder extends _OpenAPIGenBaseModel {
+    @IsNumber()
+    @IsDefined()
+    /** A number for the depth of the border. */
+    depth!: number;
+	
+    @IsString()
+    @IsOptional()
+    @Matches(/^ExtrudedBorder$/)
+    type?: string;
+	
+
+    constructor() {
+        super();
+        this.type = "ExtrudedBorder";
+    }
+
+
+    override init(_data?: any) {
+        super.init(_data);
+        if (_data) {
+            const obj = plainToClass(ExtrudedBorder, _data);
+            this.depth = obj.depth;
+            this.type = obj.type;
+        }
+    }
+
+
+    static override fromJS(data: any): ExtrudedBorder {
+        data = typeof data === 'object' ? data : {};
+
+        let result = new ExtrudedBorder();
+        result.init(data);
+        return result;
+    }
+
+	override toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        for (var property in this) {
+            if (this.hasOwnProperty(property))
+                data[property] = this[property];
+        }
+
+        data["depth"] = this.depth;
+        data["type"] = this.type;
+        data = super.toJSON(data);
+        return instanceToPlain(data);
+    }
+
+	async validate(): Promise<boolean> {
+        const errors = await validate(this);
+        if (errors.length > 0){
+			const errorMessages = errors.map((error: TsValidationError) => Object.values(error.constraints || [error]).join(', ')).join('; ');
+      		throw new Error(`Validation failed: ${errorMessages}`);
+		}
+        return true;
+    }
+}

package/models/GriddedSkylightArea.ts

@@ -0,0 +1,71 @@
+import { IsNumber, IsDefined, IsString, IsOptional, Matches, validate, ValidationError as TsValidationError } from 'class-validator';
+import { Type, plainToClass, instanceToPlain } from 'class-transformer';
+import { _OpenAPIGenBaseModel } from "./_OpenAPIGenBaseModel";
+import { Autocalculate } from "honeybee-schema";
+
+/** Gridded skylights defined by an absolute area. */
+export class GriddedSkylightArea extends _OpenAPIGenBaseModel {
+    @IsNumber()
+    @IsDefined()
+    /** A number for the skylight area in current model units. If this area is larger than the area of the roof that it is applied to, the skylight will fill the parent roof at a 99 percent ratio. */
+    skylight_area!: number;
+	
+    @IsString()
+    @IsOptional()
+    @Matches(/^GriddedSkylightArea$/)
+    type?: string;
+	
+    @IsOptional()
+    /** A number for the spacing between the centers of each grid cell. This should be less than a third of the dimension of the Roof geometry if multiple, evenly-spaced skylights are desired. If Autocalculate, a spacing of one third the smaller dimension of the parent Roof will be automatically assumed. */
+    spacing?: (Autocalculate | number);
+	
+
+    constructor() {
+        super();
+        this.type = "GriddedSkylightArea";
+        this.spacing = new Autocalculate();
+    }
+
+
+    override init(_data?: any) {
+        super.init(_data);
+        if (_data) {
+            const obj = plainToClass(GriddedSkylightArea, _data);
+            this.skylight_area = obj.skylight_area;
+            this.type = obj.type;
+            this.spacing = obj.spacing;
+        }
+    }
+
+
+    static override fromJS(data: any): GriddedSkylightArea {
+        data = typeof data === 'object' ? data : {};
+
+        let result = new GriddedSkylightArea();
+        result.init(data);
+        return result;
+    }
+
+	override toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        for (var property in this) {
+            if (this.hasOwnProperty(property))
+                data[property] = this[property];
+        }
+
+        data["skylight_area"] = this.skylight_area;
+        data["type"] = this.type;
+        data["spacing"] = this.spacing;
+        data = super.toJSON(data);
+        return instanceToPlain(data);
+    }
+
+	async validate(): Promise<boolean> {
+        const errors = await validate(this);
+        if (errors.length > 0){
+			const errorMessages = errors.map((error: TsValidationError) => Object.values(error.constraints || [error]).join(', ')).join('; ');
+      		throw new Error(`Validation failed: ${errorMessages}`);
+		}
+        return true;
+    }
+}

package/models/GriddedSkylightRatio.ts

@@ -0,0 +1,71 @@
+import { IsNumber, IsDefined, IsString, IsOptional, Matches, validate, ValidationError as TsValidationError } from 'class-validator';
+import { Type, plainToClass, instanceToPlain } from 'class-transformer';
+import { _OpenAPIGenBaseModel } from "./_OpenAPIGenBaseModel";
+import { Autocalculate } from "honeybee-schema";
+
+/** Gridded skylights derived from an area ratio with the roof. */
+export class GriddedSkylightRatio extends _OpenAPIGenBaseModel {
+    @IsNumber()
+    @IsDefined()
+    /** A number between 0 and 1 for the ratio between the skylight area and the total Roof face area. */
+    skylight_ratio!: number;
+	
+    @IsString()
+    @IsOptional()
+    @Matches(/^GriddedSkylightRatio$/)
+    type?: string;
+	
+    @IsOptional()
+    /** A number for the spacing between the centers of each grid cell. This should be less than a third of the dimension of the Roof geometry if multiple, evenly-spaced skylights are desired. If Autocalculate, a spacing of one third the smaller dimension of the parent Roof will be automatically assumed. */
+    spacing?: (Autocalculate | number);
+	
+
+    constructor() {
+        super();
+        this.type = "GriddedSkylightRatio";
+        this.spacing = new Autocalculate();
+    }
+
+
+    override init(_data?: any) {
+        super.init(_data);
+        if (_data) {
+            const obj = plainToClass(GriddedSkylightRatio, _data);
+            this.skylight_ratio = obj.skylight_ratio;
+            this.type = obj.type;
+            this.spacing = obj.spacing;
+        }
+    }
+
+
+    static override fromJS(data: any): GriddedSkylightRatio {
+        data = typeof data === 'object' ? data : {};
+
+        let result = new GriddedSkylightRatio();
+        result.init(data);
+        return result;
+    }
+
+	override toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        for (var property in this) {
+            if (this.hasOwnProperty(property))
+                data[property] = this[property];
+        }
+
+        data["skylight_ratio"] = this.skylight_ratio;
+        data["type"] = this.type;
+        data["spacing"] = this.spacing;
+        data = super.toJSON(data);
+        return instanceToPlain(data);
+    }
+
+	async validate(): Promise<boolean> {
+        const errors = await validate(this);
+        if (errors.length > 0){
+			const errorMessages = errors.map((error: TsValidationError) => Object.values(error.constraints || [error]).join(', ')).join('; ');
+      		throw new Error(`Validation failed: ${errorMessages}`);
+		}
+        return true;
+    }
+}

package/models/LouversByCount.ts

@@ -0,0 +1,63 @@
+import { IsInt, IsDefined, IsString, IsOptional, Matches, validate, ValidationError as TsValidationError } from 'class-validator';
+import { Type, plainToClass, instanceToPlain } from 'class-transformer';
+import { _LouversBase } from "./_LouversBase";
+
+/** A specific number of louvered Shades over a wall. */
+export class LouversByCount extends _LouversBase {
+    @IsInt()
+    @IsDefined()
+    /** A positive integer for the number of louvers to generate. */
+    louver_count!: number;
+	
+    @IsString()
+    @IsOptional()
+    @Matches(/^LouversByCount$/)
+    type?: string;
+	
+
+    constructor() {
+        super();
+        this.type = "LouversByCount";
+    }
+
+
+    override init(_data?: any) {
+        super.init(_data);
+        if (_data) {
+            const obj = plainToClass(LouversByCount, _data);
+            this.louver_count = obj.louver_count;
+            this.type = obj.type;
+        }
+    }
+
+
+    static override fromJS(data: any): LouversByCount {
+        data = typeof data === 'object' ? data : {};
+
+        let result = new LouversByCount();
+        result.init(data);
+        return result;
+    }
+
+	override toJSON(data?: any) {
+        data = typeof data === 'object' ? data : {};
+        for (var property in this) {
+            if (this.hasOwnProperty(property))
+                data[property] = this[property];
+        }
+
+        data["louver_count"] = this.louver_count;
+        data["type"] = this.type;
+        data = super.toJSON(data);
+        return instanceToPlain(data);
+    }
+
+	async validate(): Promise<boolean> {
+        const errors = await validate(this);
+        if (errors.length > 0){
+			const errorMessages = errors.map((error: TsValidationError) => Object.values(error.constraints || [error]).join(', ')).join('; ');
+      		throw new Error(`Validation failed: ${errorMessages}`);
+		}
+        return true;
+    }
+}