typia 8.0.3 → 8.1.0

package/lib/programmers/functional/FunctionalIsReturnProgrammer.d.mts

@@ -0,0 +1,29 @@
+import ts from "typescript";
+import { ITypiaContext } from "../../transformers/ITypiaContext";
+export declare namespace FunctionalIsReturnProgrammer {
+    interface IConfig {
+        equals: boolean;
+    }
+    interface IProps {
+        context: ITypiaContext;
+        modulo: ts.LeftHandSideExpression;
+        config: IConfig;
+        declaration: ts.FunctionDeclaration;
+        expression: ts.Expression;
+        init?: ts.Expression | undefined;
+    }
+    interface IDecomposeProps {
+        context: ITypiaContext;
+        modulo: ts.LeftHandSideExpression;
+        config: IConfig;
+        expression: ts.Expression;
+        declaration: ts.FunctionDeclaration;
+    }
+    interface IDecomposeOutput {
+        async: boolean;
+        functions: ts.Statement[];
+        statements: ts.Statement[];
+    }
+    const write: (props: IProps) => ts.CallExpression;
+    const decompose: (props: IDecomposeProps) => IDecomposeOutput;
+}

package/lib/programmers/functional/FunctionalValidateFunctionProgrammer.d.mts

@@ -0,0 +1,25 @@
+import ts from "typescript";
+import { ITypiaContext } from "../../transformers/ITypiaContext";
+export declare namespace FunctionalValidateFunctionProgrammer {
+    interface IConfig {
+        equals: boolean;
+    }
+    interface IProps {
+        context: ITypiaContext;
+        modulo: ts.LeftHandSideExpression;
+        config: IConfig;
+        declaration: ts.FunctionDeclaration;
+        expression: ts.Expression;
+        init?: ts.Expression | undefined;
+    }
+    const write: (props: IProps) => ts.CallExpression;
+    const hookErrors: (props: {
+        expression: ts.Expression;
+        replacer: ts.Expression;
+    }) => ts.CallExpression;
+    const getReturnTypeNode: (props: {
+        context: ITypiaContext;
+        declaration: ts.FunctionDeclaration;
+        async: boolean;
+    }) => ts.TypeNode | undefined;
+}

package/lib/programmers/functional/FunctionalValidateParametersProgrammer.d.mts

@@ -0,0 +1,27 @@
+import ts from "typescript";
+import { ITypiaContext } from "../../transformers/ITypiaContext";
+export declare namespace FunctionalValidateParametersProgrammer {
+    interface IConfig {
+        equals: boolean;
+    }
+    interface IProps {
+        context: ITypiaContext;
+        modulo: ts.LeftHandSideExpression;
+        config: IConfig;
+        declaration: ts.FunctionDeclaration;
+        expression: ts.Expression;
+        init?: ts.Expression | undefined;
+    }
+    interface IDecomposeProps {
+        context: ITypiaContext;
+        modulo: ts.LeftHandSideExpression;
+        config: IConfig;
+        declaration: ts.FunctionDeclaration;
+    }
+    interface IDecomposeOutput {
+        functions: ts.Statement[];
+        statements: ts.Statement[];
+    }
+    const write: (props: IProps) => ts.CallExpression;
+    const decompose: (props: IDecomposeProps) => IDecomposeOutput;
+}

package/lib/programmers/functional/FunctionalValidateReturnProgrammer.d.mts

@@ -0,0 +1,29 @@
+import ts from "typescript";
+import { ITypiaContext } from "../../transformers/ITypiaContext";
+export declare namespace FunctionalValidateReturnProgrammer {
+    interface IConfig {
+        equals: boolean;
+    }
+    interface IProps {
+        context: ITypiaContext;
+        modulo: ts.LeftHandSideExpression;
+        config: IConfig;
+        declaration: ts.FunctionDeclaration;
+        expression: ts.Expression;
+        init?: ts.Expression | undefined;
+    }
+    interface IDecomposeProps {
+        context: ITypiaContext;
+        modulo: ts.LeftHandSideExpression;
+        config: IConfig;
+        expression: ts.Expression;
+        declaration: ts.FunctionDeclaration;
+    }
+    interface IDecomposeOutput {
+        async: boolean;
+        functions: ts.Statement[];
+        statements: ts.Statement[];
+    }
+    const write: (props: IProps) => ts.CallExpression;
+    const decompose: (props: IDecomposeProps) => IDecomposeOutput;
+}

package/lib/programmers/functional/internal/FunctionalGeneralProgrammer.d.mts

@@ -0,0 +1,12 @@
+import ts from "typescript";
+export declare namespace FunctionalGeneralProgrammer {
+    interface IProps {
+        checker: ts.TypeChecker;
+        declaration: ts.FunctionDeclaration | ts.SignatureDeclaration;
+    }
+    interface IOutput {
+        type: ts.Type;
+        async: boolean;
+    }
+    const getReturnType: (props: IProps) => IOutput;
+}

package/lib/programmers/helpers/AtomicPredicator.d.mts

@@ -0,0 +1,14 @@
+import { Metadata } from "../../schemas/metadata/Metadata";
+import { Atomic } from "../../typings/Atomic";
+export declare namespace AtomicPredicator {
+    const constant: (props: {
+        metadata: Metadata;
+        name: Atomic.Literal;
+    }) => boolean;
+    const atomic: (props: {
+        metadata: Metadata;
+        name: Atomic.Literal;
+    }) => boolean;
+    const native: (name: string) => boolean;
+    const template: (metadata: Metadata) => boolean;
+}

package/lib/programmers/helpers/CloneJoiner.d.mts

@@ -0,0 +1,16 @@
+import ts from "typescript";
+import { IExpressionEntry } from "./IExpressionEntry";
+export declare namespace CloneJoiner {
+    const object: (props: {
+        input: ts.Expression;
+        entries: IExpressionEntry<ts.Expression>[];
+    }) => ts.ConciseBody;
+    const tuple: (props: {
+        elements: ts.Expression[];
+        rest: ts.Expression | null;
+    }) => ts.Expression;
+    const array: (props: {
+        input: ts.Expression;
+        arrow: ts.Expression;
+    }) => ts.CallExpression;
+}

package/lib/programmers/helpers/FunctionProgrammer.d.mts

@@ -0,0 +1,16 @@
+import ts from "typescript";
+export declare class FunctionProgrammer {
+    readonly method: string;
+    private readonly local_;
+    private readonly unions_;
+    private readonly variables_;
+    private sequence_;
+    constructor(method: string);
+    useLocal(name: string): string;
+    hasLocal(name: string): boolean;
+    declare(includeUnions?: boolean): ts.Statement[];
+    declareUnions(): ts.Statement[];
+    increment(): number;
+    emplaceUnion(prefix: string, name: string, factory: () => ts.ArrowFunction): string;
+    emplaceVariable(name: string, value: ts.Expression): ts.Expression;
+}

package/lib/programmers/helpers/HttpMetadataUtil.d.mts

@@ -0,0 +1,5 @@
+import { Metadata } from "../../schemas/metadata/Metadata";
+export declare namespace HttpMetadataUtil {
+    const atomics: (metadata: Metadata) => Set<"boolean" | "bigint" | "number" | "string">;
+    const isUnion: (metadata: Metadata) => boolean;
+}

package/lib/programmers/helpers/ICheckEntry.d.mts

@@ -0,0 +1,12 @@
+import ts from "typescript";
+export interface ICheckEntry {
+    expected: string;
+    expression: ts.Expression | null;
+    conditions: ICheckEntry.ICondition[][];
+}
+export declare namespace ICheckEntry {
+    interface ICondition {
+        expected: string;
+        expression: ts.Expression;
+    }
+}

package/lib/programmers/helpers/IExpressionEntry.d.mts

@@ -0,0 +1,8 @@
+import ts from "typescript";
+import { Metadata } from "../../schemas/metadata/Metadata";
+export interface IExpressionEntry<Expression extends ts.ConciseBody = ts.ConciseBody> {
+    input: ts.Expression;
+    key: Metadata;
+    meta: Metadata;
+    expression: Expression;
+}

package/lib/programmers/helpers/NotationJoiner.d.mts

@@ -0,0 +1,17 @@
+import ts from "typescript";
+import { IExpressionEntry } from "./IExpressionEntry";
+export declare namespace NotationJoiner {
+    const object: (props: {
+        rename: (str: string) => string;
+        input: ts.Expression;
+        entries: IExpressionEntry<ts.Expression>[];
+    }) => ts.ConciseBody;
+    const tuple: (props: {
+        elements: ts.Expression[];
+        rest: ts.Expression | null;
+    }) => ts.Expression;
+    const array: (props: {
+        input: ts.Expression;
+        arrow: ts.Expression;
+    }) => ts.CallExpression;
+}

package/lib/programmers/helpers/OptionPredicator.d.mts

@@ -0,0 +1,7 @@
+import { ITransformOptions } from "../../transformers/ITransformOptions";
+export declare namespace OptionPredicator {
+    const numeric: (options: ITransformOptions) => boolean;
+    const functional: (options: ITransformOptions) => boolean;
+    const finite: (options: ITransformOptions) => boolean;
+    const undefined: (options: ITransformOptions) => boolean;
+}

package/lib/programmers/helpers/ProtobufUtil.d.mts

@@ -0,0 +1,14 @@
+import { IMetadataTypeTag } from "../../schemas/metadata/IMetadataTypeTag";
+import { Metadata } from "../../schemas/metadata/Metadata";
+import { MetadataObjectType } from "../../schemas/metadata/MetadataObjectType";
+import { ProtobufAtomic } from "../../typings/ProtobufAtomic";
+export declare namespace ProtobufUtil {
+    const isStaticObject: (obj: MetadataObjectType) => boolean;
+    const size: (meta: Metadata) => number;
+    const getSequence: (tags: IMetadataTypeTag[]) => number | null;
+    const isUnion: (meta: Metadata) => boolean;
+    const getAtomics: (meta: Metadata, union?: Map<string, number | null>) => Map<string, number | null>;
+    const getNumbers: (meta: Metadata, union?: Map<string, number | null>) => Map<string, number | null>;
+    const getBigints: (meta: Metadata, union?: Map<string, number | null>) => Map<string, number | null>;
+    const compare: (x: ProtobufAtomic, y: ProtobufAtomic) => number;
+}

package/lib/programmers/helpers/ProtobufWire.d.mts

@@ -0,0 +1,29 @@
+export declare const enum ProtobufWire {
+    /**
+     * - integers
+     * - bool
+     * - enum
+     */
+    VARIANT = 0,
+    /**
+     * - fixed64
+     * - sfixed64
+     * - double
+     */
+    I64 = 1,
+    /**
+     * - string
+     * - bytes
+     * - mebedded messages
+     * - packed repeated fields
+     */
+    LEN = 2,
+    START_GROUP = 3,
+    END_GROUP = 4,
+    /**
+     * - fixed
+     * - sfixed32
+     * - float
+     */
+    I32 = 5
+}

package/lib/programmers/helpers/PruneJoiner.d.mts

@@ -0,0 +1,18 @@
+import ts from "typescript";
+import { MetadataObjectType } from "../../schemas/metadata/MetadataObjectType";
+import { IExpressionEntry } from "./IExpressionEntry";
+export declare namespace PruneJoiner {
+    const object: (props: {
+        input: ts.Expression;
+        entries: IExpressionEntry[];
+        object: MetadataObjectType;
+    }) => ts.ConciseBody;
+    const array: (props: {
+        input: ts.Expression;
+        arrow: ts.ArrowFunction;
+    }) => ts.CallExpression;
+    const tuple: (props: {
+        elements: ts.ConciseBody[];
+        rest: ts.ConciseBody | null;
+    }) => ts.Block;
+}

package/lib/programmers/helpers/RandomJoiner.d.mts

@@ -0,0 +1,23 @@
+import { OpenApi } from "@samchon/openapi";
+import ts from "typescript";
+import { Metadata } from "../../schemas/metadata/Metadata";
+import { MetadataArrayType } from "../../schemas/metadata/MetadataArrayType";
+import { MetadataObjectType } from "../../schemas/metadata/MetadataObjectType";
+export declare namespace RandomJoiner {
+    type Decoder = (metadata: Metadata) => ts.Expression;
+    const array: (props: {
+        decode: Decoder;
+        recursive: boolean;
+        expression: ts.Expression;
+        array: MetadataArrayType;
+        schema: Omit<OpenApi.IJsonSchema.IArray, "items"> | undefined;
+    }) => ts.Expression;
+    const tuple: (props: {
+        decode: Decoder;
+        elements: Metadata[];
+    }) => ts.ArrayLiteralExpression;
+    const object: (props: {
+        decode: Decoder;
+        object: MetadataObjectType;
+    }) => ts.ConciseBody;
+}

package/lib/programmers/helpers/StringifyJoinder.d.mts

@@ -0,0 +1,17 @@
+import ts from "typescript";
+import { ITypiaContext } from "../../transformers/ITypiaContext";
+import { IExpressionEntry } from "./IExpressionEntry";
+export declare namespace StringifyJoiner {
+    const object: (props: {
+        context: ITypiaContext;
+        entries: IExpressionEntry<ts.Expression>[];
+    }) => ts.Expression;
+    const array: (props: {
+        input: ts.Expression;
+        arrow: ts.ArrowFunction;
+    }) => ts.Expression;
+    const tuple: (props: {
+        elements: ts.Expression[];
+        rest: ts.Expression | null;
+    }) => ts.Expression;
+}

package/lib/programmers/helpers/StringifyPredicator.d.mts

@@ -0,0 +1,5 @@
+import { Metadata } from "../../schemas/metadata/Metadata";
+export declare namespace StringifyPredicator {
+    const require_escape: (value: string) => boolean;
+    const undefindable: (metadata: Metadata) => boolean;
+}

package/lib/programmers/helpers/UnionExplorer.d.mts

@@ -0,0 +1,79 @@
+import ts from "typescript";
+import { Metadata } from "../../schemas/metadata/Metadata";
+import { MetadataArray } from "../../schemas/metadata/MetadataArray";
+import { MetadataMap } from "../../schemas/metadata/MetadataMap";
+import { MetadataObjectType } from "../../schemas/metadata/MetadataObjectType";
+import { MetadataSet } from "../../schemas/metadata/MetadataSet";
+import { MetadataTuple } from "../../schemas/metadata/MetadataTuple";
+import { FeatureProgrammer } from "../FeatureProgrammer";
+import { check_union_array_like } from "../internal/check_union_array_like";
+export declare namespace UnionExplorer {
+    interface Decoder<T> {
+        (props: {
+            input: ts.Expression;
+            definition: T;
+            explore: FeatureProgrammer.IExplore;
+        }): ts.Expression;
+    }
+    type ObjectCombiner = Decoder<MetadataObjectType[]>;
+    const object: (props: {
+        config: FeatureProgrammer.IConfig;
+        level?: number;
+        objects: MetadataObjectType[];
+        input: ts.Expression;
+        explore: FeatureProgrammer.IExplore;
+    }) => ts.Expression;
+    const tuple: (props: {
+        config: check_union_array_like.IConfig<MetadataTuple, MetadataTuple>;
+        parameters: ts.ParameterDeclaration[];
+        input: ts.Expression;
+        tuples: MetadataTuple[];
+        explore: FeatureProgrammer.IExplore;
+    }) => ts.ArrowFunction;
+    namespace tuple {
+        type IConfig = check_union_array_like.IConfig<MetadataTuple, MetadataTuple>;
+    }
+    const array: (props: {
+        config: array.IConfig;
+        parameters: ts.ParameterDeclaration[];
+        input: ts.Expression;
+        arrays: MetadataArray[];
+        explore: FeatureProgrammer.IExplore;
+    }) => ts.ArrowFunction;
+    namespace array {
+        type IConfig = check_union_array_like.IConfig<MetadataArray, Metadata>;
+    }
+    const array_or_tuple: (props: {
+        config: array_or_tuple.IConfig;
+        parameters: ts.ParameterDeclaration[];
+        input: ts.Expression;
+        definitions: (MetadataArray | MetadataTuple)[];
+        explore: FeatureProgrammer.IExplore;
+    }) => ts.ArrowFunction;
+    namespace array_or_tuple {
+        type IConfig = check_union_array_like.IConfig<MetadataArray | MetadataTuple, Metadata | MetadataTuple>;
+    }
+    const set: (props: {
+        config: set.IConfig;
+        parameters: ts.ParameterDeclaration[];
+        input: ts.Expression;
+        sets: MetadataSet[];
+        explore: FeatureProgrammer.IExplore;
+    }) => ts.ArrowFunction;
+    namespace set {
+        type IConfig = check_union_array_like.IConfig<MetadataArray, Metadata>;
+    }
+    const map: (props: {
+        config: map.IConfig;
+        parameters: ts.ParameterDeclaration[];
+        input: ts.Expression;
+        maps: MetadataMap[];
+        explore: FeatureProgrammer.IExplore;
+    }) => ts.ArrowFunction;
+    namespace map {
+        type IConfig = check_union_array_like.IConfig<MetadataArray, [
+            Metadata,
+            Metadata
+        ]>;
+    }
+}

package/lib/programmers/helpers/UnionPredicator.d.mts

@@ -0,0 +1,11 @@
+import { MetadataObjectType } from "../../schemas/metadata/MetadataObjectType";
+import { MetadataProperty } from "../../schemas/metadata/MetadataProperty";
+export declare namespace UnionPredicator {
+    interface ISpecialized {
+        index: number;
+        object: MetadataObjectType;
+        property: MetadataProperty;
+        neighbor: boolean;
+    }
+    const object: (objects: MetadataObjectType[]) => Array<ISpecialized>;
+}

package/lib/programmers/helpers/disable_function_programmer_declare.d.mts

@@ -0,0 +1,2 @@
+import { FunctionProgrammer } from "./FunctionProgrammer";
+export declare const disable_function_programmer_declare: (functor: FunctionProgrammer) => FunctionProgrammer;

package/lib/programmers/http/HttpAssertFormDataProgrammer.d.mts

@@ -0,0 +1,15 @@
+import ts from "typescript";
+import { IProgrammerProps } from "../../transformers/IProgrammerProps";
+import { ITypiaContext } from "../../transformers/ITypiaContext";
+import { FeatureProgrammer } from "../FeatureProgrammer";
+import { FunctionProgrammer } from "../helpers/FunctionProgrammer";
+export declare namespace HttpAssertFormDataProgrammer {
+    const decompose: (props: {
+        context: ITypiaContext;
+        functor: FunctionProgrammer;
+        type: ts.Type;
+        name: string | undefined;
+        init?: ts.Expression | undefined;
+    }) => FeatureProgrammer.IDecomposed;
+    const write: (props: IProgrammerProps) => ts.CallExpression;
+}

package/lib/programmers/http/HttpAssertHeadersProgrammer.d.mts

@@ -0,0 +1,15 @@
+import ts from "typescript";
+import { IProgrammerProps } from "../../transformers/IProgrammerProps";
+import { ITypiaContext } from "../../transformers/ITypiaContext";
+import { FeatureProgrammer } from "../FeatureProgrammer";
+import { FunctionProgrammer } from "../helpers/FunctionProgrammer";
+export declare namespace HttpAssertHeadersProgrammer {
+    const decompose: (props: {
+        context: ITypiaContext;
+        functor: FunctionProgrammer;
+        type: ts.Type;
+        name: string | undefined;
+        init?: ts.Expression | undefined;
+    }) => FeatureProgrammer.IDecomposed;
+    const write: (props: IProgrammerProps) => ts.CallExpression;
+}

package/lib/programmers/http/HttpAssertQueryProgrammer.d.mts

@@ -0,0 +1,19 @@
+import ts from "typescript";
+import { IProgrammerProps } from "../../transformers/IProgrammerProps";
+import { ITypiaContext } from "../../transformers/ITypiaContext";
+import { FeatureProgrammer } from "../FeatureProgrammer";
+import { FunctionProgrammer } from "../helpers/FunctionProgrammer";
+export declare namespace HttpAssertQueryProgrammer {
+    interface IProps extends IProgrammerProps {
+        allowOptional?: boolean;
+    }
+    const decompose: (props: {
+        context: ITypiaContext;
+        functor: FunctionProgrammer;
+        type: ts.Type;
+        name: string | undefined;
+        init?: ts.Expression | undefined;
+        allowOptional: boolean;
+    }) => FeatureProgrammer.IDecomposed;
+    const write: (props: IProps) => ts.CallExpression;
+}

package/lib/programmers/http/HttpFormDataProgrammer.d.mts

@@ -0,0 +1,17 @@
+import ts from "typescript";
+import { MetadataFactory } from "../../factories/MetadataFactory";
+import { Metadata } from "../../schemas/metadata/Metadata";
+import { IProgrammerProps } from "../../transformers/IProgrammerProps";
+import { ITypiaContext } from "../../transformers/ITypiaContext";
+import { FeatureProgrammer } from "../FeatureProgrammer";
+import { FunctionProgrammer } from "../helpers/FunctionProgrammer";
+export declare namespace HttpFormDataProgrammer {
+    const decompose: (props: {
+        context: ITypiaContext;
+        functor: FunctionProgrammer;
+        type: ts.Type;
+        name: string | undefined;
+    }) => FeatureProgrammer.IDecomposed;
+    const write: (props: IProgrammerProps) => ts.CallExpression;
+    const validate: (meta: Metadata, explore: MetadataFactory.IExplore) => string[];
+}

package/lib/programmers/http/HttpHeadersProgrammer.d.mts

@@ -0,0 +1,18 @@
+import ts from "typescript";
+import { MetadataFactory } from "../../factories/MetadataFactory";
+import { Metadata } from "../../schemas/metadata/Metadata";
+import { IProgrammerProps } from "../../transformers/IProgrammerProps";
+import { ITypiaContext } from "../../transformers/ITypiaContext";
+import { FeatureProgrammer } from "../FeatureProgrammer";
+import { FunctionProgrammer } from "../helpers/FunctionProgrammer";
+export declare namespace HttpHeadersProgrammer {
+    const INPUT_TYPE = "Record<string, string | string[] | undefined>";
+    const decompose: (props: {
+        context: ITypiaContext;
+        functor: FunctionProgrammer;
+        type: ts.Type;
+        name: string | undefined;
+    }) => FeatureProgrammer.IDecomposed;
+    const write: (props: IProgrammerProps) => ts.CallExpression;
+    const validate: (metadata: Metadata, explore: MetadataFactory.IExplore) => string[];
+}

package/lib/programmers/http/HttpIsFormDataProgrammer.d.mts

@@ -0,0 +1,14 @@
+import ts from "typescript";
+import { IProgrammerProps } from "../../transformers/IProgrammerProps";
+import { ITypiaContext } from "../../transformers/ITypiaContext";
+import { FeatureProgrammer } from "../FeatureProgrammer";
+import { FunctionProgrammer } from "../helpers/FunctionProgrammer";
+export declare namespace HttpIsFormDataProgrammer {
+    const decompose: (props: {
+        context: ITypiaContext;
+        functor: FunctionProgrammer;
+        type: ts.Type;
+        name: string | undefined;
+    }) => FeatureProgrammer.IDecomposed;
+    const write: (props: IProgrammerProps) => ts.CallExpression;
+}

package/lib/programmers/http/HttpIsHeadersProgrammer.d.mts

@@ -0,0 +1,14 @@
+import ts from "typescript";
+import { IProgrammerProps } from "../../transformers/IProgrammerProps";
+import { ITypiaContext } from "../../transformers/ITypiaContext";
+import { FeatureProgrammer } from "../FeatureProgrammer";
+import { FunctionProgrammer } from "../helpers/FunctionProgrammer";
+export declare namespace HttpIsHeadersProgrammer {
+    const decompose: (props: {
+        context: ITypiaContext;
+        functor: FunctionProgrammer;
+        type: ts.Type;
+        name: string | undefined;
+    }) => FeatureProgrammer.IDecomposed;
+    const write: (props: IProgrammerProps) => ts.CallExpression;
+}

package/lib/programmers/http/HttpIsQueryProgrammer.d.mts

@@ -0,0 +1,18 @@
+import ts from "typescript";
+import { IProgrammerProps } from "../../transformers/IProgrammerProps";
+import { ITypiaContext } from "../../transformers/ITypiaContext";
+import { FeatureProgrammer } from "../FeatureProgrammer";
+import { FunctionProgrammer } from "../helpers/FunctionProgrammer";
+export declare namespace HttpIsQueryProgrammer {
+    interface IProps extends IProgrammerProps {
+        allowOptional?: boolean;
+    }
+    const decompose: (props: {
+        context: ITypiaContext;
+        functor: FunctionProgrammer;
+        type: ts.Type;
+        name: string | undefined;
+        allowOptional: boolean;
+    }) => FeatureProgrammer.IDecomposed;
+    const write: (props: IProps) => ts.CallExpression;
+}

package/lib/programmers/http/HttpParameterProgrammer.d.mts

@@ -0,0 +1,7 @@
+import ts from "typescript";
+import { Metadata } from "../../schemas/metadata/Metadata";
+import { IProgrammerProps } from "../../transformers/IProgrammerProps";
+export declare namespace HttpParameterProgrammer {
+    const write: (props: IProgrammerProps) => ts.ArrowFunction;
+    const validate: (meta: Metadata) => string[];
+}

package/lib/programmers/http/HttpQueryProgrammer.d.mts

@@ -0,0 +1,21 @@
+import ts from "typescript";
+import { MetadataFactory } from "../../factories/MetadataFactory";
+import { Metadata } from "../../schemas/metadata/Metadata";
+import { IProgrammerProps } from "../../transformers/IProgrammerProps";
+import { ITypiaContext } from "../../transformers/ITypiaContext";
+import { FeatureProgrammer } from "../FeatureProgrammer";
+import { FunctionProgrammer } from "../helpers/FunctionProgrammer";
+export declare namespace HttpQueryProgrammer {
+    interface IProps extends IProgrammerProps {
+        allowOptional?: boolean;
+    }
+    const decompose: (props: {
+        context: ITypiaContext;
+        functor: FunctionProgrammer;
+        allowOptional: boolean;
+        type: ts.Type;
+        name: string | undefined;
+    }) => FeatureProgrammer.IDecomposed;
+    const write: (props: IProps) => ts.CallExpression;
+    const validate: (meta: Metadata, explore: MetadataFactory.IExplore, allowOptional?: boolean) => string[];
+}

package/lib/programmers/http/HttpValidateFormDataProgrammer.d.mts

@@ -0,0 +1,15 @@
+import ts from "typescript";
+import { IProgrammerProps } from "../../transformers/IProgrammerProps";
+import { ITypiaContext } from "../../transformers/ITypiaContext";
+import { FeatureProgrammer } from "../FeatureProgrammer";
+import { FunctionProgrammer } from "../helpers/FunctionProgrammer";
+export declare namespace HttpValidateFormDataProgrammer {
+    const decompose: (props: {
+        context: ITypiaContext;
+        modulo: ts.LeftHandSideExpression;
+        functor: FunctionProgrammer;
+        type: ts.Type;
+        name: string | undefined;
+    }) => FeatureProgrammer.IDecomposed;
+    const write: (props: IProgrammerProps) => ts.CallExpression;
+}

package/lib/programmers/http/HttpValidateHeadersProgrammer.d.mts

@@ -0,0 +1,15 @@
+import ts from "typescript";
+import { IProgrammerProps } from "../../transformers/IProgrammerProps";
+import { ITypiaContext } from "../../transformers/ITypiaContext";
+import { FeatureProgrammer } from "../FeatureProgrammer";
+import { FunctionProgrammer } from "../helpers/FunctionProgrammer";
+export declare namespace HttpValidateHeadersProgrammer {
+    const decompose: (props: {
+        context: ITypiaContext;
+        modulo: ts.LeftHandSideExpression;
+        functor: FunctionProgrammer;
+        type: ts.Type;
+        name: string | undefined;
+    }) => FeatureProgrammer.IDecomposed;
+    const write: (props: IProgrammerProps) => ts.CallExpression;
+}