@schematichq/schematic-typescript-node 1.2.6 → 1.3.0

package/dist/core/fetcher/EndpointSupplier.d.ts

@@ -0,0 +1,12 @@
+import type { EndpointMetadata } from "./EndpointMetadata";
+import type { Supplier } from "./Supplier";
+type EndpointSupplierFn<T> = (arg: {
+    endpointMetadata: EndpointMetadata;
+}) => T | Promise<T>;
+export type EndpointSupplier<T> = Supplier<T> | EndpointSupplierFn<T>;
+export declare const EndpointSupplier: {
+    get: <T>(supplier: EndpointSupplier<T>, arg: {
+        endpointMetadata: EndpointMetadata;
+    }) => Promise<T>;
+};
+export {};

package/dist/core/fetcher/Fetcher.d.ts

@@ -1,22 +1,28 @@
-import { APIResponse } from "./APIResponse";
+import { type LogConfig, type Logger } from "../logging/logger";
+import type { APIResponse } from "./APIResponse";
+import type { EndpointMetadata } from "./EndpointMetadata";
+import { EndpointSupplier } from "./EndpointSupplier";
 export type FetchFunction = <R = unknown>(args: Fetcher.Args) => Promise<APIResponse<R, Fetcher.Error>>;
 export declare namespace Fetcher {
     interface Args {
         url: string;
         method: string;
         contentType?: string;
-        headers?: Record<string, string | undefined>;
-        queryParameters?: Record<string, string | string[] | object | object[] | null>;
+        headers?: Record<string, string | EndpointSupplier<string | null | undefined> | null | undefined>;
+        queryParameters?: Record<string, unknown>;
         body?: unknown;
         timeoutMs?: number;
         maxRetries?: number;
         withCredentials?: boolean;
         abortSignal?: AbortSignal;
-        requestType?: "json" | "file" | "bytes";
-        responseType?: "json" | "blob" | "sse" | "streaming" | "text" | "arrayBuffer";
+        requestType?: "json" | "file" | "bytes" | "form" | "other";
+        responseType?: "json" | "blob" | "sse" | "streaming" | "text" | "arrayBuffer" | "binary-response";
         duplex?: "half";
+        endpointMetadata?: EndpointMetadata;
+        fetchFn?: typeof fetch;
+        logging?: LogConfig | Logger;
     }
-    type Error = FailedStatusCodeError | NonJsonError | TimeoutError | UnknownError;
+    type Error = FailedStatusCodeError | NonJsonError | BodyIsNullError | TimeoutError | UnknownError;
     interface FailedStatusCodeError {
         reason: "status-code";
         statusCode: number;
@@ -27,6 +33,10 @@ export declare namespace Fetcher {
         statusCode: number;
         rawBody: string;
     }
+    interface BodyIsNullError {
+        reason: "body-is-null";
+        statusCode: number;
+    }
     interface TimeoutError {
         reason: "timeout";
     }

package/dist/core/fetcher/HttpResponsePromise.d.ts

@@ -1,4 +1,4 @@
-import { WithRawResponse } from "./RawResponse";
+import type { WithRawResponse } from "./RawResponse";
 /**
  * A promise that returns the parsed response and lets you retrieve the raw response too.
  */

package/dist/core/fetcher/createRequestUrl.d.ts

@@ -1 +1 @@
-export declare function createRequestUrl(baseUrl: string, queryParameters?: Record<string, string | string[] | object | object[] | null>): string;
+export declare function createRequestUrl(baseUrl: string, queryParameters?: Record<string, unknown>): string;

package/dist/core/fetcher/getErrorResponseBody.d.ts

@@ -0,0 +1 @@
+export declare function getErrorResponseBody(response: Response): Promise<unknown>;

package/dist/core/fetcher/getRequestBody.d.ts

@@ -1,7 +1,7 @@
 export declare namespace GetRequestBody {
     interface Args {
         body: unknown;
-        type: "json" | "file" | "bytes" | "other";
+        type: "json" | "file" | "bytes" | "form" | "other";
     }
 }
 export declare function getRequestBody({ body, type }: GetRequestBody.Args): Promise<BodyInit | undefined>;

package/dist/core/fetcher/index.d.ts

@@ -1,8 +1,11 @@
 export type { APIResponse } from "./APIResponse";
-export { fetcher } from "./Fetcher";
+export type { BinaryResponse } from "./BinaryResponse";
+export type { EndpointMetadata } from "./EndpointMetadata";
+export { EndpointSupplier } from "./EndpointSupplier";
 export type { Fetcher, FetchFunction } from "./Fetcher";
+export { fetcher } from "./Fetcher";
 export { getHeader } from "./getHeader";
-export { Supplier } from "./Supplier";
-export { abortRawResponse, toRawResponse, unknownRawResponse } from "./RawResponse";
-export type { RawResponse, WithRawResponse } from "./RawResponse";
 export { HttpResponsePromise } from "./HttpResponsePromise";
+export type { RawResponse, WithRawResponse } from "./RawResponse";
+export { abortRawResponse, toRawResponse, unknownRawResponse } from "./RawResponse";
+export { Supplier } from "./Supplier";

package/dist/core/fetcher/makeRequest.d.ts

@@ -1 +1 @@
-export declare const makeRequest: (fetchFn: (url: string, init: RequestInit) => Promise<Response>, url: string, method: string, headers: Record<string, string>, requestBody: BodyInit | undefined, timeoutMs?: number, abortSignal?: AbortSignal, withCredentials?: boolean, duplex?: "half") => Promise<Response>;
+export declare const makeRequest: (fetchFn: (url: string, init: RequestInit) => Promise<Response>, url: string, method: string, headers: Headers | Record<string, string>, requestBody: BodyInit | undefined, timeoutMs?: number, abortSignal?: AbortSignal, withCredentials?: boolean, duplex?: "half") => Promise<Response>;

package/dist/core/fetcher/signals.d.ts

@@ -1,11 +1,5 @@
 export declare function getTimeoutSignal(timeoutMs: number): {
     signal: AbortSignal;
-    abortId: NodeJS.Timeout;
+    abortId: ReturnType<typeof setTimeout>;
 };
-/**
- * Returns an abort signal that is getting aborted when
- * at least one of the specified abort signals is aborted.
- *
- * Requires at least node.js 18.
- */
 export declare function anySignal(...args: AbortSignal[] | [AbortSignal[]]): AbortSignal;

package/dist/core/fetcher/stream-wrappers/Node18UniversalStreamWrapper.d.ts

@@ -1,5 +1,5 @@
 import type { Writable } from "readable-stream";
-import { EventCallback, StreamWrapper } from "./chooseStreamWrapper";
+import type { EventCallback, StreamWrapper } from "./chooseStreamWrapper";
 export declare class Node18UniversalStreamWrapper<ReadFormat extends Uint8Array | Uint16Array | Uint32Array> implements StreamWrapper<Node18UniversalStreamWrapper<ReadFormat> | Writable | WritableStream<ReadFormat>, ReadFormat> {
     private readableStream;
     private reader;

package/dist/core/fetcher/stream-wrappers/NodePre18StreamWrapper.d.ts

@@ -1,5 +1,5 @@
 import type { Readable, Writable } from "readable-stream";
-import { EventCallback, StreamWrapper } from "./chooseStreamWrapper";
+import type { EventCallback, StreamWrapper } from "./chooseStreamWrapper";
 export declare class NodePre18StreamWrapper implements StreamWrapper<Writable, Buffer> {
     private readableStream;
     private encoding;

package/dist/core/fetcher/stream-wrappers/UndiciStreamWrapper.d.ts

@@ -1,4 +1,4 @@
-import { StreamWrapper } from "./chooseStreamWrapper";
+import type { StreamWrapper } from "./chooseStreamWrapper";
 type EventCallback = (data?: any) => void;
 export declare class UndiciStreamWrapper<ReadFormat extends Uint8Array | Uint16Array | Uint32Array> implements StreamWrapper<UndiciStreamWrapper<ReadFormat> | WritableStream<ReadFormat>, ReadFormat> {
     private readableStream;

package/dist/core/headers.d.ts

@@ -0,0 +1,2 @@
+export declare function mergeHeaders<THeaderValue>(...headersArray: (Record<string, THeaderValue> | null | undefined)[]): Record<string, string | THeaderValue>;
+export declare function mergeOnlyDefinedHeaders<THeaderValue>(...headersArray: (Record<string, THeaderValue> | null | undefined)[]): Record<string, THeaderValue>;

package/dist/core/index.d.ts

@@ -1,3 +1,7 @@
+export * from "./auth";
+export * from "./base64";
 export * from "./fetcher";
+export * as logging from "./logging";
 export * from "./runtime";
 export * as serialization from "./schemas";
+export * as url from "./url";

package/dist/core/logging/exports.d.ts

@@ -0,0 +1,18 @@
+import * as logger from "./logger";
+export declare namespace logging {
+    /**
+     * Configuration for logger instances.
+     */
+    type LogConfig = logger.LogConfig;
+    type LogLevel = logger.LogLevel;
+    const LogLevel: typeof logger.LogLevel;
+    type ILogger = logger.ILogger;
+    /**
+     * Console logger implementation that outputs to the console.
+     */
+    type ConsoleLogger = logger.ConsoleLogger;
+    /**
+     * Console logger implementation that outputs to the console.
+     */
+    const ConsoleLogger: typeof logger.ConsoleLogger;
+}

package/dist/core/logging/index.d.ts

@@ -0,0 +1 @@
+export * from "./logger";

package/dist/core/logging/logger.d.ts

@@ -0,0 +1,126 @@
+export declare const LogLevel: {
+    readonly Debug: "debug";
+    readonly Info: "info";
+    readonly Warn: "warn";
+    readonly Error: "error";
+};
+export type LogLevel = (typeof LogLevel)[keyof typeof LogLevel];
+export interface ILogger {
+    /**
+     * Logs a debug message.
+     * @param message - The message to log
+     * @param args - Additional arguments to log
+     */
+    debug(message: string, ...args: unknown[]): void;
+    /**
+     * Logs an info message.
+     * @param message - The message to log
+     * @param args - Additional arguments to log
+     */
+    info(message: string, ...args: unknown[]): void;
+    /**
+     * Logs a warning message.
+     * @param message - The message to log
+     * @param args - Additional arguments to log
+     */
+    warn(message: string, ...args: unknown[]): void;
+    /**
+     * Logs an error message.
+     * @param message - The message to log
+     * @param args - Additional arguments to log
+     */
+    error(message: string, ...args: unknown[]): void;
+}
+/**
+ * Configuration for logger initialization.
+ */
+export interface LogConfig {
+    /**
+     * Minimum log level to output.
+     * @default LogLevel.Info
+     */
+    level?: LogLevel;
+    /**
+     * Logger implementation to use.
+     * @default new ConsoleLogger()
+     */
+    logger?: ILogger;
+    /**
+     * Whether logging should be silenced.
+     * @default true
+     */
+    silent?: boolean;
+}
+/**
+ * Default console-based logger implementation.
+ */
+export declare class ConsoleLogger implements ILogger {
+    debug(message: string, ...args: unknown[]): void;
+    info(message: string, ...args: unknown[]): void;
+    warn(message: string, ...args: unknown[]): void;
+    error(message: string, ...args: unknown[]): void;
+}
+/**
+ * Logger class that provides level-based logging functionality.
+ */
+export declare class Logger {
+    private readonly level;
+    private readonly logger;
+    private readonly silent;
+    /**
+     * Creates a new logger instance.
+     * @param config - Logger configuration
+     */
+    constructor(config: Required<LogConfig>);
+    /**
+     * Checks if a log level should be output based on configuration.
+     * @param level - The log level to check
+     * @returns True if the level should be logged
+     */
+    shouldLog(level: LogLevel): boolean;
+    /**
+     * Checks if debug logging is enabled.
+     * @returns True if debug logs should be output
+     */
+    isDebug(): boolean;
+    /**
+     * Logs a debug message if debug logging is enabled.
+     * @param message - The message to log
+     * @param args - Additional arguments to log
+     */
+    debug(message: string, ...args: unknown[]): void;
+    /**
+     * Checks if info logging is enabled.
+     * @returns True if info logs should be output
+     */
+    isInfo(): boolean;
+    /**
+     * Logs an info message if info logging is enabled.
+     * @param message - The message to log
+     * @param args - Additional arguments to log
+     */
+    info(message: string, ...args: unknown[]): void;
+    /**
+     * Checks if warning logging is enabled.
+     * @returns True if warning logs should be output
+     */
+    isWarn(): boolean;
+    /**
+     * Logs a warning message if warning logging is enabled.
+     * @param message - The message to log
+     * @param args - Additional arguments to log
+     */
+    warn(message: string, ...args: unknown[]): void;
+    /**
+     * Checks if error logging is enabled.
+     * @returns True if error logs should be output
+     */
+    isError(): boolean;
+    /**
+     * Logs an error message if error logging is enabled.
+     * @param message - The message to log
+     * @param args - Additional arguments to log
+     */
+    error(message: string, ...args: unknown[]): void;
+}
+export declare function createLogger(config?: LogConfig | Logger): Logger;

package/dist/core/schemas/Schema.d.ts

@@ -1,4 +1,4 @@
-import { SchemaUtils } from "./builders";
+import type { SchemaUtils } from "./builders/index";
 export type Schema<Raw = unknown, Parsed = unknown> = BaseSchema<Raw, Parsed> & SchemaUtils<Raw, Parsed>;
 export type inferRaw<S extends Schema> = S extends Schema<infer Raw, any> ? Raw : never;
 export type inferParsed<S extends Schema> = S extends Schema<any, infer Parsed> ? Parsed : never;
@@ -20,6 +20,7 @@ export declare const SchemaType: {
     readonly NUMBER: "number";
     readonly STRING: "string";
     readonly UNKNOWN: "unknown";
+    readonly NEVER: "never";
     readonly RECORD: "record";
     readonly SET: "set";
     readonly UNION: "union";

package/dist/core/schemas/builders/bigint/bigint.d.ts

@@ -1,2 +1,2 @@
-import { Schema } from "../../Schema";
+import { type Schema } from "../../Schema";
 export declare function bigint(): Schema<bigint | number, bigint>;

package/dist/core/schemas/builders/date/date.d.ts

@@ -1,2 +1,2 @@
-import { Schema } from "../../Schema";
+import { type Schema } from "../../Schema";
 export declare function date(): Schema<string, Date>;

package/dist/core/schemas/builders/enum/enum.d.ts

@@ -1,2 +1,2 @@
-import { Schema } from "../../Schema";
+import { type Schema } from "../../Schema";
 export declare function enum_<U extends string, E extends U[]>(values: E): Schema<E[number], E[number]>;

package/dist/core/schemas/builders/index.d.ts

@@ -1,14 +1,14 @@
-export * from "./bigint";
-export * from "./date";
-export * from "./enum";
-export * from "./lazy";
-export * from "./list";
-export * from "./literals";
-export * from "./object";
-export * from "./object-like";
-export * from "./primitives";
-export * from "./record";
-export * from "./schema-utils";
-export * from "./set";
-export * from "./undiscriminated-union";
-export * from "./union";
+export * from "./bigint/index";
+export * from "./date/index";
+export * from "./enum/index";
+export * from "./lazy/index";
+export * from "./list/index";
+export * from "./literals/index";
+export * from "./object/index";
+export * from "./object-like/index";
+export * from "./primitives/index";
+export * from "./record/index";
+export * from "./schema-utils/index";
+export * from "./set/index";
+export * from "./undiscriminated-union/index";
+export * from "./union/index";

package/dist/core/schemas/builders/lazy/index.d.ts

@@ -1,3 +1,3 @@
-export { lazy } from "./lazy";
 export type { SchemaGetter } from "./lazy";
+export { lazy } from "./lazy";
 export { lazyObject } from "./lazyObject";

package/dist/core/schemas/builders/lazy/lazy.d.ts

@@ -1,4 +1,4 @@
-import { BaseSchema, Schema } from "../../Schema";
+import type { BaseSchema, Schema } from "../../Schema";
 export type SchemaGetter<SchemaType extends Schema<any, any>> = () => SchemaType;
 export declare function lazy<Raw, Parsed>(getter: SchemaGetter<Schema<Raw, Parsed>>): Schema<Raw, Parsed>;
 export declare function constructLazyBaseSchema<Raw, Parsed>(getter: SchemaGetter<Schema<Raw, Parsed>>): BaseSchema<Raw, Parsed>;

package/dist/core/schemas/builders/lazy/lazyObject.d.ts

@@ -1,3 +1,3 @@
-import { ObjectSchema } from "../object/types";
-import { SchemaGetter } from "./lazy";
+import type { ObjectSchema } from "../object/types";
+import { type SchemaGetter } from "./lazy";
 export declare function lazyObject<Raw, Parsed>(getter: SchemaGetter<ObjectSchema<Raw, Parsed>>): ObjectSchema<Raw, Parsed>;

package/dist/core/schemas/builders/list/list.d.ts

@@ -1,2 +1,2 @@
-import { Schema } from "../../Schema";
+import { type Schema } from "../../Schema";
 export declare function list<Raw, Parsed>(schema: Schema<Raw, Parsed>): Schema<Raw[], Parsed[]>;

package/dist/core/schemas/builders/literals/booleanLiteral.d.ts

@@ -1,2 +1,2 @@
-import { Schema } from "../../Schema";
+import { type Schema } from "../../Schema";
 export declare function booleanLiteral<V extends boolean>(literal: V): Schema<V, V>;

package/dist/core/schemas/builders/literals/index.d.ts

@@ -1,2 +1,2 @@
-export { stringLiteral } from "./stringLiteral";
 export { booleanLiteral } from "./booleanLiteral";
+export { stringLiteral } from "./stringLiteral";

package/dist/core/schemas/builders/literals/stringLiteral.d.ts

@@ -1,2 +1,2 @@
-import { Schema } from "../../Schema";
+import { type Schema } from "../../Schema";
 export declare function stringLiteral<V extends string>(literal: V): Schema<V, V>;

package/dist/core/schemas/builders/object/index.d.ts

@@ -1,6 +1,6 @@
 export { getObjectUtils, object } from "./object";
-export { objectWithoutOptionalProperties } from "./objectWithoutOptionalProperties";
 export type { inferObjectWithoutOptionalPropertiesSchemaFromPropertySchemas, inferParsedObjectWithoutOptionalPropertiesFromPropertySchemas, } from "./objectWithoutOptionalProperties";
-export { isProperty, property } from "./property";
+export { objectWithoutOptionalProperties } from "./objectWithoutOptionalProperties";
 export type { Property } from "./property";
+export { isProperty, property } from "./property";
 export type { BaseObjectSchema, inferObjectSchemaFromPropertySchemas, inferParsedObject, inferParsedObjectFromPropertySchemas, inferParsedPropertySchema, inferRawKey, inferRawObject, inferRawObjectFromPropertySchemas, inferRawPropertySchema, ObjectSchema, ObjectUtils, PropertySchemas, } from "./types";

package/dist/core/schemas/builders/object/object.d.ts

@@ -1,3 +1,3 @@
-import { BaseObjectSchema, ObjectUtils, PropertySchemas, inferObjectSchemaFromPropertySchemas } from "./types";
+import type { BaseObjectSchema, inferObjectSchemaFromPropertySchemas, ObjectUtils, PropertySchemas } from "./types";
 export declare function object<ParsedKeys extends string, T extends PropertySchemas<ParsedKeys>>(schemas: T): inferObjectSchemaFromPropertySchemas<T>;
 export declare function getObjectUtils<Raw, Parsed>(schema: BaseObjectSchema<Raw, Parsed>): ObjectUtils<Raw, Parsed>;

package/dist/core/schemas/builders/object/objectWithoutOptionalProperties.d.ts

@@ -1,4 +1,4 @@
-import { ObjectSchema, PropertySchemas, inferParsedPropertySchema, inferRawObjectFromPropertySchemas } from "./types";
+import type { inferParsedPropertySchema, inferRawObjectFromPropertySchemas, ObjectSchema, PropertySchemas } from "./types";
 export declare function objectWithoutOptionalProperties<ParsedKeys extends string, T extends PropertySchemas<ParsedKeys>>(schemas: T): inferObjectWithoutOptionalPropertiesSchemaFromPropertySchemas<T>;
 export type inferObjectWithoutOptionalPropertiesSchemaFromPropertySchemas<T extends PropertySchemas<keyof T>> = ObjectSchema<inferRawObjectFromPropertySchemas<T>, inferParsedObjectWithoutOptionalPropertiesFromPropertySchemas<T>>;
 export type inferParsedObjectWithoutOptionalPropertiesFromPropertySchemas<T extends PropertySchemas<keyof T>> = {

package/dist/core/schemas/builders/object/property.d.ts

@@ -1,4 +1,4 @@
-import { Schema } from "../../Schema";
+import type { Schema } from "../../Schema";
 export declare function property<RawKey extends string, RawValue, ParsedValue>(rawKey: RawKey, valueSchema: Schema<RawValue, ParsedValue>): Property<RawKey, RawValue, ParsedValue>;
 export interface Property<RawKey extends string, RawValue, ParsedValue> {
     rawKey: RawKey;

package/dist/core/schemas/builders/object/types.d.ts

@@ -1,8 +1,8 @@
-import { BaseSchema, Schema, inferParsed, inferRaw } from "../../Schema";
-import { addQuestionMarksToNullableProperties } from "../../utils/addQuestionMarksToNullableProperties";
-import { ObjectLikeUtils } from "../object-like";
-import { SchemaUtils } from "../schema-utils";
-import { Property } from "./property";
+import type { BaseSchema, inferParsed, inferRaw, Schema } from "../../Schema";
+import type { addQuestionMarksToNullableProperties } from "../../utils/addQuestionMarksToNullableProperties";
+import type { ObjectLikeUtils } from "../object-like/index";
+import type { SchemaUtils } from "../schema-utils/index";
+import type { Property } from "./property";
 export type ObjectSchema<Raw, Parsed> = BaseObjectSchema<Raw, Parsed> & ObjectLikeUtils<Raw, Parsed> & ObjectUtils<Raw, Parsed> & SchemaUtils<Raw, Parsed>;
 export interface BaseObjectSchema<Raw, Parsed> extends BaseSchema<Raw, Parsed> {
     _getRawProperties: () => (keyof Raw)[];

package/dist/core/schemas/builders/object-like/getObjectLikeUtils.d.ts

@@ -1,5 +1,5 @@
-import { BaseSchema } from "../../Schema";
-import { ObjectLikeSchema, ObjectLikeUtils } from "./types";
+import type { BaseSchema } from "../../Schema";
+import type { ObjectLikeSchema, ObjectLikeUtils } from "./types";
 export declare function getObjectLikeUtils<Raw, Parsed>(schema: BaseSchema<Raw, Parsed>): ObjectLikeUtils<Raw, Parsed>;
 /**
  * object-like utils are defined in one file to resolve issues with circular imports

package/dist/core/schemas/builders/object-like/types.d.ts

@@ -1,4 +1,4 @@
-import { BaseSchema, Schema } from "../../Schema";
+import type { BaseSchema, Schema } from "../../Schema";
 export type ObjectLikeSchema<Raw, Parsed> = Schema<Raw, Parsed> & BaseSchema<Raw, Parsed> & ObjectLikeUtils<Raw, Parsed>;
 export interface ObjectLikeUtils<Raw, Parsed> {
     withParsedProperties: <T extends Record<string, any>>(properties: {

package/dist/core/schemas/builders/primitives/any.d.ts

@@ -1 +1,2 @@
-export declare const any: () => import("../../Schema").Schema<any, any>;
+import { type Schema } from "../../Schema";
+export declare const any: () => Schema<any, any>;

package/dist/core/schemas/builders/primitives/boolean.d.ts

@@ -1 +1,2 @@
-export declare const boolean: () => import("../../Schema").Schema<boolean, boolean>;
+import { type Schema } from "../../Schema";
+export declare const boolean: () => Schema<boolean, boolean>;

package/dist/core/schemas/builders/primitives/index.d.ts

@@ -1,5 +1,6 @@
 export { any } from "./any";
 export { boolean } from "./boolean";
+export { never } from "./never";
 export { number } from "./number";
 export { string } from "./string";
 export { unknown } from "./unknown";

package/dist/core/schemas/builders/primitives/never.d.ts

@@ -0,0 +1,2 @@
+import { type Schema } from "../../Schema";
+export declare const never: () => Schema<never, never>;

package/dist/core/schemas/builders/primitives/number.d.ts

@@ -1 +1,2 @@
-export declare const number: () => import("../../Schema").Schema<number, number>;
+import { type Schema } from "../../Schema";
+export declare const number: () => Schema<number, number>;

package/dist/core/schemas/builders/primitives/string.d.ts

@@ -1 +1,2 @@
-export declare const string: () => import("../../Schema").Schema<string, string>;
+import { type Schema } from "../../Schema";
+export declare const string: () => Schema<string, string>;

package/dist/core/schemas/builders/primitives/unknown.d.ts

@@ -1 +1,2 @@
-export declare const unknown: () => import("../../Schema").Schema<unknown, unknown>;
+import { type Schema } from "../../Schema";
+export declare const unknown: () => Schema<unknown, unknown>;

package/dist/core/schemas/builders/record/record.d.ts

@@ -1,3 +1,3 @@
-import { Schema } from "../../Schema";
-import { RecordSchema } from "./types";
+import { type Schema } from "../../Schema";
+import type { RecordSchema } from "./types";
 export declare function record<RawKey extends string | number, RawValue, ParsedValue, ParsedKey extends string | number>(keySchema: Schema<RawKey, ParsedKey>, valueSchema: Schema<RawValue, ParsedValue>): RecordSchema<RawKey, RawValue, ParsedKey, ParsedValue>;

package/dist/core/schemas/builders/record/types.d.ts

@@ -1,4 +1,4 @@
-import { BaseSchema } from "../../Schema";
-import { SchemaUtils } from "../schema-utils";
+import type { BaseSchema } from "../../Schema";
+import type { SchemaUtils } from "../schema-utils/index";
 export type RecordSchema<RawKey extends string | number, RawValue, ParsedKey extends string | number, ParsedValue> = BaseRecordSchema<RawKey, RawValue, ParsedKey, ParsedValue> & SchemaUtils<Record<RawKey, RawValue>, Record<ParsedKey, ParsedValue>>;
 export type BaseRecordSchema<RawKey extends string | number, RawValue, ParsedKey extends string | number, ParsedValue> = BaseSchema<Record<RawKey, RawValue>, Record<ParsedKey, ParsedValue>>;

package/dist/core/schemas/builders/schema-utils/JsonError.d.ts

@@ -1,4 +1,4 @@
-import { ValidationError } from "../../Schema";
+import type { ValidationError } from "../../Schema";
 export declare class JsonError extends Error {
     readonly errors: ValidationError[];
     constructor(errors: ValidationError[]);

package/dist/core/schemas/builders/schema-utils/ParseError.d.ts

@@ -1,4 +1,4 @@
-import { ValidationError } from "../../Schema";
+import type { ValidationError } from "../../Schema";
 export declare class ParseError extends Error {
     readonly errors: ValidationError[];
     constructor(errors: ValidationError[]);

package/dist/core/schemas/builders/schema-utils/getSchemaUtils.d.ts

@@ -1,4 +1,4 @@
-import { BaseSchema, Schema, SchemaOptions } from "../../Schema";
+import { type BaseSchema, type Schema, type SchemaOptions } from "../../Schema";
 export interface SchemaUtils<Raw, Parsed> {
     nullable: () => Schema<Raw | null, Parsed | null>;
     optional: () => Schema<Raw | null | undefined, Parsed | undefined>;

package/dist/core/schemas/builders/schema-utils/index.d.ts

@@ -1,4 +1,4 @@
-export { getSchemaUtils, optional, transform } from "./getSchemaUtils";
 export type { SchemaUtils } from "./getSchemaUtils";
+export { getSchemaUtils, optional, transform } from "./getSchemaUtils";
 export { JsonError } from "./JsonError";
 export { ParseError } from "./ParseError";

package/dist/core/schemas/builders/schema-utils/stringifyValidationErrors.d.ts

@@ -1,2 +1,2 @@
-import { ValidationError } from "../../Schema";
+import type { ValidationError } from "../../Schema";
 export declare function stringifyValidationError(error: ValidationError): string;

package/dist/core/schemas/builders/set/set.d.ts

@@ -1,2 +1,2 @@
-import { Schema } from "../../Schema";
+import { type Schema } from "../../Schema";
 export declare function set<Raw, Parsed>(schema: Schema<Raw, Parsed>): Schema<Raw[], Set<Parsed>>;

package/dist/core/schemas/builders/undiscriminated-union/types.d.ts

@@ -1,4 +1,4 @@
-import { Schema, inferParsed, inferRaw } from "../../Schema";
+import type { inferParsed, inferRaw, Schema } from "../../Schema";
 export type UndiscriminatedUnionSchema<Schemas extends [...Schema[]]> = Schema<inferRawUnidiscriminatedUnionSchema<Schemas>, inferParsedUnidiscriminatedUnionSchema<Schemas>>;
 export type inferRawUnidiscriminatedUnionSchema<Schemas extends [...Schema[]]> = inferRaw<Schemas[number]>;
 export type inferParsedUnidiscriminatedUnionSchema<Schemas extends [...Schema[]]> = inferParsed<Schemas[number]>;

package/dist/core/schemas/builders/undiscriminated-union/undiscriminatedUnion.d.ts

@@ -1,3 +1,3 @@
-import { Schema } from "../../Schema";
-import { inferParsedUnidiscriminatedUnionSchema, inferRawUnidiscriminatedUnionSchema } from "./types";
+import { type Schema } from "../../Schema";
+import type { inferParsedUnidiscriminatedUnionSchema, inferRawUnidiscriminatedUnionSchema } from "./types";
 export declare function undiscriminatedUnion<Schemas extends [Schema<any, any>, ...Schema<any, any>[]]>(schemas: Schemas): Schema<inferRawUnidiscriminatedUnionSchema<Schemas>, inferParsedUnidiscriminatedUnionSchema<Schemas>>;

package/dist/core/schemas/builders/union/index.d.ts

@@ -1,4 +1,4 @@
-export { discriminant } from "./discriminant";
 export type { Discriminant } from "./discriminant";
+export { discriminant } from "./discriminant";
 export type { inferParsedDiscriminant, inferParsedUnion, inferRawDiscriminant, inferRawUnion, UnionSubtypes, } from "./types";
 export { union } from "./union";

package/dist/core/schemas/builders/union/types.d.ts

@@ -1,5 +1,5 @@
-import { ObjectSchema, inferParsedObject, inferRawObject } from "../object";
-import { Discriminant } from "./discriminant";
+import type { inferParsedObject, inferRawObject, ObjectSchema } from "../object/index";
+import type { Discriminant } from "./discriminant";
 export type UnionSubtypes<DiscriminantValues extends string | number | symbol> = {
     [K in DiscriminantValues]: ObjectSchema<any, any>;
 };

package/dist/core/schemas/builders/union/union.d.ts

@@ -1,4 +1,4 @@
-import { ObjectLikeSchema } from "../object-like";
-import { Discriminant } from "./discriminant";
-import { UnionSubtypes, inferParsedUnion, inferRawUnion } from "./types";
+import { type ObjectLikeSchema } from "../object-like";
+import type { Discriminant } from "./discriminant";
+import type { inferParsedUnion, inferRawUnion, UnionSubtypes } from "./types";
 export declare function union<D extends string | Discriminant<any, any>, U extends UnionSubtypes<any>>(discriminant: D, union: U): ObjectLikeSchema<inferRawUnion<D, U>, inferParsedUnion<D, U>>;

package/dist/core/schemas/index.d.ts

@@ -1,2 +1,2 @@
-export * from "./builders";
+export * from "./builders/index";
 export type { inferParsed, inferRaw, Schema, SchemaOptions } from "./Schema";