@duplojs/data-parser-tools 0.2.4 → 0.2.6

package/dist/toJsonSchema/transformer/transformer.cjs

@@ -3,16 +3,19 @@
 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}`;
 }
 function transformer(schema, params) {
+    if (schema.definition.overrideJsonSchema?.[params.mode]) {
+        return utils.E.right("buildSuccess", schema.definition.overrideJsonSchema[params.mode]);
+    }
     const currentSchema = utils.A.reduce(params.hooks, utils.A.reduceFrom(schema), ({ element: hook, lastValue, next, exit }) => {
         const result = hook({
             schema: lastValue,

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

@@ -1,16 +1,16 @@
 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;
     };

package/dist/toJsonSchema/transformer/transformer.mjs

@@ -1,16 +1,19 @@
-import { A, E, whenElse, justReturn, unwrap } from '@duplojs/utils';
+import { E, A, 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}`;
 }
 function transformer(schema, params) {
+    if (schema.definition.overrideJsonSchema?.[params.mode]) {
+        return E.right("buildSuccess", schema.definition.overrideJsonSchema[params.mode]);
+    }
     const currentSchema = A.reduce(params.hooks, A.reduceFrom(schema), ({ element: hook, lastValue, next, exit }) => {
         const result = hook({
             schema: lastValue,

package/dist/toTypescript/override.cjs

@@ -11,3 +11,17 @@ dataParser.dataParserInit.overrideHandler.setMethod("addIdentifier", (schema, id
     newSchema.setIdentifier(identifier);
     return newSchema;
 });
+dataParser.dataParserInit.overrideHandler.setMethod("setOverrideTypeNode", (schema, overrideTypeNode) => {
+    schema.definition.overrideTypeNode = "kind" in overrideTypeNode
+        ? {
+            in: overrideTypeNode,
+            out: overrideTypeNode,
+        }
+        : overrideTypeNode;
+    return schema;
+});
+dataParser.dataParserInit.overrideHandler.setMethod("addOverrideTypeNode", (schema, overrideTypeNode) => {
+    const newSchema = schema.clone();
+    newSchema.setOverrideTypeNode(overrideTypeNode);
+    return newSchema;
+});

package/dist/toTypescript/override.d.ts

@@ -1,3 +1,6 @@
+import { type TypeNode } from "typescript";
+import { type TransformerMode } from "./transformer";
+export type OverrideTypeNodeDataParser = Partial<Record<TransformerMode, TypeNode>>;
 declare module "@duplojs/utils/dataParser" {
     interface DataParser {
         /**
@@ -5,9 +8,14 @@ declare module "@duplojs/utils/dataParser" {
          */
         setIdentifier(input: string): this;
         addIdentifier(input: string): this;
+        /**
+         * @deprecated this method mutated the dataParser by adding an override type node
+         */
+        setOverrideTypeNode(typeNode: TypeNode | OverrideTypeNodeDataParser): this;
+        addOverrideTypeNode(typeNode: TypeNode | OverrideTypeNodeDataParser): this;
     }
     interface DataParserDefinition {
         identifier?: string;
+        overrideTypeNode?: OverrideTypeNodeDataParser;
     }
 }
-export {};

package/dist/toTypescript/override.mjs

@@ -9,3 +9,17 @@ dataParserInit.overrideHandler.setMethod("addIdentifier", (schema, identifier) =
     newSchema.setIdentifier(identifier);
     return newSchema;
 });
+dataParserInit.overrideHandler.setMethod("setOverrideTypeNode", (schema, overrideTypeNode) => {
+    schema.definition.overrideTypeNode = "kind" in overrideTypeNode
+        ? {
+            in: overrideTypeNode,
+            out: overrideTypeNode,
+        }
+        : overrideTypeNode;
+    return schema;
+});
+dataParserInit.overrideHandler.setMethod("addOverrideTypeNode", (schema, overrideTypeNode) => {
+    const newSchema = schema.clone();
+    newSchema.setOverrideTypeNode(overrideTypeNode);
+    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;

package/dist/toTypescript/transformer/defaults/date.cjs

@@ -4,12 +4,22 @@ var utils = require('@duplojs/utils');
 var typescript = require('typescript');
 var create = require('../create.cjs');
 
-const dateTransformer = create.createTransformer(utils.DP.dateKind.has, (__schema, { success }) => success(typescript.factory.createTemplateLiteralType(typescript.factory.createTemplateHead("date", "date"), [
-    typescript.factory.createTemplateLiteralTypeSpan(typescript.factory.createKeywordTypeNode(typescript.SyntaxKind.NumberKeyword), typescript.factory.createTemplateMiddle("", "")),
-    typescript.factory.createTemplateLiteralTypeSpan(typescript.factory.createUnionTypeNode([
-        typescript.factory.createLiteralTypeNode(typescript.factory.createStringLiteral("-")),
-        typescript.factory.createLiteralTypeNode(typescript.factory.createStringLiteral("+")),
-    ]), typescript.factory.createTemplateTail("", "")),
-])));
+const theDate = typescript.factory.createTypeReferenceNode(typescript.factory.createIdentifier("TheDate"));
+const serializedTheDate = typescript.factory.createTypeReferenceNode(typescript.factory.createIdentifier("SerializedTheDate"));
+const nativeDate = typescript.factory.createTypeReferenceNode(typescript.factory.createIdentifier("Date"), undefined);
+const dateTransformer = create.createTransformer(utils.DP.dateKind.has, (__schema, { mode, success, addImport, }) => {
+    addImport("@duplojs/utils/date", "TheDate");
+    return utils.P.match(mode)
+        .with("out", () => success(theDate))
+        .with("in", () => {
+        addImport("@duplojs/utils/date", "SerializedTheDate");
+        return success(typescript.factory.createUnionTypeNode([
+            theDate,
+            nativeDate,
+            serializedTheDate,
+        ]));
+    })
+        .exhaustive();
+});
 
 exports.dateTransformer = dateTransformer;

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

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

package/dist/toTypescript/transformer/defaults/date.mjs

@@ -1,13 +1,23 @@
-import { DP } from '@duplojs/utils';
-import { factory, SyntaxKind } from 'typescript';
+import { DP, P } from '@duplojs/utils';
+import { factory } from 'typescript';
 import { createTransformer } from '../create.mjs';
 
-const dateTransformer = createTransformer(DP.dateKind.has, (__schema, { success }) => success(factory.createTemplateLiteralType(factory.createTemplateHead("date", "date"), [
-    factory.createTemplateLiteralTypeSpan(factory.createKeywordTypeNode(SyntaxKind.NumberKeyword), factory.createTemplateMiddle("", "")),
-    factory.createTemplateLiteralTypeSpan(factory.createUnionTypeNode([
-        factory.createLiteralTypeNode(factory.createStringLiteral("-")),
-        factory.createLiteralTypeNode(factory.createStringLiteral("+")),
-    ]), factory.createTemplateTail("", "")),
-])));
+const theDate = factory.createTypeReferenceNode(factory.createIdentifier("TheDate"));
+const serializedTheDate = factory.createTypeReferenceNode(factory.createIdentifier("SerializedTheDate"));
+const nativeDate = factory.createTypeReferenceNode(factory.createIdentifier("Date"), undefined);
+const dateTransformer = createTransformer(DP.dateKind.has, (__schema, { mode, success, addImport, }) => {
+    addImport("@duplojs/utils/date", "TheDate");
+    return P.match(mode)
+        .with("out", () => success(theDate))
+        .with("in", () => {
+        addImport("@duplojs/utils/date", "SerializedTheDate");
+        return success(factory.createUnionTypeNode([
+            theDate,
+            nativeDate,
+            serializedTheDate,
+        ]));
+    })
+        .exhaustive();
+});
 
 export { dateTransformer };

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

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

package/dist/toTypescript/transformer/defaults/file.cjs

@@ -0,0 +1,13 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+var serverUtils = require('@duplojs/server-utils');
+var typescript = require('typescript');
+var create = require('../create.cjs');
+
+const fileTransformer = create.createTransformer(serverUtils.SDP.fileKind.has, (schema, { success, addImport, }) => {
+    addImport("@duplojs/server-utils/file", "FileInterface");
+    return utils.pipe("FileInterface", typescript.factory.createIdentifier, typescript.factory.createTypeReferenceNode, success);
+});
+
+exports.fileTransformer = fileTransformer;

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

@@ -0,0 +1 @@
+export declare const fileTransformer: (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;

package/dist/toTypescript/transformer/defaults/file.mjs

@@ -0,0 +1,11 @@
+import { pipe } from '@duplojs/utils';
+import { SDP } from '@duplojs/server-utils';
+import { factory } from 'typescript';
+import { createTransformer } from '../create.mjs';
+
+const fileTransformer = createTransformer(SDP.fileKind.has, (schema, { success, addImport, }) => {
+    addImport("@duplojs/server-utils/file", "FileInterface");
+    return pipe("FileInterface", factory.createIdentifier, factory.createTypeReferenceNode, success);
+});
+
+export { fileTransformer };

package/dist/toTypescript/transformer/defaults/index.cjs

@@ -22,6 +22,7 @@ var union = require('./union.cjs');
 var unknown = require('./unknown.cjs');
 var date = require('./date.cjs');
 var time = require('./time.cjs');
+var file = require('./file.cjs');
 
 const defaultTransformers = [
     array.arrayTransformer,
@@ -46,6 +47,7 @@ const defaultTransformers = [
     unknown.unknownTransformer,
     date.dateTransformer,
     time.timeTransformer,
+    file.fileTransformer,
 ];
 
 exports.arrayTransformer = array.arrayTransformer;

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

@@ -20,4 +20,4 @@ export * from "./union";
 export * from "./unknown";
 export * from "./date";
 export * from "./time";
-export declare const defaultTransformers: readonly [(schema: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither];
+export declare const defaultTransformers: readonly [(schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither];

package/dist/toTypescript/transformer/defaults/index.mjs

@@ -20,6 +20,7 @@ import { unionTransformer } from './union.mjs';
 import { unknownTransformer } from './unknown.mjs';
 import { dateTransformer } from './date.mjs';
 import { timeTransformer } from './time.mjs';
+import { fileTransformer } from './file.mjs';
 
 const defaultTransformers = [
     arrayTransformer,
@@ -44,6 +45,7 @@ const defaultTransformers = [
     unknownTransformer,
     dateTransformer,
     timeTransformer,
+    fileTransformer,
 ];
 
 export { arrayTransformer, bigIntTransformer, booleanTransformer, dateTransformer, defaultTransformers, emptyTransformer, lazyTransformer, literalTransformer, nilTransformer, nullableTransformer, numberTransformer, objectTransformer, optionalTransformer, pipeTransformer, recordTransformer, recoverTransformer, stringTransformer, templateLiteralTransformer, timeTransformer, transformTransformer, tupleTransformer, unionTransformer, unknownTransformer };

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -4,12 +4,22 @@ var utils = require('@duplojs/utils');
 var typescript = require('typescript');
 var create = require('../create.cjs');
 
-const timeTransformer = create.createTransformer(utils.DP.timeKind.has, (__schema, { success }) => success(typescript.factory.createTemplateLiteralType(typescript.factory.createTemplateHead("time", "time"), [
-    typescript.factory.createTemplateLiteralTypeSpan(typescript.factory.createKeywordTypeNode(typescript.SyntaxKind.NumberKeyword), typescript.factory.createTemplateMiddle("", "")),
-    typescript.factory.createTemplateLiteralTypeSpan(typescript.factory.createUnionTypeNode([
-        typescript.factory.createLiteralTypeNode(typescript.factory.createStringLiteral("-")),
-        typescript.factory.createLiteralTypeNode(typescript.factory.createStringLiteral("+")),
-    ]), typescript.factory.createTemplateTail("", "")),
-])));
+const theTime = typescript.factory.createTypeReferenceNode(typescript.factory.createIdentifier("TheTime"));
+const serializedTheTime = typescript.factory.createTypeReferenceNode(typescript.factory.createIdentifier("SerializedTheTime"));
+const number = typescript.factory.createKeywordTypeNode(typescript.SyntaxKind.NumberKeyword);
+const timeTransformer = create.createTransformer(utils.DP.timeKind.has, (__schema, { mode, success, addImport, }) => {
+    addImport("@duplojs/utils/date", "TheTime");
+    return utils.P.match(mode)
+        .with("out", () => success(theTime))
+        .with("in", () => {
+        addImport("@duplojs/utils/date", "SerializedTheTime");
+        return success(typescript.factory.createUnionTypeNode([
+            serializedTheTime,
+            number,
+            theTime,
+        ]));
+    })
+        .exhaustive();
+});
 
 exports.timeTransformer = timeTransformer;

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

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

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

@@ -1,13 +1,23 @@
-import { DP } from '@duplojs/utils';
+import { DP, P } from '@duplojs/utils';
 import { factory, SyntaxKind } from 'typescript';
 import { createTransformer } from '../create.mjs';
 
-const timeTransformer = createTransformer(DP.timeKind.has, (__schema, { success }) => success(factory.createTemplateLiteralType(factory.createTemplateHead("time", "time"), [
-    factory.createTemplateLiteralTypeSpan(factory.createKeywordTypeNode(SyntaxKind.NumberKeyword), factory.createTemplateMiddle("", "")),
-    factory.createTemplateLiteralTypeSpan(factory.createUnionTypeNode([
-        factory.createLiteralTypeNode(factory.createStringLiteral("-")),
-        factory.createLiteralTypeNode(factory.createStringLiteral("+")),
-    ]), factory.createTemplateTail("", "")),
-])));
+const theTime = factory.createTypeReferenceNode(factory.createIdentifier("TheTime"));
+const serializedTheTime = factory.createTypeReferenceNode(factory.createIdentifier("SerializedTheTime"));
+const number = factory.createKeywordTypeNode(SyntaxKind.NumberKeyword);
+const timeTransformer = createTransformer(DP.timeKind.has, (__schema, { mode, success, addImport, }) => {
+    addImport("@duplojs/utils/date", "TheTime");
+    return P.match(mode)
+        .with("out", () => success(theTime))
+        .with("in", () => {
+        addImport("@duplojs/utils/date", "SerializedTheTime");
+        return success(factory.createUnionTypeNode([
+            serializedTheTime,
+            number,
+            theTime,
+        ]));
+    })
+        .exhaustive();
+});
 
 export { timeTransformer };

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

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

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

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

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

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