typia 8.0.3 → 8.0.4

package/lib/AssertionGuard.d.mts

@@ -0,0 +1 @@
+export type AssertionGuard<T> = (input: unknown) => asserts input is T;

package/lib/CamelCase.d.mts

@@ -0,0 +1,26 @@
+import { Equal } from "./typings/Equal";
+import { IsTuple } from "./typings/IsTuple";
+import { NativeClass } from "./typings/NativeClass";
+import { ValueOf } from "./typings/ValueOf";
+/**
+ * Camel case type.
+ *
+ * `CamelCase` type is a type that all keys of an object are camelized.
+ *
+ * It also erase every method properties like {@link Resolved} type.
+ *
+ * @template T Target type to be camelized
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export type CamelCase<T> = Equal<T, CamelizeMain<T>> extends true ? T : CamelizeMain<T>;
+type CamelizeMain<T> = T extends [never] ? never : T extends {
+    valueOf(): boolean | bigint | number | string;
+} ? ValueOf<T> : T extends Function ? never : T extends object ? CamelizeObject<T> : T;
+type CamelizeObject<T extends object> = T extends Array<infer U> ? IsTuple<T> extends true ? CamelizeTuple<T> : CamelizeMain<U>[] : T extends Set<infer U> ? Set<CamelizeMain<U>> : T extends Map<infer K, infer V> ? Map<CamelizeMain<K>, CamelizeMain<V>> : T extends WeakSet<any> | WeakMap<any, any> ? never : T extends NativeClass ? T : {
+    [Key in keyof T as CamelizeString<Key & string>]: CamelizeMain<T[Key]>;
+};
+type CamelizeTuple<T extends readonly any[]> = T extends [] ? [] : T extends [infer F] ? [CamelizeMain<F>] : T extends [infer F, ...infer Rest extends readonly any[]] ? [CamelizeMain<F>, ...CamelizeTuple<Rest>] : T extends [(infer F)?] ? [CamelizeMain<F>?] : T extends [(infer F)?, ...infer Rest extends readonly any[]] ? [CamelizeMain<F>?, ...CamelizeTuple<Rest>] : [];
+type CamelizeString<Key extends string> = Key extends `_${infer R}` ? `_${CamelizeString<R>}` : Key extends `${infer _F}_${infer _R}` ? CamelizeSnakeString<Key> : Key extends Uppercase<Key> ? Lowercase<Key> : CamelizePascalString<Key>;
+type CamelizePascalString<Key extends string> = Key extends `${infer F}${infer R}` ? `${Lowercase<F>}${R}` : Key;
+type CamelizeSnakeString<Key extends string> = Key extends `_${infer R}` ? CamelizeSnakeString<R> : Key extends `${infer F}_${infer M}${infer R}` ? M extends "_" ? CamelizeSnakeString<`${F}_${R}`> : `${Lowercase<F>}${Uppercase<M>}${CamelizeSnakeString<R>}` : Lowercase<Key>;
+export {};

package/lib/IRandomGenerator.d.mts

@@ -0,0 +1,40 @@
+import { OpenApi } from "@samchon/openapi";
+export interface IRandomGenerator {
+    boolean(): boolean | undefined;
+    number(schema: OpenApi.IJsonSchema.INumber): number;
+    integer(schema: OpenApi.IJsonSchema.IInteger): number;
+    bigint(schema: OpenApi.IJsonSchema.IInteger): bigint;
+    string(schema: OpenApi.IJsonSchema.IString): string;
+    array<T>(schema: Omit<OpenApi.IJsonSchema.IArray, "items"> & {
+        element: (index: number, count: number) => T;
+    }): T[];
+    pattern(regex: RegExp): string;
+    byte(): string;
+    password(): string;
+    regex(): string;
+    uuid(): string;
+    email(): string;
+    hostname(): string;
+    idnEmail(): string;
+    idnHostname(): string;
+    iri(): string;
+    iriReference(): string;
+    ipv4(): string;
+    ipv6(): string;
+    uri(): string;
+    uriReference(): string;
+    uriTemplate(): string;
+    url(): string;
+    datetime(props?: {
+        minimum?: number;
+        maximum?: number;
+    }): string;
+    date(props?: {
+        minimum?: number;
+        maximum?: number;
+    }): string;
+    time(): string;
+    duration(): string;
+    jsonPointer(): string;
+    relativeJsonPointer(): string;
+}

package/lib/IReadableURLSearchParams.d.mts

@@ -0,0 +1,9 @@
+/**
+ * Interface for a readable URLSearchParams object.
+ *
+ * This interface is a subset of the {@link URLSearchParams} interface,
+ * designed especially for the [Hono.JS](https://hono.dev/) library.
+ *
+ * @author https://github.com/miyaji255
+ */
+export type IReadableURLSearchParams = Pick<URLSearchParams, "get" | "getAll">;

package/lib/IValidation.d.mts

@@ -0,0 +1 @@
+export { IValidation } from "@samchon/openapi";

package/lib/PascalCase.d.mts

@@ -0,0 +1,25 @@
+import { Equal } from "./typings/Equal";
+import { IsTuple } from "./typings/IsTuple";
+import { NativeClass } from "./typings/NativeClass";
+import { ValueOf } from "./typings/ValueOf";
+/**
+ * Pascal case type.
+ *
+ * `PascalCase` type is a type that all keys of an object are pascalized.
+ *
+ * It also erase every method properties like {@link Resolved} type.
+ *
+ * @template T Target type to be pascalized
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export type PascalCase<T> = Equal<T, PascalizeMain<T>> extends true ? T : PascalizeMain<T>;
+type PascalizeMain<T> = T extends [never] ? never : T extends {
+    valueOf(): boolean | bigint | number | string;
+} ? ValueOf<T> : T extends Function ? never : T extends object ? PascalizeObject<T> : T;
+type PascalizeObject<T extends object> = T extends Array<infer U> ? IsTuple<T> extends true ? PascalizeTuple<T> : PascalizeMain<U>[] : T extends Set<infer U> ? Set<PascalizeMain<U>> : T extends Map<infer K, infer V> ? Map<PascalizeMain<K>, PascalizeMain<V>> : T extends WeakSet<any> | WeakMap<any, any> ? never : T extends NativeClass ? T : {
+    [Key in keyof T as PascalizeString<Key & string>]: PascalizeMain<T[Key]>;
+};
+type PascalizeTuple<T extends readonly any[]> = T extends [] ? [] : T extends [infer F] ? [PascalizeMain<F>] : T extends [infer F, ...infer Rest extends readonly any[]] ? [PascalizeMain<F>, ...PascalizeTuple<Rest>] : T extends [(infer F)?] ? [PascalizeMain<F>?] : T extends [(infer F)?, ...infer Rest extends readonly any[]] ? [PascalizeMain<F>?, ...PascalizeTuple<Rest>] : [];
+type PascalizeString<Key extends string> = Key extends `_${infer R}` ? `_${PascalizeString<R>}` : Key extends `${infer _F}_${infer _R}` ? PascalizeSnakeString<Key> : Capitalize<Key>;
+type PascalizeSnakeString<Key extends string> = Key extends `_${infer R}` ? PascalizeSnakeString<R> : Key extends `${infer F}${infer M}_${infer R}` ? `${Uppercase<F>}${Lowercase<M>}${PascalizeSnakeString<R>}` : Key extends `${infer F}${infer R}` ? `${Uppercase<F>}${Lowercase<R>}` : Key;
+export {};

package/lib/Primitive.d.mts

@@ -0,0 +1,49 @@
+import { Equal } from "./typings/Equal";
+import { IsTuple } from "./typings/IsTuple";
+import { NativeClass } from "./typings/NativeClass";
+import { ValueOf } from "./typings/ValueOf";
+import { Format } from "./tags";
+/**
+ * Primitive type of JSON.
+ *
+ * `Primitive<T>` is a TMP (Type Meta Programming) type which converts
+ * its argument as a primitive type within framework JSON.
+ *
+ * If the target argument is a built-in class which returns its origin primitive type
+ * through the `valueOf()` method like the `String` or `Number`, its return type would
+ * be the `string` or `number`. Otherwise, the built-in class does not have the
+ * `valueOf()` method, the return type would be an empty object (`{}`).
+ *
+ * Otherwise, the target argument is a type of custom class, all of its custom method
+ * would be erased and its prototype would be changed to the primitive `object`.
+ * Therefore, return type of the TMP type finally be the primitive object.
+ *
+ * In addition, if the target argument is a type of custom class and it has a special
+ * method `toJSON()`, return type of this `Primitive` would be not `Primitive<Instance>`
+ * but `Primitive<ReturnType<Instance.toJSON>>`.
+ *
+ * Before                  | After
+ * ------------------------|----------------------------------------
+ * `Boolean`               | `boolean`
+ * `Number`                | `number`
+ * `String`                | `string`
+ * `Class`                 | `object`
+ * `Class` with `toJSON()` | `Primitive<ReturnType<Class.toJSON>>`
+ * Native Class            | never
+ * Others                  | No change
+ *
+ * @template T Target argument type.
+ * @author Jeongho Nam - https://github.com/samchon
+ * @author Kyungsu Kang - https://github.com/kakasoo
+ * @author Michael - https://github.com/8471919
+ */
+export type Primitive<T> = Equal<T, PrimitiveMain<T>> extends true ? T : PrimitiveMain<T>;
+type PrimitiveMain<Instance> = Instance extends [never] ? never : ValueOf<Instance> extends bigint ? never : ValueOf<Instance> extends boolean | number | string ? ValueOf<Instance> : Instance extends Function ? never : ValueOf<Instance> extends object ? Instance extends object ? Instance extends Date ? string & Format<"date-time"> : Instance extends IJsonable<infer Raw> ? ValueOf<Raw> extends object ? Raw extends object ? PrimitiveObject<Raw> : never : ValueOf<Raw> : Instance extends Exclude<NativeClass, Date> ? never : PrimitiveObject<Instance> : never : ValueOf<Instance>;
+type PrimitiveObject<Instance extends object> = Instance extends Array<infer T> ? IsTuple<Instance> extends true ? PrimitiveTuple<Instance> : PrimitiveMain<T>[] : {
+    [P in keyof Instance]: PrimitiveMain<Instance[P]>;
+};
+type PrimitiveTuple<T extends readonly any[]> = T extends [] ? [] : T extends [infer F] ? [PrimitiveMain<F>] : T extends [infer F, ...infer Rest extends readonly any[]] ? [PrimitiveMain<F>, ...PrimitiveTuple<Rest>] : T extends [(infer F)?] ? [PrimitiveMain<F>?] : T extends [(infer F)?, ...infer Rest extends readonly any[]] ? [PrimitiveMain<F>?, ...PrimitiveTuple<Rest>] : [];
+interface IJsonable<T> {
+    toJSON(): T;
+}
+export {};

package/lib/Resolved.d.mts

@@ -0,0 +1,39 @@
+import { Equal } from "./typings/Equal";
+import { IsTuple } from "./typings/IsTuple";
+import { NativeClass } from "./typings/NativeClass";
+import { ValueOf } from "./typings/ValueOf";
+/**
+ * Resolved type erased every methods.
+ *
+ * `Resolved` is a type of TMP (Type Meta Programming) type which converts
+ * its argument as a resolved type that erased every method properties.
+ *
+ * If the target argument is a built-in class which returns its origin primitive type
+ * through the `valueOf()` method like the `String` or `Number`, its return type would
+ * be the `string` or `number`. Otherwise, the built-in class does not have the
+ * `valueOf()` method, the return type would be same with the target argument.
+ *
+ * Otherwise, the target argument is a type of custom class, all of its custom methods
+ * would be erased and its prototype would be changed to the primitive `object`.
+ * Therefore, return type of the TMP type finally be the resolved object.
+ *
+ * Before                  | After
+ * ------------------------|----------------------------------------
+ * `Boolean`               | `boolean`
+ * `Number`                | `number`
+ * `BigInt`                | `bigint`
+ * `String`                | `string`
+ * `Class`                 | `interface`
+ * Native Class or Others  | No change
+ *
+ * @template T Target argument type.
+ * @author Jeongho Nam - https://github.com/samchon
+ * @author Kyungsu Kang - https://github.com/kakasoo
+ */
+export type Resolved<T> = Equal<T, ResolvedMain<T>> extends true ? T : ResolvedMain<T>;
+type ResolvedMain<T> = T extends [never] ? never : ValueOf<T> extends boolean | number | bigint | string ? ValueOf<T> : T extends Function ? never : T extends object ? ResolvedObject<T> : ValueOf<T>;
+type ResolvedObject<T extends object> = T extends Array<infer U> ? IsTuple<T> extends true ? ResolvedTuple<T> : ResolvedMain<U>[] : T extends Set<infer U> ? Set<ResolvedMain<U>> : T extends Map<infer K, infer V> ? Map<ResolvedMain<K>, ResolvedMain<V>> : T extends WeakSet<any> | WeakMap<any, any> ? never : T extends NativeClass ? T : {
+    [P in keyof T]: ResolvedMain<T[P]>;
+};
+type ResolvedTuple<T extends readonly any[]> = T extends [] ? [] : T extends [infer F] ? [ResolvedMain<F>] : T extends [infer F, ...infer Rest extends readonly any[]] ? [ResolvedMain<F>, ...ResolvedTuple<Rest>] : T extends [(infer F)?] ? [ResolvedMain<F>?] : T extends [(infer F)?, ...infer Rest extends readonly any[]] ? [ResolvedMain<F>?, ...ResolvedTuple<Rest>] : [];
+export {};

package/lib/SnakeCase.d.mts

@@ -0,0 +1,31 @@
+import { Equal } from "./typings/Equal";
+import { NativeClass } from "./typings/NativeClass";
+import { ValueOf } from "./typings/ValueOf";
+/**
+ * Snake case type.
+ *
+ * `SnakeCase` type is a type that all keys of an object are converted to snake case.
+ *
+ * It also erase every method properties like {@link Resolved} type.
+ *
+ * @template T Target type to be snake cased
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export type SnakeCase<T> = Equal<T, SnakageMain<T>> extends true ? T : SnakageMain<T>;
+type SnakageMain<T> = T extends [never] ? never : T extends {
+    valueOf(): boolean | bigint | number | string;
+} ? ValueOf<T> : T extends Function ? never : T extends object ? SnakageObject<T> : T;
+type SnakageObject<T extends object> = T extends Array<infer U> ? IsTuple<T> extends true ? SnakageTuple<T> : SnakageMain<U>[] : T extends Set<infer U> ? Set<SnakageMain<U>> : T extends Map<infer K, infer V> ? Map<SnakageMain<K>, SnakageMain<V>> : T extends WeakSet<any> | WeakMap<any, any> ? never : T extends NativeClass ? T : {
+    [Key in keyof T as SnakageString<Key & string>]: SnakageMain<T[Key]>;
+};
+type IsTuple<T extends readonly any[] | {
+    length: number;
+}> = [T] extends [
+    never
+] ? false : T extends readonly any[] ? number extends T["length"] ? false : true : false;
+type SnakageTuple<T extends readonly any[]> = T extends [] ? [] : T extends [infer F] ? [SnakageMain<F>] : T extends [infer F, ...infer Rest extends readonly any[]] ? [SnakageMain<F>, ...SnakageTuple<Rest>] : T extends [(infer F)?] ? [SnakageMain<F>?] : T extends [(infer F)?, ...infer Rest extends readonly any[]] ? [SnakageMain<F>?, ...SnakageTuple<Rest>] : [];
+type SnakageString<Key extends string> = Key extends `${infer _}` ? SnakageStringRepeatedly<Key, ""> : Key;
+type SnakageStringRepeatedly<S extends string, Previous extends string> = S extends `${infer First}${infer Second}${infer Rest}` ? `${Underscore<Previous, First>}${Lowercase<First>}${Underscore<First, Second>}${Lowercase<Second>}${SnakageStringRepeatedly<Rest, Second>}` : S extends `${infer First}` ? `${Underscore<Previous, First>}${Lowercase<First>}` : "";
+type Underscore<First extends string, Second extends string> = First extends UpperAlphabetic | "" | "_" ? "" : Second extends UpperAlphabetic ? "_" : "";
+type UpperAlphabetic = "A" | "B" | "C" | "D" | "E" | "F" | "G" | "H" | "I" | "J" | "K" | "L" | "M" | "N" | "O" | "P" | "Q" | "R" | "S" | "T" | "U" | "V" | "W" | "X" | "Y" | "Z";
+export {};

package/lib/TypeGuardError.d.mts

@@ -0,0 +1,17 @@
+export declare class TypeGuardError<T = any> extends Error {
+    readonly method: string;
+    readonly path: string | undefined;
+    readonly expected: string;
+    readonly value: any;
+    protected readonly fake_expected_typed_value_?: T | undefined;
+    constructor(props: TypeGuardError.IProps);
+}
+export declare namespace TypeGuardError {
+    interface IProps {
+        method: string;
+        path?: undefined | string;
+        expected: string;
+        value: any;
+        message?: undefined | string;
+    }
+}

package/lib/executable/TypiaGenerateWizard.d.mts

@@ -0,0 +1,8 @@
+export declare namespace TypiaGenerateWizard {
+    function generate(): Promise<void>;
+    interface IArguments {
+        input: string;
+        output: string;
+        project: string;
+    }
+}

package/lib/executable/TypiaPatchWizard.d.mts

@@ -0,0 +1,4 @@
+export declare namespace TypiaPatchWizard {
+    const main: () => Promise<void>;
+    const patch: () => Promise<void>;
+}

package/lib/executable/TypiaSetupWizard.d.mts

@@ -0,0 +1,7 @@
+export declare namespace TypiaSetupWizard {
+    interface IArguments {
+        manager: "npm" | "pnpm" | "yarn" | "bun";
+        project: string | null;
+    }
+    const setup: () => Promise<void>;
+}

package/lib/executable/setup/ArgumentParser.d.mts

@@ -0,0 +1,7 @@
+import commander from "commander";
+import inquirer from "inquirer";
+import { PackageManager } from "./PackageManager";
+export declare namespace ArgumentParser {
+    type Inquiry<T> = (pack: PackageManager, command: commander.Command, prompt: (opt?: inquirer.StreamOptions) => inquirer.PromptModule, action: (closure: (options: Partial<T>) => Promise<T>) => Promise<T>) => Promise<T>;
+    const parse: <T>(pack: PackageManager, inquiry: (pack: PackageManager, command: commander.Command, prompt: (opt?: inquirer.StreamOptions) => inquirer.PromptModule, action: (closure: (options: Partial<T>) => Promise<T>) => Promise<T>) => Promise<T>) => Promise<T>;
+}

package/lib/executable/setup/CommandExecutor.d.mts

@@ -0,0 +1,3 @@
+export declare namespace CommandExecutor {
+    const run: (str: string) => void;
+}

package/lib/executable/setup/FileRetriever.d.mts

@@ -0,0 +1,7 @@
+export declare namespace FileRetriever {
+    const directory: (props: {
+        file: string;
+        location: string;
+        depth?: number;
+    }) => string | null;
+}

package/lib/executable/setup/PackageManager.d.mts

@@ -0,0 +1,24 @@
+export declare class PackageManager {
+    readonly directory: string;
+    data: Package.Data;
+    manager: Manager;
+    get file(): string;
+    static mount(): Promise<PackageManager>;
+    save(modifier: (data: Package.Data) => void): Promise<void>;
+    install(props: {
+        dev: boolean;
+        modulo: string;
+        version: string;
+    }): boolean;
+    private constructor();
+    private static load;
+}
+export declare namespace Package {
+    interface Data {
+        scripts?: Record<string, string>;
+        dependencies?: Record<string, string>;
+        devDependencies?: Record<string, string>;
+    }
+}
+type Manager = "npm" | "pnpm" | "yarn" | "bun";
+export {};

package/lib/executable/setup/PluginConfigurator.d.mts

@@ -0,0 +1,4 @@
+import { TypiaSetupWizard } from "../TypiaSetupWizard";
+export declare namespace PluginConfigurator {
+    function configure(args: TypiaSetupWizard.IArguments): Promise<void>;
+}

package/lib/executable/typia.d.mts

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+declare const USAGE = "Wrong command has been detected. Use like below:\n\n  npx typia setup \\\n    --manager (npm|pnpm|yarn) \\\n    --project {tsconfig.json file path}\n\n    - npx typia setup\n    - npx typia setup --manager pnpm\n    - npx typia setup --project tsconfig.test.json\n\n  npx typia generate \n    --input {directory} \\\n    --output {directory}\n\n    --npx typia generate --input src/templates --output src/functinoal\n";
+declare const halt: (desc: string) => never;
+declare const main: () => Promise<void>;

package/lib/factories/CommentFactory.d.mts

@@ -0,0 +1,5 @@
+import ts from "typescript";
+export declare namespace CommentFactory {
+    const description: (symbol: ts.Symbol, includeTags?: boolean) => string | undefined;
+    const merge: (comments: ts.SymbolDisplayPart[]) => string;
+}

package/lib/factories/ExpressionFactory.d.mts

@@ -0,0 +1,29 @@
+import ts from "typescript";
+import { ImportProgrammer } from "../programmers/ImportProgrammer";
+export declare namespace ExpressionFactory {
+    const number: (value: number) => ts.PrefixUnaryExpression | ts.NumericLiteral;
+    const bigint: (value: number | bigint) => ts.CallExpression;
+    const isRequired: (input: ts.Expression) => ts.Expression;
+    const isArray: (input: ts.Expression) => ts.Expression;
+    const isObject: (props: {
+        checkNull: boolean;
+        checkArray: boolean;
+        input: ts.Expression;
+    }) => ts.Expression;
+    const isInstanceOf: (type: string, input: ts.Expression) => ts.Expression;
+    const coalesce: (x: ts.Expression, y: ts.Expression) => ts.Expression;
+    const currying: (props: {
+        function: ts.Expression;
+        arguments: ts.Expression[];
+    }) => ts.CallExpression;
+    const selfCall: (body: ts.ConciseBody) => ts.CallExpression;
+    const getEscapedText: (props: {
+        printer: ts.Printer;
+        input: ts.Expression;
+    }) => string;
+    const transpile: (props: {
+        transformer?: ts.TransformationContext;
+        importer?: ImportProgrammer;
+        script: string;
+    }) => (input: ts.Expression) => ts.Expression;
+}

package/lib/factories/IdentifierFactory.d.mts

@@ -0,0 +1,8 @@
+import ts from "typescript";
+export declare namespace IdentifierFactory {
+    const identifier: (name: string) => ts.Identifier | ts.StringLiteral;
+    const access: (input: ts.Expression, key: string, chain?: boolean) => ts.PropertyAccessExpression | ts.ElementAccessExpression;
+    const getName: (input: ts.Expression) => string;
+    const postfix: (str: string) => string;
+    const parameter: (name: string | ts.BindingName, type?: ts.TypeNode | undefined, init?: ts.Expression | ts.PunctuationToken<ts.SyntaxKind.QuestionToken> | undefined) => ts.ParameterDeclaration;
+}

package/lib/factories/JsonMetadataFactory.d.mts

@@ -0,0 +1,19 @@
+import ts from "typescript";
+import { Metadata } from "../schemas/metadata/Metadata";
+import { MetadataCollection } from "./MetadataCollection";
+import { MetadataFactory } from "./MetadataFactory";
+export declare namespace JsonMetadataFactory {
+    interface IProps {
+        method: string;
+        checker: ts.TypeChecker;
+        transformer?: ts.TransformationContext;
+        type: ts.Type;
+        validate?: MetadataFactory.Validator;
+    }
+    interface IOutput {
+        collection: MetadataCollection;
+        metadata: Metadata;
+    }
+    const analyze: (props: IProps) => IOutput;
+    const validate: (meta: Metadata) => string[];
+}

package/lib/factories/LiteralFactory.d.mts

@@ -0,0 +1,4 @@
+import ts from "typescript";
+export declare namespace LiteralFactory {
+    const write: (input: any) => ts.Expression;
+}

package/lib/factories/MetadataCollection.d.mts

@@ -0,0 +1,40 @@
+import ts from "typescript";
+import { IMetadataComponents } from "../schemas/metadata/IMetadataComponents";
+import { Metadata } from "../schemas/metadata/Metadata";
+import { MetadataAliasType } from "../schemas/metadata/MetadataAliasType";
+import { MetadataArrayType } from "../schemas/metadata/MetadataArrayType";
+import { MetadataObjectType } from "../schemas/metadata/MetadataObjectType";
+import { MetadataTupleType } from "../schemas/metadata/MetadataTupleType";
+export declare class MetadataCollection {
+    private options?;
+    private objects_;
+    private object_unions_;
+    private aliases_;
+    private arrays_;
+    private tuples_;
+    private names_;
+    private object_index_;
+    private recursive_array_index_;
+    private recursive_tuple_index_;
+    constructor(options?: Partial<MetadataCollection.IOptions> | undefined);
+    clone(): MetadataCollection;
+    aliases(): MetadataAliasType[];
+    objects(): MetadataObjectType[];
+    unions(): MetadataObjectType[][];
+    arrays(): MetadataArrayType[];
+    tuples(): MetadataTupleType[];
+    private getName;
+    emplace(checker: ts.TypeChecker, type: ts.Type): [MetadataObjectType, boolean];
+    emplaceAlias(checker: ts.TypeChecker, type: ts.Type, symbol: ts.Symbol): [MetadataAliasType, boolean, (meta: Metadata) => void];
+    emplaceArray(checker: ts.TypeChecker, type: ts.Type): [MetadataArrayType, boolean, (meta: Metadata) => void];
+    emplaceTuple(checker: ts.TypeChecker, type: ts.TupleType): [MetadataTupleType, boolean, (elements: Metadata[]) => void];
+    setTupleRecursive(tuple: MetadataTupleType, recursive: boolean): void;
+    toJSON(): IMetadataComponents;
+}
+export declare namespace MetadataCollection {
+    interface IOptions {
+        replace?(str: string): string;
+    }
+    const replace: (str: string) => string;
+    const escape: (str: string) => string;
+}

package/lib/factories/MetadataCommentTagFactory.d.mts

@@ -0,0 +1 @@
+export {};

package/lib/factories/MetadataFactory.d.mts

@@ -0,0 +1,48 @@
+import ts from "typescript";
+import { Metadata } from "../schemas/metadata/Metadata";
+import { MetadataAliasType } from "../schemas/metadata/MetadataAliasType";
+import { MetadataArrayType } from "../schemas/metadata/MetadataArrayType";
+import { MetadataObjectType } from "../schemas/metadata/MetadataObjectType";
+import { MetadataTupleType } from "../schemas/metadata/MetadataTupleType";
+import { ValidationPipe } from "../typings/ValidationPipe";
+import { MetadataCollection } from "./MetadataCollection";
+export declare namespace MetadataFactory {
+    type Validator = (meta: Metadata, explore: IExplore) => string[];
+    interface IProps {
+        checker: ts.TypeChecker;
+        transformer: ts.TransformationContext | undefined;
+        options: IOptions;
+        collection: MetadataCollection;
+        type: ts.Type | null;
+    }
+    interface IOptions {
+        escape: boolean;
+        constant: boolean;
+        absorb: boolean;
+        functional?: boolean;
+        validate?: Validator;
+        onError?: (node: ts.Node | undefined, message: string) => void;
+    }
+    interface IExplore {
+        top: boolean;
+        object: MetadataObjectType | null;
+        property: string | object | null;
+        nested: null | MetadataAliasType | MetadataArrayType | MetadataTupleType;
+        parameter: string | null;
+        output: boolean;
+        escaped: boolean;
+        aliased: boolean;
+    }
+    interface IError {
+        name: string;
+        explore: IExplore;
+        messages: string[];
+    }
+    const analyze: (props: IProps) => ValidationPipe<Metadata, IError>;
+    const validate: (props: {
+        transformer?: ts.TransformationContext;
+        options: IOptions;
+        functor: Validator;
+        metadata: Metadata;
+    }) => IError[];
+}

package/lib/factories/MetadataTypeTagFactory.d.mts

@@ -0,0 +1,20 @@
+import { IMetadataTypeTag } from "../schemas/metadata/IMetadataTypeTag";
+import { MetadataObjectType } from "../schemas/metadata/MetadataObjectType";
+import { MetadataFactory } from "./MetadataFactory";
+export declare namespace MetadataTypeTagFactory {
+    const is: (obj: MetadataObjectType) => boolean;
+    const analyze: (props: {
+        errors: MetadataFactory.IError[];
+        type: "boolean" | "bigint" | "number" | "string" | "array" | "object";
+        objects: MetadataObjectType[];
+        explore: MetadataFactory.IExplore;
+    }) => IMetadataTypeTag[];
+    const validate: (props: {
+        report: (next: {
+            property: string | null;
+            message: string;
+        }) => false;
+        type: "boolean" | "bigint" | "number" | "string" | "array" | "object";
+        tags: IMetadataTypeTag[];
+    }) => boolean;
+}

package/lib/factories/MetadataTypeTagSchemaFactory.d.mts

@@ -0,0 +1,7 @@
+import { MetadataObjectType } from "../schemas/metadata/MetadataObjectType";
+export declare namespace MetadataTypeTagSchemaFactory {
+    const object: (props: {
+        report: (msg: string) => false;
+        object: MetadataObjectType;
+    }) => object | undefined;
+}

package/lib/factories/NumericRangeFactory.d.mts

@@ -0,0 +1,6 @@
+import ts from "typescript";
+import { ProtobufAtomic } from "../typings/ProtobufAtomic";
+export declare namespace NumericRangeFactory {
+    const number: (type: ProtobufAtomic.Numeric, input: ts.Expression) => ts.Expression;
+    const bigint: (type: ProtobufAtomic.BigNumeric, input: ts.Expression) => ts.Expression;
+}

package/lib/factories/ProtobufFactory.d.mts

@@ -0,0 +1,13 @@
+import ts from "typescript";
+import { Metadata } from "../schemas/metadata/Metadata";
+import { MetadataCollection } from "./MetadataCollection";
+export declare namespace ProtobufFactory {
+    interface IProps {
+        method: string;
+        checker: ts.TypeChecker;
+        transformer?: ts.TransformationContext;
+        collection: MetadataCollection;
+        type: ts.Type;
+    }
+    const metadata: (props: IProps) => Metadata;
+}

package/lib/factories/StatementFactory.d.mts

@@ -0,0 +1,19 @@
+import ts from "typescript";
+export declare namespace StatementFactory {
+    const mut: (props: {
+        name: string;
+        type?: ts.TypeNode | undefined;
+        initializer?: ts.Expression | undefined;
+    }) => ts.VariableStatement;
+    const constant: (props: {
+        name: string;
+        type?: ts.TypeNode | undefined;
+        value?: ts.Expression | undefined;
+    }) => ts.VariableStatement;
+    const entry: (props: {
+        key: string;
+        value: string;
+    }) => ts.VariableDeclarationList;
+    const transpile: (script: string) => ts.ExpressionStatement;
+    const block: (expression: ts.Expression) => ts.Block;
+}

package/lib/factories/TemplateFactory.d.mts

@@ -0,0 +1,4 @@
+import ts from "typescript";
+export declare namespace TemplateFactory {
+    const generate: (expressions: ts.Expression[]) => ts.Expression;
+}

package/lib/factories/TypeFactory.d.mts

@@ -0,0 +1,16 @@
+import ts from "typescript";
+export declare namespace TypeFactory {
+    const isFunction: (type: ts.Type) => boolean;
+    const getFunction: (type: ts.Type) => ts.SignatureDeclaration | null;
+    const getReturnTypeOfClassMethod: (props: {
+        checker: ts.TypeChecker;
+        class: ts.Type;
+        function: string;
+    }) => ts.Type | null;
+    const getFullName: (props: {
+        checker: ts.TypeChecker;
+        type: ts.Type;
+        symbol?: ts.Symbol;
+    }) => string;
+    const keyword: (type: "void" | "any" | "unknown" | "boolean" | "number" | "bigint" | "string") => ts.KeywordTypeNode<ts.SyntaxKind.VoidKeyword | ts.SyntaxKind.AnyKeyword | ts.SyntaxKind.BooleanKeyword | ts.SyntaxKind.NumberKeyword | ts.SyntaxKind.StringKeyword | ts.SyntaxKind.UnknownKeyword | ts.SyntaxKind.BigIntKeyword>;
+}

package/lib/factories/ValueFactory.d.mts

@@ -0,0 +1,8 @@
+import ts from "typescript";
+export declare namespace ValueFactory {
+    const NULL: () => ts.NullLiteral;
+    const UNDEFINED: () => ts.Identifier;
+    const BOOLEAN: (value: boolean) => ts.TrueLiteral | ts.FalseLiteral;
+    const INPUT: (str?: string) => ts.Identifier;
+    const TYPEOF: (input: ts.Expression) => ts.TypeOfExpression;
+}

package/lib/factories/internal/metadata/IMetadataIteratorProps.d.mts

@@ -0,0 +1,14 @@
+import ts from "typescript";
+import { Metadata } from "../../../schemas/metadata/Metadata";
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
+export interface IMetadataIteratorProps<Type extends ts.Type = ts.Type> {
+    options: MetadataFactory.IOptions;
+    checker: ts.TypeChecker;
+    collection: MetadataCollection;
+    errors: MetadataFactory.IError[];
+    metadata: Metadata;
+    type: Type;
+    explore: MetadataFactory.IExplore;
+    intersected?: boolean;
+}

package/lib/factories/internal/metadata/MetadataHelper.d.mts

@@ -0,0 +1,4 @@
+import { Metadata } from "../../../schemas/metadata/Metadata";
+export declare namespace MetadataHelper {
+    const literal_to_metadata: (key: string) => Metadata;
+}