@nestia/sdk 11.2.1 → 12.0.0-dev.20260520.1

package/lib/internal/legacy.d.ts

@@ -0,0 +1,180 @@
+import type { IJsonSchemaCollection, IMetadataComponents, IMetadataSchema, IMetadataTypeTag, OpenApi } from "@typia/interface";
+declare module "@typia/interface" {
+    namespace IMetadataSchema {
+        interface IReference {
+            type?: IArrayType | ITupleType | IObjectType | IAliasType;
+        }
+    }
+}
+/**
+ * Plain `IMetadataSchema` augmented with the fields the nestia transform
+ * pre-bakes. `size`, `name`, and `empty` replace the methods the legacy
+ * `MetadataSchema` class exposed; `jsonSchema` is the OpenAPI 3.1
+ * conversion typia's Go-side produces but does not expose to JS at
+ * runtime.
+ *
+ * Fields are declared optional so that nested `IMetadataSchema` values
+ * (`metadata.rest`, `metadata.escaped.original`, `IObjectType.value`,
+ * …) — which are not top-level route inputs and therefore do not carry
+ * the pre-baked overlay — still satisfy the type when passed through
+ * legacy utilities. The utilities read the fields via the optional
+ * accessor and fall back when absent.
+ */
+export interface IReflectMetadata extends IMetadataSchema {
+    size?: number;
+    name?: string;
+    empty?: boolean;
+    jsonSchema?: IReflectJsonSchema;
+}
+export interface IReflectJsonSchema {
+    version: "3.0" | "3.1";
+    components: OpenApi.IComponents;
+    schema: OpenApi.IJsonSchema;
+}
+/**
+ * Cross-reference dictionary produced by `MetadataComponents.from`. Each
+ * map is keyed by the entry's `.name`, matching the lookup pattern the
+ * legacy `MetadataComponents.dictionary` getter offered.
+ */
+export interface IMetadataDictionary {
+    objects: Map<string, IMetadataSchema.IObjectType>;
+    aliases: Map<string, IMetadataSchema.IAliasType>;
+    arrays: Map<string, IMetadataSchema.IArrayType>;
+    tuples: Map<string, IMetadataSchema.ITupleType>;
+}
+export type MetadataSchema = IMetadataSchema;
+export type MetadataComponents = IMetadataComponents & {
+    dictionary: IMetadataDictionary;
+};
+export type MetadataAliasType = IMetadataSchema.IAliasType;
+export type MetadataArrayType = IMetadataSchema.IArrayType;
+export type MetadataTupleType = IMetadataSchema.ITupleType;
+export type MetadataObjectType = IMetadataSchema.IObjectType;
+export type MetadataAtomic = IMetadataSchema.IAtomic;
+/**
+ * Flattened constant-value shape: typia v13 splits `IConstant.IValue<T>` by
+ * the atomic discriminator, but sdk's literal writer just needs the runtime
+ * `value` payload, so collapse the union to a single ergonomic shape.
+ */
+export interface MetadataConstantValue {
+    value: string | number | bigint | boolean;
+    tags: IMetadataTypeTag[][];
+}
+export type MetadataEscaped = IMetadataSchema.IEscaped;
+export type MetadataProperty = IMetadataSchema.IProperty;
+/**
+ * Reference to a named array/tuple/object/alias type. typia v13's
+ * plain `IReference` carries only the symbolic `name` + tags; the
+ * legacy class additionally exposed `.type` as a getter that resolved
+ * against the dictionary. `MetadataSchema.from` walks the metadata
+ * tree once and attaches the resolved `.type` field so downstream
+ * sdk code can keep its `ref.type` access pattern.
+ */
+export type MetadataArray = IMetadataSchema.IReference & {
+    type: MetadataArrayType;
+};
+export type MetadataTuple = IMetadataSchema.IReference & {
+    type: MetadataTupleType;
+};
+export type MetadataObject = IMetadataSchema.IReference & {
+    type: MetadataObjectType;
+};
+export type MetadataAlias = IMetadataSchema.IReference & {
+    type: MetadataAliasType;
+};
+/** `MetadataSchema.size()` → reads the pre-baked `size` field. */
+export declare const sizeOf: (m: IMetadataSchema) => number;
+/** `MetadataSchema.getName()` → reads the pre-baked `name` field. */
+export declare const nameOf: (m: IMetadataSchema) => string;
+/** `MetadataSchema.empty()` → reads the pre-baked `empty` field. */
+export declare const emptyOf: (m: IMetadataSchema) => boolean;
+/**
+ * Equivalent of the legacy `MetadataSchema.isSoleLiteral()` method:
+ * `true` when the schema represents exactly one constant literal value
+ * and nothing else. Used by sdk's type printer to fall back to literal
+ * emission instead of a union.
+ */
+export declare const isSoleLiteralOf: (m: IMetadataSchema) => boolean;
+export declare namespace MetadataComponents {
+    const from: (plain: IMetadataComponents) => MetadataComponents;
+}
+export declare namespace MetadataSchema {
+    /**
+     * Walks the metadata tree and attaches the resolved `.type` field to
+     * every `IReference` it encounters, using the supplied dictionary as
+     * the lookup index. This is idempotent — references whose `.type`
+     * has already been resolved are left alone — and mutates the input,
+     * matching the in-place resolution model `@typia/core` 12.x used.
+     */
+    const from: (plain: IMetadataSchema, dictionary?: IMetadataDictionary) => IMetadataSchema;
+}
+export declare namespace MetadataFactory {
+    interface IExplore {
+        object: IMetadataSchema.IObjectType | null;
+        property: string | null;
+        parameter: string | null;
+        output: boolean;
+    }
+    interface IError {
+        name: string;
+        explore: IExplore;
+        messages: string[];
+    }
+    type Validator = (props: {
+        metadata: IMetadataSchema;
+        explore: IExplore;
+    }) => string[];
+    /**
+     * Walks the metadata tree once, invoking the provided validator on each
+     * visited node, and accumulates the produced messages into `IError`
+     * entries. The walk skips back-edges through references so cyclic
+     * structures terminate. This is a faithful reimplementation of the
+     * legacy `@typia/core` walker, kept lean: the typia native transform
+     * has already validated structural invariants, so the validator is only
+     * called for SDK-side policy checks (JSON-serializability, query/header
+     * atomic-only rules, …).
+     */
+    const validate: (props: {
+        options?: unknown;
+        functor: Validator;
+        metadata: IMetadataSchema;
+    }) => IError[];
+}
+export declare namespace JsonMetadataFactory {
+    /**
+     * Rejects metadata that cannot be losslessly JSON-serialized. The typia
+     * native runtime already screens out most structurally invalid types, so
+     * this only adds the JSON-policy bans the legacy `@typia/core` walker
+     * enforced — bare `bigint` payloads, function-typed properties, and
+     * `Map` / `Set` containers that have no canonical JSON representation.
+     */
+    const validate: MetadataFactory.Validator;
+}
+export declare namespace HttpQueryProgrammer {
+    const validate: MetadataFactory.Validator;
+}
+export declare namespace HttpHeadersProgrammer {
+    const validate: MetadataFactory.Validator;
+}
+export declare namespace HttpParameterProgrammer {
+    const validate: MetadataFactory.Validator;
+}
+export declare namespace HttpFormDataProgrammer {
+    const validate: MetadataFactory.Validator;
+}
+export declare namespace JsonSchemasProgrammer {
+    /**
+     * Consumes the per-metadata `jsonSchema` field the nestia transform
+     * pre-bakes. Top-level route metadata (success / parameter / exception)
+     * always carries a baked schema; for nested metadata (object property
+     * values reached by the decomposed-query path), the bake is absent and
+     * this function falls back to a minimal JS-side converter that handles
+     * the schema shapes decompose actually emits — atomics, constants,
+     * templates, arrays of those, named references — without re-implementing
+     * the typia native programmer wholesale.
+     */
+    const writeSchemas: (props: {
+        version: "3.0" | "3.1";
+        metadatas: readonly IMetadataSchema[];
+    }) => IJsonSchemaCollection;
+}

package/lib/internal/legacy.js

@@ -0,0 +1,361 @@
+"use strict";
+// nestia-internal namespace of utility functions that fill the surface
+// the legacy `@typia/core` 12.x package exposed at JS runtime. typia v13
+// dropped that package because the equivalent logic lives in the Go-side
+// transform; the nestia native transform now embeds the pre-computed
+// results next to each metadata blob (see `packages/core/native/cmd/
+// ttsc-nestia/sdk_transform.go`), and the helpers here are thin
+// consumers — no runtime class wrapping, no vendored fork.
+//
+// `MetadataComponents.from` is the only utility that performs a real
+// runtime transformation: it walks the aggregated `IMetadataComponents`
+// and indexes each entry by name so the analyzer can resolve
+// cross-reference lookups in O(1). Everything else either reads a
+// pre-baked field or short-circuits because typia's compile-time
+// transform already enforces the invariant.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonSchemasProgrammer = exports.HttpFormDataProgrammer = exports.HttpParameterProgrammer = exports.HttpHeadersProgrammer = exports.HttpQueryProgrammer = exports.JsonMetadataFactory = exports.MetadataFactory = exports.MetadataSchema = exports.MetadataComponents = exports.isSoleLiteralOf = exports.emptyOf = exports.nameOf = exports.sizeOf = void 0;
+// ---------------------------------------------------------------------
+//  Metadata utility functions — read pre-baked fields, no class wrapping.
+// ---------------------------------------------------------------------
+/** `MetadataSchema.size()` → reads the pre-baked `size` field. */
+const sizeOf = (m) => { var _a; return (_a = m.size) !== null && _a !== void 0 ? _a : 0; };
+exports.sizeOf = sizeOf;
+/** `MetadataSchema.getName()` → reads the pre-baked `name` field. */
+const nameOf = (m) => { var _a; return (_a = m.name) !== null && _a !== void 0 ? _a : ""; };
+exports.nameOf = nameOf;
+/** `MetadataSchema.empty()` → reads the pre-baked `empty` field. */
+const emptyOf = (m) => { var _a; return (_a = m.empty) !== null && _a !== void 0 ? _a : false; };
+exports.emptyOf = emptyOf;
+/**
+ * Equivalent of the legacy `MetadataSchema.isSoleLiteral()` method:
+ * `true` when the schema represents exactly one constant literal value
+ * and nothing else. Used by sdk's type printer to fall back to literal
+ * emission instead of a union.
+ */
+const isSoleLiteralOf = (m) => {
+    if (m.any)
+        return false;
+    if (m.nullable)
+        return false;
+    if (m.functions.length !== 0)
+        return false;
+    if (m.atomics.length !== 0)
+        return false;
+    if (m.templates.length !== 0)
+        return false;
+    if (m.arrays.length !== 0)
+        return false;
+    if (m.tuples.length !== 0)
+        return false;
+    if (m.objects.length !== 0)
+        return false;
+    if (m.aliases.length !== 0)
+        return false;
+    if (m.natives.length !== 0)
+        return false;
+    if (m.sets.length !== 0)
+        return false;
+    if (m.maps.length !== 0)
+        return false;
+    if (m.rest !== null)
+        return false;
+    if (m.escaped !== null)
+        return false;
+    if (m.constants.length !== 1)
+        return false;
+    return m.constants[0].values.length === 1;
+};
+exports.isSoleLiteralOf = isSoleLiteralOf;
+// ---------------------------------------------------------------------
+//  `MetadataComponents.from(plain)` — namespace utility, not a class.
+// ---------------------------------------------------------------------
+var MetadataComponents;
+(function (MetadataComponents) {
+    MetadataComponents.from = (plain) => {
+        const dictionary = {
+            objects: new Map(plain.objects.map((o) => [o.name, o])),
+            aliases: new Map(plain.aliases.map((a) => [a.name, a])),
+            arrays: new Map(plain.arrays.map((a) => [a.name, a])),
+            tuples: new Map(plain.tuples.map((t) => [t.name, t])),
+        };
+        return Object.assign({}, plain, { dictionary });
+    };
+})(MetadataComponents || (exports.MetadataComponents = MetadataComponents = {}));
+// ---------------------------------------------------------------------
+//  `MetadataSchema.from(plain, _dictionary)` — passthrough.
+// ---------------------------------------------------------------------
+var MetadataSchema;
+(function (MetadataSchema) {
+    /**
+     * Walks the metadata tree and attaches the resolved `.type` field to
+     * every `IReference` it encounters, using the supplied dictionary as
+     * the lookup index. This is idempotent — references whose `.type`
+     * has already been resolved are left alone — and mutates the input,
+     * matching the in-place resolution model `@typia/core` 12.x used.
+     */
+    MetadataSchema.from = (plain, dictionary) => {
+        if (dictionary !== undefined) {
+            attachTypes(plain, dictionary, new WeakSet());
+        }
+        return plain;
+    };
+})(MetadataSchema || (exports.MetadataSchema = MetadataSchema = {}));
+/**
+ * The walk tracks visited *targets* (the IObjectType / IArrayType / …
+ * instances reached through the dictionary), not the wrapper schemas.
+ * Wrapper schemas are reconstructed on the JS side and are not shared
+ * across recursive references, so a `visited<IMetadataSchema>` set never
+ * matches and the walk would recurse forever on cycles like
+ * `interface Node { children: Node[] }`.
+ */
+const attachTypes = (schema, dict, visited) => {
+    var _a, _b, _c;
+    if (schema === null || schema === undefined)
+        return;
+    attachReferences(schema.arrays, dict.arrays, visited, (target) => attachTypes(target.value, dict, visited));
+    attachReferences(schema.tuples, dict.tuples, visited, (target) => {
+        for (const elem of target.elements)
+            attachTypes(elem, dict, visited);
+    });
+    attachReferences(schema.objects, dict.objects, visited, (target) => {
+        for (const prop of target.properties)
+            attachTypes(prop.value, dict, visited);
+    });
+    attachReferences(schema.aliases, dict.aliases, visited, (target) => attachTypes(target.value, dict, visited));
+    for (const fn of (_a = schema.functions) !== null && _a !== void 0 ? _a : []) {
+        for (const param of fn.parameters)
+            attachTypes(param.type, dict, visited);
+        attachTypes(fn.output, dict, visited);
+    }
+    for (const set of (_b = schema.sets) !== null && _b !== void 0 ? _b : [])
+        attachTypes(set.value, dict, visited);
+    for (const map of (_c = schema.maps) !== null && _c !== void 0 ? _c : []) {
+        attachTypes(map.key, dict, visited);
+        attachTypes(map.value, dict, visited);
+    }
+    if (schema.rest)
+        attachTypes(schema.rest, dict, visited);
+    if (schema.escaped) {
+        attachTypes(schema.escaped.original, dict, visited);
+        attachTypes(schema.escaped.returns, dict, visited);
+    }
+};
+const attachReferences = (refs, index, visited, walk) => {
+    if (!refs)
+        return;
+    for (const ref of refs) {
+        const mutable = ref;
+        if (mutable.type === undefined) {
+            const target = index.get(ref.name);
+            if (target !== undefined)
+                mutable.type = target;
+        }
+        if (mutable.type !== undefined && visited.has(mutable.type) === false) {
+            visited.add(mutable.type);
+            walk(mutable.type);
+        }
+    }
+};
+// ---------------------------------------------------------------------
+//  Validators — the typia native transform already enforces most of the
+//  invariants the legacy `@typia/core` 12.x helpers re-checked at runtime,
+//  but a few JSON-serialization constraints (bare `bigint` payloads, etc.)
+//  are SDK-policy choices that the SDK still has to flag itself.
+// ---------------------------------------------------------------------
+var MetadataFactory;
+(function (MetadataFactory) {
+    /**
+     * Walks the metadata tree once, invoking the provided validator on each
+     * visited node, and accumulates the produced messages into `IError`
+     * entries. The walk skips back-edges through references so cyclic
+     * structures terminate. This is a faithful reimplementation of the
+     * legacy `@typia/core` walker, kept lean: the typia native transform
+     * has already validated structural invariants, so the validator is only
+     * called for SDK-side policy checks (JSON-serializability, query/header
+     * atomic-only rules, …).
+     */
+    MetadataFactory.validate = (props) => {
+        const errors = [];
+        // Tracks visited *targets* (IObjectType / IArrayType / IAliasType /
+        // ITupleType) so recursive schemas like `interface Node { children:
+        // Node[] }` terminate. Wrapper IMetadataSchema instances are not
+        // shared across recursive references, so they cannot stand in for
+        // the visit marker.
+        const visited = new WeakSet();
+        const visit = (metadata, explore) => {
+            var _a, _b;
+            var _c;
+            const messages = props.functor({ metadata, explore });
+            if (messages.length)
+                errors.push({ name: (0, exports.nameOf)(metadata), explore, messages });
+            for (const obj of metadata.objects) {
+                const type = obj.type;
+                if (type === undefined || visited.has(type))
+                    continue;
+                visited.add(type);
+                for (const prop of type.properties)
+                    visit(prop.value, {
+                        object: type,
+                        property: (0, exports.nameOf)(prop.key) || String((_c = (_b = (_a = prop.key.constants[0]) === null || _a === void 0 ? void 0 : _a.values[0]) === null || _b === void 0 ? void 0 : _b.value) !== null && _c !== void 0 ? _c : ""),
+                        parameter: null,
+                        output: explore.output,
+                    });
+            }
+            for (const arr of metadata.arrays) {
+                const type = arr.type;
+                if (type === undefined || visited.has(type))
+                    continue;
+                visited.add(type);
+                visit(type.value, explore);
+            }
+            for (const tuple of metadata.tuples) {
+                const type = tuple.type;
+                if (type === undefined || visited.has(type))
+                    continue;
+                visited.add(type);
+                for (const elem of type.elements)
+                    visit(elem, explore);
+            }
+            for (const alias of metadata.aliases) {
+                const type = alias.type;
+                if (type === undefined || visited.has(type))
+                    continue;
+                visited.add(type);
+                visit(type.value, explore);
+            }
+            if (metadata.escaped) {
+                visit(metadata.escaped.original, explore);
+                visit(metadata.escaped.returns, explore);
+            }
+        };
+        visit(props.metadata, {
+            object: null,
+            property: null,
+            parameter: null,
+            output: false,
+        });
+        return errors;
+    };
+})(MetadataFactory || (exports.MetadataFactory = MetadataFactory = {}));
+var JsonMetadataFactory;
+(function (JsonMetadataFactory) {
+    /**
+     * Rejects metadata that cannot be losslessly JSON-serialized. The typia
+     * native runtime already screens out most structurally invalid types, so
+     * this only adds the JSON-policy bans the legacy `@typia/core` walker
+     * enforced — bare `bigint` payloads, function-typed properties, and
+     * `Map` / `Set` containers that have no canonical JSON representation.
+     */
+    JsonMetadataFactory.validate = (props) => {
+        const messages = [];
+        if (props.metadata.atomics.some((a) => a.type === "bigint"))
+            messages.push("does not allow bigint type in JSON.");
+        if (props.metadata.functions.length !== 0)
+            messages.push("does not allow function type in JSON.");
+        if (props.metadata.sets.length !== 0)
+            messages.push("does not allow Set type in JSON.");
+        if (props.metadata.maps.length !== 0)
+            messages.push("does not allow Map type in JSON.");
+        return messages;
+    };
+})(JsonMetadataFactory || (exports.JsonMetadataFactory = JsonMetadataFactory = {}));
+var HttpQueryProgrammer;
+(function (HttpQueryProgrammer) {
+    HttpQueryProgrammer.validate = () => [];
+})(HttpQueryProgrammer || (exports.HttpQueryProgrammer = HttpQueryProgrammer = {}));
+var HttpHeadersProgrammer;
+(function (HttpHeadersProgrammer) {
+    HttpHeadersProgrammer.validate = () => [];
+})(HttpHeadersProgrammer || (exports.HttpHeadersProgrammer = HttpHeadersProgrammer = {}));
+var HttpParameterProgrammer;
+(function (HttpParameterProgrammer) {
+    HttpParameterProgrammer.validate = () => [];
+})(HttpParameterProgrammer || (exports.HttpParameterProgrammer = HttpParameterProgrammer = {}));
+var HttpFormDataProgrammer;
+(function (HttpFormDataProgrammer) {
+    HttpFormDataProgrammer.validate = () => [];
+})(HttpFormDataProgrammer || (exports.HttpFormDataProgrammer = HttpFormDataProgrammer = {}));
+// ---------------------------------------------------------------------
+//  `JsonSchemasProgrammer.writeSchemas` — consumes the per-metadata
+//  pre-baked `jsonSchema` field the nestia transform emits.
+// ---------------------------------------------------------------------
+var JsonSchemasProgrammer;
+(function (JsonSchemasProgrammer) {
+    /**
+     * Consumes the per-metadata `jsonSchema` field the nestia transform
+     * pre-bakes. Top-level route metadata (success / parameter / exception)
+     * always carries a baked schema; for nested metadata (object property
+     * values reached by the decomposed-query path), the bake is absent and
+     * this function falls back to a minimal JS-side converter that handles
+     * the schema shapes decompose actually emits — atomics, constants,
+     * templates, arrays of those, named references — without re-implementing
+     * the typia native programmer wholesale.
+     */
+    JsonSchemasProgrammer.writeSchemas = (props) => {
+        var _a, _b;
+        const components = { schemas: {} };
+        const schemas = [];
+        for (const m of props.metadatas) {
+            const baked = m.jsonSchema;
+            if (baked !== undefined) {
+                schemas.push(baked.schema);
+                Object.assign(((_a = components.schemas) !== null && _a !== void 0 ? _a : (components.schemas = {})), (_b = baked.components.schemas) !== null && _b !== void 0 ? _b : {});
+            }
+            else {
+                schemas.push(schemaFromMetadata(m));
+            }
+        }
+        return {
+            version: props.version,
+            components,
+            schemas,
+        };
+    };
+})(JsonSchemasProgrammer || (exports.JsonSchemasProgrammer = JsonSchemasProgrammer = {}));
+const schemaFromMetadata = (m) => {
+    const union = [];
+    if (m.nullable)
+        union.push({ type: "null" });
+    for (const atomic of m.atomics)
+        union.push(schemaFromAtomic(atomic));
+    for (const constant of m.constants)
+        for (const value of constant.values)
+            union.push({
+                const: value.value,
+            });
+    for (const tpl of m.templates) {
+        union.push({ type: "string" });
+        void tpl;
+    }
+    for (const arr of m.arrays) {
+        const inner = arr.type;
+        union.push({
+            type: "array",
+            items: inner ? schemaFromMetadata(inner.value) : {},
+        });
+    }
+    for (const obj of m.objects)
+        union.push({
+            $ref: `#/components/schemas/${obj.name}`,
+        });
+    for (const alias of m.aliases)
+        union.push({
+            $ref: `#/components/schemas/${alias.name}`,
+        });
+    if (m.any || union.length === 0)
+        return {};
+    if (union.length === 1)
+        return union[0];
+    return { oneOf: union };
+};
+const schemaFromAtomic = (atomic) => {
+    if (atomic.type === "boolean")
+        return { type: "boolean" };
+    if (atomic.type === "bigint" || atomic.type === "number")
+        return { type: atomic.type === "bigint" ? "integer" : "number" };
+    if (atomic.type === "string")
+        return { type: "string" };
+    return {};
+};
+//# sourceMappingURL=legacy.js.map

package/lib/internal/legacy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"legacy.js","sourceRoot":"","sources":["../../src/internal/legacy.ts"],"names":[],"mappings":"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"}

package/lib/structures/INestiaProject.d.ts

@@ -1,11 +1,9 @@
-import ts from "typescript";
 import { INestiaConfig } from "../INestiaConfig";
 import { INestiaSdkInput } from "./INestiaSdkInput";
 import { IReflectOperationError } from "./IReflectOperationError";
 export interface INestiaProject {
     config: INestiaConfig;
     input: INestiaSdkInput;
-    checker: ts.TypeChecker;
     errors: IReflectOperationError[];
     warnings: IReflectOperationError[];
 }

package/lib/{transformers → structures}/IOperationMetadata.d.ts

@@ -1,7 +1,7 @@
 import { IMetadataComponents, IMetadataSchema, ValidationPipe } from "@typia/interface";
 import { IJsDocTagInfo } from "typia";
-import { IReflectImport } from "../structures/IReflectImport";
-import { IReflectType } from "../structures/IReflectType";
+import { IReflectImport } from "./IReflectImport";
+import { IReflectType } from "./IReflectType";
 export interface IOperationMetadata {
     parameters: IOperationMetadata.IParameter[];
     success: IOperationMetadata.IResponse;
@@ -22,11 +22,6 @@ export declare namespace IOperationMetadata {
         primitive: ValidationPipe<ISchema, IError>;
         resolved: ValidationPipe<ISchema, IError>;
     }
-    interface IException {
-        type: IReflectType | null;
-        imports: IReflectImport[];
-        primitive: ValidationPipe<ISchema, IError>;
-    }
     interface ISchema {
         components: IMetadataComponents;
         metadata: IMetadataSchema;

package/lib/structures/IOperationMetadata.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IOperationMetadata.js","sourceRoot":"","sources":["../../src/structures/IOperationMetadata.ts"],"names":[],"mappings":""}

package/lib/structures/IReflectHttpOperationException.d.ts

@@ -1,4 +1,4 @@
-import { MetadataFactory } from "@typia/core";
+import { MetadataFactory } from "../internal/legacy";
 import { IMetadataComponents, IMetadataSchema } from "@typia/interface";
 import { IReflectType } from "./IReflectType";
 export interface IReflectHttpOperationException {

package/lib/structures/IReflectHttpOperationParameter.d.ts

@@ -1,4 +1,4 @@
-import { MetadataFactory } from "@typia/core";
+import { MetadataFactory } from "../internal/legacy";
 import { IJsDocTagInfo, IMetadataComponents, IMetadataSchema } from "@typia/interface";
 import { IReflectType } from "./IReflectType";
 export type IReflectHttpOperationParameter = IReflectHttpOperationParameter.IBody | IReflectHttpOperationParameter.IHeaders | IReflectHttpOperationParameter.IParam | IReflectHttpOperationParameter.IQuery;

package/lib/structures/IReflectHttpOperationSuccess.d.ts

@@ -1,4 +1,4 @@
-import { MetadataFactory } from "@typia/core";
+import { MetadataFactory } from "../internal/legacy";
 import { IMetadataComponents, IMetadataSchema } from "@typia/interface";
 import { IReflectType } from "./IReflectType";
 export interface IReflectHttpOperationSuccess {

package/lib/structures/IReflectOperationError.d.ts

@@ -1,5 +1,5 @@
 import { IComparable } from "tstl";
-import { IOperationMetadata } from "../transformers/IOperationMetadata";
+import { IOperationMetadata } from "../structures/IOperationMetadata";
 export interface IReflectOperationError {
     file: string;
     class: string;

package/lib/structures/IReflectOperationError.js.map

@@ -1 +1 @@
-{"version":3,"file":"IReflectOperationError.js","sourceRoot":"","sources":["../../src/structures/IReflectOperationError.ts"],"names":[],"mappings":";;;AAWA,IAAiB,sBAAsB,CActC;AAdD,WAAiB,sBAAsB;IACrC,MAAa,GAAG;QACd,YAAmC,KAA6B;YAA7B,UAAK,GAAL,KAAK,CAAwB;QAAG,CAAC;QAE7D,IAAI,CAAC,GAAQ;;YAClB,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI,KAAK,GAAG,CAAC,KAAK,CAAC,IAAI;gBACpC,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,GAAG,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC;iBACrC,IAAI,IAAI,CAAC,KAAK,CAAC,KAAK,KAAK,GAAG,CAAC,KAAK,CAAC,KAAK;gBAC3C,OAAO,IAAI,CAAC,KAAK,CAAC,KAAK,GAAG,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC;iBACvC,IAAI,IAAI,CAAC,KAAK,CAAC,QAAQ,KAAK,GAAG,CAAC,KAAK,CAAC,QAAQ;gBACjD,OAAO,CAAC,MAAA,IAAI,CAAC,KAAK,CAAC,QAAQ,mCAAI,EAAE,CAAC,GAAG,CAAC,MAAA,GAAG,CAAC,KAAK,CAAC,QAAQ,mCAAI,EAAE,CAAC,CAAC;YAClE,OAAO,CAAC,MAAA,IAAI,CAAC,KAAK,CAAC,IAAI,mCAAI,EAAE,CAAC,GAAG,CAAC,MAAA,GAAG,CAAC,KAAK,CAAC,IAAI,mCAAI,EAAE,CAAC,CAAC;QAC1D,CAAC;KACF;IAZY,0BAAG,MAYf,CAAA;AACH,CAAC,EAdgB,sBAAsB,sCAAtB,sBAAsB,QActC"}
+{"version":3,"file":"IReflectOperationError.js","sourceRoot":"","sources":["../../src/structures/IReflectOperationError.ts"],"names":[],"mappings":";;;AAWA,IAAiB,sBAAsB,CActC;AAdD,WAAiB,sBAAsB;IACrC,MAAa,GAAG;QACd,YAAmC,KAA6B;yBAA7B,KAAK;QAA2B,CAAC;QAE7D,IAAI,CAAC,GAAQ;;YAClB,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI,KAAK,GAAG,CAAC,KAAK,CAAC,IAAI;gBACpC,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,GAAG,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC;iBACrC,IAAI,IAAI,CAAC,KAAK,CAAC,KAAK,KAAK,GAAG,CAAC,KAAK,CAAC,KAAK;gBAC3C,OAAO,IAAI,CAAC,KAAK,CAAC,KAAK,GAAG,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC;iBACvC,IAAI,IAAI,CAAC,KAAK,CAAC,QAAQ,KAAK,GAAG,CAAC,KAAK,CAAC,QAAQ;gBACjD,OAAO,OAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,mCAAI,EAAE,CAAC,GAAG,OAAC,GAAG,CAAC,KAAK,CAAC,QAAQ,mCAAI,EAAE,CAAC,CAAC;YAClE,OAAO,OAAC,IAAI,CAAC,KAAK,CAAC,IAAI,mCAAI,EAAE,CAAC,GAAG,OAAC,GAAG,CAAC,KAAK,CAAC,IAAI,mCAAI,EAAE,CAAC,CAAC;QAC1D,CAAC;KACF;IAZY,uBAAA,GAAG,MAYf,CAAA;AACH,CAAC,EAdgB,sBAAsB,aAAtB,sBAAsB,GAAtB,sBAAsB,QActC"}

package/lib/structures/IReflectWebSocketOperation.d.ts

@@ -1,5 +1,5 @@
 import { VERSION_NEUTRAL } from "@nestjs/common";
-import ts from "typescript";
+import { IJsDocTagInfo } from "typia";
 import { IReflectImport } from "./IReflectImport";
 import { IReflectWebSocketOperationParameter } from "./IReflectWebSocketOperationParameter";
 export interface IReflectWebSocketOperation {
@@ -11,5 +11,5 @@ export interface IReflectWebSocketOperation {
     parameters: IReflectWebSocketOperationParameter[];
     imports: IReflectImport[];
     description: string | null;
-    jsDocTags: ts.JSDocTagInfo[];
+    jsDocTags: IJsDocTagInfo[];
 }

package/lib/structures/ITypedApplication.d.ts

@@ -1,4 +1,4 @@
-import { IMetadataDictionary } from "@typia/core";
+import { IMetadataDictionary } from "../internal/legacy";
 import { INestiaProject } from "./INestiaProject";
 import { ITypedHttpRoute } from "./ITypedHttpRoute";
 import { ITypedWebSocketRoute } from "./ITypedWebSocketRoute";