svelte-reflector 2.1.9 → 2.5.1

package/dist/core/Reflector.js

@@ -33,7 +33,8 @@ export class Reflector {
             context: this.context,
             config: this.config,
         });
-        this.registry = new SchemaRegistry({ components, fieldConfigs, context: this.context });
+        const requestBodyNames = new Set(this.modules.flatMap((m) => m.requestBodyNames));
+        this.registry = new SchemaRegistry({ components, fieldConfigs, context: this.context, requestBodyNames });
         this.schemas = this.registry.schemas;
         this.propertiesNames = this.registry.propertiesNames;
     }

package/dist/core/api/ApiClassBuilder.js

@@ -53,17 +53,17 @@ export class ApiClassBuilder {
             this.imports.addReflectorImport("genericArrayBundler");
         }
         const className = capitalizeFirstLetter(method.name);
-        const classCode = `
-      export class ${className} {
-        ${stateProps.join(";")}
-        ${processedParams.paramAttributes.map((a) => `${a};`).join("\n        ")}
-
-        ${callMethod}
-
-        reset() {
-          ${resetLines.join(";")}
-        }
-      }
+        const classCode = `
+      export class ${className} {
+        ${stateProps.join(";")}
+        ${processedParams.paramAttributes.map((a) => `${a};`).join("\n        ")}
+
+        ${callMethod}
+
+        reset() {
+          ${resetLines.join(";")}
+        }
+      }
     `;
         const paramCode = processedParams.paramClasses.join("\n");
         return { paramCode, classCode, schemaEntries };
@@ -91,7 +91,7 @@ export class ApiClassBuilder {
         const { attributeType, bodyType } = method.request;
         const lines = [];
         if (attributeType === "form" && bodyType) {
-            lines.push(`this.form = new ${bodyType}()`);
+            lines.push(`this.form.reset()`);
         }
         else if (attributeType === "list") {
             lines.push("this.data = []");

package/dist/core/config/ReflectorConfig.d.ts

@@ -6,8 +6,10 @@
 export interface ReflectorConfig {
     /** Alias that resolves to the generated reflector folder (e.g. `$reflector`). */
     reflectorAlias: string;
-    /** Full import path to the validators/sanitizers module. */
+    /** Full import path to the validators module (exports `validateInputs`). */
     validatorsImport: string;
+    /** Full import path to the sanitizers module (input masks; exports `sanitizers`). */
+    sanitizersImport: string;
     /** Module path for the environment flag (e.g. `$env/static/public`). */
     environmentImport: string;
     /** Name of the exported environment flag — values other than `DEV` are treated as prod. */

package/dist/core/config/ReflectorConfig.js

@@ -1,6 +1,7 @@
 export const DEFAULT_REFLECTOR_CONFIG = {
     reflectorAlias: "$reflector",
     validatorsImport: "$lib/sanitizers/validateFormats",
+    sanitizersImport: "$lib/sanitizers/input-sanitizers",
     environmentImport: "$env/static/public",
     environmentFlag: "PUBLIC_ENVIRONMENT",
     toastImport: "$lib/utils/toast.svelte",

package/dist/core/generators/ApiCallStrategy.d.ts

@@ -2,6 +2,7 @@ import type { CallMethodInput, CallStrategy } from "./CallStrategy.js";
 export declare class ApiCallStrategy implements CallStrategy {
     listStateAccess(_method: CallMethodInput): string;
     buildSignature(method: CallMethodInput): string;
+    buildLegacyWrapper(method: CallMethodInput): string;
     entityStateAccess(_method: CallMethodInput): string;
     formStateAccess(_method: CallMethodInput): string;
     private buildParamsType;

package/dist/core/generators/ApiCallStrategy.js

@@ -5,7 +5,16 @@ export class ApiCallStrategy {
     }
     buildSignature(method) {
         const paramsType = this.buildParamsType(method);
-        return `async call(params?: ${paramsType})`;
+        return `async run(params?: ${paramsType})`;
+    }
+    buildLegacyWrapper(method) {
+        const paramsType = this.buildParamsType(method);
+        return `
+      /** @deprecated use \`run()\` — returns a discriminated ApiResult */
+      async call(params?: ${paramsType}) {
+        const res = await this.run(params);
+        return res.ok ? res.data : undefined;
+      }`;
     }
     entityStateAccess(_method) {
         return "this.data";

package/dist/core/generators/CallMethodGenerator.js

@@ -8,6 +8,7 @@ export class CallMethodGenerator {
         const { inside, outside } = this.buildApiCall(method, strategy);
         const methodReturn = this.buildMethodReturn(method, strategy);
         const signature = strategy.buildSignature(method);
+        const legacyWrapper = strategy.buildLegacyWrapper(method);
         return `
       ${description}
       ${signature} {
@@ -25,7 +26,7 @@ export class CallMethodGenerator {
           ${inside}
           await onSuccess?.(response);
 
-          return ${methodReturn};
+          return { ok: true, data: ${methodReturn} };
         } catch (e) {
           let parsedError: ApiErrorResponse;
           try {
@@ -33,11 +34,14 @@ export class CallMethodGenerator {
           } catch {
             parsedError = { error: 'unknown', message: (e as Error).message ?? String(e) };
           }
-          return await onError?.(parsedError);
+          await onError?.(parsedError);
+          return { ok: false, error: parsedError };
         } finally {
           this.loading = false;
         }
       }
+
+      ${legacyWrapper}
     `;
     }
     buildProps(method) {

package/dist/core/generators/CallStrategy.d.ts

@@ -17,8 +17,13 @@ export interface CallMethodInput {
  * (per-endpoint Api class vs Module `_methodName` protected method).
  */
 export interface CallStrategy {
-    /** Full method signature incl. params — e.g. `async call(params?: ...)` or `protected async _foo(params?: ...)` */
+    /** Full signature of the discriminated `run` method incl. params —
+     *  e.g. `async run(params?: ...)` (api) or `protected async _fooRun(params?: ...)` (module). */
     buildSignature(method: CallMethodInput): string;
+    /** Full `@deprecated` legacy method that delegates to the `run` variant and
+     *  reproduces the old `Res | null | undefined` return shape. Emitted verbatim
+     *  after the run method. Api → `call()`; module → `_foo()`. */
+    buildLegacyWrapper(method: CallMethodInput): string;
     /** State field holding list results — e.g. `this.list` / `this.listControllers` (module) or `this.data` (api).
      *  Takes `method` so the module strategy can suffix the field when two list
      *  operations collide in the same controller. */

package/dist/core/generators/ModuleCallStrategy.d.ts

@@ -2,6 +2,7 @@ import type { CallMethodInput, CallStrategy } from "./CallStrategy.js";
 export declare class ModuleCallStrategy implements CallStrategy {
     listStateAccess(method: CallMethodInput): string;
     buildSignature(method: CallMethodInput): string;
+    buildLegacyWrapper(method: CallMethodInput): string;
     entityStateAccess(method: CallMethodInput): string;
     formStateAccess(method: CallMethodInput): string;
     private buildParamsType;

package/dist/core/generators/ModuleCallStrategy.js

@@ -6,7 +6,16 @@ export class ModuleCallStrategy {
     }
     buildSignature(method) {
         const paramsType = this.buildParamsType(method);
-        return `protected async _${method.name}(params?: ${paramsType})`;
+        return `protected async _${method.name}Run(params?: ${paramsType})`;
+    }
+    buildLegacyWrapper(method) {
+        const paramsType = this.buildParamsType(method);
+        return `
+      /** @deprecated use \`_${method.name}Run()\` — returns a discriminated ApiResult */
+      protected async _${method.name}(params?: ${paramsType}) {
+        const res = await this._${method.name}Run(params);
+        return res.ok ? res.data : undefined;
+      }`;
     }
     entityStateAccess(method) {
         const rType = method.analyzers.request.responseType ?? "";

package/dist/core/module/Module.d.ts

@@ -12,6 +12,8 @@ export declare class Module {
     readonly methods: Method[];
     /** Schema class names directly used by this module (for per-module schema generation) */
     readonly schemaClassNames: string[];
+    /** Nomes-raiz dos request body DTOs deste módulo (para serialização schema-aware) */
+    readonly requestBodyNames: string[];
     private readonly imports;
     private readonly methodProcessor;
     private readonly classBuilder;

package/dist/core/module/Module.js

@@ -14,6 +14,8 @@ export class Module {
     methods;
     /** Schema class names directly used by this module (for per-module schema generation) */
     schemaClassNames;
+    /** Nomes-raiz dos request body DTOs deste módulo (para serialização schema-aware) */
+    requestBodyNames;
     imports;
     methodProcessor;
     classBuilder;
@@ -55,6 +57,7 @@ export class Module {
         // Extract schema class names for per-module schema generation
         this.schemaClassNames = Array.from(processedMethods.entries)
             .filter((e) => e !== "type any" && !e.startsWith("type "));
+        this.requestBodyNames = Array.from(processedMethods.requestBodyNames);
         // Monta o resultado final
         const allBuilded = this.buildModuleData(processedMethods, processedParams);
         const moduleConstructor = this.constructorBuilder.build(allBuilded.form);
@@ -97,7 +100,7 @@ export class Module {
       `);
             moduleInit.add("this.clearForms()");
             moduleClear.add(`
-        protected clearForms() { this.forms = this.buildForms(true) }
+        protected clearForms() { ${form.map((f) => `this.forms.${f.name}.reset()`).join("; ")} }
       `);
         }
         return {

package/dist/core/module/ModuleMethodProcessor.d.ts

@@ -6,6 +6,8 @@ import type { Form } from "./ModuleConstructorBuilder.js";
 export interface ProcessedMethods {
     buildedMethods: string[];
     entries: Set<string>;
+    /** Nomes-raiz dos request body DTOs (para serialização schema-aware via bundleInputs) */
+    requestBodyNames: Set<string>;
     form: Form[];
     formSet: Set<string>;
     methodsAttributes: string[];

package/dist/core/module/ModuleMethodProcessor.js

@@ -13,6 +13,7 @@ export class ModuleMethodProcessor {
         const form = [];
         const formSet = new Set();
         const entries = new Set();
+        const requestBodyNames = new Set();
         const buildedMethods = [];
         const queryMap = new Map();
         const headerMap = new Map();
@@ -54,6 +55,7 @@ export class ModuleMethodProcessor {
             }
             if (bodyType) {
                 entries.add(bodyType);
+                requestBodyNames.add(bodyType);
             }
             if (responseType && responseType !== "response" && !isPrimitiveResponse) {
                 entries.add(`type ${responseType}Interface`);
@@ -64,6 +66,7 @@ export class ModuleMethodProcessor {
             form,
             formSet,
             entries,
+            requestBodyNames,
             buildedMethods,
             methodsAttributes: Array.from(methodsAttributes),
             methodsInit: Array.from(methodsInit),

package/dist/core/module/ModuleSchemaFileBuilder.js

@@ -16,11 +16,25 @@ export class ModuleSchemaFileBuilder {
                 customTypeDeps.add(t);
             }
         }
+        // só presença importa (o import é o objeto `sanitizers` inteiro), não os refs
+        const usesSanitizers = schemas.some((s) => s.sanitizerDeps.length > 0);
         const treatedSchemas = schemas.map((s) => `${s.interface};\n${s.schema};`);
+        // import preciso: response usa bundleStrict, request usa bundleInputs, array-root
+        // não usa nenhum. Evita import morto (svelte-check/eslint do consumer reclama).
+        const needsStrict = schemas.some((s) => s.bundleHelper === "strict");
+        const needsInputs = schemas.some((s) => s.bundleHelper === "inputs");
+        const reflectorImports = ["build", "BuildedInput"];
+        if (needsStrict)
+            reflectorImports.push("bundleStrict");
+        if (needsInputs)
+            reflectorImports.push("bundleInputs");
         const imports = [
-            `import { build, BuildedInput, bundleStrict } from "${config.reflectorAlias}/reflector.svelte";`,
+            `import { ${reflectorImports.join(", ")} } from "${config.reflectorAlias}/reflector.svelte";`,
             `import { validateInputs } from "${config.validatorsImport}";`,
         ];
+        if (usesSanitizers) {
+            imports.push(`import { sanitizers } from "${config.sanitizersImport}";`);
+        }
         if (enumDeps.size > 0) {
             imports.push(`import type { ${[...enumDeps].join(", ")} } from "${config.reflectorAlias}/enums"`);
         }

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

@@ -0,0 +1,35 @@
+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";
+/**
+ * Renders a schema's `Interface` as a *discriminated union* type alias when one
+ * of its properties is a `oneOf` carrying a `discriminator` whose `propertyName`
+ * points at a sibling enum property (e.g. `NotificationData.actionMeta` keyed by
+ * `action`). Each `discriminator.mapping` entry (action value → variant schema)
+ * becomes a union member that pins `action` to its literal(s) and `actionMeta`
+ * to the matching variant `Interface`:
+ *
+ * ```ts
+ * export type NotificationDataInterface =
+ *   | { ...commons; action: "STOCK_LOW" | "STOCK_OUT"; actionMeta: ProductStockMetaInterface }
+ *   | { ...commons; action: "ANNOUNCEMENT"; actionMeta: UrlMetaInterface };
+ * ```
+ *
+ * This is what makes `if (n.action === "STOCK_LOW") n.actionMeta.productId`
+ * narrow on plain `Interface`-typed values (raw response data, `.bundle()`,
+ * `.discriminated()`). It never narrows on the live `$state` class instance —
+ * TS can't correlate two independent mutable fields.
+ */
+export declare class DiscriminatedInterfaceRenderer {
+    static render(params: {
+        name: string;
+        union: UnionProp;
+        primitiveProps: PrimitiveProp[];
+        arrayProps: ArrayProp[];
+        objectProps: ObjectProp[];
+        enumProps: EnumProp[];
+        otherUnionProps: UnionProp[];
+    }): string;
+}

package/dist/core/schema/DiscriminatedInterfaceRenderer.js

@@ -0,0 +1,70 @@
+/**
+ * Renders a schema's `Interface` as a *discriminated union* type alias when one
+ * of its properties is a `oneOf` carrying a `discriminator` whose `propertyName`
+ * points at a sibling enum property (e.g. `NotificationData.actionMeta` keyed by
+ * `action`). Each `discriminator.mapping` entry (action value → variant schema)
+ * becomes a union member that pins `action` to its literal(s) and `actionMeta`
+ * to the matching variant `Interface`:
+ *
+ * ```ts
+ * export type NotificationDataInterface =
+ *   | { ...commons; action: "STOCK_LOW" | "STOCK_OUT"; actionMeta: ProductStockMetaInterface }
+ *   | { ...commons; action: "ANNOUNCEMENT"; actionMeta: UrlMetaInterface };
+ * ```
+ *
+ * This is what makes `if (n.action === "STOCK_LOW") n.actionMeta.productId`
+ * narrow on plain `Interface`-typed values (raw response data, `.bundle()`,
+ * `.discriminated()`). It never narrows on the live `$state` class instance —
+ * TS can't correlate two independent mutable fields.
+ */
+export class DiscriminatedInterfaceRenderer {
+    static render(params) {
+        const { name, union, primitiveProps, arrayProps, objectProps, enumProps, otherUnionProps } = params;
+        const discProp = union.discriminator.propertyName;
+        const mapping = union.discriminator.mapping ?? {};
+        // Commons = every property except the discriminant and the discriminated union itself.
+        const allProps = [
+            ...primitiveProps,
+            ...arrayProps,
+            ...objectProps,
+            ...enumProps,
+            ...otherUnionProps,
+        ];
+        const commons = allProps
+            .filter((p) => p.name !== discProp && p.name !== union.name)
+            .map((p) => p.interfaceBuild());
+        // Invert the mapping: variant schema name → the action literals that select it,
+        // preserving first-seen order so output stays deterministic.
+        const byVariant = new Map();
+        for (const [actionValue, ref] of Object.entries(mapping)) {
+            const variant = ref.split("/").at(-1) ?? "";
+            if (!variant)
+                continue;
+            const list = byVariant.get(variant) ?? [];
+            list.push(actionValue);
+            byVariant.set(variant, list);
+        }
+        // The discriminated part: only the discriminant + the union field vary per variant.
+        // Commons are factored into a single object type and intersected with the union —
+        // narrowing on `action` still works through the intersection.
+        const members = [...byVariant.entries()].map(([variant, actions]) => {
+            const literals = actions.map((a) => `"${a}"`).join(" | ");
+            return `{ ${discProp}: ${literals}; ${union.name}: ${variant}Interface }`;
+        });
+        const variantUnion = members.map((m) => `| ${m}`).join("\n");
+        // No commons → emit the bare union (avoid a pointless `{} & (...)`).
+        if (commons.length === 0) {
+            return `
+      export type ${name}Interface =
+        ${variantUnion};
+    `;
+        }
+        return `
+      export type ${name}Interface = {
+        ${commons.join(";\n")}
+      } & (
+        ${variantUnion}
+      );
+    `;
+    }
+}

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

@@ -2,6 +2,7 @@ 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 declare class ReflectorInterface {
     builded: string;
     constructor(params: {
@@ -10,5 +11,6 @@ export declare class ReflectorInterface {
         name: string;
         objectProps: ObjectProp[];
         enumProps: EnumProp[];
+        unionProps: UnionProp[];
     });
 }

package/dist/core/schema/ReflectorInterface.js

@@ -1,7 +1,7 @@
 export class ReflectorInterface {
     builded;
     constructor(params) {
-        const { name, arrayProps, primitiveProps, objectProps, enumProps } = params;
+        const { name, arrayProps, primitiveProps, objectProps, enumProps, unionProps } = params;
         const buildedProps = [];
         primitiveProps.forEach((prop) => {
             buildedProps.push(prop.interfaceBuild());
@@ -15,6 +15,9 @@ export class ReflectorInterface {
         enumProps.forEach((prop) => {
             buildedProps.push(prop.interfaceBuild());
         });
+        unionProps.forEach((prop) => {
+            buildedProps.push(prop.interfaceBuild());
+        });
         this.builded = `
       export interface ${name}Interface {
         ${buildedProps}

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

@@ -2,6 +2,7 @@ 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";
@@ -11,14 +12,23 @@ export declare class Schema {
     arrayProps: ArrayProp[];
     objectProps: ObjectProp[];
     enumProps: EnumProp[];
+    unionProps: UnionProp[];
     /** Other schema class names this schema depends on (via ObjectProp/$ref arrays) */
     readonly schemaDeps: string[];
     /** Enum type names used by this schema */
     readonly enumDeps: string[];
     /** Custom type names used by this schema (from fieldConfigs) */
     readonly customTypeDeps: string[];
+    /** Sanitizer refs used by this schema (from fieldConfigs) — gates the `sanitizers` import */
+    readonly sanitizerDeps: string[];
     schema: string;
     interface: string;
+    /**
+     * Qual helper de runtime o `bundle()` renderizado referencia — controla os imports
+     * do schema file. `'strict'` = response (bundleStrict), `'inputs'` = request
+     * (bundleInputs), `null` = array-root (mapeia `item.bundle()`, não usa nenhum).
+     */
+    bundleHelper: "strict" | "inputs" | null;
     /**
      * Builds a Schema for an array-root component (top-level `type: array`), e.g.
      * a promoted `data: array` response envelope. Renders a wrapper class whose
@@ -48,4 +58,12 @@ export declare class Schema {
         fieldConfigs: FieldConfigs;
         context: CodegenContext;
     });
+    /**
+     * Re-renderiza este schema como request DTO: `bundle()` passa a serializar a partir
+     * das instâncias `BuildedInput` via `bundleInputs` (em vez de `bundleStrict` sobre os
+     * `.value` extraídos). Idempotente. Schemas array-root não têm props → no-op
+     * (continuam mapeando `item.bundle()`). Chamado pelo `SchemaRegistry` para o fecho
+     * transitivo dos request bodies.
+     */
+    setRequestMode(): void;
 }

package/dist/core/schema/Schema.js

@@ -2,6 +2,7 @@ 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 } from "../../helpers/helpers.js";
 import { SchemaPropertyClassifier } from "./SchemaPropertyClassifier.js";
 import { SchemaDependencyCollector } from "./SchemaDependencyCollector.js";
@@ -13,14 +14,23 @@ export class Schema {
     arrayProps = [];
     objectProps = [];
     enumProps = [];
+    unionProps = [];
     /** Other schema class names this schema depends on (via ObjectProp/$ref arrays) */
     schemaDeps;
     /** Enum type names used by this schema */
     enumDeps;
     /** Custom type names used by this schema (from fieldConfigs) */
     customTypeDeps;
+    /** Sanitizer refs used by this schema (from fieldConfigs) — gates the `sanitizers` import */
+    sanitizerDeps;
     schema;
     interface;
+    /**
+     * Qual helper de runtime o `bundle()` renderizado referencia — controla os imports
+     * do schema file. `'strict'` = response (bundleStrict), `'inputs'` = request
+     * (bundleInputs), `null` = array-root (mapeia `item.bundle()`, não usa nenhum).
+     */
+    bundleHelper;
     /**
      * Builds a Schema for an array-root component (top-level `type: array`), e.g.
      * a promoted `data: array` response envelope. Renders a wrapper class whose
@@ -37,9 +47,11 @@ export class Schema {
         schema.arrayProps = [];
         schema.objectProps = [];
         schema.enumProps = [];
+        schema.unionProps = [];
         schema.schemaDeps = element.kind === "ref" ? [element.type] : [];
         schema.enumDeps = element.kind === "enum" ? [element.type] : [];
         schema.customTypeDeps = [];
+        schema.sanitizerDeps = [];
         const rendered = ArraySchemaRenderer.render({
             name,
             elementType: element.type,
@@ -47,6 +59,7 @@ export class Schema {
         });
         schema.interface = rendered.interface;
         schema.schema = rendered.schema;
+        schema.bundleHelper = null;
         return schema;
     }
     /**
@@ -100,24 +113,52 @@ export class Schema {
                 this.objectProps.push(prop);
             else if (prop instanceof EnumProp)
                 this.enumProps.push(prop);
+            else if (prop instanceof UnionProp)
+                this.unionProps.push(prop);
         }
         const deps = SchemaDependencyCollector.collect({
             primitiveProps: this.primitiveProps,
             arrayProps: this.arrayProps,
             objectProps: this.objectProps,
             enumProps: this.enumProps,
+            unionProps: this.unionProps,
         });
         this.schemaDeps = deps.schemaDeps;
         this.enumDeps = deps.enumDeps;
         this.customTypeDeps = deps.customTypeDeps;
+        this.sanitizerDeps = deps.sanitizerDeps;
         const rendered = SchemaClassRenderer.render({
             name: this.name,
             primitiveProps: this.primitiveProps,
             arrayProps: this.arrayProps,
             objectProps: this.objectProps,
             enumProps: this.enumProps,
+            unionProps: this.unionProps,
         });
         this.interface = rendered.interface;
         this.schema = rendered.schema;
+        this.bundleHelper = rendered.bundleHelper;
+    }
+    /**
+     * Re-renderiza este schema como request DTO: `bundle()` passa a serializar a partir
+     * das instâncias `BuildedInput` via `bundleInputs` (em vez de `bundleStrict` sobre os
+     * `.value` extraídos). Idempotente. Schemas array-root não têm props → no-op
+     * (continuam mapeando `item.bundle()`). Chamado pelo `SchemaRegistry` para o fecho
+     * transitivo dos request bodies.
+     */
+    setRequestMode() {
+        if (this.bundleHelper !== "strict")
+            return;
+        const rendered = SchemaClassRenderer.render({
+            name: this.name,
+            primitiveProps: this.primitiveProps,
+            arrayProps: this.arrayProps,
+            objectProps: this.objectProps,
+            enumProps: this.enumProps,
+            unionProps: this.unionProps,
+            mode: "request",
+        });
+        this.schema = rendered.schema;
+        this.bundleHelper = rendered.bundleHelper;
     }
 }

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

@@ -2,6 +2,7 @@ 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 declare class SchemaClassRenderer {
     static render(params: {
         name: string;
@@ -9,8 +10,11 @@ export declare class SchemaClassRenderer {
         arrayProps: ArrayProp[];
         objectProps: ObjectProp[];
         enumProps: EnumProp[];
+        unionProps: UnionProp[];
+        mode?: "request" | "response";
     }): {
         interface: string;
         schema: string;
+        bundleHelper: "strict" | "inputs";
     };
 }