dragonfly-schema 1.12.1-v10

package/helpers/class-validator.ts

@@ -0,0 +1,94 @@
+import { registerDecorator, ValidationOptions, ValidationArguments } from 'class-validator';
+
+
+// Custom decorator to validate nested arrays of numbers
+export function IsNestedNumberArray(validationOptions?: ValidationOptions) {
+    return function (object: Object, propertyName: string) {
+        registerDecorator({
+            name: 'isNestedNumberArray',
+            target: object.constructor,
+            propertyName: propertyName,
+            options: validationOptions,
+            validator: {
+                validate(value: any, args: ValidationArguments) {
+                    if (value === undefined || value === null) return true; // Allow optional values
+                    if (!Array.isArray(value)) return false;
+                    return value.every(
+                        (arr: any) => Array.isArray(arr) && arr.every(
+                            (subArr: any) => 
+                              (Array.isArray(subArr) && subArr.every(
+                                (num: any) => typeof num === 'number'
+                              )) || 
+                              typeof subArr === 'number'
+                        )
+                    );
+                },
+                defaultMessage(args: ValidationArguments) {
+                    return `${args.property} must be number[][] or number[][][]`;
+                }
+            }
+        });
+    };
+}
+  
+  
+// Custom decorator to validate nested arrays of numbers
+export function IsNestedIntegerArray(validationOptions?: ValidationOptions) {
+    return function (object: Object, propertyName: string) {
+        registerDecorator({
+            name: 'isNestedIntegerArray',
+            target: object.constructor,
+            propertyName: propertyName,
+            options: validationOptions,
+            validator: {
+                validate(value: any, args: ValidationArguments) {
+                    if (value === undefined || value === null) return true; // Allow optional values
+                    if (!Array.isArray(value)) return false;
+                    return value.every(
+                        (arr: any) => Array.isArray(arr) && arr.every(
+                            (subArr: any) => 
+                              (Array.isArray(subArr) && subArr.every(
+                                (num: any) => Number.isInteger(num)
+                              )) || 
+                              Number.isInteger(subArr)
+                        )
+                    );
+                },
+                defaultMessage(args: ValidationArguments) {
+                    return `${args.property} must be number[][] or number[][][]`;
+                }
+            }
+        });
+    };
+}
+
+
+// Custom decorator to validate nested arrays of numbers
+export function IsNestedStringArray(validationOptions?: ValidationOptions) {
+    return function (object: Object, propertyName: string) {
+        registerDecorator({
+            name: 'isNestedStringArray',
+            target: object.constructor,
+            propertyName: propertyName,
+            options: validationOptions,
+            validator: {
+                validate(value: any, args: ValidationArguments) {
+                    if (value === undefined || value === null) return true; // Allow optional values
+                    if (!Array.isArray(value)) return false;
+                    return value.every(
+                        (arr: any) => Array.isArray(arr) && arr.every(
+                            (subArr: any) => 
+                              (Array.isArray(subArr) && subArr.every(
+                                (num: any) => typeof num === 'string'
+                              )) || 
+                              typeof subArr === 'string'
+                        )
+                    );
+                },
+                defaultMessage(args: ValidationArguments) {
+                    return `${args.property} must be string[][] or string[][][]`;
+                }
+            }
+        });
+    };
+}

package/index.ts

@@ -0,0 +1 @@
+export * from "./models";

package/models/Building.ts

@@ -0,0 +1,98 @@
+import { IsInstance, ValidateNested, IsDefined, IsString, IsOptional, Matches, IsArray, validate, ValidationError as TsValidationError } from 'class-validator';
+import { Type, plainToClass, instanceToPlain } from 'class-transformer';
+import { BuildingPropertiesAbridged } from "./BuildingPropertiesAbridged";
+import { IDdBaseModel } from "honeybee-schema";
+import { RoofSpecification } from "./RoofSpecification";
+import { Room } from "honeybee-schema";
+import { Story } from "./Story";
+
+/** Base class for all objects requiring a identifiers acceptable for all engines. */
+export class Building extends IDdBaseModel {
+    @IsInstance(BuildingPropertiesAbridged)
+    @Type(() => BuildingPropertiesAbridged)
+    @ValidateNested()
+    @IsDefined()
+    /** Extension properties for particular simulation engines (Radiance, EnergyPlus). */
+    properties!: BuildingPropertiesAbridged;
+	
+    @IsString()
+    @IsOptional()
+    @Matches(/^Building$/)
+    type?: string;
+	
+    @IsArray()
+    @IsInstance(Story, { each: true })
+    @Type(() => Story)
+    @ValidateNested({ each: true })
+    @IsOptional()
+    /** An array of unique dragonfly Story objects that together form the entire building. Stories should generally be ordered from lowest floor to highest floor, though this is not required. Note that, if a given Story is repeated several times over the height of the building and this is represented by the multiplier, the unique story included in this list should be the first (lowest) story of the repeated floors. */
+    unique_stories?: Story [];
+	
+    @IsArray()
+    @IsInstance(Room, { each: true })
+    @Type(() => Room)
+    @ValidateNested({ each: true })
+    @IsOptional()
+    /** An optional array of 3D Honeybee Room objects for additional Rooms that are a part of the Building but are not represented within the unique_stories. This is useful when there are parts of the Building geometry that cannot easily be represented with the extruded floor plate and sloped roof assumptions that underlie Dragonfly Room2Ds and RoofSpecification. Cases where this input is most useful include sloped walls and certain types of domed roofs that become tedious to implement with RoofSpecification. Matching the Honeybee Room.story property to the Dragonfly Story.display_name of an object within the unique_stories will effectively place the Honeybee Room on that Story for the purposes of floor_area, exterior_wall_area, etc. However, note that the Honeybee Room.multiplier property takes precedence over whatever multiplier is assigned to the Dragonfly Story that the Room.story may reference. (Default: None). */
+    room_3ds?: Room [];
+	
+    @IsInstance(RoofSpecification)
+    @Type(() => RoofSpecification)
+    @ValidateNested()
+    @IsOptional()
+    /** An optional RoofSpecification object that provides an alternative way to describe roof geometry over rooms (instead of specifying roofs on each story). If trying to decide between the two, specifying geometry on each story is closer to how dragonfly natively works with roof geometry as it relates to rooms. However, when it is unknown which roof geometries correspond to which stories, this Building-level attribute may be used and each roof geometry will automatically be added to the best Story in the Building upon serialization to Python. This automatic assignment will happen by checking for overlaps between the Story Room2Ds and the Roof geometry in plan. When a given roof geometry overlaps with several Stories, the top-most Story will get the roof geometry assigned to it unless this top Story has a floor_height above the roof geometry, in which case the next highest story will be checked until a compatible one is found. */
+    roof?: RoofSpecification;
+	
+
+    constructor() {
+        super();
+        this.type = "Building";
+    }
+
+
+    override init(_data?: any) {
+        super.init(_data);
+        if (_data) {
+            const obj = plainToClass(Building, _data);
+            this.properties = obj.properties;
+            this.type = obj.type;
+            this.unique_stories = obj.unique_stories;
+            this.room_3ds = obj.room_3ds;
+            this.roof = obj.roof;
+        }
+    }
+
+
+    static override fromJS(data: any): Building {
+        data = typeof data === 'object' ? data : {};
+
+        let result = new Building();
+        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["properties"] = this.properties;
+        data["type"] = this.type;
+        data["unique_stories"] = this.unique_stories;
+        data["room_3ds"] = this.room_3ds;
+        data["roof"] = this.roof;
+        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/BuildingEnergyPropertiesAbridged.ts

@@ -0,0 +1,65 @@
+import { IsString, IsOptional, Matches, MinLength, MaxLength, 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 BuildingEnergyPropertiesAbridged extends _OpenAPIGenBaseModel {
+    @IsString()
+    @IsOptional()
+    @Matches(/^BuildingEnergyPropertiesAbridged$/)
+    type?: string;
+	
+    @IsString()
+    @IsOptional()
+    @MinLength(1)
+    @MaxLength(100)
+    /** Name of a ConstructionSet to specify all constructions for the Building. If None, the Model global_construction_set will be used. */
+    construction_set?: string;
+	
+
+    constructor() {
+        super();
+        this.type = "BuildingEnergyPropertiesAbridged";
+    }
+
+
+    override init(_data?: any) {
+        super.init(_data);
+        if (_data) {
+            const obj = plainToClass(BuildingEnergyPropertiesAbridged, _data);
+            this.type = obj.type;
+            this.construction_set = obj.construction_set;
+        }
+    }
+
+
+    static override fromJS(data: any): BuildingEnergyPropertiesAbridged {
+        data = typeof data === 'object' ? data : {};
+
+        let result = new BuildingEnergyPropertiesAbridged();
+        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 = 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/BuildingPropertiesAbridged.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 { BuildingEnergyPropertiesAbridged } from "./BuildingEnergyPropertiesAbridged";
+import { BuildingRadiancePropertiesAbridged } from "./BuildingRadiancePropertiesAbridged";
+
+export class BuildingPropertiesAbridged extends _OpenAPIGenBaseModel {
+    @IsString()
+    @IsOptional()
+    @Matches(/^BuildingPropertiesAbridged$/)
+    type?: string;
+	
+    @IsInstance(BuildingEnergyPropertiesAbridged)
+    @Type(() => BuildingEnergyPropertiesAbridged)
+    @ValidateNested()
+    @IsOptional()
+    energy?: BuildingEnergyPropertiesAbridged;
+	
+    @IsInstance(BuildingRadiancePropertiesAbridged)
+    @Type(() => BuildingRadiancePropertiesAbridged)
+    @ValidateNested()
+    @IsOptional()
+    radiance?: BuildingRadiancePropertiesAbridged;
+	
+
+    constructor() {
+        super();
+        this.type = "BuildingPropertiesAbridged";
+    }
+
+
+    override init(_data?: any) {
+        super.init(_data);
+        if (_data) {
+            const obj = plainToClass(BuildingPropertiesAbridged, _data);
+            this.type = obj.type;
+            this.energy = obj.energy;
+            this.radiance = obj.radiance;
+        }
+    }
+
+
+    static override fromJS(data: any): BuildingPropertiesAbridged {
+        data = typeof data === 'object' ? data : {};
+
+        let result = new BuildingPropertiesAbridged();
+        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/BuildingRadiancePropertiesAbridged.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 BuildingRadiancePropertiesAbridged extends _OpenAPIGenBaseModel {
+    @IsString()
+    @IsOptional()
+    @Matches(/^BuildingRadiancePropertiesAbridged$/)
+    type?: string;
+	
+    @IsString()
+    @IsOptional()
+    /** Name of a ModifierSet to specify all modifiers for the Building. If None, the Model global_modifier_set will be used. */
+    modifier_set?: string;
+	
+
+    constructor() {
+        super();
+        this.type = "BuildingRadiancePropertiesAbridged";
+    }
+
+
+    override init(_data?: any) {
+        super.init(_data);
+        if (_data) {
+            const obj = plainToClass(BuildingRadiancePropertiesAbridged, _data);
+            this.type = obj.type;
+            this.modifier_set = obj.modifier_set;
+        }
+    }
+
+
+    static override fromJS(data: any): BuildingRadiancePropertiesAbridged {
+        data = typeof data === 'object' ? data : {};
+
+        let result = new BuildingRadiancePropertiesAbridged();
+        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 = 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/ContextShade.ts

@@ -0,0 +1,83 @@
+import { IsArray, IsDefined, IsInstance, ValidateNested, IsString, IsOptional, Matches, IsBoolean, validate, ValidationError as TsValidationError } from 'class-validator';
+import { Type, plainToClass, instanceToPlain } from 'class-transformer';
+import { ContextShadePropertiesAbridged } from "./ContextShadePropertiesAbridged";
+import { Face3D } from "honeybee-schema";
+import { IDdBaseModel } from "honeybee-schema";
+import { Mesh3D } from "honeybee-schema";
+
+/** Base class for all objects requiring a identifiers acceptable for all engines. */
+export class ContextShade extends IDdBaseModel {
+    @IsArray()
+    @IsDefined()
+    /** An array of planar Face3Ds and or Mesh3Ds that together represent the context shade. */
+    geometry!: (Face3D | Mesh3D) [];
+	
+    @IsInstance(ContextShadePropertiesAbridged)
+    @Type(() => ContextShadePropertiesAbridged)
+    @ValidateNested()
+    @IsDefined()
+    /** Extension properties for particular simulation engines (Radiance, EnergyPlus). */
+    properties!: ContextShadePropertiesAbridged;
+	
+    @IsString()
+    @IsOptional()
+    @Matches(/^ContextShade$/)
+    type?: string;
+	
+    @IsBoolean()
+    @IsOptional()
+    /** Boolean to note whether this shade is detached from any of the other geometry in the model. Cases where this should be True include shade representing surrounding buildings or context. */
+    is_detached?: boolean;
+	
+
+    constructor() {
+        super();
+        this.type = "ContextShade";
+        this.is_detached = true;
+    }
+
+
+    override init(_data?: any) {
+        super.init(_data);
+        if (_data) {
+            const obj = plainToClass(ContextShade, _data);
+            this.geometry = obj.geometry;
+            this.properties = obj.properties;
+            this.type = obj.type;
+            this.is_detached = obj.is_detached;
+        }
+    }
+
+
+    static override fromJS(data: any): ContextShade {
+        data = typeof data === 'object' ? data : {};
+
+        let result = new ContextShade();
+        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["geometry"] = this.geometry;
+        data["properties"] = this.properties;
+        data["type"] = this.type;
+        data["is_detached"] = this.is_detached;
+        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/ContextShadeEnergyPropertiesAbridged.ts

@@ -0,0 +1,74 @@
+import { IsString, IsOptional, Matches, MinLength, MaxLength, 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 ContextShadeEnergyPropertiesAbridged extends _OpenAPIGenBaseModel {
+    @IsString()
+    @IsOptional()
+    @Matches(/^ContextShadeEnergyPropertiesAbridged$/)
+    type?: string;
+	
+    @IsString()
+    @IsOptional()
+    @MinLength(1)
+    @MaxLength(100)
+    /** Name of a ShadeConstruction to set the reflectance and specularity of the ContextShade. If None, the the EnergyPlus default of 0.2 diffuse reflectance will be used. */
+    construction?: string;
+	
+    @IsString()
+    @IsOptional()
+    @MinLength(1)
+    @MaxLength(100)
+    /** Name of a schedule to set the transmittance of the ContextShade, which can vary throughout the simulation. If None, the ContextShade will be completely opaque. */
+    transmittance_schedule?: string;
+	
+
+    constructor() {
+        super();
+        this.type = "ContextShadeEnergyPropertiesAbridged";
+    }
+
+
+    override init(_data?: any) {
+        super.init(_data);
+        if (_data) {
+            const obj = plainToClass(ContextShadeEnergyPropertiesAbridged, _data);
+            this.type = obj.type;
+            this.construction = obj.construction;
+            this.transmittance_schedule = obj.transmittance_schedule;
+        }
+    }
+
+
+    static override fromJS(data: any): ContextShadeEnergyPropertiesAbridged {
+        data = typeof data === 'object' ? data : {};
+
+        let result = new ContextShadeEnergyPropertiesAbridged();
+        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"] = this.construction;
+        data["transmittance_schedule"] = this.transmittance_schedule;
+        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/ContextShadePropertiesAbridged.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 { ContextShadeEnergyPropertiesAbridged } from "./ContextShadeEnergyPropertiesAbridged";
+import { ContextShadeRadiancePropertiesAbridged } from "./ContextShadeRadiancePropertiesAbridged";
+
+export class ContextShadePropertiesAbridged extends _OpenAPIGenBaseModel {
+    @IsString()
+    @IsOptional()
+    @Matches(/^ContextShadePropertiesAbridged$/)
+    type?: string;
+	
+    @IsInstance(ContextShadeEnergyPropertiesAbridged)
+    @Type(() => ContextShadeEnergyPropertiesAbridged)
+    @ValidateNested()
+    @IsOptional()
+    energy?: ContextShadeEnergyPropertiesAbridged;
+	
+    @IsInstance(ContextShadeRadiancePropertiesAbridged)
+    @Type(() => ContextShadeRadiancePropertiesAbridged)
+    @ValidateNested()
+    @IsOptional()
+    radiance?: ContextShadeRadiancePropertiesAbridged;
+	
+
+    constructor() {
+        super();
+        this.type = "ContextShadePropertiesAbridged";
+    }
+
+
+    override init(_data?: any) {
+        super.init(_data);
+        if (_data) {
+            const obj = plainToClass(ContextShadePropertiesAbridged, _data);
+            this.type = obj.type;
+            this.energy = obj.energy;
+            this.radiance = obj.radiance;
+        }
+    }
+
+
+    static override fromJS(data: any): ContextShadePropertiesAbridged {
+        data = typeof data === 'object' ? data : {};
+
+        let result = new ContextShadePropertiesAbridged();
+        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;
+    }
+}