dragonfly-schema 1.12.1-v10

package/models/Room2D.ts

@@ -0,0 +1,166 @@
+import { IsArray, IsDefined, IsNumber, IsInstance, ValidateNested, 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 { Adiabatic } from "honeybee-schema";
+import { DetailedSkylights } from "./DetailedSkylights";
+import { DetailedWindows } from "./DetailedWindows";
+import { ExtrudedBorder } from "./ExtrudedBorder";
+import { GriddedSkylightArea } from "./GriddedSkylightArea";
+import { GriddedSkylightRatio } from "./GriddedSkylightRatio";
+import { Ground } from "honeybee-schema";
+import { IDdBaseModel } from "honeybee-schema";
+import { LouversByCount } from "./LouversByCount";
+import { LouversByDistance } from "./LouversByDistance";
+import { OtherSideTemperature } from "honeybee-schema";
+import { Outdoors } from "honeybee-schema";
+import { Overhang } from "./Overhang";
+import { RectangularWindows } from "./RectangularWindows";
+import { RepeatingWindowRatio } from "./RepeatingWindowRatio";
+import { Room2DPropertiesAbridged } from "./Room2DPropertiesAbridged";
+import { SimpleWindowArea } from "./SimpleWindowArea";
+import { SimpleWindowRatio } from "./SimpleWindowRatio";
+import { SingleWindow } from "./SingleWindow";
+import { Surface } from "honeybee-schema";
+
+/** Base class for all objects requiring a identifiers acceptable for all engines. */
+export class Room2D extends IDdBaseModel {
+    @IsArray()
+    @IsNestedNumberArray()
+    @IsDefined()
+    /** A list of 2D points representing the outer boundary vertices of the Room2D. The list should include at least 3 points and each point should be a list of 2 (x, y) values. */
+    floor_boundary!: number [] [];
+	
+    @IsNumber()
+    @IsDefined()
+    /** A number to indicate the height of the floor plane in the Z axis. */
+    floor_height!: number;
+	
+    @IsNumber()
+    @IsDefined()
+    /** A number for the distance between the floor and the ceiling. */
+    floor_to_ceiling_height!: number;
+	
+    @IsInstance(Room2DPropertiesAbridged)
+    @Type(() => Room2DPropertiesAbridged)
+    @ValidateNested()
+    @IsDefined()
+    /** Extension properties for particular simulation engines (Radiance, EnergyPlus). */
+    properties!: Room2DPropertiesAbridged;
+	
+    @IsString()
+    @IsOptional()
+    @Matches(/^Room2D$/)
+    type?: string;
+	
+    @IsArray()
+    @IsNestedNumberArray()
+    @IsOptional()
+    /** Optional list of lists with one list for each hole in the floor plate. Each hole should be a list of at least 2 points and each point a list of 2 (x, y) values. If None, it will be assumed that there are no holes in the floor plate. */
+    floor_holes?: number [] [] [];
+	
+    @IsBoolean()
+    @IsOptional()
+    /** A boolean noting whether this Room2D has its floor in contact with the ground. */
+    is_ground_contact?: boolean;
+	
+    @IsBoolean()
+    @IsOptional()
+    /** A boolean noting whether this Room2D has its ceiling exposed to the outdoors. */
+    is_top_exposed?: boolean;
+	
+    @IsArray()
+    @IsOptional()
+    /** A list of boundary conditions that match the number of segments in the input floor_geometry + floor_holes. These will be used to assign boundary conditions to each of the walls of the Room in the resulting model. Their order should align with the order of segments in the floor_boundary and then with each hole segment. If None, all boundary conditions will be Outdoors or Ground depending on whether ceiling height of the room is at or below 0 (the assumed ground plane). */
+    boundary_conditions?: (Ground | Outdoors | Surface | Adiabatic | OtherSideTemperature) [];
+	
+    @IsArray()
+    @IsOptional()
+    /** A list of WindowParameter objects that dictate how the window geometries will be generated for each of the walls. If None, no windows will exist over the entire Room2D. */
+    window_parameters?: (SingleWindow | SimpleWindowArea | SimpleWindowRatio | RepeatingWindowRatio | RectangularWindows | DetailedWindows) [];
+	
+    @IsArray()
+    @IsOptional()
+    /** A list of ShadingParameter objects that dictate how the shade geometries will be generated for each of the walls. If None, no shades will exist over the entire Room2D. */
+    shading_parameters?: (ExtrudedBorder | Overhang | LouversByDistance | LouversByCount) [];
+	
+    @IsArray()
+    @IsBoolean({ each: true })
+    @IsOptional()
+    /** A list of booleans for whether each wall has an air boundary type. False values indicate a standard opaque type while True values indicate an AirBoundary type. All walls will be False by default. Note that any walls with a True air boundary must have a Surface boundary condition without any windows. */
+    air_boundaries?: boolean [];
+	
+    @IsOptional()
+    /** A SkylightParameter object describing how to generate skylights. If None, no skylights will exist on the Room2D. */
+    skylight_parameters?: (GriddedSkylightArea | GriddedSkylightRatio | DetailedSkylights);
+	
+
+    constructor() {
+        super();
+        this.type = "Room2D";
+        this.is_ground_contact = false;
+        this.is_top_exposed = false;
+    }
+
+
+    override init(_data?: any) {
+        super.init(_data);
+        if (_data) {
+            const obj = plainToClass(Room2D, _data);
+            this.floor_boundary = obj.floor_boundary;
+            this.floor_height = obj.floor_height;
+            this.floor_to_ceiling_height = obj.floor_to_ceiling_height;
+            this.properties = obj.properties;
+            this.type = obj.type;
+            this.floor_holes = obj.floor_holes;
+            this.is_ground_contact = obj.is_ground_contact;
+            this.is_top_exposed = obj.is_top_exposed;
+            this.boundary_conditions = obj.boundary_conditions;
+            this.window_parameters = obj.window_parameters;
+            this.shading_parameters = obj.shading_parameters;
+            this.air_boundaries = obj.air_boundaries;
+            this.skylight_parameters = obj.skylight_parameters;
+        }
+    }
+
+
+    static override fromJS(data: any): Room2D {
+        data = typeof data === 'object' ? data : {};
+
+        let result = new Room2D();
+        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["floor_boundary"] = this.floor_boundary;
+        data["floor_height"] = this.floor_height;
+        data["floor_to_ceiling_height"] = this.floor_to_ceiling_height;
+        data["properties"] = this.properties;
+        data["type"] = this.type;
+        data["floor_holes"] = this.floor_holes;
+        data["is_ground_contact"] = this.is_ground_contact;
+        data["is_top_exposed"] = this.is_top_exposed;
+        data["boundary_conditions"] = this.boundary_conditions;
+        data["window_parameters"] = this.window_parameters;
+        data["shading_parameters"] = this.shading_parameters;
+        data["air_boundaries"] = this.air_boundaries;
+        data["skylight_parameters"] = this.skylight_parameters;
+        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/Room2DEnergyPropertiesAbridged.ts

@@ -0,0 +1,123 @@
+import { IsString, IsOptional, Matches, MinLength, MaxLength, IsInstance, ValidateNested, IsArray, validate, ValidationError as TsValidationError } from 'class-validator';
+import { Type, plainToClass, instanceToPlain } from 'class-transformer';
+import { _OpenAPIGenBaseModel } from "./_OpenAPIGenBaseModel";
+import { ProcessAbridged } from "honeybee-schema";
+import { VentilationControlAbridged } from "honeybee-schema";
+import { VentilationOpening } from "honeybee-schema";
+
+/** 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 Room2DEnergyPropertiesAbridged extends _OpenAPIGenBaseModel {
+    @IsString()
+    @IsOptional()
+    @Matches(/^Room2DEnergyPropertiesAbridged$/)
+    type?: string;
+	
+    @IsString()
+    @IsOptional()
+    @MinLength(1)
+    @MaxLength(100)
+    /** Name of a ConstructionSet to specify all constructions for the Room2D. If None, the Room2D will use the Story or Building construction_set or the Model global_construction_set. Any ConstructionSet assigned here will override those assigned to these objects. */
+    construction_set?: string;
+	
+    @IsString()
+    @IsOptional()
+    @MinLength(1)
+    @MaxLength(100)
+    /** Name of a ProgramType to specify all schedules and loads for the Room2D. If None, the Room2D will have no loads or setpoints. */
+    program_type?: string;
+	
+    @IsString()
+    @IsOptional()
+    @MinLength(1)
+    @MaxLength(100)
+    /** An optional identifier of a HVAC system (such as an IdealAirSystem) that specifies how the Room2D is conditioned. If None, it will be assumed that the Room2D is not conditioned. */
+    hvac?: string;
+	
+    @IsString()
+    @IsOptional()
+    @MinLength(1)
+    @MaxLength(100)
+    /** An optional identifier of a Service Hot Water (SHW) system that specifies how the hot water load of the Room is met. If None, the hot water load will be met with a generic system that only measures thermal loadand does not account for system efficiencies. */
+    shw?: string;
+	
+    @IsInstance(VentilationControlAbridged)
+    @Type(() => VentilationControlAbridged)
+    @ValidateNested()
+    @IsOptional()
+    /** An optional VentilationControl object to dictate the opening of windows. If None, the windows will never open. */
+    window_vent_control?: VentilationControlAbridged;
+	
+    @IsInstance(VentilationOpening)
+    @Type(() => VentilationOpening)
+    @ValidateNested()
+    @IsOptional()
+    /** An optional VentilationOpening to specify the operable portion of all windows of the Room2D. If None, the windows will never open. */
+    window_vent_opening?: VentilationOpening;
+	
+    @IsArray()
+    @IsInstance(ProcessAbridged, { each: true })
+    @Type(() => ProcessAbridged)
+    @ValidateNested({ each: true })
+    @IsOptional()
+    /** An optional list of Process objects for process loads within the room. These can represent wood burning fireplaces, kilns, manufacturing equipment, and various industrial processes. They can also be used to represent certain pieces of equipment to be separated from the other end uses, such as MRI machines, theatrical lighting, and elevators. */
+    process_loads?: ProcessAbridged [];
+	
+
+    constructor() {
+        super();
+        this.type = "Room2DEnergyPropertiesAbridged";
+    }
+
+
+    override init(_data?: any) {
+        super.init(_data);
+        if (_data) {
+            const obj = plainToClass(Room2DEnergyPropertiesAbridged, _data);
+            this.type = obj.type;
+            this.construction_set = obj.construction_set;
+            this.program_type = obj.program_type;
+            this.hvac = obj.hvac;
+            this.shw = obj.shw;
+            this.window_vent_control = obj.window_vent_control;
+            this.window_vent_opening = obj.window_vent_opening;
+            this.process_loads = obj.process_loads;
+        }
+    }
+
+
+    static override fromJS(data: any): Room2DEnergyPropertiesAbridged {
+        data = typeof data === 'object' ? data : {};
+
+        let result = new Room2DEnergyPropertiesAbridged();
+        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["construction_set"] = this.construction_set;
+        data["program_type"] = this.program_type;
+        data["hvac"] = this.hvac;
+        data["shw"] = this.shw;
+        data["window_vent_control"] = this.window_vent_control;
+        data["window_vent_opening"] = this.window_vent_opening;
+        data["process_loads"] = this.process_loads;
+        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/Room2DPropertiesAbridged.ts

@@ -0,0 +1,73 @@
+import { IsString, IsOptional, Matches, IsInstance, ValidateNested, validate, ValidationError as TsValidationError } from 'class-validator';
+import { Type, plainToClass, instanceToPlain } from 'class-transformer';
+import { _OpenAPIGenBaseModel } from "./_OpenAPIGenBaseModel";
+import { Room2DEnergyPropertiesAbridged } from "./Room2DEnergyPropertiesAbridged";
+import { Room2DRadiancePropertiesAbridged } from "./Room2DRadiancePropertiesAbridged";
+
+export class Room2DPropertiesAbridged extends _OpenAPIGenBaseModel {
+    @IsString()
+    @IsOptional()
+    @Matches(/^Room2DPropertiesAbridged$/)
+    type?: string;
+	
+    @IsInstance(Room2DEnergyPropertiesAbridged)
+    @Type(() => Room2DEnergyPropertiesAbridged)
+    @ValidateNested()
+    @IsOptional()
+    energy?: Room2DEnergyPropertiesAbridged;
+	
+    @IsInstance(Room2DRadiancePropertiesAbridged)
+    @Type(() => Room2DRadiancePropertiesAbridged)
+    @ValidateNested()
+    @IsOptional()
+    radiance?: Room2DRadiancePropertiesAbridged;
+	
+
+    constructor() {
+        super();
+        this.type = "Room2DPropertiesAbridged";
+    }
+
+
+    override init(_data?: any) {
+        super.init(_data);
+        if (_data) {
+            const obj = plainToClass(Room2DPropertiesAbridged, _data);
+            this.type = obj.type;
+            this.energy = obj.energy;
+            this.radiance = obj.radiance;
+        }
+    }
+
+
+    static override fromJS(data: any): Room2DPropertiesAbridged {
+        data = typeof data === 'object' ? data : {};
+
+        let result = new Room2DPropertiesAbridged();
+        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["energy"] = this.energy;
+        data["radiance"] = this.radiance;
+        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/Room2DRadiancePropertiesAbridged.ts

@@ -0,0 +1,74 @@
+import { IsString, IsOptional, Matches, IsArray, validate, ValidationError as TsValidationError } from 'class-validator';
+import { Type, plainToClass, instanceToPlain } from 'class-transformer';
+import { _OpenAPIGenBaseModel } from "./_OpenAPIGenBaseModel";
+import { ExteriorApertureGridParameter } from "./ExteriorApertureGridParameter";
+import { ExteriorFaceGridParameter } from "./ExteriorFaceGridParameter";
+import { RoomGridParameter } from "./RoomGridParameter";
+import { RoomRadialGridParameter } from "./RoomRadialGridParameter";
+
+/** 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 Room2DRadiancePropertiesAbridged extends _OpenAPIGenBaseModel {
+    @IsString()
+    @IsOptional()
+    @Matches(/^Room2DRadiancePropertiesAbridged$/)
+    type?: string;
+	
+    @IsString()
+    @IsOptional()
+    /** Identifier of a ModifierSet to specify all modifiers for the Room2D. If None, the Room2D will use the Story or Building modifier_set or the Model global_modifier_set. Any ModifierSet assigned here will override those assigned to the parent objects. */
+    modifier_set?: string;
+	
+    @IsArray()
+    @IsOptional()
+    /** An optional list of GridParameter objects to describe how sensor grids should be generated for the Room2D. */
+    grid_parameters?: (RoomGridParameter | RoomRadialGridParameter | ExteriorFaceGridParameter | ExteriorApertureGridParameter) [];
+	
+
+    constructor() {
+        super();
+        this.type = "Room2DRadiancePropertiesAbridged";
+    }
+
+
+    override init(_data?: any) {
+        super.init(_data);
+        if (_data) {
+            const obj = plainToClass(Room2DRadiancePropertiesAbridged, _data);
+            this.type = obj.type;
+            this.modifier_set = obj.modifier_set;
+            this.grid_parameters = obj.grid_parameters;
+        }
+    }
+
+
+    static override fromJS(data: any): Room2DRadiancePropertiesAbridged {
+        data = typeof data === 'object' ? data : {};
+
+        let result = new Room2DRadiancePropertiesAbridged();
+        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_set"] = this.modifier_set;
+        data["grid_parameters"] = this.grid_parameters;
+        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/RoomGridParameter.ts

@@ -0,0 +1,72 @@
+import { IsString, IsOptional, Matches, IsNumber, validate, ValidationError as TsValidationError } from 'class-validator';
+import { Type, plainToClass, instanceToPlain } from 'class-transformer';
+import { _GridParameterBase } from "./_GridParameterBase";
+
+/** Instructions for a SensorGrid generated from a Room2D's floors. */
+export class RoomGridParameter extends _GridParameterBase {
+    @IsString()
+    @IsOptional()
+    @Matches(/^RoomGridParameter$/)
+    type?: string;
+	
+    @IsNumber()
+    @IsOptional()
+    /** A number for how far to offset the grid from the Room2D floors. (Default: 1.0, suitable for Models in Meters). */
+    offset?: number;
+	
+    @IsNumber()
+    @IsOptional()
+    /** A number for the distance at which sensors close to walls should be removed. Note that this option has no effect unless the value is more than half of the dimension. */
+    wall_offset?: number;
+	
+
+    constructor() {
+        super();
+        this.type = "RoomGridParameter";
+        this.offset = 1;
+        this.wall_offset = 0;
+    }
+
+
+    override init(_data?: any) {
+        super.init(_data);
+        if (_data) {
+            const obj = plainToClass(RoomGridParameter, _data);
+            this.type = obj.type;
+            this.offset = obj.offset;
+            this.wall_offset = obj.wall_offset;
+        }
+    }
+
+
+    static override fromJS(data: any): RoomGridParameter {
+        data = typeof data === 'object' ? data : {};
+
+        let result = new RoomGridParameter();
+        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["wall_offset"] = this.wall_offset;
+        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/RoomRadialGridParameter.ts

@@ -0,0 +1,80 @@
+import { IsInt, IsOptional, IsArray, IsNumber, IsString, Matches, validate, ValidationError as TsValidationError } from 'class-validator';
+import { Type, plainToClass, instanceToPlain } from 'class-transformer';
+import { Autocalculate } from "honeybee-schema";
+import { RoomGridParameter } from "./RoomGridParameter";
+
+/** Instructions for a SensorGrid of radial directions around positions from floors.\n\nThis type of sensor grid is particularly helpful for studies of multiple\nview directions, such as imageless glare studies. */
+export class RoomRadialGridParameter extends RoomGridParameter {
+    @IsInt()
+    @IsOptional()
+    /** A positive integer for the number of radial directions to be generated around each position. */
+    dir_count?: number;
+	
+    @IsArray()
+    @IsNumber({},{ each: true })
+    @IsOptional()
+    /** A vector as 3 (x, y, z) values to set the start direction of the generated directions. This can be used to orient the resulting sensors to specific parts of the scene. It can also change the elevation of the resulting directions since this start vector will always be rotated in the XY plane to generate the resulting directions. */
+    start_vector?: number [];
+	
+    @IsOptional()
+    /** An optional number to override the radius of the meshes generated around each sensor. If Autocalculate, it will be equal to 45 percent of the grid dimension. */
+    mesh_radius?: (Autocalculate | number);
+	
+    @IsString()
+    @IsOptional()
+    @Matches(/^RoomRadialGridParameter$/)
+    type?: string;
+	
+
+    constructor() {
+        super();
+        this.dir_count = 8;
+        this.mesh_radius = new Autocalculate();
+        this.type = "RoomRadialGridParameter";
+    }
+
+
+    override init(_data?: any) {
+        super.init(_data);
+        if (_data) {
+            const obj = plainToClass(RoomRadialGridParameter, _data);
+            this.dir_count = obj.dir_count;
+            this.start_vector = obj.start_vector;
+            this.mesh_radius = obj.mesh_radius;
+            this.type = obj.type;
+        }
+    }
+
+
+    static override fromJS(data: any): RoomRadialGridParameter {
+        data = typeof data === 'object' ? data : {};
+
+        let result = new RoomRadialGridParameter();
+        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["dir_count"] = this.dir_count;
+        data["start_vector"] = this.start_vector;
+        data["mesh_radius"] = this.mesh_radius;
+        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/SimpleWindowArea.ts

@@ -0,0 +1,71 @@
+import { IsNumber, IsDefined, IsString, IsOptional, Matches, IsBoolean, validate, ValidationError as TsValidationError } from 'class-validator';
+import { Type, plainToClass, instanceToPlain } from 'class-transformer';
+import { _WindowParameterBase } from "./_WindowParameterBase";
+
+/** A single window defined by an absolute area. */
+export class SimpleWindowArea extends _WindowParameterBase {
+    @IsNumber()
+    @IsDefined()
+    /** A number for the window area in current model units. If this area is larger than the area of the Wall that it is appliedto, the window will fill the parent Wall at a 99 percent ratio. */
+    window_area!: number;
+	
+    @IsString()
+    @IsOptional()
+    @Matches(/^SimpleWindowArea$/)
+    type?: string;
+	
+    @IsBoolean()
+    @IsOptional()
+    /** Boolean to note whether rectangular portions of base Face should be extracted before scaling them to create apertures. For pentagonal gabled geometries, this results in one rectangle and one triangle, which can often look more realistic and is a better input for engines like EnergyPlus that cannot model windows with more than 4 vertices. However, if a single pentagonal window is desired for such a gabled shape, this input can be set to False to produce such a result. */
+    rect_split?: boolean;
+	
+
+    constructor() {
+        super();
+        this.type = "SimpleWindowArea";
+        this.rect_split = true;
+    }
+
+
+    override init(_data?: any) {
+        super.init(_data);
+        if (_data) {
+            const obj = plainToClass(SimpleWindowArea, _data);
+            this.window_area = obj.window_area;
+            this.type = obj.type;
+            this.rect_split = obj.rect_split;
+        }
+    }
+
+
+    static override fromJS(data: any): SimpleWindowArea {
+        data = typeof data === 'object' ? data : {};
+
+        let result = new SimpleWindowArea();
+        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["window_area"] = this.window_area;
+        data["type"] = this.type;
+        data["rect_split"] = this.rect_split;
+        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;
+    }
+}