@duplojs/data-parser-tools 0.2.3 → 0.2.5

package/dist/toJsonSchema/transformer/defaults/literal.d.ts

@@ -1,6 +1,14 @@
 import { DP } from "@duplojs/utils";
-export interface JsonSchemaLiteral {
-    const?: string | number | boolean | null;
-    type?: "string" | "number" | "integer" | "boolean" | "null";
-}
+type JsonPrimitive = string | number | boolean | null;
+type JsonType = "string" | "number" | "integer" | "boolean" | "null";
+export type JsonSchemaLiteral = {
+    const: JsonPrimitive;
+    type: JsonType;
+} | {
+    enum: readonly [JsonPrimitive];
+    type: JsonType;
+} | {
+    enum: readonly [null];
+};
 export declare const literalTransformer: (schema: DP.DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;
+export {};

package/dist/toJsonSchema/transformer/defaults/literal.mjs

@@ -1,45 +1,81 @@
-import { DP, A, P, isType, pipe } from '@duplojs/utils';
+import { DP, A, P, isType, justReturn, pipe } from '@duplojs/utils';
 import { createTransformer } from '../create.mjs';
 
-const literalTransformer = createTransformer(DP.literalKind.has, (schema, { success, }) => {
+function isOldVersion(version) {
+    return (version === "jsonSchema4"
+        || version === "openApi3");
+}
+const literalTransformer = createTransformer(DP.literalKind.has, (schema, { success, version, }) => {
     const reduced = A.reduce(schema.definition.value, A.reduceFrom({
         literals: [],
-        canBeUndefined: false,
+        isOptional: false,
     }), ({ element, lastValue, next, nextWithObject, }) => P.match(element)
-        .when(isType("undefined"), () => nextWithObject(lastValue, { canBeUndefined: true }))
+        .when(isType("undefined"), () => nextWithObject(lastValue, { isOptional: true }))
         .when(isType("bigint"), (value) => nextWithObject(lastValue, {
-        literals: A.push(lastValue.literals, {
-            const: value.toString(),
-            type: "string",
-        }),
+        literals: A.push(lastValue.literals, isOldVersion(version)
+            ? {
+                enum: [value.toString()],
+                type: "string",
+            }
+            : {
+                const: value.toString(),
+                type: "string",
+            }),
     }))
         .when(isType("string"), (value) => nextWithObject(lastValue, {
-        literals: A.push(lastValue.literals, {
-            const: value,
-            type: "string",
-        }),
+        literals: A.push(lastValue.literals, isOldVersion(version)
+            ? {
+                enum: [value],
+                type: "string",
+            }
+            : {
+                const: value,
+                type: "string",
+            }),
     }))
         .when(isType("number"), (value) => nextWithObject(lastValue, {
-        literals: A.push(lastValue.literals, {
-            const: value,
-            type: Number.isInteger(value) ? "integer" : "number",
-        }),
+        literals: A.push(lastValue.literals, isOldVersion(version)
+            ? {
+                enum: [value],
+                type: Number.isInteger(value)
+                    ? "integer"
+                    : "number",
+            }
+            : {
+                const: value,
+                type: Number.isInteger(value)
+                    ? "integer"
+                    : "number",
+            }),
     }))
         .when(isType("boolean"), (value) => nextWithObject(lastValue, {
-        literals: A.push(lastValue.literals, {
-            const: value,
-            type: "boolean",
-        }),
+        literals: A.push(lastValue.literals, isOldVersion(version)
+            ? {
+                enum: [value],
+                type: "boolean",
+            }
+            : {
+                const: value,
+                type: "boolean",
+            }),
     }))
         .when(isType("null"), () => nextWithObject(lastValue, {
-        literals: A.push(lastValue.literals, {
-            const: null,
+        literals: A.push(lastValue.literals, P.match(version)
+            .with("openApi3", justReturn({
+            enum: [null],
+        }))
+            .with("jsonSchema4", justReturn({
+            type: "null",
+            enum: [null],
+        }))
+            .otherwise(justReturn({
             type: "null",
-        }),
+            const: null,
+        }))),
     }))
         .otherwise(() => next(lastValue)));
     const schemaDefinition = pipe(reduced.literals, P.when(A.lengthEqual(0), () => ({})), P.when(A.lengthEqual(1), A.first), P.otherwise((value) => ({ anyOf: value })));
-    return success(schemaDefinition, reduced.canBeUndefined);
+    return success(schemaDefinition, reduced.isOptional);
 });
 
 export { literalTransformer };

package/dist/toJsonSchema/transformer/defaults/nullable.cjs

@@ -9,12 +9,21 @@ const nullableTransformer = create.createTransformer(utils.DP.nullableKind.has,
         return innerResult;
     }
     const inner = utils.unwrap(innerResult);
-    return utils.pipe(mode, utils.P.match("in", () => ({
+    return utils.pipe({
+        mode,
+        coalescingValue: schema.definition.coalescingValue,
+    }, (value) => utils.P.match(value)
+        .with(utils.P.union({ mode: "in" }, {
+        mode: "out",
+        coalescingValue: undefined,
+    }), () => ({
         anyOf: [
             inner.schema,
             { type: "null" },
         ],
-    })), utils.P.match("out", () => inner.schema), utils.P.exhaustive, (schema) => success(schema, inner.canBeUndefined));
+    }))
+        .with({ mode: "out" }, () => inner.schema)
+        .exhaustive(), (schema) => success(schema, inner.isOptional));
 });
 
 exports.nullableTransformer = nullableTransformer;

package/dist/toJsonSchema/transformer/defaults/nullable.mjs

@@ -7,12 +7,21 @@ const nullableTransformer = createTransformer(DP.nullableKind.has, (schema, { tr
         return innerResult;
     }
     const inner = unwrap(innerResult);
-    return pipe(mode, P.match("in", () => ({
+    return pipe({
+        mode,
+        coalescingValue: schema.definition.coalescingValue,
+    }, (value) => P.match(value)
+        .with(P.union({ mode: "in" }, {
+        mode: "out",
+        coalescingValue: undefined,
+    }), () => ({
         anyOf: [
             inner.schema,
             { type: "null" },
         ],
-    })), P.match("out", () => inner.schema), P.exhaustive, (schema) => success(schema, inner.canBeUndefined));
+    }))
+        .with({ mode: "out" }, () => inner.schema)
+        .exhaustive(), (schema) => success(schema, inner.isOptional));
 });
 
 export { nullableTransformer };

package/dist/toJsonSchema/transformer/defaults/object.cjs

@@ -14,7 +14,7 @@ const objectTransformer = create.createTransformer(utils.DP.objectKind.has, (sch
             ...lastValue.properties,
             [key]: inner.schema,
         },
-        required: inner.canBeUndefined
+        required: inner.isOptional
             ? lastValue.required
             : utils.A.push(lastValue.required ?? [], key),
     })))));

package/dist/toJsonSchema/transformer/defaults/object.mjs

@@ -12,7 +12,7 @@ const objectTransformer = createTransformer(DP.objectKind.has, (schema, { transf
             ...lastValue.properties,
             [key]: inner.schema,
         },
-        required: inner.canBeUndefined
+        required: inner.isOptional
             ? lastValue.required
             : A.push(lastValue.required ?? [], key),
     })))));

package/dist/toJsonSchema/transformer/defaults/optional.cjs

@@ -3,6 +3,15 @@
 var utils = require('@duplojs/utils');
 var create = require('../create.cjs');
 
-const optionalTransformer = create.createTransformer(utils.DP.optionalKind.has, (schema, { transformer, success, mode, }) => utils.pipe(schema.definition.inner, transformer, utils.E.whenIsRight((inner) => utils.pipe(mode, utils.P.match("in", () => true), utils.P.match("out", () => inner.canBeUndefined), utils.P.exhaustive, (value) => success(inner.schema, value)))));
+const optionalTransformer = create.createTransformer(utils.DP.optionalKind.has, (schema, { transformer, success, mode, }) => utils.pipe(schema.definition.inner, transformer, utils.E.whenIsRight((inner) => utils.pipe({
+    mode,
+    coalescingValue: schema.definition.coalescingValue,
+}, (value) => utils.P.match(value)
+    .with(utils.P.union({ mode: "in" }, {
+    mode: "out",
+    coalescingValue: undefined,
+}), () => true)
+    .with({ mode: "out" }, () => inner.isOptional)
+    .exhaustive(), (isOptional) => success(inner.schema, isOptional)))));
 
 exports.optionalTransformer = optionalTransformer;

package/dist/toJsonSchema/transformer/defaults/optional.mjs

@@ -1,6 +1,15 @@
 import { DP, pipe, E, P } from '@duplojs/utils';
 import { createTransformer } from '../create.mjs';
 
-const optionalTransformer = createTransformer(DP.optionalKind.has, (schema, { transformer, success, mode, }) => pipe(schema.definition.inner, transformer, E.whenIsRight((inner) => pipe(mode, P.match("in", () => true), P.match("out", () => inner.canBeUndefined), P.exhaustive, (value) => success(inner.schema, value)))));
+const optionalTransformer = createTransformer(DP.optionalKind.has, (schema, { transformer, success, mode, }) => pipe(schema.definition.inner, transformer, E.whenIsRight((inner) => pipe({
+    mode,
+    coalescingValue: schema.definition.coalescingValue,
+}, (value) => P.match(value)
+    .with(P.union({ mode: "in" }, {
+    mode: "out",
+    coalescingValue: undefined,
+}), () => true)
+    .with({ mode: "out" }, () => inner.isOptional)
+    .exhaustive(), (isOptional) => success(inner.schema, isOptional)))));
 
 export { optionalTransformer };

package/dist/toJsonSchema/transformer/defaults/time.cjs

@@ -6,7 +6,7 @@ var create = require('../create.cjs');
 const timeTransformer = create.createTransformer(utils.DP.timeKind.has, (schema, { success, mode, }) => {
     const base = {
         type: "string",
-        pattern: utils.D.theTimeRegex.source,
+        pattern: utils.D.serializeTheTimeRegex.source,
     };
     if (mode === "in" && schema.definition.coerce) {
         return success({

package/dist/toJsonSchema/transformer/defaults/time.mjs

@@ -4,7 +4,7 @@ import { createTransformer } from '../create.mjs';
 const timeTransformer = createTransformer(DP.timeKind.has, (schema, { success, mode, }) => {
     const base = {
         type: "string",
-        pattern: D.theTimeRegex.source,
+        pattern: D.serializeTheTimeRegex.source,
     };
     if (mode === "in" && schema.definition.coerce) {
         return success({

package/dist/toJsonSchema/transformer/defaults/union.cjs

@@ -4,9 +4,9 @@ var utils = require('@duplojs/utils');
 var create = require('../create.cjs');
 
 const unionTransformer = create.createTransformer(utils.DP.unionKind.has, (schema, { transformer, success, }) => {
-    let canBeUndefined = false;
+    let isOptional = false;
     const optionsResult = utils.A.reduce(schema.definition.options, utils.A.reduceFrom([]), ({ element, lastValue, nextPush, exit }) => utils.pipe(transformer(element), utils.when(utils.E.isLeft, exit), utils.E.whenIsRight((option) => {
-        canBeUndefined ||= option.canBeUndefined;
+        isOptional ||= option.isOptional;
         return nextPush(lastValue, option.schema);
     })));
     if (utils.E.isLeft(optionsResult)) {
@@ -14,7 +14,7 @@ const unionTransformer = create.createTransformer(utils.DP.unionKind.has, (schem
     }
     return success({
         anyOf: optionsResult,
-    }, canBeUndefined);
+    }, isOptional);
 });
 
 exports.unionTransformer = unionTransformer;

package/dist/toJsonSchema/transformer/defaults/union.mjs

@@ -2,9 +2,9 @@ import { DP, A, pipe, when, E } from '@duplojs/utils';
 import { createTransformer } from '../create.mjs';
 
 const unionTransformer = createTransformer(DP.unionKind.has, (schema, { transformer, success, }) => {
-    let canBeUndefined = false;
+    let isOptional = false;
     const optionsResult = A.reduce(schema.definition.options, A.reduceFrom([]), ({ element, lastValue, nextPush, exit }) => pipe(transformer(element), when(E.isLeft, exit), E.whenIsRight((option) => {
-        canBeUndefined ||= option.canBeUndefined;
+        isOptional ||= option.isOptional;
         return nextPush(lastValue, option.schema);
     })));
     if (E.isLeft(optionsResult)) {
@@ -12,7 +12,7 @@ const unionTransformer = createTransformer(DP.unionKind.has, (schema, { transfor
     }
     return success({
         anyOf: optionsResult,
-    }, canBeUndefined);
+    }, isOptional);
 });
 
 export { unionTransformer };

package/dist/toJsonSchema/transformer/transformer.cjs

@@ -3,11 +3,11 @@
 var utils = require('@duplojs/utils');
 
 function buildRef(name, version) {
-    if (version === "https://spec.openapis.org/oas/3.0.3"
-        || version === "https://spec.openapis.org/oas/3.1.0") {
+    if (version === "openApi3"
+        || version === "openApi31") {
         return `#/components/schemas/${name}`;
     }
-    if (version === "https://json-schema.org/draft/2020-12/schema") {
+    if (version === "jsonSchema202012") {
         return `#/$defs/${name}`;
     }
     return `#/definitions/${name}`;
@@ -33,22 +33,22 @@ function transformer(schema, params) {
     if (currentDeclaration) {
         return utils.E.right("buildSuccess", {
             schema: { $ref: buildRef(currentDeclaration.name, params.version) },
-            canBeUndefined: currentDeclaration.canBeUndefined,
+            isOptional: currentDeclaration.isOptional,
         });
     }
     const currentIdentifier = utils.whenElse(params.recursiveDataParsers, utils.A.includes(currentSchema), () => {
         const identifier = currentSchema.definition.identifier ?? `RecursiveType${params.context.size}`;
         params.context.set(currentSchema, {
             name: identifier,
-            canBeUndefined: false,
+            isOptional: false,
         });
         return identifier;
     }, utils.justReturn(currentSchema.definition.identifier));
     const functionParams = {
-        success(result, canBeUndefined = false) {
+        success(result, isOptional = false) {
             return utils.E.right("buildSuccess", {
                 schema: result,
-                canBeUndefined,
+                isOptional,
             });
         },
         transformer(schema) {
@@ -75,13 +75,13 @@ function transformer(schema, params) {
         return result;
     }
     if (currentIdentifier) {
-        const { schema: builtSchema, canBeUndefined } = utils.unwrap(result);
+        const { schema: builtSchema, isOptional } = utils.unwrap(result);
         params.context.set(currentSchema, {
             name: currentIdentifier,
             schema: builtSchema,
-            canBeUndefined,
+            isOptional,
         });
-        return functionParams.success({ $ref: buildRef(currentIdentifier, params.version) }, canBeUndefined);
+        return functionParams.success({ $ref: buildRef(currentIdentifier, params.version) }, isOptional);
     }
     return result;
 }

package/dist/toJsonSchema/transformer/transformer.d.ts

@@ -1,18 +1,18 @@
 import { E, type DP } from "@duplojs/utils";
-import { type MapContext, type DataParserNotSupportedEither, type createTransformer, type TransformerMode, type SupportedVersionsUrl, type DataParserErrorEither } from "./create";
+import { type MapContext, type DataParserNotSupportedEither, type createTransformer, type TransformerMode, type DataParserErrorEither, type SupportedVersions } from "./create";
 import { type TransformerHook } from "./hook";
 export interface TransformerFunctionParams {
     readonly transformers: readonly ReturnType<typeof createTransformer>[];
     readonly context: MapContext;
     readonly mode: TransformerMode;
-    readonly version: SupportedVersionsUrl;
+    readonly version: SupportedVersions;
     readonly hooks: readonly TransformerHook[];
     readonly recursiveDataParsers: DP.DataParser[];
 }
-export declare function buildRef(name: string, version: SupportedVersionsUrl): string;
-export declare function transformer(schema: DP.DataParser, params: TransformerFunctionParams): import("./create").TransformerSuccessEither | DataParserNotSupportedEither | DataParserErrorEither | E.EitherRight<"buildSuccess", {
+export declare function buildRef(name: string, version: SupportedVersions): string;
+export declare function transformer(schema: DP.DataParser, params: TransformerFunctionParams): import("./create").TransformerSuccessEither | DataParserNotSupportedEither | DataParserErrorEither | E.Right<"buildSuccess", {
     readonly schema: {
         readonly $ref: string;
     };
-    readonly canBeUndefined: boolean;
+    readonly isOptional: boolean;
 }>;

package/dist/toJsonSchema/transformer/transformer.mjs

@@ -1,11 +1,11 @@
 import { A, E, whenElse, justReturn, unwrap } from '@duplojs/utils';
 
 function buildRef(name, version) {
-    if (version === "https://spec.openapis.org/oas/3.0.3"
-        || version === "https://spec.openapis.org/oas/3.1.0") {
+    if (version === "openApi3"
+        || version === "openApi31") {
         return `#/components/schemas/${name}`;
     }
-    if (version === "https://json-schema.org/draft/2020-12/schema") {
+    if (version === "jsonSchema202012") {
         return `#/$defs/${name}`;
     }
     return `#/definitions/${name}`;
@@ -31,22 +31,22 @@ function transformer(schema, params) {
     if (currentDeclaration) {
         return E.right("buildSuccess", {
             schema: { $ref: buildRef(currentDeclaration.name, params.version) },
-            canBeUndefined: currentDeclaration.canBeUndefined,
+            isOptional: currentDeclaration.isOptional,
         });
     }
     const currentIdentifier = whenElse(params.recursiveDataParsers, A.includes(currentSchema), () => {
         const identifier = currentSchema.definition.identifier ?? `RecursiveType${params.context.size}`;
         params.context.set(currentSchema, {
             name: identifier,
-            canBeUndefined: false,
+            isOptional: false,
         });
         return identifier;
     }, justReturn(currentSchema.definition.identifier));
     const functionParams = {
-        success(result, canBeUndefined = false) {
+        success(result, isOptional = false) {
             return E.right("buildSuccess", {
                 schema: result,
-                canBeUndefined,
+                isOptional,
             });
         },
         transformer(schema) {
@@ -73,13 +73,13 @@ function transformer(schema, params) {
         return result;
     }
     if (currentIdentifier) {
-        const { schema: builtSchema, canBeUndefined } = unwrap(result);
+        const { schema: builtSchema, isOptional } = unwrap(result);
         params.context.set(currentSchema, {
             name: currentIdentifier,
             schema: builtSchema,
-            canBeUndefined,
+            isOptional,
         });
-        return functionParams.success({ $ref: buildRef(currentIdentifier, params.version) }, canBeUndefined);
+        return functionParams.success({ $ref: buildRef(currentIdentifier, params.version) }, isOptional);
     }
     return result;
 }

package/dist/toTypescript/index.cjs

@@ -29,6 +29,7 @@ var union = require('./transformer/defaults/union.cjs');
 var unknown = require('./transformer/defaults/unknown.cjs');
 var date = require('./transformer/defaults/date.cjs');
 var time = require('./transformer/defaults/time.cjs');
+var includesUndefinedTypeNode = require('./transformer/includesUndefinedTypeNode.cjs');
 
 
 
@@ -60,3 +61,4 @@ exports.unionTransformer = union.unionTransformer;
 exports.unknownTransformer = unknown.unknownTransformer;
 exports.dateTransformer = date.dateTransformer;
 exports.timeTransformer = time.timeTransformer;
+exports.includesUndefinedTypeNode = includesUndefinedTypeNode.includesUndefinedTypeNode;

package/dist/toTypescript/index.mjs

@@ -27,3 +27,4 @@ export { unionTransformer } from './transformer/defaults/union.mjs';
 export { unknownTransformer } from './transformer/defaults/unknown.mjs';
 export { dateTransformer } from './transformer/defaults/date.mjs';
 export { timeTransformer } from './transformer/defaults/time.mjs';
+export { includesUndefinedTypeNode } from './transformer/includesUndefinedTypeNode.mjs';

package/dist/toTypescript/override.cjs

@@ -6,10 +6,8 @@ dataParser.dataParserInit.overrideHandler.setMethod("setIdentifier", (schema, id
     schema.definition.identifier = identifier;
     return schema;
 });
-dataParser.dataParserInit.overrideHandler.setMethod("addIdentifier", (schema, identifier) => ({
-    ...schema,
-    definition: {
-        ...schema.definition,
-        identifier,
-    },
-}));
+dataParser.dataParserInit.overrideHandler.setMethod("addIdentifier", (schema, identifier) => {
+    const newSchema = schema.clone();
+    newSchema.setIdentifier(identifier);
+    return newSchema;
+});

package/dist/toTypescript/override.mjs

@@ -4,10 +4,8 @@ dataParserInit.overrideHandler.setMethod("setIdentifier", (schema, identifier) =
     schema.definition.identifier = identifier;
     return schema;
 });
-dataParserInit.overrideHandler.setMethod("addIdentifier", (schema, identifier) => ({
-    ...schema,
-    definition: {
-        ...schema.definition,
-        identifier,
-    },
-}));
+dataParserInit.overrideHandler.setMethod("addIdentifier", (schema, identifier) => {
+    const newSchema = schema.clone();
+    newSchema.setIdentifier(identifier);
+    return newSchema;
+});

package/dist/toTypescript/render.cjs

@@ -5,6 +5,7 @@ require('./transformer/index.cjs');
 var typescript = require('typescript');
 var kind = require('./kind.cjs');
 var getRecursiveDataParser = require('../utils/getRecursiveDataParser.cjs');
+var importTypesTransformer = require('./transformer/importTypesTransformer.cjs');
 var transformer = require('./transformer/transformer.cjs');
 
 class DataParserToTypescriptRenderError extends utils.kindHeritage("data-parser-to-typescript-render-error", kind.createToTypescriptKind("data-parser-to-typescript-render-error"), Error) {
@@ -18,12 +19,14 @@ class DataParserToTypescriptRenderError extends utils.kindHeritage("data-parser-
 }
 function render(schema, params) {
     const context = new Map(params.context);
+    const importType = new Map(params.importType);
     const result = transformer.transformer(schema, {
         ...params,
         context,
         mode: params.mode ?? "out",
         hooks: params.hooks ?? [],
         recursiveDataParsers: getRecursiveDataParser.getRecursiveDataParser(schema),
+        importType,
     });
     if (utils.E.isLeft(result)) {
         throw new DataParserToTypescriptRenderError(schema, result);
@@ -36,7 +39,10 @@ function render(schema, params) {
     }
     const sourceFile = typescript.createSourceFile("print.ts", "", typescript.ScriptTarget.Latest, false, typescript.ScriptKind.TS);
     const printer = typescript.createPrinter();
-    return utils.pipe(context.values(), utils.G.map((value) => printer.printNode(typescript.EmitHint.Unspecified, value, sourceFile)), utils.A.from, utils.A.join("\n\n"), utils.S.trim);
+    return utils.pipe([
+        ...importTypesTransformer.importTypesTransformer(importType),
+        ...context.values(),
+    ], utils.G.map((value) => printer.printNode(typescript.EmitHint.Unspecified, value, sourceFile)), utils.A.from, utils.A.join("\n\n"), utils.S.trim);
 }
 
 exports.DataParserToTypescriptRenderError = DataParserToTypescriptRenderError;

package/dist/toTypescript/render.d.ts

@@ -1,19 +1,19 @@
-import { DP } from "@duplojs/utils";
-import { type DataParserErrorEither, type DataParserNotSupportedEither, type MapContext, type TransformerMode, type TransformerHook, type createTransformer } from "./transformer";
+import { type DataParserErrorEither, type DataParserNotSupportedEither, type MapContext, type TransformerMode, type TransformerHook, type createTransformer, type SupportedDataParsers, type MapImportType } from "./transformer";
 export interface RenderParams {
     readonly identifier: string;
     readonly transformers: readonly ReturnType<typeof createTransformer>[];
     readonly context?: MapContext;
     readonly mode?: TransformerMode;
     readonly hooks?: readonly TransformerHook[];
+    readonly importType?: MapImportType;
 }
 declare const DataParserToTypescriptRenderError_base: new (params: {
     "@DuplojsDataParserToolsToTypescript/data-parser-to-typescript-render-error"?: unknown;
-}, parentParams: [message?: string | undefined, options?: ErrorOptions | undefined]) => import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsDataParserToolsToTypescript/data-parser-to-typescript-render-error", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"data-parser-to-typescript-render-error", unknown>, unknown> & Error;
+}, parentParams: readonly [message?: string | undefined, options?: ErrorOptions | undefined]) => import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsDataParserToolsToTypescript/data-parser-to-typescript-render-error", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"data-parser-to-typescript-render-error", unknown>, unknown> & Error;
 export declare class DataParserToTypescriptRenderError extends DataParserToTypescriptRenderError_base {
-    schema: DP.DataParsers;
+    schema: SupportedDataParsers;
     error: DataParserNotSupportedEither | DataParserErrorEither;
-    constructor(schema: DP.DataParsers, error: DataParserNotSupportedEither | DataParserErrorEither);
+    constructor(schema: SupportedDataParsers, error: DataParserNotSupportedEither | DataParserErrorEither);
 }
-export declare function render(schema: DP.DataParsers, params: RenderParams): string;
+export declare function render(schema: SupportedDataParsers, params: RenderParams): string;
 export {};

package/dist/toTypescript/render.mjs

@@ -3,6 +3,7 @@ import './transformer/index.mjs';
 import { factory, SyntaxKind, createSourceFile, ScriptTarget, ScriptKind, createPrinter, EmitHint } from 'typescript';
 import { createToTypescriptKind } from './kind.mjs';
 import { getRecursiveDataParser } from '../utils/getRecursiveDataParser.mjs';
+import { importTypesTransformer } from './transformer/importTypesTransformer.mjs';
 import { transformer } from './transformer/transformer.mjs';
 
 class DataParserToTypescriptRenderError extends kindHeritage("data-parser-to-typescript-render-error", createToTypescriptKind("data-parser-to-typescript-render-error"), Error) {
@@ -16,12 +17,14 @@ class DataParserToTypescriptRenderError extends kindHeritage("data-parser-to-typ
 }
 function render(schema, params) {
     const context = new Map(params.context);
+    const importType = new Map(params.importType);
     const result = transformer(schema, {
         ...params,
         context,
         mode: params.mode ?? "out",
         hooks: params.hooks ?? [],
         recursiveDataParsers: getRecursiveDataParser(schema),
+        importType,
     });
     if (E.isLeft(result)) {
         throw new DataParserToTypescriptRenderError(schema, result);
@@ -34,7 +37,10 @@ function render(schema, params) {
     }
     const sourceFile = createSourceFile("print.ts", "", ScriptTarget.Latest, false, ScriptKind.TS);
     const printer = createPrinter();
-    return pipe(context.values(), G.map((value) => printer.printNode(EmitHint.Unspecified, value, sourceFile)), A.from, A.join("\n\n"), S.trim);
+    return pipe([
+        ...importTypesTransformer(importType),
+        ...context.values(),
+    ], G.map((value) => printer.printNode(EmitHint.Unspecified, value, sourceFile)), A.from, A.join("\n\n"), S.trim);
 }
 
 export { DataParserToTypescriptRenderError, render };

package/dist/toTypescript/transformer/create.d.ts

@@ -1,16 +1,21 @@
 import { type TypeAliasDeclaration, type TypeNode } from "typescript";
 import { type DP, E } from "@duplojs/utils";
-export type TransformerSuccessEither = E.EitherRight<"buildSuccess", TypeNode>;
-export type DataParserNotSupportedEither = E.EitherLeft<"dataParserNotSupport", DP.DataParser>;
-export type DataParserErrorEither = E.EitherLeft<"buildDataParserError", DP.DataParser>;
-export type MapContext = Map<DP.DataParsers, TypeAliasDeclaration>;
+import { type SDP } from "@duplojs/server-utils";
+export type TransformerSuccessEither = E.Right<"buildSuccess", TypeNode>;
+export type DataParserNotSupportedEither = E.Left<"dataParserNotSupport", DP.DataParser>;
+export type DataParserErrorEither = E.Left<"buildDataParserError", DP.DataParser>;
+export type SupportedDataParsers = DP.DataParsers | SDP.DataParserFile;
+export type MapContext = Map<SupportedDataParsers, TypeAliasDeclaration>;
+export type MapImportType = Map<string, string[]>;
 export type MaybeTransformerEither = TransformerSuccessEither | DataParserNotSupportedEither | DataParserErrorEither;
 export type TransformerMode = "in" | "out";
 export interface TransformerParams {
     readonly mode: TransformerMode;
     readonly context: MapContext;
+    readonly importType: MapImportType;
     transformer(schema: DP.DataParser): MaybeTransformerEither;
     success(result: TypeNode): TransformerSuccessEither;
     buildError(): DataParserErrorEither;
+    addImport(path: string, typeName: string): void;
 }
-export declare function createTransformer<GenericDataParser extends DP.DataParsers>(support: (schema: DP.DataParsers) => schema is GenericDataParser, builder: (schema: GenericDataParser, params: TransformerParams) => MaybeTransformerEither): (schema: DP.DataParsers, params: TransformerParams) => MaybeTransformerEither;
+export declare function createTransformer<GenericDataParser extends SupportedDataParsers>(support: (schema: SupportedDataParsers) => schema is GenericDataParser, builder: (schema: GenericDataParser, params: TransformerParams) => MaybeTransformerEither): (schema: SupportedDataParsers, params: TransformerParams) => MaybeTransformerEither;

package/dist/toTypescript/transformer/defaults/array.d.ts

@@ -1,2 +1 @@
-import { DP } from "@duplojs/utils";
-export declare const arrayTransformer: (schema: DP.DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;
+export declare const arrayTransformer: (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;

package/dist/toTypescript/transformer/defaults/bigint.d.ts

@@ -1,2 +1 @@
-import { DP } from "@duplojs/utils";
-export declare const bigIntTransformer: (schema: DP.DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;
+export declare const bigIntTransformer: (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;

package/dist/toTypescript/transformer/defaults/boolean.d.ts

@@ -1,2 +1 @@
-import { DP } from "@duplojs/utils";
-export declare const booleanTransformer: (schema: DP.DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;
+export declare const booleanTransformer: (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;