typia 8.0.3 → 8.0.4

package/lib/schemas/json/IJsonApplication.d.mts

@@ -0,0 +1,12 @@
+import { IJsonSchemaCollection } from "./IJsonSchemaCollection";
+/**
+ * Collection of JSON schemas.
+ *
+ * @deprecated Use {@link IJsonSchemaCollection} instead please.
+ *             This interface type would be changed to {@link ILlmApplication} like
+ *             structure in the future version (maybe next v8 major update).
+ * @template Version Version of the OpenAPI specification.
+ * @template Types Original TypeScript types used in the JSON schemas.
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export import IJsonApplication = IJsonSchemaCollection;

package/lib/schemas/json/IJsonSchemaCollection.d.mts

@@ -0,0 +1,23 @@
+import type { OpenApi, OpenApiV3 } from "@samchon/openapi";
+/**
+ * Collection of JSON schemas.
+ *
+ * @template Version Version of the OpenAPI specification.
+ * @template Types Original TypeScript types used in the JSON schemas.
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export type IJsonSchemaCollection<Version extends "3.0" | "3.1" = "3.1", Types = unknown[]> = Version extends "3.0" ? IJsonSchemaCollection.IV3_0<Types> : IJsonSchemaCollection.IV3_1<Types>;
+export declare namespace IJsonSchemaCollection {
+    interface IV3_0<Types = unknown[]> {
+        version: "3.0";
+        schemas: OpenApiV3.IJsonSchema[];
+        components: OpenApiV3.IComponents;
+        __types?: Types | undefined;
+    }
+    interface IV3_1<Types = unknown[]> {
+        version: "3.1";
+        components: OpenApi.IComponents;
+        schemas: OpenApi.IJsonSchema[];
+        __types?: Types | undefined;
+    }
+}

package/lib/schemas/json/__IJsonApplication.d.mts

@@ -0,0 +1,35 @@
+import { OpenApi, OpenApiV3 } from "@samchon/openapi";
+export interface __IJsonApplication<Version extends "3.0" | "3.1" = "3.1", App extends any = object> {
+    version: Version;
+    components: __IJsonApplication.IComponents<__IJsonApplication.Schema<Version>>;
+    functions: __IJsonApplication.IFunction<__IJsonApplication.Schema<Version>>[];
+    __application?: App | undefined;
+}
+export declare namespace __IJsonApplication {
+    type Schema<Version extends "3.0" | "3.1"> = Version extends "3.1" ? OpenApi.IJsonSchema : OpenApiV3.IJsonSchema;
+    interface IComponents<Schema extends OpenApi.IJsonSchema | OpenApiV3.IJsonSchema = OpenApi.IJsonSchema> {
+        schemas?: Record<string, Schema>;
+    }
+    interface IFunction<Schema extends OpenApi.IJsonSchema | OpenApiV3.IJsonSchema = OpenApi.IJsonSchema> {
+        async: boolean;
+        name: string;
+        parameters: IParameter<Schema>[];
+        output: IOutput<Schema> | undefined;
+        summary?: string | undefined;
+        description?: string | undefined;
+        deprecated?: boolean;
+        tags?: string[];
+    }
+    interface IParameter<Schema extends OpenApi.IJsonSchema | OpenApiV3.IJsonSchema = OpenApi.IJsonSchema> {
+        name: string;
+        required: boolean;
+        schema: Schema;
+        title?: string | undefined;
+        description?: string | undefined;
+    }
+    interface IOutput<Schema extends OpenApi.IJsonSchema | OpenApiV3.IJsonSchema = OpenApi.IJsonSchema> {
+        schema: Schema;
+        required: boolean;
+        description?: string | undefined;
+    }
+}

package/lib/schemas/llm/ILlmApplicationOfValidate.d.mts

@@ -0,0 +1,5 @@
+import { ILlmApplication } from "@samchon/openapi";
+/**
+ * @deprecated Use `ILlmApplication` type instead
+ */
+export import ILlmApplicationOfValidate = ILlmApplication;

package/lib/schemas/llm/ILlmFunctionOfValidate.d.mts

@@ -0,0 +1,5 @@
+import { ILlmFunction } from "@samchon/openapi";
+/**
+ * @deprecated Use `ILlmFunction` type instead
+ */
+export import ILlmFunctionOfValidate = ILlmFunction;

package/lib/schemas/metadata/IJsDocTagInfo.d.mts

@@ -0,0 +1,10 @@
+export interface IJsDocTagInfo {
+    name: string;
+    text?: IJsDocTagInfo.IText[];
+}
+export declare namespace IJsDocTagInfo {
+    interface IText {
+        text: string;
+        kind: string;
+    }
+}

package/lib/schemas/metadata/IMetadata.d.mts

@@ -0,0 +1,31 @@
+import { IMetadataAlias } from "./IMetadataAlias";
+import { IMetadataArray } from "./IMetadataArray";
+import { IMetadataAtomic } from "./IMetadataAtomic";
+import { IMetadataConstant } from "./IMetadataConstant";
+import { IMetadataEscaped } from "./IMetadataEscaped";
+import { IMetadataFunction } from "./IMetadataFunction";
+import { IMetadataMap } from "./IMetadataMap";
+import { IMetadataNative } from "./IMetadataNative";
+import { IMetadataObject } from "./IMetadataObject";
+import { IMetadataSet } from "./IMetadataSet";
+import { IMetadataTemplate } from "./IMetadataTemplate";
+import { IMetadataTuple } from "./IMetadataTuple";
+export interface IMetadata {
+    any: boolean;
+    required: boolean;
+    optional: boolean;
+    nullable: boolean;
+    functions: IMetadataFunction[];
+    atomics: IMetadataAtomic[];
+    constants: IMetadataConstant[];
+    templates: IMetadataTemplate[];
+    escaped: IMetadataEscaped | null;
+    rest: IMetadata | null;
+    arrays: IMetadataArray[];
+    tuples: IMetadataTuple[];
+    objects: IMetadataObject[];
+    aliases: IMetadataAlias[];
+    natives: IMetadataNative[];
+    sets: IMetadataSet[];
+    maps: IMetadataMap[];
+}

package/lib/schemas/metadata/IMetadataAlias.d.mts

@@ -0,0 +1,5 @@
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
+export interface IMetadataAlias {
+    name: string;
+    tags: IMetadataTypeTag[][];
+}

package/lib/schemas/metadata/IMetadataAliasType.d.mts

@@ -0,0 +1,10 @@
+import { IJsDocTagInfo } from "./IJsDocTagInfo";
+import { IMetadata } from "./IMetadata";
+export interface IMetadataAliasType {
+    name: string;
+    value: IMetadata;
+    nullables: boolean[];
+    description: string | null;
+    jsDocTags: IJsDocTagInfo[];
+    recursive: boolean;
+}

package/lib/schemas/metadata/IMetadataApplication.d.mts

@@ -0,0 +1,6 @@
+import { IMetadata } from "./IMetadata";
+import { IMetadataComponents } from "./IMetadataComponents";
+export interface IMetadataApplication {
+    metadatas: IMetadata[];
+    components: IMetadataComponents;
+}

package/lib/schemas/metadata/IMetadataArray.d.mts

@@ -0,0 +1,5 @@
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
+export interface IMetadataArray {
+    name: string;
+    tags: IMetadataTypeTag[][];
+}

package/lib/schemas/metadata/IMetadataArrayType.d.mts

@@ -0,0 +1,8 @@
+import { IMetadata } from "./IMetadata";
+export interface IMetadataArrayType {
+    name: string;
+    value: IMetadata;
+    nullables: boolean[];
+    recursive: boolean;
+    index: number | null;
+}

package/lib/schemas/metadata/IMetadataAtomic.d.mts

@@ -0,0 +1,5 @@
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
+export interface IMetadataAtomic {
+    type: "boolean" | "bigint" | "number" | "string";
+    tags: IMetadataTypeTag[][];
+}

package/lib/schemas/metadata/IMetadataComponents.d.mts

@@ -0,0 +1,10 @@
+import { IMetadataAliasType } from "./IMetadataAliasType";
+import { IMetadataArrayType } from "./IMetadataArrayType";
+import { IMetadataObjectType } from "./IMetadataObjectType";
+import { IMetadataTupleType } from "./IMetadataTupleType";
+export interface IMetadataComponents {
+    objects: IMetadataObjectType[];
+    aliases: IMetadataAliasType[];
+    arrays: IMetadataArrayType[];
+    tuples: IMetadataTupleType[];
+}

package/lib/schemas/metadata/IMetadataConstant.d.mts

@@ -0,0 +1,9 @@
+import { Atomic } from "../../typings/Atomic";
+import { IMetadataConstantValue } from "./IMetadataConstantValue";
+export type IMetadataConstant = IMetadataConstant.IBase<"boolean", boolean> | IMetadataConstant.IBase<"number", number> | IMetadataConstant.IBase<"string", string> | IMetadataConstant.IBase<"bigint", string>;
+export declare namespace IMetadataConstant {
+    interface IBase<Type extends Atomic.Literal, Value extends Atomic.Type> {
+        type: Type;
+        values: IMetadataConstantValue<Value>[];
+    }
+}

package/lib/schemas/metadata/IMetadataConstantValue.d.mts

@@ -0,0 +1,9 @@
+import { Atomic } from "../../typings/Atomic";
+import { IJsDocTagInfo } from "./IJsDocTagInfo";
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
+export interface IMetadataConstantValue<T extends Atomic.Type> {
+    value: T;
+    tags: IMetadataTypeTag[][];
+    description?: string | null;
+    jsDocTags?: IJsDocTagInfo[];
+}

package/lib/schemas/metadata/IMetadataDictionary.d.mts

@@ -0,0 +1,10 @@
+import { MetadataAliasType } from "./MetadataAliasType";
+import { MetadataArrayType } from "./MetadataArrayType";
+import { MetadataObjectType } from "./MetadataObjectType";
+import { MetadataTupleType } from "./MetadataTupleType";
+export interface IMetadataDictionary {
+    objects: Map<string, MetadataObjectType>;
+    aliases: Map<string, MetadataAliasType>;
+    arrays: Map<string, MetadataArrayType>;
+    tuples: Map<string, MetadataTupleType>;
+}

package/lib/schemas/metadata/IMetadataEscaped.d.mts

@@ -0,0 +1,5 @@
+import { IMetadata } from "./IMetadata";
+export interface IMetadataEscaped {
+    original: IMetadata;
+    returns: IMetadata;
+}

package/lib/schemas/metadata/IMetadataFunction.d.mts

@@ -0,0 +1,7 @@
+import { IMetadata } from "./IMetadata";
+import { IMetadataParameter } from "./IMetadataParameter";
+export interface IMetadataFunction {
+    parameters: IMetadataParameter[];
+    output: IMetadata;
+    async: boolean;
+}

package/lib/schemas/metadata/IMetadataMap.d.mts

@@ -0,0 +1,7 @@
+import { IMetadata } from "./IMetadata";
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
+export interface IMetadataMap {
+    key: IMetadata;
+    value: IMetadata;
+    tags: IMetadataTypeTag[][];
+}

package/lib/schemas/metadata/IMetadataNative.d.mts

@@ -0,0 +1,5 @@
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
+export interface IMetadataNative {
+    name: string;
+    tags: IMetadataTypeTag[][];
+}

package/lib/schemas/metadata/IMetadataObject.d.mts

@@ -0,0 +1,5 @@
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
+export interface IMetadataObject {
+    name: string;
+    tags: IMetadataTypeTag[][];
+}

package/lib/schemas/metadata/IMetadataObjectType.d.mts

@@ -0,0 +1,11 @@
+import { IJsDocTagInfo } from "./IJsDocTagInfo";
+import { IMetadataProperty } from "./IMetadataProperty";
+export interface IMetadataObjectType {
+    name: string;
+    properties: IMetadataProperty[];
+    description?: undefined | string;
+    jsDocTags: IJsDocTagInfo[];
+    index: number;
+    recursive: boolean;
+    nullables: boolean[];
+}

package/lib/schemas/metadata/IMetadataParameter.d.mts

@@ -0,0 +1,8 @@
+import { IJsDocTagInfo } from "./IJsDocTagInfo";
+import { IMetadata } from "./IMetadata";
+export interface IMetadataParameter {
+    name: string;
+    type: IMetadata;
+    description: string | null;
+    jsDocTags: IJsDocTagInfo[];
+}

package/lib/schemas/metadata/IMetadataProperty.d.mts

@@ -0,0 +1,8 @@
+import { IJsDocTagInfo } from "./IJsDocTagInfo";
+import { IMetadata } from "./IMetadata";
+export interface IMetadataProperty {
+    key: IMetadata;
+    value: IMetadata;
+    description: string | null;
+    jsDocTags: IJsDocTagInfo[];
+}

package/lib/schemas/metadata/IMetadataSet.d.mts

@@ -0,0 +1,6 @@
+import { IMetadata } from "./IMetadata";
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
+export interface IMetadataSet {
+    value: IMetadata;
+    tags: IMetadataTypeTag[][];
+}

package/lib/schemas/metadata/IMetadataTemplate.d.mts

@@ -0,0 +1,6 @@
+import { IMetadata } from "./IMetadata";
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
+export interface IMetadataTemplate {
+    row: IMetadata[];
+    tags: IMetadataTypeTag[][];
+}

package/lib/schemas/metadata/IMetadataTuple.d.mts

@@ -0,0 +1,5 @@
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
+export interface IMetadataTuple {
+    name: string;
+    tags: IMetadataTypeTag[][];
+}

package/lib/schemas/metadata/IMetadataTupleType.d.mts

@@ -0,0 +1,8 @@
+import { IMetadata } from "./IMetadata";
+export interface IMetadataTupleType {
+    name: string;
+    elements: IMetadata[];
+    index: number | null;
+    recursive: boolean;
+    nullables: boolean[];
+}

package/lib/schemas/metadata/IMetadataTypeTag.d.mts

@@ -0,0 +1,9 @@
+export interface IMetadataTypeTag {
+    target: "boolean" | "bigint" | "number" | "string" | "array" | "object";
+    name: string;
+    kind: string;
+    exclusive: boolean | string[];
+    value?: any;
+    validate?: string | undefined;
+    schema?: object | undefined;
+}

package/lib/schemas/metadata/Metadata.d.mts

@@ -0,0 +1,50 @@
+import { IMetadata } from "./IMetadata";
+import { IMetadataDictionary } from "./IMetadataDictionary";
+import { MetadataAlias } from "./MetadataAlias";
+import { MetadataArray } from "./MetadataArray";
+import { MetadataAtomic } from "./MetadataAtomic";
+import { MetadataConstant } from "./MetadataConstant";
+import { MetadataEscaped } from "./MetadataEscaped";
+import { MetadataFunction } from "./MetadataFunction";
+import { MetadataMap } from "./MetadataMap";
+import { MetadataNative } from "./MetadataNative";
+import { MetadataObject } from "./MetadataObject";
+import { MetadataSet } from "./MetadataSet";
+import { MetadataTemplate } from "./MetadataTemplate";
+import { MetadataTuple } from "./MetadataTuple";
+export declare class Metadata {
+    any: boolean;
+    required: boolean;
+    optional: boolean;
+    nullable: boolean;
+    escaped: MetadataEscaped | null;
+    atomics: MetadataAtomic[];
+    constants: MetadataConstant[];
+    templates: MetadataTemplate[];
+    rest: Metadata | null;
+    aliases: MetadataAlias[];
+    arrays: MetadataArray[];
+    tuples: MetadataTuple[];
+    objects: MetadataObject[];
+    functions: MetadataFunction[];
+    natives: MetadataNative[];
+    sets: MetadataSet[];
+    maps: MetadataMap[];
+    /**
+     * @hidden
+     */
+    private constructor();
+    toJSON(): IMetadata;
+    static from(meta: IMetadata, dict: IMetadataDictionary): Metadata;
+    getName(): string;
+    empty(): boolean;
+    size(): number;
+    bucket(): number;
+    isConstant(): boolean;
+    isRequired(): boolean;
+    isSoleLiteral(): boolean;
+}
+export declare namespace Metadata {
+    const intersects: (x: Metadata, y: Metadata) => boolean;
+    const covers: (x: Metadata, y: Metadata, level?: number, escaped?: boolean) => boolean;
+}

package/lib/schemas/metadata/MetadataAlias.d.mts

@@ -0,0 +1,13 @@
+import { ClassProperties } from "../../typings/ClassProperties";
+import { IMetadataAlias } from "./IMetadataAlias";
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
+import { MetadataAliasType } from "./MetadataAliasType";
+export declare class MetadataAlias {
+    readonly type: MetadataAliasType;
+    readonly tags: IMetadataTypeTag[][];
+    private name_?;
+    private constructor();
+    static create(props: ClassProperties<MetadataAlias>): MetadataAlias;
+    getName(): string;
+    toJSON(): IMetadataAlias;
+}

package/lib/schemas/metadata/MetadataAliasType.d.mts

@@ -0,0 +1,16 @@
+import { IJsDocTagInfo } from "./IJsDocTagInfo";
+import { IMetadataAliasType } from "./IMetadataAliasType";
+import { Metadata } from "./Metadata";
+export declare class MetadataAliasType {
+    readonly name: string;
+    readonly value: Metadata;
+    readonly description: string | null;
+    readonly jsDocTags: IJsDocTagInfo[];
+    readonly recursive: boolean;
+    readonly nullables: boolean[];
+    /**
+     * @hidden
+     */
+    private constructor();
+    toJSON(): IMetadataAliasType;
+}

package/lib/schemas/metadata/MetadataApplication.d.mts

@@ -0,0 +1,13 @@
+import { IMetadataApplication } from "./IMetadataApplication";
+import { Metadata } from "./Metadata";
+import { MetadataComponents } from "./MetadataComponents";
+export declare class MetadataApplication {
+    readonly metadatas: Metadata[];
+    readonly components: MetadataComponents;
+    /**
+     * @hidden
+     */
+    private constructor();
+    static from(app: IMetadataApplication): MetadataApplication;
+    toJSON(): IMetadataApplication;
+}

package/lib/schemas/metadata/MetadataArray.d.mts

@@ -0,0 +1,16 @@
+import { ClassProperties } from "../../typings/ClassProperties";
+import { IMetadataArray } from "./IMetadataArray";
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
+import { MetadataArrayType } from "./MetadataArrayType";
+export declare class MetadataArray {
+    readonly type: MetadataArrayType;
+    readonly tags: IMetadataTypeTag[][];
+    private name_?;
+    /**
+     * @hidden
+     */
+    private constructor();
+    static create(props: ClassProperties<MetadataArray>): MetadataArray;
+    getName(): string;
+    toJSON(): IMetadataArray;
+}

package/lib/schemas/metadata/MetadataArrayType.d.mts

@@ -0,0 +1,14 @@
+import { IMetadataArrayType } from "./IMetadataArrayType";
+import { Metadata } from "./Metadata";
+export declare class MetadataArrayType {
+    readonly name: string;
+    readonly value: Metadata;
+    readonly nullables: boolean[];
+    readonly recursive: boolean;
+    readonly index: number | null;
+    /**
+     * @hidden
+     */
+    private constructor();
+    toJSON(): IMetadataArrayType;
+}

package/lib/schemas/metadata/MetadataAtomic.d.mts

@@ -0,0 +1,12 @@
+import { ClassProperties } from "../../typings/ClassProperties";
+import { IMetadataAtomic } from "./IMetadataAtomic";
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
+export declare class MetadataAtomic {
+    readonly type: "boolean" | "bigint" | "number" | "string";
+    readonly tags: IMetadataTypeTag[][];
+    private name_?;
+    static create(props: ClassProperties<MetadataAtomic>): MetadataAtomic;
+    static from(json: IMetadataAtomic): MetadataAtomic;
+    getName(): string;
+    toJSON(): IMetadataAtomic;
+}

package/lib/schemas/metadata/MetadataComponents.d.mts

@@ -0,0 +1,16 @@
+import { IMetadataComponents } from "./IMetadataComponents";
+import { IMetadataDictionary } from "./IMetadataDictionary";
+import { MetadataAliasType } from "./MetadataAliasType";
+import { MetadataArrayType } from "./MetadataArrayType";
+import { MetadataObjectType } from "./MetadataObjectType";
+import { MetadataTupleType } from "./MetadataTupleType";
+export declare class MetadataComponents {
+    readonly aliases: MetadataAliasType[];
+    readonly objects: MetadataObjectType[];
+    readonly arrays: MetadataArrayType[];
+    readonly tuples: MetadataTupleType[];
+    readonly dictionary: IMetadataDictionary;
+    private constructor();
+    static from(json: IMetadataComponents): MetadataComponents;
+    toJSON(): IMetadataComponents;
+}

package/lib/schemas/metadata/MetadataConstant.d.mts

@@ -0,0 +1,11 @@
+import { ClassProperties } from "../../typings/ClassProperties";
+import { IMetadataConstant } from "./IMetadataConstant";
+import { MetadataConstantValue } from "./MetadataConstantValue";
+export declare class MetadataConstant {
+    readonly type: "boolean" | "bigint" | "number" | "string";
+    readonly values: MetadataConstantValue[];
+    private constructor();
+    static create(props: ClassProperties<MetadataConstant>): MetadataConstant;
+    static from(json: IMetadataConstant): MetadataConstant;
+    toJSON(): IMetadataConstant;
+}

package/lib/schemas/metadata/MetadataConstantValue.d.mts

@@ -0,0 +1,16 @@
+import { ClassProperties } from "../../typings/ClassProperties";
+import { IJsDocTagInfo } from "./IJsDocTagInfo";
+import { IMetadataConstantValue } from "./IMetadataConstantValue";
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
+export declare class MetadataConstantValue {
+    readonly value: boolean | bigint | number | string;
+    tags: IMetadataTypeTag[][];
+    readonly description?: string | null;
+    readonly jsDocTags?: IJsDocTagInfo[];
+    private name_?;
+    private constructor();
+    static create(props: ClassProperties<MetadataConstantValue>): MetadataConstantValue;
+    static from(json: IMetadataConstantValue<any>): MetadataConstantValue;
+    getName(): string;
+    toJSON(): IMetadataConstantValue<any>;
+}

package/lib/schemas/metadata/MetadataEscaped.d.mts

@@ -0,0 +1,12 @@
+import { IMetadataEscaped } from "./IMetadataEscaped";
+import { Metadata } from "./Metadata";
+export declare class MetadataEscaped {
+    readonly original: Metadata;
+    readonly returns: Metadata;
+    /**
+     * @hidden
+     */
+    private constructor();
+    getName(): string;
+    toJSON(): IMetadataEscaped;
+}

package/lib/schemas/metadata/MetadataFunction.d.mts

@@ -0,0 +1,15 @@
+import { IMetadataDictionary } from "./IMetadataDictionary";
+import { IMetadataFunction } from "./IMetadataFunction";
+import { Metadata } from "./Metadata";
+import { MetadataParameter } from "./MetadataParameter";
+export declare class MetadataFunction {
+    parameters: MetadataParameter[];
+    output: Metadata;
+    async: boolean;
+    /**
+     * @hidden
+     */
+    private constructor();
+    static from(json: IMetadataFunction, dict: IMetadataDictionary): MetadataFunction;
+    toJSON(): IMetadataFunction;
+}

package/lib/schemas/metadata/MetadataMap.d.mts

@@ -0,0 +1,14 @@
+import { ClassProperties } from "../../typings/ClassProperties";
+import { IMetadataMap } from "./IMetadataMap";
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
+import { Metadata } from "./Metadata";
+export declare class MetadataMap {
+    readonly key: Metadata;
+    readonly value: Metadata;
+    readonly tags: IMetadataTypeTag[][];
+    private name_?;
+    private constructor();
+    static create(props: ClassProperties<MetadataMap>): MetadataMap;
+    getName(): string;
+    toJSON(): IMetadataMap;
+}

package/lib/schemas/metadata/MetadataNative.d.mts

@@ -0,0 +1,12 @@
+import { ClassProperties } from "../../typings/ClassProperties";
+import { IMetadataNative } from "./IMetadataNative";
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
+export declare class MetadataNative {
+    readonly name: string;
+    readonly tags: IMetadataTypeTag[][];
+    private typeName_?;
+    private constructor();
+    static create(props: ClassProperties<MetadataNative>): MetadataNative;
+    getName(): string;
+    toJSON(): IMetadataNative;
+}

package/lib/schemas/metadata/MetadataObject.d.mts

@@ -0,0 +1,16 @@
+import { ClassProperties } from "../../typings/ClassProperties";
+import { IMetadataObject } from "./IMetadataObject";
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
+import { MetadataObjectType } from "./MetadataObjectType";
+export declare class MetadataObject {
+    readonly type: MetadataObjectType;
+    readonly tags: IMetadataTypeTag[][];
+    private name_?;
+    /**
+     * @hidden
+     */
+    private constructor();
+    static create(props: ClassProperties<MetadataObject>): MetadataObject;
+    getName(): string;
+    toJSON(): IMetadataObject;
+}

package/lib/schemas/metadata/MetadataObjectType.d.mts

@@ -0,0 +1,20 @@
+import { IJsDocTagInfo } from "./IJsDocTagInfo";
+import { IMetadataObjectType } from "./IMetadataObjectType";
+import { MetadataProperty } from "./MetadataProperty";
+export declare class MetadataObjectType {
+    readonly name: string;
+    readonly properties: Array<MetadataProperty>;
+    readonly description: string | undefined;
+    readonly jsDocTags: IJsDocTagInfo[];
+    readonly index: number;
+    validated: boolean;
+    recursive: boolean;
+    nullables: boolean[];
+    /**
+     * @hidden
+     */
+    private constructor();
+    isPlain(level?: number): boolean;
+    isLiteral(): boolean;
+    toJSON(): IMetadataObjectType;
+}