typia 8.0.0 → 8.0.1

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

package/lib/transformers/features/json/JsonApplicationTransformer.mjs

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=JsonApplicationTransformer.mjs.map

package/lib/transformers/features/json/JsonApplicationTransformer.mjs.map

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

package/lib/transformers/features/json/JsonAssertParseTransformer.mjs

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

package/lib/transformers/features/json/JsonAssertParseTransformer.mjs.map

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

package/lib/transformers/features/json/JsonAssertStringifyTransformer.mjs

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

package/lib/transformers/features/json/JsonAssertStringifyTransformer.mjs.map

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

package/lib/transformers/features/json/JsonCreateAssertParseTransformer.mjs

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

package/lib/transformers/features/json/JsonCreateAssertParseTransformer.mjs.map

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

package/lib/transformers/features/json/JsonCreateAssertStringifyTransformer.mjs

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

package/lib/transformers/features/json/JsonCreateAssertStringifyTransformer.mjs.map

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

package/lib/transformers/features/json/JsonCreateIsParseTransformer.mjs

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

package/lib/transformers/features/json/JsonCreateIsParseTransformer.mjs.map

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

package/lib/transformers/features/json/JsonCreateIsStringifyTransformer.mjs

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

package/lib/transformers/features/json/JsonCreateIsStringifyTransformer.mjs.map

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

package/lib/transformers/features/json/JsonCreateStringifyTransformer.mjs

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

package/lib/transformers/features/json/JsonCreateStringifyTransformer.mjs.map

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

package/lib/transformers/features/json/JsonCreateValidateParseTransformer.mjs

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

package/lib/transformers/features/json/JsonCreateValidateParseTransformer.mjs.map

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

package/lib/transformers/features/json/JsonCreateValidateStringifyProgrammer.mjs

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

package/lib/transformers/features/json/JsonCreateValidateStringifyProgrammer.mjs.map

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

package/lib/transformers/features/json/JsonIsParseTransformer.mjs

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

package/lib/transformers/features/json/JsonIsParseTransformer.mjs.map

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

package/lib/transformers/features/json/JsonIsStringifyTransformer.mjs

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

package/lib/transformers/features/json/JsonIsStringifyTransformer.mjs.map

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

package/lib/transformers/features/json/JsonSchemasTransformer.mjs

@@ -0,0 +1,113 @@
+import ts from 'typescript';
+import { LiteralFactory } from '../../../factories/LiteralFactory.mjs';
+import { MetadataCollection } from '../../../factories/MetadataCollection.mjs';
+import { MetadataFactory } from '../../../factories/MetadataFactory.mjs';
+import { JsonSchemasProgrammer } from '../../../programmers/json/JsonSchemasProgrammer.mjs';
+import { TransformerError } from '../../TransformerError.mjs';
+
+var JsonSchemasTransformer;
+(function (JsonSchemasTransformer) {
+    JsonSchemasTransformer.transform = (props) => {
+        if (!props.expression.typeArguments?.length)
+            throw new TransformerError({
+                code: "typia.json.application",
+                message: "no generic argument.",
+            });
+        //----
+        // GET ARGUMENTS
+        //----
+        // VALIDATE TUPLE ARGUMENTS
+        const top = props.expression.typeArguments[0];
+        if (!ts.isTupleTypeNode(top))
+            return props.expression;
+        else if (top.elements.some((child) => !ts.isTypeNode(child)))
+            return props.expression;
+        // GET TYPES
+        const types = top.elements.map((child) => props.context.checker.getTypeFromTypeNode(child));
+        if (types.some((t) => t.isTypeParameter()))
+            throw new TransformerError({
+                code: "typia.json.application",
+                message: "non-specified generic argument(s).",
+            });
+        // ADDITIONAL PARAMETERS
+        const version = get_parameter({
+            checker: props.context.checker,
+            name: "Version",
+            is: (str) => str === "3.0" || str === "3.1",
+            cast: (str) => str,
+            default: () => "3.1",
+        })(props.expression.typeArguments[1]);
+        //----
+        // GENERATORS
+        //----
+        // METADATA
+        const analyze = (validate) => {
+            const results = types.map((type) => MetadataFactory.analyze({
+                checker: props.context.checker,
+                transformer: props.context.transformer,
+                options: {
+                    absorb: validate,
+                    constant: true,
+                    escape: true,
+                    validate: validate === true ? JsonSchemasProgrammer.validate : undefined,
+                },
+                collection: new MetadataCollection({
+                    replace: MetadataCollection.replace,
+                }),
+                type,
+            }));
+            const metadatas = [];
+            const errors = [];
+            for (const r of results) {
+                if (r.success === false)
+                    errors.push(...r.errors);
+                else
+                    metadatas.push(r.data);
+            }
+            if (errors.length)
+                throw TransformerError.from({
+                    code: "typia.json.application",
+                    errors,
+                });
+            return metadatas;
+        };
+        analyze(true);
+        // APPLICATION
+        const app = JsonSchemasProgrammer.write({
+            version,
+            metadatas: analyze(false),
+        });
+        return ts.factory.createAsExpression(LiteralFactory.write(app), props.context.importer.type({
+            file: "typia",
+            name: "IJsonSchemaCollection",
+            arguments: [
+                ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(version)),
+            ],
+        }));
+    };
+    const get_parameter = (props) => (node) => {
+        if (!node)
+            return props.default();
+        // CHECK LITERAL TYPE
+        const type = props.checker.getTypeFromTypeNode(node);
+        if (!type.isLiteral() &&
+            (type.getFlags() & ts.TypeFlags.BooleanLiteral) === 0)
+            throw new TransformerError({
+                code: "typia.json.application",
+                message: `generic argument "${props.name}" must be constant.`,
+            });
+        // GET VALUE AND VALIDATE IT
+        const value = type.isLiteral()
+            ? type.value
+            : props.checker.typeToString(type);
+        if (typeof value !== "string" || props.is(value) === false)
+            throw new TransformerError({
+                code: "typia.json.application",
+                message: `invalid value on generic argument "${props.name}".`,
+            });
+        return props.cast(value);
+    };
+})(JsonSchemasTransformer || (JsonSchemasTransformer = {}));
+
+export { JsonSchemasTransformer };
+//# sourceMappingURL=JsonSchemasTransformer.mjs.map

package/lib/transformers/features/json/JsonSchemasTransformer.mjs.map

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

package/lib/transformers/features/json/JsonStringifyTransformer.mjs

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

package/lib/transformers/features/json/JsonStringifyTransformer.mjs.map

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

package/lib/transformers/features/json/JsonValidateParseTransformer.mjs

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

package/lib/transformers/features/json/JsonValidateParseTransformer.mjs.map

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

package/lib/transformers/features/json/JsonValidateStringifyTransformer.mjs

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

package/lib/transformers/features/json/JsonValidateStringifyTransformer.mjs.map

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