svelte-reflector 2.1.9 → 2.5.1

package/dist/core/schema/SchemaClassRenderer.js

@@ -1,14 +1,23 @@
+import { DiscriminatedInterfaceRenderer } from "./DiscriminatedInterfaceRenderer.js";
 import { ReflectorInterface } from "./ReflectorInterface.js";
 export class SchemaClassRenderer {
     static render(params) {
-        const { name, primitiveProps, arrayProps, objectProps, enumProps } = params;
-        const reflectorInterface = new ReflectorInterface({
-            name,
-            arrayProps,
-            primitiveProps,
-            objectProps,
-            enumProps,
-        });
+        const { name, primitiveProps, arrayProps, objectProps, enumProps, unionProps } = params;
+        const mode = params.mode ?? "response";
+        // A `oneOf` with a usable discriminator turns the Interface into a discriminated
+        // union type alias; the matching `discriminated()` accessor is emitted below.
+        const discriminatedUnion = unionProps.find((u) => u.hasDiscriminator);
+        const interfaceStr = discriminatedUnion
+            ? DiscriminatedInterfaceRenderer.render({
+                name,
+                union: discriminatedUnion,
+                primitiveProps,
+                arrayProps,
+                objectProps,
+                enumProps,
+                otherUnionProps: unionProps.filter((u) => u !== discriminatedUnion),
+            })
+            : new ReflectorInterface({ name, arrayProps, primitiveProps, objectProps, enumProps, unionProps }).builded;
         const constructorThis = [];
         const keys = [];
         const bundleParams = [];
@@ -34,9 +43,54 @@ export class SchemaClassRenderer {
             keys.push(prop.classBuild());
             bundleParams.push(prop.bundleBuild());
         });
-        const constructorCode = `constructor(params?: { data?: ${name}Interface | undefined, empty?: boolean }) { 
+        unionProps.forEach((prop) => {
+            constructorThis.push(prop.constructorBuild());
+            keys.push(prop.classBuild());
+            bundleParams.push(prop.bundleBuild());
+        });
+        const constructorCode = `constructor(params?: { data?: ${name}Interface | undefined, empty?: boolean }) {
         ${constructorThis.join(";\n")}
       }`;
+        const hydrateLines = [];
+        primitiveProps.forEach((p) => hydrateLines.push(p.hydrateBuild()));
+        arrayProps.forEach((p) => hydrateLines.push(p.hydrateBuild()));
+        objectProps.forEach((p) => hydrateLines.push(p.hydrateBuild()));
+        enumProps.forEach((p) => hydrateLines.push(p.hydrateBuild()));
+        unionProps.forEach((p) => hydrateLines.push(p.hydrateBuild()));
+        const hydrateCode = `
+      hydrate(data: Partial<${name}Interface>): void {
+        ${hydrateLines.join(";\n")}
+      }
+
+      reset(): void {
+        this.hydrate(new ${name}({ empty: true }).bundle() as Partial<${name}Interface>);
+      }
+    `;
+        // Live class instances can't narrow `actionMeta` by `action` (independent
+        // `$state` fields), so expose a plain discriminated snapshot for consumers
+        // that want the narrowing. `bundle()` already returns the discriminated type
+        // (see below), so this is just an ergonomic, cast-free alias.
+        const discriminatedAccessor = discriminatedUnion
+            ? `discriminated(): ${name}Interface { return this.bundle(); }`
+            : "";
+        // Request DTO serializa a partir das instâncias `BuildedInput` (carregam os flags
+        // required/nullable), não do `.value` pré-extraído — bundleInputs faz a coerção
+        // nullable ''→null e cobre array/aninhado. Response fica em bundleStrict (inalterado).
+        //
+        // Para um schema com união discriminada, `bundleStrict` infere a forma plana (action
+        // = enum inteiro), que NÃO é atribuível a nenhum membro da união — o array-root wrapper
+        // (`item.bundle()` tipado como `Interface[]` discriminada) quebraria. O único `as` do
+        // feature mora aqui, fazendo `bundle()` devolver a própria união; `discriminated()` e
+        // `reset()` ficam cast-free por consequência.
+        const bundleHelper = mode === "request" ? "inputs" : "strict";
+        const responseBundle = discriminatedUnion
+            ? `return bundleStrict({ ${bundleParams.join(",")} }) as ${name}Interface`
+            : `return bundleStrict({ ${bundleParams.join(",")} })`;
+        const bundleBody = mode === "request"
+            ? `return bundleInputs({ ${[...primitiveProps, ...arrayProps, ...objectProps, ...enumProps, ...unionProps]
+                .map((p) => `${p.name}: this.${p.name}`)
+                .join(",")} })`
+            : responseBundle;
         const schema = `
     export class ${name} {
       ${keys.join(";")}
@@ -45,10 +99,14 @@ export class SchemaClassRenderer {
 
       ${staticMethod}
 
+      ${hydrateCode}
+
       bundle(){
-        return bundleStrict({ ${bundleParams.join(",")} })
+        ${bundleBody}
       }
+
+      ${discriminatedAccessor}
     };`;
-        return { interface: reflectorInterface.builded, schema };
+        return { interface: interfaceStr, schema, bundleHelper };
     }
 }

package/dist/core/schema/SchemaDependencyCollector.d.ts

@@ -2,10 +2,12 @@ import type { ArrayProp } from "../../props/array.property.js";
 import type { EnumProp } from "../../props/enum.property.js";
 import type { ObjectProp } from "../../props/object.property.js";
 import type { PrimitiveProp } from "../../props/primitive.property.js";
+import type { UnionProp } from "../../props/union.property.js";
 export interface SchemaDependencies {
     schemaDeps: string[];
     enumDeps: string[];
     customTypeDeps: string[];
+    sanitizerDeps: string[];
 }
 export declare class SchemaDependencyCollector {
     static collect(props: {
@@ -13,5 +15,6 @@ export declare class SchemaDependencyCollector {
         arrayProps: ArrayProp[];
         objectProps: ObjectProp[];
         enumProps: EnumProp[];
+        unionProps: UnionProp[];
     }): SchemaDependencies;
 }

package/dist/core/schema/SchemaDependencyCollector.js

@@ -1,6 +1,6 @@
 export class SchemaDependencyCollector {
     static collect(props) {
-        const { primitiveProps, arrayProps, objectProps, enumProps } = props;
+        const { primitiveProps, arrayProps, objectProps, enumProps, unionProps } = props;
         const schemaDepsSet = new Set();
         for (const prop of objectProps) {
             schemaDepsSet.add(prop.type);
@@ -10,6 +10,11 @@ export class SchemaDependencyCollector {
                 schemaDepsSet.add(prop.type);
             }
         }
+        for (const prop of unionProps) {
+            for (const variant of prop.variantTypes) {
+                schemaDepsSet.add(variant);
+            }
+        }
         const enumDepsSet = new Set();
         for (const prop of enumProps) {
             if (prop.enumName)
@@ -20,14 +25,18 @@ export class SchemaDependencyCollector {
                 enumDepsSet.add(prop.type);
         }
         const customTypeDepsSet = new Set();
+        const sanitizerDepsSet = new Set();
         for (const prop of primitiveProps) {
             if (prop.customType)
                 customTypeDepsSet.add(prop.customType);
+            if (prop.sanitizer)
+                sanitizerDepsSet.add(prop.sanitizer);
         }
         return {
             schemaDeps: [...schemaDepsSet],
             enumDeps: [...enumDepsSet],
             customTypeDeps: [...customTypeDepsSet],
+            sanitizerDeps: [...sanitizerDepsSet],
         };
     }
 }

package/dist/core/schema/SchemaPropertyClassifier.d.ts

@@ -2,10 +2,11 @@ import { ArrayProp } from "../../props/array.property.js";
 import { EnumProp } from "../../props/enum.property.js";
 import { ObjectProp } from "../../props/object.property.js";
 import { PrimitiveProp } from "../../props/primitive.property.js";
+import { UnionProp } from "../../props/union.property.js";
 import type { SchemaObject, ReferenceObject } from "../../types/open-api-spec.interface.js";
 import type { FieldConfigs } from "../../types/types.js";
 import type { CodegenContext } from "../CodegenContext.js";
-export type ClassifiedProp = PrimitiveProp | ArrayProp | ObjectProp | EnumProp;
+export type ClassifiedProp = PrimitiveProp | ArrayProp | ObjectProp | EnumProp | UnionProp;
 export declare class SchemaPropertyClassifier {
     static classify(params: {
         key: string;

package/dist/core/schema/SchemaPropertyClassifier.js

@@ -2,11 +2,21 @@ import { ArrayProp } from "../../props/array.property.js";
 import { EnumProp } from "../../props/enum.property.js";
 import { ObjectProp } from "../../props/object.property.js";
 import { PrimitiveProp } from "../../props/primitive.property.js";
+import { UnionProp } from "../../props/union.property.js";
 import { isReferenceObject, isPrimitiveEnumValues } from "../../helpers/helpers.js";
 export class SchemaPropertyClassifier {
     static classify(params) {
         const { key, value, requireds, fieldConfigs, schemaName, context } = params;
         if (isReferenceObject(value) || !value?.type) {
+            if (!isReferenceObject(value) && value.oneOf) {
+                return new UnionProp({
+                    name: key,
+                    oneOf: value.oneOf,
+                    discriminator: value.discriminator,
+                    isRequired: requireds.includes(key),
+                    isNullable: value.nullable,
+                });
+            }
             if (!isReferenceObject(value) && value.additionalProperties) {
                 const fakeStringSchema = { ...value, type: "string" };
                 const config = fieldConfigs.get(key);
@@ -15,6 +25,7 @@ export class SchemaPropertyClassifier {
                     schemaObject: fakeStringSchema,
                     required: requireds.includes(key),
                     validator: config?.validator,
+                    sanitizer: config?.sanitizer,
                     customType: config?.type,
                     isParam: undefined,
                     isNullable: value.nullable,
@@ -53,6 +64,7 @@ export class SchemaPropertyClassifier {
         }
         const config = fieldConfigs.get(key);
         const validator = config?.validator;
+        const sanitizer = config?.sanitizer;
         const customType = config?.type;
         const type = value.type;
         if (type === "object") {
@@ -63,6 +75,7 @@ export class SchemaPropertyClassifier {
                     schemaObject: fakeStringSchema,
                     required,
                     validator,
+                    sanitizer,
                     customType,
                     isParam: undefined,
                     isNullable: value.nullable,
@@ -87,6 +100,7 @@ export class SchemaPropertyClassifier {
             schemaObject: value,
             required,
             validator,
+            sanitizer,
             customType,
             isParam: undefined,
             isNullable: value.nullable,

package/dist/core/schema/SchemaRegistry.d.ts

@@ -10,6 +10,8 @@ export declare class SchemaRegistry {
         components: ComponentsObject;
         fieldConfigs: FieldConfigs;
         context: CodegenContext;
+        /** Nomes-raiz dos request body DTOs — eles e seu fecho transitivo serializam via bundleInputs */
+        requestBodyNames?: Set<string>;
     });
     /** Resolve transitive schema dependencies from a list of schema class names */
     resolveTransitiveDeps(names: string[]): Schema[];

package/dist/core/schema/SchemaRegistry.js

@@ -5,7 +5,7 @@ export class SchemaRegistry {
     propertiesNames = new Set();
     schemaMap = new Map();
     constructor(params) {
-        const { components, fieldConfigs, context } = params;
+        const { components, fieldConfigs, context, requestBodyNames } = params;
         const componentSchemas = components.schemas;
         if (!componentSchemas)
             return;
@@ -32,6 +32,15 @@ export class SchemaRegistry {
         for (const schema of this.schemas) {
             this.schemaMap.set(schema.name, schema);
         }
+        // Request body DTOs (e seu fecho transitivo de deps) serializam via bundleInputs:
+        // o bundle() lê os flags do BuildedInput em vez de só o .value extraído. Transitivo
+        // porque um DTO aninhado (ex.: createBody.role → UserRole) também é serializado no
+        // request — marcar só a raiz deixaria o nested em bundleStrict (bug nested).
+        if (requestBodyNames && requestBodyNames.size > 0) {
+            for (const schema of this.resolveTransitiveDeps([...requestBodyNames])) {
+                schema.setRequestMode();
+            }
+        }
         console.log(`${this.schemas.length} schemas generated successfully.`);
     }
     /** Resolve transitive schema dependencies from a list of schema class names */

package/dist/helpers/generate-doc.helper.d.ts

@@ -1,6 +1,7 @@
 interface LooseFieldConfig {
     fields: string[];
     validator?: string;
+    sanitizer?: string;
     type?: string;
 }
 export declare function parseFieldConfigsFromConfig(code: string): LooseFieldConfig[];

package/dist/helpers/generate-doc.helper.js

@@ -96,12 +96,17 @@ export function parseFieldConfigsFromConfig(code) {
         // extrai validator (referência sem aspas, ex: validateInputs.email)
         const validatorMatch = block.match(/validator\s*:\s*([A-Za-z0-9_$.]+)/);
         const validator = validatorMatch?.[1]?.trim();
+        // extrai sanitizer (referência sem aspas, ex: sanitizers.phone)
+        const sanitizerMatch = block.match(/sanitizer\s*:\s*([A-Za-z0-9_$.]+)/);
+        const sanitizer = sanitizerMatch?.[1]?.trim();
         // extrai type (string literal com aspas, ex: 'IconName')
         const typeMatch = block.match(/type\s*:\s*['"`]([^'"`]+)['"`]/);
         const type = typeMatch?.[1]?.trim();
         const config = { fields };
         if (validator)
             config.validator = validator;
+        if (sanitizer)
+            config.sanitizer = sanitizer;
         if (type)
             config.type = type;
         results.push(config);

package/dist/loaders/ConfigLoader.js

@@ -22,6 +22,8 @@ export class ConfigLoader {
                 const config = {};
                 if (rel.validator)
                     config.validator = rel.validator;
+                if (rel.sanitizer)
+                    config.sanitizer = rel.sanitizer;
                 if (rel.type)
                     config.type = rel.type;
                 fieldConfigs.set(field, config);

package/dist/props/array.property.d.ts

@@ -28,5 +28,6 @@ export declare class ArrayProp {
     bundleBuild(): string;
     queryBundleBuild(): string;
     queryBuild(): string;
+    hydrateBuild(): string;
     staticBuild(): string;
 }

package/dist/props/array.property.js

@@ -96,6 +96,12 @@ export class ArrayProp {
             .join(", ")}]`;
         return `readonly ${this.name} = new EnumQueryBuilder<${this.type}>({ key: '${this.name}', defaultValues: ${literal} })`;
     }
+    hydrateBuild() {
+        if (this.isSchemaRef) {
+            return `if (data.${this.name} !== undefined) this.${this.name} = (data.${this.name} ?? []).map((i) => new ${this.type}({ data: i as never }))`;
+        }
+        return `if (data.${this.name} !== undefined) this.${this.name} = data.${this.name} ?? []`;
+    }
     staticBuild() {
         const result = this._isPrimitiveType ? "obj" : `new ${this.type}({ data: obj })`;
         const aType = this._isPrimitiveType ? this.type : `${this.type}Interface`;

package/dist/props/enum.property.d.ts

@@ -19,4 +19,5 @@ export declare class EnumProp {
     interfaceBuild(): string;
     queryBuild(): string;
     bundleBuild(): string;
+    hydrateBuild(): string;
 }

package/dist/props/enum.property.js

@@ -39,4 +39,8 @@ export class EnumProp {
     bundleBuild() {
         return `${this.name}: this.${this.name}?.value`;
     }
+    hydrateBuild() {
+        const opt = this.isRequired ? "" : "?";
+        return `if (data.${this.name} !== undefined) this.${this.name}${opt}.hydrate(data.${this.name} as never)`;
+    }
 }

package/dist/props/object.property.d.ts

@@ -14,4 +14,5 @@ export declare class ObjectProp {
     classBuild(): string;
     interfaceBuild(): string;
     bundleBuild(): string;
+    hydrateBuild(): string;
 }

package/dist/props/object.property.js

@@ -31,4 +31,17 @@ export class ObjectProp {
         const nullable = this.isNullable ? "?? null" : "";
         return `${this.name}: this.${this.name}?.bundle() ${nullable}`;
     }
+    hydrateBuild() {
+        if (this.isNullable) {
+            return `if (data.${this.name} !== undefined) {
+        if (data.${this.name} === null) this.${this.name} = null;
+        else if (this.${this.name}) this.${this.name}.hydrate(data.${this.name} as never);
+        else this.${this.name} = new ${this.type}({ data: data.${this.name} as never });
+      }`;
+        }
+        return `if (data.${this.name} !== undefined) {
+      if (this.${this.name}) this.${this.name}.hydrate(data.${this.name} as never);
+      else this.${this.name} = new ${this.type}({ data: data.${this.name} as never });
+    }`;
+    }
 }

package/dist/props/primitive.property.d.ts

@@ -10,6 +10,7 @@ export declare class PrimitiveProp {
     private readonly isNullable;
     readonly rawType: ReflectorParamType;
     readonly customType: string | undefined;
+    readonly sanitizer: string | undefined;
     private readonly buildedConst;
     private readonly example;
     private readonly fallbackExample;
@@ -23,6 +24,7 @@ export declare class PrimitiveProp {
         schemaObject: SchemaObject;
         required: boolean;
         validator: string | undefined;
+        sanitizer?: string | undefined;
         customType?: string | undefined;
         isParam: boolean | undefined;
         isNullable?: boolean | undefined;
@@ -38,5 +40,6 @@ export declare class PrimitiveProp {
     queryBuild(): string;
     updateQueryBuild(): string;
     bundleBuild(): string;
+    hydrateBuild(): string;
 }
 export {};

package/dist/props/primitive.property.js

@@ -9,6 +9,7 @@ export class PrimitiveProp {
     isNullable;
     rawType;
     customType;
+    sanitizer;
     buildedConst;
     example;
     fallbackExample;
@@ -22,7 +23,7 @@ export class PrimitiveProp {
         return this.isNullable || !this.required;
     }
     constructor(params) {
-        const { name, schemaObject, required, validator, customType, isParam, isNullable } = params;
+        const { name, schemaObject, required, validator, sanitizer, customType, isParam, isNullable } = params;
         const { type: rawType } = schemaObject;
         this.isNullable = !!isNullable;
         const normalizedRawType = rawType === "integer" ? "number" : rawType;
@@ -38,10 +39,13 @@ export class PrimitiveProp {
         this.isSpecial = treated.isSpecial;
         this.rawType = type ?? "any";
         this.customType = customType;
+        // sanitizer só vale para campo string — gate aqui garante que emissão e
+        // rastreio de dependência (import) concordam.
+        this.sanitizer = type === "string" ? sanitizer : undefined;
         this.type = `BuildedInput<${buildedType}>`;
         this.required = required;
         this.isParam = !!isParam;
-        this.buildedConst = this.buildConst({ example, name: this.name, required, type, validator, emptyExample: this.example });
+        this.buildedConst = this.buildConst({ example, name: this.name, required, type, validator, sanitizer: this.sanitizer, emptyExample: this.example });
     }
     getEmptyExample(params) {
         const { schemaObject, type, name } = params;
@@ -83,7 +87,7 @@ export class PrimitiveProp {
         };
     }
     buildConst(params) {
-        const { name, required, type, validator } = params;
+        const { name, required, type, validator, sanitizer } = params;
         const getValidator = (type) => {
             if (type === "string") {
                 return "emptyString";
@@ -114,10 +118,22 @@ export class PrimitiveProp {
         else if (this.customType) {
             typeParam = `<${this.effectiveType}>`;
         }
-        const nullableParam = this.isNullable ? "nullable: true, " : "";
-        const maxParam = this.max !== undefined ? `max: ${this.max}, ` : "";
+        // Monta as props num array e junta com vírgula: com dois opcionais
+        // (validator + sanitizer) o controle manual de vírgula quebrava.
+        const props = [
+            `key: ${keyExpr}`,
+            `placeholder: ${this.example}`,
+            `example: ${buildedExample}`,
+            `required: ${required}`,
+            this.isNullable ? "nullable: true" : "",
+            this.max !== undefined ? `max: ${this.max}` : "",
+            buildedValidator(),
+            sanitizer ? `sanitizer: ${sanitizer}` : "",
+        ]
+            .filter(Boolean)
+            .join(", ");
         return `
-      build${typeParam}({ key: ${keyExpr}, placeholder: ${this.example}, example: ${buildedExample}, required: ${required}, ${nullableParam}${maxParam}${buildedValidator()}})
+      build${typeParam}({ ${props} })
     `;
     }
     thisDot() {
@@ -154,4 +170,7 @@ export class PrimitiveProp {
     bundleBuild() {
         return `${this.name}: ${this.thisDot()}${this.name}?.value`;
     }
+    hydrateBuild() {
+        return `if (data.${this.name} !== undefined) ${this.thisDot()}${this.name}.hydrate(data.${this.name} as never)`;
+    }
 }

package/dist/props/union.property.d.ts

@@ -0,0 +1,37 @@
+import type { DiscriminatorObject, ReferenceObject, SchemaObject } from "../types/open-api-spec.interface.js";
+/**
+ * Property whose OpenAPI schema is a `oneOf` — a union of `$ref`ed component
+ * schemas, optionally carrying a `discriminator`. Only `$ref` variants are
+ * supported (inline `oneOf` members aren't promoted today).
+ *
+ * Runtime model is intentionally flat/passthrough: the class field stores the
+ * raw incoming object typed as the union of the variants' `Interface`s — there
+ * is no `new` (you can't instantiate a union) and no `.bundle()` on it
+ * (`bundleStrict`/`bundleInputs` pass plain objects through unchanged). The
+ * elegant discriminated narrowing lives in the schema's `Interface` type alias
+ * (see `DiscriminatedInterfaceRenderer`), not on the live class instance.
+ */
+export declare class UnionProp {
+    name: string;
+    /** Variant component names extracted from each `oneOf` `$ref` (deduped, order-preserving). */
+    readonly variantTypes: string[];
+    readonly discriminator: DiscriminatorObject | undefined;
+    private readonly required;
+    private readonly isNullable;
+    constructor(params: {
+        name: string;
+        oneOf: (SchemaObject | ReferenceObject)[];
+        discriminator?: DiscriminatorObject | undefined;
+        isRequired?: boolean;
+        isNullable?: boolean | undefined;
+    });
+    /** `AInterface | BInterface | ...` — the flat union used for the class field type. */
+    flatUnion(): string;
+    /** True when this union can render as a discriminated `Interface` (needs a mapping). */
+    get hasDiscriminator(): boolean;
+    classBuild(): string;
+    constructorBuild(): string;
+    bundleBuild(): string;
+    interfaceBuild(): string;
+    hydrateBuild(): string;
+}

package/dist/props/union.property.js

@@ -0,0 +1,62 @@
+import { isReferenceObject } from "../helpers/helpers.js";
+/**
+ * Property whose OpenAPI schema is a `oneOf` — a union of `$ref`ed component
+ * schemas, optionally carrying a `discriminator`. Only `$ref` variants are
+ * supported (inline `oneOf` members aren't promoted today).
+ *
+ * Runtime model is intentionally flat/passthrough: the class field stores the
+ * raw incoming object typed as the union of the variants' `Interface`s — there
+ * is no `new` (you can't instantiate a union) and no `.bundle()` on it
+ * (`bundleStrict`/`bundleInputs` pass plain objects through unchanged). The
+ * elegant discriminated narrowing lives in the schema's `Interface` type alias
+ * (see `DiscriminatedInterfaceRenderer`), not on the live class instance.
+ */
+export class UnionProp {
+    name;
+    /** Variant component names extracted from each `oneOf` `$ref` (deduped, order-preserving). */
+    variantTypes;
+    discriminator;
+    required;
+    isNullable;
+    constructor(params) {
+        const { name, oneOf, discriminator, isRequired, isNullable } = params;
+        this.name = name;
+        this.discriminator = discriminator;
+        this.required = isRequired ?? true;
+        this.isNullable = !!isNullable;
+        const refs = oneOf
+            .filter(isReferenceObject)
+            .map((ref) => ref.$ref.split("/").at(-1) ?? "")
+            .filter(Boolean);
+        this.variantTypes = [...new Set(refs)];
+    }
+    /** `AInterface | BInterface | ...` — the flat union used for the class field type. */
+    flatUnion() {
+        return this.variantTypes.map((t) => `${t}Interface`).join(" | ");
+    }
+    /** True when this union can render as a discriminated `Interface` (needs a mapping). */
+    get hasDiscriminator() {
+        return !!this.discriminator?.mapping && Object.keys(this.discriminator.mapping).length > 0;
+    }
+    classBuild() {
+        const req = this.required ? "" : "?";
+        const nullable = this.isNullable ? " | null" : "";
+        // No `new` for a union — `$state<T>()` (no arg) yields `T | undefined`,
+        // populated by the constructor from the incoming data.
+        return `${this.name}${req} = $state<${this.flatUnion()}${nullable}>()`;
+    }
+    constructorBuild() {
+        return `this.${this.name} = params?.data?.${this.name}`;
+    }
+    bundleBuild() {
+        return `${this.name}: this.${this.name}`;
+    }
+    interfaceBuild() {
+        const req = this.required ? "" : "?";
+        const nullable = this.isNullable ? " | null" : "";
+        return `${this.name}${req}: ${this.flatUnion()}${nullable}`;
+    }
+    hydrateBuild() {
+        return `if (data.${this.name} !== undefined) this.${this.name} = data.${this.name}`;
+    }
+}