typia 8.0.0 → 8.0.1

package/lib/transformers/NodeTransformer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"NodeTransformer.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/transformers/TransformerError.mjs

@@ -0,0 +1,51 @@
+import { Escaper } from '../utils/Escaper.mjs';
+
+class TransformerError extends Error {
+    code;
+    constructor(props) {
+        super(props.message);
+        this.code = props.code;
+        // INHERITANCE POLYFILL
+        const proto = new.target.prototype;
+        if (Object.setPrototypeOf)
+            Object.setPrototypeOf(this, proto);
+        else
+            this.__proto__ = proto;
+    }
+}
+(function (TransformerError) {
+    TransformerError.from = (props) => {
+        const body = props.errors
+            .map((e) => {
+            const subject = e.explore.object === null
+                ? ""
+                : join(e.explore.object)(e.explore.property);
+            const middle = e.explore.parameter
+                ? `(parameter: ${JSON.stringify(e.explore.parameter)})`
+                : e.explore.output
+                    ? "(return type)"
+                    : "";
+            const type = `${subject.length ? `${subject}: ` : ""}${e.name}`;
+            return `- ${type}${middle}\n${e.messages
+                .map((msg) => `  - ${msg}`)
+                .join("\n")}`;
+        })
+            .join("\n\n");
+        return new TransformerError({
+            code: props.code,
+            message: `unsupported type detected\n\n${body}`,
+        });
+    };
+    const join = (object) => (key) => {
+        if (key === null)
+            return object.name;
+        else if (typeof key === "object")
+            return `${object.name}[key]`;
+        else if (Escaper.variable(key))
+            return `${object.name}.${key}`;
+        return `${object.name}[${JSON.stringify(key)}]`;
+    };
+})(TransformerError || (TransformerError = {}));
+
+export { TransformerError };
+//# sourceMappingURL=TransformerError.mjs.map

package/lib/transformers/TransformerError.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"TransformerError.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/transformers/features/AssertTransformer.mjs

@@ -0,0 +1,23 @@
+import { AssertProgrammer } from '../../programmers/AssertProgrammer.mjs';
+import { GenericTransformer } from '../internal/GenericTransformer.mjs';
+
+var AssertTransformer;
+(function (AssertTransformer) {
+    AssertTransformer.transform = (config) => (props) => GenericTransformer.scalar({
+        ...props,
+        method: config.equals
+            ? config.guard
+                ? "assertGuardEquals"
+                : "assertEquals"
+            : config.guard
+                ? "assertGuard"
+                : "assert",
+        write: (x) => AssertProgrammer.write({
+            ...x,
+            config,
+        }),
+    });
+})(AssertTransformer || (AssertTransformer = {}));
+
+export { AssertTransformer };
+//# sourceMappingURL=AssertTransformer.mjs.map

package/lib/transformers/features/AssertTransformer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"AssertTransformer.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/transformers/features/CreateAssertTransformer.mjs

@@ -0,0 +1,23 @@
+import { AssertProgrammer } from '../../programmers/AssertProgrammer.mjs';
+import { GenericTransformer } from '../internal/GenericTransformer.mjs';
+
+var CreateAssertTransformer;
+(function (CreateAssertTransformer) {
+    CreateAssertTransformer.transform = (config) => (props) => GenericTransformer.factory({
+        ...props,
+        method: config.equals
+            ? config.guard
+                ? "assertGuardEquals"
+                : "assertEquals"
+            : config.guard
+                ? "assertGuard"
+                : "assert",
+        write: (x) => AssertProgrammer.write({
+            ...x,
+            config,
+        }),
+    });
+})(CreateAssertTransformer || (CreateAssertTransformer = {}));
+
+export { CreateAssertTransformer };
+//# sourceMappingURL=CreateAssertTransformer.mjs.map

package/lib/transformers/features/CreateAssertTransformer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"CreateAssertTransformer.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/transformers/features/CreateIsTransformer.mjs

@@ -0,0 +1,17 @@
+import { IsProgrammer } from '../../programmers/IsProgrammer.mjs';
+import { GenericTransformer } from '../internal/GenericTransformer.mjs';
+
+var CreateIsTransformer;
+(function (CreateIsTransformer) {
+    CreateIsTransformer.transform = (config) => (props) => GenericTransformer.factory({
+        ...props,
+        method: config.equals ? "equals" : "is",
+        write: (x) => IsProgrammer.write({
+            ...x,
+            config,
+        }),
+    });
+})(CreateIsTransformer || (CreateIsTransformer = {}));
+
+export { CreateIsTransformer };
+//# sourceMappingURL=CreateIsTransformer.mjs.map

package/lib/transformers/features/CreateIsTransformer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"CreateIsTransformer.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/transformers/features/CreateRandomTransformer.mjs

@@ -0,0 +1,40 @@
+import { RandomProgrammer } from '../../programmers/RandomProgrammer.mjs';
+import { TransformerError } from '../TransformerError.mjs';
+
+var CreateRandomTransformer;
+(function (CreateRandomTransformer) {
+    CreateRandomTransformer.transform = (props) => {
+        // CHECK GENERIC ARGUMENT EXISTENCE
+        if (!props.expression.typeArguments?.[0])
+            throw new TransformerError({
+                code: "typia.createRandom",
+                message: "generic argument is not specified.",
+            });
+        // GET TYPE INFO
+        const node = props.expression.typeArguments[0];
+        const type = props.context.checker.getTypeFromTypeNode(node);
+        if (type.isTypeParameter())
+            throw new TransformerError({
+                code: "typia.createRandom",
+                message: "non-specified generic argument.",
+            });
+        // DO TRANSFORM
+        return RandomProgrammer.write({
+            context: {
+                ...props.context,
+                options: {
+                    ...props.context.options,
+                    functional: false,
+                    numeric: false,
+                },
+            },
+            modulo: props.modulo,
+            type,
+            name: node.getFullText().trim(),
+            init: props.expression.arguments?.[0],
+        });
+    };
+})(CreateRandomTransformer || (CreateRandomTransformer = {}));
+
+export { CreateRandomTransformer };
+//# sourceMappingURL=CreateRandomTransformer.mjs.map

package/lib/transformers/features/CreateRandomTransformer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"CreateRandomTransformer.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/transformers/features/CreateValidateTransformer.mjs

@@ -0,0 +1,17 @@
+import { ValidateProgrammer } from '../../programmers/ValidateProgrammer.mjs';
+import { GenericTransformer } from '../internal/GenericTransformer.mjs';
+
+var CreateValidateTransformer;
+(function (CreateValidateTransformer) {
+    CreateValidateTransformer.transform = (config) => (props) => GenericTransformer.factory({
+        ...props,
+        method: config.equals ? "validateEquals" : "validate",
+        write: (x) => ValidateProgrammer.write({
+            ...x,
+            config,
+        }),
+    });
+})(CreateValidateTransformer || (CreateValidateTransformer = {}));
+
+export { CreateValidateTransformer };
+//# sourceMappingURL=CreateValidateTransformer.mjs.map

package/lib/transformers/features/CreateValidateTransformer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"CreateValidateTransformer.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/transformers/features/IsTransformer.mjs

@@ -0,0 +1,17 @@
+import { IsProgrammer } from '../../programmers/IsProgrammer.mjs';
+import { GenericTransformer } from '../internal/GenericTransformer.mjs';
+
+var IsTransformer;
+(function (IsTransformer) {
+    IsTransformer.transform = (config) => (props) => GenericTransformer.scalar({
+        ...props,
+        method: config.equals ? "equals" : "is",
+        write: (x) => IsProgrammer.write({
+            ...x,
+            config,
+        }),
+    });
+})(IsTransformer || (IsTransformer = {}));
+
+export { IsTransformer };
+//# sourceMappingURL=IsTransformer.mjs.map

package/lib/transformers/features/IsTransformer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"IsTransformer.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/transformers/features/RandomTransformer.mjs

@@ -0,0 +1,35 @@
+import ts from 'typescript';
+import { RandomProgrammer } from '../../programmers/RandomProgrammer.mjs';
+import { TransformerError } from '../TransformerError.mjs';
+
+var RandomTransformer;
+(function (RandomTransformer) {
+    RandomTransformer.transform = (props) => {
+        // CHECK GENERIC ARGUMENT EXISTENCE
+        if (!props.expression.typeArguments?.[0])
+            throw new TransformerError({
+                code: `typia.${props.modulo.getText()}`,
+                message: "generic argument is not specified.",
+            });
+        // GET TYPE INFO
+        const node = props.expression.typeArguments[0];
+        const type = props.context.checker.getTypeFromTypeNode(node);
+        if (type.isTypeParameter())
+            throw new TransformerError({
+                code: `typia.${props.modulo.getText()}`,
+                message: "non-specified generic argument.",
+            });
+        return ts.factory.createCallExpression(RandomProgrammer.write({
+            context: props.context,
+            modulo: props.modulo,
+            type,
+            name: node.getFullText().trim(),
+            init: undefined,
+        }), undefined, props.expression.arguments.length
+            ? [props.expression.arguments[0]]
+            : undefined);
+    };
+})(RandomTransformer || (RandomTransformer = {}));
+
+export { RandomTransformer };
+//# sourceMappingURL=RandomTransformer.mjs.map

package/lib/transformers/features/RandomTransformer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"RandomTransformer.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/transformers/features/ValidateTransformer.mjs

@@ -0,0 +1,17 @@
+import { ValidateProgrammer } from '../../programmers/ValidateProgrammer.mjs';
+import { GenericTransformer } from '../internal/GenericTransformer.mjs';
+
+var ValidateTransformer;
+(function (ValidateTransformer) {
+    ValidateTransformer.transform = (config) => (props) => GenericTransformer.scalar({
+        ...props,
+        method: config.equals ? "validateEquals" : "validate",
+        write: (x) => ValidateProgrammer.write({
+            ...x,
+            config,
+        }),
+    });
+})(ValidateTransformer || (ValidateTransformer = {}));
+
+export { ValidateTransformer };
+//# sourceMappingURL=ValidateTransformer.mjs.map

package/lib/transformers/features/ValidateTransformer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ValidateTransformer.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/transformers/features/functional/FunctionalGenericTransformer.mjs

@@ -0,0 +1,33 @@
+import { TypeFactory } from '../../../factories/TypeFactory.mjs';
+import { TransformerError } from '../../TransformerError.mjs';
+
+var FunctionalGenericTransformer;
+(function (FunctionalGenericTransformer) {
+    FunctionalGenericTransformer.transform = (spec) => (props) => {
+        // CHECK PARAMETER
+        if (props.expression.arguments.length === 0)
+            throw new TransformerError({
+                code: `typia.functional.${spec.method}`,
+                message: `no input value.`,
+            });
+        // GET TYPE INFO
+        const type = props.expression.typeArguments && props.expression.typeArguments[0]
+            ? props.context.checker.getTypeFromTypeNode(props.expression.typeArguments[0])
+            : props.context.checker.getTypeAtLocation(props.expression.arguments[0]);
+        if (TypeFactory.isFunction(type) === false)
+            throw new TransformerError({
+                code: `typia.functional.${spec.method}`,
+                message: `input value is not a function.`,
+            });
+        return spec.programmer({
+            ...props,
+            config: spec.config,
+            expression: props.expression.arguments[0],
+            declaration: type.symbol.declarations[0],
+            init: props.expression.arguments[1],
+        });
+    };
+})(FunctionalGenericTransformer || (FunctionalGenericTransformer = {}));
+
+export { FunctionalGenericTransformer };
+//# sourceMappingURL=FunctionalGenericTransformer.mjs.map

package/lib/transformers/features/functional/FunctionalGenericTransformer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"FunctionalGenericTransformer.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/transformers/features/http/CreateHttpAssertFormDataTransformer.mjs

@@ -0,0 +1,14 @@
+import { HttpAssertFormDataProgrammer } from '../../../programmers/http/HttpAssertFormDataProgrammer.mjs';
+import { GenericTransformer } from '../../internal/GenericTransformer.mjs';
+
+var CreateHttpAssertFormDataTransformer;
+(function (CreateHttpAssertFormDataTransformer) {
+    CreateHttpAssertFormDataTransformer.transform = (props) => GenericTransformer.factory({
+        ...props,
+        method: "http.createAssertFormData",
+        write: HttpAssertFormDataProgrammer.write,
+    });
+})(CreateHttpAssertFormDataTransformer || (CreateHttpAssertFormDataTransformer = {}));
+
+export { CreateHttpAssertFormDataTransformer };
+//# sourceMappingURL=CreateHttpAssertFormDataTransformer.mjs.map

package/lib/transformers/features/http/CreateHttpAssertFormDataTransformer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"CreateHttpAssertFormDataTransformer.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/transformers/features/http/CreateHttpAssertHeadersTransformer.mjs

@@ -0,0 +1,14 @@
+import { HttpAssertHeadersProgrammer } from '../../../programmers/http/HttpAssertHeadersProgrammer.mjs';
+import { GenericTransformer } from '../../internal/GenericTransformer.mjs';
+
+var CreateHttpAssertHeadersTransformer;
+(function (CreateHttpAssertHeadersTransformer) {
+    CreateHttpAssertHeadersTransformer.transform = (props) => GenericTransformer.factory({
+        ...props,
+        method: "http.createAssertHeaders",
+        write: HttpAssertHeadersProgrammer.write,
+    });
+})(CreateHttpAssertHeadersTransformer || (CreateHttpAssertHeadersTransformer = {}));
+
+export { CreateHttpAssertHeadersTransformer };
+//# sourceMappingURL=CreateHttpAssertHeadersTransformer.mjs.map

package/lib/transformers/features/http/CreateHttpAssertHeadersTransformer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"CreateHttpAssertHeadersTransformer.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/transformers/features/http/CreateHttpAssertQueryTransformer.mjs

@@ -0,0 +1,14 @@
+import { HttpAssertQueryProgrammer } from '../../../programmers/http/HttpAssertQueryProgrammer.mjs';
+import { GenericTransformer } from '../../internal/GenericTransformer.mjs';
+
+var CreateHttpAssertQueryTransformer;
+(function (CreateHttpAssertQueryTransformer) {
+    CreateHttpAssertQueryTransformer.transform = (props) => GenericTransformer.factory({
+        ...props,
+        method: "http.createAssertQuery",
+        write: HttpAssertQueryProgrammer.write,
+    });
+})(CreateHttpAssertQueryTransformer || (CreateHttpAssertQueryTransformer = {}));
+
+export { CreateHttpAssertQueryTransformer };
+//# sourceMappingURL=CreateHttpAssertQueryTransformer.mjs.map

package/lib/transformers/features/http/CreateHttpAssertQueryTransformer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"CreateHttpAssertQueryTransformer.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/transformers/features/http/CreateHttpFormDataTransformer.mjs

@@ -0,0 +1,14 @@
+import { HttpFormDataProgrammer } from '../../../programmers/http/HttpFormDataProgrammer.mjs';
+import { GenericTransformer } from '../../internal/GenericTransformer.mjs';
+
+var CreateHttpFormDataTransformer;
+(function (CreateHttpFormDataTransformer) {
+    CreateHttpFormDataTransformer.transform = (props) => GenericTransformer.factory({
+        ...props,
+        method: "http.createFormData",
+        write: HttpFormDataProgrammer.write,
+    });
+})(CreateHttpFormDataTransformer || (CreateHttpFormDataTransformer = {}));
+
+export { CreateHttpFormDataTransformer };
+//# sourceMappingURL=CreateHttpFormDataTransformer.mjs.map

package/lib/transformers/features/http/CreateHttpFormDataTransformer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"CreateHttpFormDataTransformer.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/transformers/features/http/CreateHttpHeadersTransformer.mjs

@@ -0,0 +1,14 @@
+import { HttpHeadersProgrammer } from '../../../programmers/http/HttpHeadersProgrammer.mjs';
+import { GenericTransformer } from '../../internal/GenericTransformer.mjs';
+
+var CreateHttpHeadersTransformer;
+(function (CreateHttpHeadersTransformer) {
+    CreateHttpHeadersTransformer.transform = (props) => GenericTransformer.factory({
+        ...props,
+        method: "http.createHeaders",
+        write: HttpHeadersProgrammer.write,
+    });
+})(CreateHttpHeadersTransformer || (CreateHttpHeadersTransformer = {}));
+
+export { CreateHttpHeadersTransformer };
+//# sourceMappingURL=CreateHttpHeadersTransformer.mjs.map

package/lib/transformers/features/http/CreateHttpHeadersTransformer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"CreateHttpHeadersTransformer.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/transformers/features/http/CreateHttpIsFormDataTransformer.mjs

@@ -0,0 +1,14 @@
+import { HttpIsFormDataProgrammer } from '../../../programmers/http/HttpIsFormDataProgrammer.mjs';
+import { GenericTransformer } from '../../internal/GenericTransformer.mjs';
+
+var CreateHttpIsFormDataTransformer;
+(function (CreateHttpIsFormDataTransformer) {
+    CreateHttpIsFormDataTransformer.transform = (props) => GenericTransformer.factory({
+        ...props,
+        method: "http.createIsFormData",
+        write: HttpIsFormDataProgrammer.write,
+    });
+})(CreateHttpIsFormDataTransformer || (CreateHttpIsFormDataTransformer = {}));
+
+export { CreateHttpIsFormDataTransformer };
+//# sourceMappingURL=CreateHttpIsFormDataTransformer.mjs.map

package/lib/transformers/features/http/CreateHttpIsFormDataTransformer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"CreateHttpIsFormDataTransformer.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/transformers/features/http/CreateHttpIsHeadersTransformer.mjs

@@ -0,0 +1,14 @@
+import { HttpIsHeadersProgrammer } from '../../../programmers/http/HttpIsHeadersProgrammer.mjs';
+import { GenericTransformer } from '../../internal/GenericTransformer.mjs';
+
+var CreateHttpIsHeadersTransformer;
+(function (CreateHttpIsHeadersTransformer) {
+    CreateHttpIsHeadersTransformer.transform = (props) => GenericTransformer.factory({
+        ...props,
+        method: "http.createIsHeaders",
+        write: HttpIsHeadersProgrammer.write,
+    });
+})(CreateHttpIsHeadersTransformer || (CreateHttpIsHeadersTransformer = {}));
+
+export { CreateHttpIsHeadersTransformer };
+//# sourceMappingURL=CreateHttpIsHeadersTransformer.mjs.map

package/lib/transformers/features/http/CreateHttpIsHeadersTransformer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"CreateHttpIsHeadersTransformer.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/transformers/features/http/CreateHttpIsQueryTransformer.mjs

@@ -0,0 +1,14 @@
+import { HttpIsQueryProgrammer } from '../../../programmers/http/HttpIsQueryProgrammer.mjs';
+import { GenericTransformer } from '../../internal/GenericTransformer.mjs';
+
+var CreateHttpIsQueryTransformer;
+(function (CreateHttpIsQueryTransformer) {
+    CreateHttpIsQueryTransformer.transform = (props) => GenericTransformer.factory({
+        ...props,
+        method: "http.createIsQuery",
+        write: HttpIsQueryProgrammer.write,
+    });
+})(CreateHttpIsQueryTransformer || (CreateHttpIsQueryTransformer = {}));
+
+export { CreateHttpIsQueryTransformer };
+//# sourceMappingURL=CreateHttpIsQueryTransformer.mjs.map

package/lib/transformers/features/http/CreateHttpIsQueryTransformer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"CreateHttpIsQueryTransformer.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/transformers/features/http/CreateHttpParameterTransformer.mjs

@@ -0,0 +1,14 @@
+import { HttpParameterProgrammer } from '../../../programmers/http/HttpParameterProgrammer.mjs';
+import { GenericTransformer } from '../../internal/GenericTransformer.mjs';
+
+var CreateHttpParameterTransformer;
+(function (CreateHttpParameterTransformer) {
+    CreateHttpParameterTransformer.transform = (props) => GenericTransformer.factory({
+        ...props,
+        method: "http.createParameter",
+        write: HttpParameterProgrammer.write,
+    });
+})(CreateHttpParameterTransformer || (CreateHttpParameterTransformer = {}));
+
+export { CreateHttpParameterTransformer };
+//# sourceMappingURL=CreateHttpParameterTransformer.mjs.map

package/lib/transformers/features/http/CreateHttpParameterTransformer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"CreateHttpParameterTransformer.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/transformers/features/http/CreateHttpQueryTransformer.mjs

@@ -0,0 +1,14 @@
+import { HttpQueryProgrammer } from '../../../programmers/http/HttpQueryProgrammer.mjs';
+import { GenericTransformer } from '../../internal/GenericTransformer.mjs';
+
+var CreateHttpQueryTransformer;
+(function (CreateHttpQueryTransformer) {
+    CreateHttpQueryTransformer.transform = (props) => GenericTransformer.factory({
+        ...props,
+        method: "http.createQuery",
+        write: HttpQueryProgrammer.write,
+    });
+})(CreateHttpQueryTransformer || (CreateHttpQueryTransformer = {}));
+
+export { CreateHttpQueryTransformer };
+//# sourceMappingURL=CreateHttpQueryTransformer.mjs.map

package/lib/transformers/features/http/CreateHttpQueryTransformer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"CreateHttpQueryTransformer.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/transformers/features/http/CreateHttpValidateFormDataTransformer.mjs

@@ -0,0 +1,14 @@
+import { HttpValidateFormDataProgrammer } from '../../../programmers/http/HttpValidateFormDataProgrammer.mjs';
+import { GenericTransformer } from '../../internal/GenericTransformer.mjs';
+
+var CreateHttpValidateFormDataTransformer;
+(function (CreateHttpValidateFormDataTransformer) {
+    CreateHttpValidateFormDataTransformer.transform = (props) => GenericTransformer.factory({
+        ...props,
+        method: "http.createValidateFormData",
+        write: HttpValidateFormDataProgrammer.write,
+    });
+})(CreateHttpValidateFormDataTransformer || (CreateHttpValidateFormDataTransformer = {}));
+
+export { CreateHttpValidateFormDataTransformer };
+//# sourceMappingURL=CreateHttpValidateFormDataTransformer.mjs.map

package/lib/transformers/features/http/CreateHttpValidateFormDataTransformer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"CreateHttpValidateFormDataTransformer.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/transformers/features/http/CreateHttpValidateHeadersTransformer.mjs

@@ -0,0 +1,14 @@
+import { HttpValidateHeadersProgrammer } from '../../../programmers/http/HttpValidateHeadersProgrammer.mjs';
+import { GenericTransformer } from '../../internal/GenericTransformer.mjs';
+
+var CreateHttpValidateHeadersTransformer;
+(function (CreateHttpValidateHeadersTransformer) {
+    CreateHttpValidateHeadersTransformer.transform = (props) => GenericTransformer.factory({
+        ...props,
+        method: "http.createValidateHeaders",
+        write: HttpValidateHeadersProgrammer.write,
+    });
+})(CreateHttpValidateHeadersTransformer || (CreateHttpValidateHeadersTransformer = {}));
+
+export { CreateHttpValidateHeadersTransformer };
+//# sourceMappingURL=CreateHttpValidateHeadersTransformer.mjs.map

package/lib/transformers/features/http/CreateHttpValidateHeadersTransformer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"CreateHttpValidateHeadersTransformer.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/transformers/features/http/CreateHttpValidateQueryTransformer.mjs

@@ -0,0 +1,14 @@
+import { HttpValidateQueryProgrammer } from '../../../programmers/http/HttpValidateQueryProgrammer.mjs';
+import { GenericTransformer } from '../../internal/GenericTransformer.mjs';
+
+var CreateHttpValidateQueryTransformer;
+(function (CreateHttpValidateQueryTransformer) {
+    CreateHttpValidateQueryTransformer.transform = (props) => GenericTransformer.factory({
+        ...props,
+        method: "http.createValidateQuery",
+        write: HttpValidateQueryProgrammer.write,
+    });
+})(CreateHttpValidateQueryTransformer || (CreateHttpValidateQueryTransformer = {}));
+
+export { CreateHttpValidateQueryTransformer };
+//# sourceMappingURL=CreateHttpValidateQueryTransformer.mjs.map

package/lib/transformers/features/http/CreateHttpValidateQueryTransformer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"CreateHttpValidateQueryTransformer.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/transformers/features/http/HttpAssertFormDataTransformer.mjs

@@ -0,0 +1,14 @@
+import { HttpAssertFormDataProgrammer } from '../../../programmers/http/HttpAssertFormDataProgrammer.mjs';
+import { GenericTransformer } from '../../internal/GenericTransformer.mjs';
+
+var HttpAssertFormDataTransformer;
+(function (HttpAssertFormDataTransformer) {
+    HttpAssertFormDataTransformer.transform = (props) => GenericTransformer.scalar({
+        ...props,
+        method: "http.assertFormData",
+        write: HttpAssertFormDataProgrammer.write,
+    });
+})(HttpAssertFormDataTransformer || (HttpAssertFormDataTransformer = {}));
+
+export { HttpAssertFormDataTransformer };
+//# sourceMappingURL=HttpAssertFormDataTransformer.mjs.map

package/lib/transformers/features/http/HttpAssertFormDataTransformer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"HttpAssertFormDataTransformer.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/transformers/features/http/HttpAssertHeadersTransformer.mjs

@@ -0,0 +1,14 @@
+import { HttpAssertHeadersProgrammer } from '../../../programmers/http/HttpAssertHeadersProgrammer.mjs';
+import { GenericTransformer } from '../../internal/GenericTransformer.mjs';
+
+var HttpAssertHeadersTransformer;
+(function (HttpAssertHeadersTransformer) {
+    HttpAssertHeadersTransformer.transform = (props) => GenericTransformer.scalar({
+        ...props,
+        method: "http.assertHeaders",
+        write: HttpAssertHeadersProgrammer.write,
+    });
+})(HttpAssertHeadersTransformer || (HttpAssertHeadersTransformer = {}));
+
+export { HttpAssertHeadersTransformer };
+//# sourceMappingURL=HttpAssertHeadersTransformer.mjs.map

package/lib/transformers/features/http/HttpAssertHeadersTransformer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"HttpAssertHeadersTransformer.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/transformers/features/http/HttpAssertQueryTransformer.mjs

@@ -0,0 +1,14 @@
+import { HttpAssertQueryProgrammer } from '../../../programmers/http/HttpAssertQueryProgrammer.mjs';
+import { GenericTransformer } from '../../internal/GenericTransformer.mjs';
+
+var HttpAssertQueryTransformer;
+(function (HttpAssertQueryTransformer) {
+    HttpAssertQueryTransformer.transform = (props) => GenericTransformer.scalar({
+        ...props,
+        method: "http.assertQuery",
+        write: HttpAssertQueryProgrammer.write,
+    });
+})(HttpAssertQueryTransformer || (HttpAssertQueryTransformer = {}));
+
+export { HttpAssertQueryTransformer };
+//# sourceMappingURL=HttpAssertQueryTransformer.mjs.map

package/lib/transformers/features/http/HttpAssertQueryTransformer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"HttpAssertQueryTransformer.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}