@depup/sinclair__typebox 0.34.48-depup.0

package/build/cjs/type/template-literal/template-literal.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TemplateLiteral = TemplateLiteral;
+const type_1 = require("../create/type");
+const syntax_1 = require("./syntax");
+const pattern_1 = require("./pattern");
+const value_1 = require("../guard/value");
+const index_1 = require("../symbols/index");
+/** `[Json]` Creates a TemplateLiteral type */
+// prettier-ignore
+function TemplateLiteral(unresolved, options) {
+    const pattern = (0, value_1.IsString)(unresolved)
+        ? (0, pattern_1.TemplateLiteralPattern)((0, syntax_1.TemplateLiteralSyntax)(unresolved))
+        : (0, pattern_1.TemplateLiteralPattern)(unresolved);
+    return (0, type_1.CreateType)({ [index_1.Kind]: 'TemplateLiteral', type: 'string', pattern }, options);
+}

package/build/cjs/type/template-literal/union.d.ts

@@ -0,0 +1,9 @@
+import type { Static } from '../static/index';
+import type { TTemplateLiteral } from './template-literal';
+import type { UnionToTuple } from '../helpers/index';
+import { type TUnionEvaluated } from '../union/index';
+import { type TLiteral } from '../literal/index';
+export type TTemplateLiteralToUnionLiteralArray<T extends string[], Acc extends TLiteral[] = []> = (T extends [infer L extends string, ...infer R extends string[]] ? TTemplateLiteralToUnionLiteralArray<R, [...Acc, TLiteral<L>]> : Acc);
+export type TTemplateLiteralToUnion<T extends TTemplateLiteral, U extends string[] = UnionToTuple<Static<T>>> = TUnionEvaluated<TTemplateLiteralToUnionLiteralArray<U>>;
+/** Returns a Union from the given TemplateLiteral */
+export declare function TemplateLiteralToUnion<T extends TTemplateLiteral>(schema: TTemplateLiteral): TTemplateLiteralToUnion<T>;

package/build/cjs/type/template-literal/union.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TemplateLiteralToUnion = TemplateLiteralToUnion;
+const index_1 = require("../union/index");
+const index_2 = require("../literal/index");
+const generate_1 = require("./generate");
+/** Returns a Union from the given TemplateLiteral */
+function TemplateLiteralToUnion(schema) {
+    const R = (0, generate_1.TemplateLiteralGenerate)(schema);
+    const L = R.map((S) => (0, index_2.Literal)(S));
+    return (0, index_1.UnionEvaluated)(L);
+}

package/build/cjs/type/transform/index.d.ts

@@ -0,0 +1 @@
+export * from './transform';

package/build/cjs/type/transform/index.js

@@ -0,0 +1,18 @@
+"use strict";
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./transform"), exports);

package/build/cjs/type/transform/transform.d.ts

@@ -0,0 +1,30 @@
+import type { TSchema } from '../schema/index';
+import type { Static, StaticDecode } from '../static/index';
+import { TransformKind } from '../symbols/index';
+export declare class TransformDecodeBuilder<T extends TSchema> {
+    private readonly schema;
+    constructor(schema: T);
+    Decode<U extends unknown, D extends TransformFunction<StaticDecode<T>, U>>(decode: D): TransformEncodeBuilder<T, D>;
+}
+export declare class TransformEncodeBuilder<T extends TSchema, D extends TransformFunction> {
+    private readonly schema;
+    private readonly decode;
+    constructor(schema: T, decode: D);
+    private EncodeTransform;
+    private EncodeSchema;
+    Encode<E extends TransformFunction<ReturnType<D>, StaticDecode<T>>>(encode: E): TTransform<T, ReturnType<D>>;
+}
+type TransformStatic<T extends TSchema, P extends unknown[] = []> = T extends TTransform<infer _, infer S> ? S : Static<T, P>;
+export type TransformFunction<T = any, U = any> = (value: T) => U;
+export interface TransformOptions<I extends TSchema = TSchema, O extends unknown = unknown> {
+    Decode: TransformFunction<StaticDecode<I>, O>;
+    Encode: TransformFunction<O, StaticDecode<I>>;
+}
+export interface TTransform<I extends TSchema = TSchema, O extends unknown = unknown> extends TSchema {
+    static: TransformStatic<I, this['params']>;
+    [TransformKind]: TransformOptions<I, O>;
+    [key: string]: any;
+}
+/** `[Json]` Creates a Transform type */
+export declare function Transform<I extends TSchema>(schema: I): TransformDecodeBuilder<I>;
+export {};

package/build/cjs/type/transform/transform.js

@@ -0,0 +1,47 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransformEncodeBuilder = exports.TransformDecodeBuilder = void 0;
+exports.Transform = Transform;
+const index_1 = require("../symbols/index");
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+const kind_1 = require("../guard/kind");
+// ------------------------------------------------------------------
+// TransformBuilders
+// ------------------------------------------------------------------
+class TransformDecodeBuilder {
+    constructor(schema) {
+        this.schema = schema;
+    }
+    Decode(decode) {
+        return new TransformEncodeBuilder(this.schema, decode);
+    }
+}
+exports.TransformDecodeBuilder = TransformDecodeBuilder;
+// prettier-ignore
+class TransformEncodeBuilder {
+    constructor(schema, decode) {
+        this.schema = schema;
+        this.decode = decode;
+    }
+    EncodeTransform(encode, schema) {
+        const Encode = (value) => schema[index_1.TransformKind].Encode(encode(value));
+        const Decode = (value) => this.decode(schema[index_1.TransformKind].Decode(value));
+        const Codec = { Encode: Encode, Decode: Decode };
+        return { ...schema, [index_1.TransformKind]: Codec };
+    }
+    EncodeSchema(encode, schema) {
+        const Codec = { Decode: this.decode, Encode: encode };
+        return { ...schema, [index_1.TransformKind]: Codec };
+    }
+    Encode(encode) {
+        return ((0, kind_1.IsTransform)(this.schema) ? this.EncodeTransform(encode, this.schema) : this.EncodeSchema(encode, this.schema));
+    }
+}
+exports.TransformEncodeBuilder = TransformEncodeBuilder;
+/** `[Json]` Creates a Transform type */
+function Transform(schema) {
+    return new TransformDecodeBuilder(schema);
+}

package/build/cjs/type/tuple/index.d.ts

@@ -0,0 +1 @@
+export * from './tuple';

package/build/cjs/type/tuple/index.js

@@ -0,0 +1,18 @@
+"use strict";
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./tuple"), exports);

package/build/cjs/type/tuple/tuple.d.ts

@@ -0,0 +1,16 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import type { Static } from '../static/index';
+import { Kind } from '../symbols/index';
+type TupleStatic<T extends TSchema[], P extends unknown[], Acc extends unknown[] = []> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TupleStatic<R, P, [...Acc, Static<L, P>]> : Acc;
+export interface TTuple<T extends TSchema[] = TSchema[]> extends TSchema {
+    [Kind]: 'Tuple';
+    static: TupleStatic<T, this['params']>;
+    type: 'array';
+    items: T;
+    additionalItems?: false;
+    minItems: T['length'];
+    maxItems: T['length'];
+}
+/** `[Json]` Creates a Tuple type */
+export declare function Tuple<Types extends TSchema[]>(types: [...Types], options?: SchemaOptions): TTuple<Types>;
+export {};

package/build/cjs/type/tuple/tuple.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Tuple = Tuple;
+const type_1 = require("../create/type");
+const index_1 = require("../symbols/index");
+/** `[Json]` Creates a Tuple type */
+function Tuple(types, options) {
+    // prettier-ignore
+    return (0, type_1.CreateType)(types.length > 0 ?
+        { [index_1.Kind]: 'Tuple', type: 'array', items: types, additionalItems: false, minItems: types.length, maxItems: types.length } :
+        { [index_1.Kind]: 'Tuple', type: 'array', minItems: types.length, maxItems: types.length }, options);
+}

package/build/cjs/type/type/index.d.ts

@@ -0,0 +1,6 @@
+export { JsonTypeBuilder } from './json';
+import { JavaScriptTypeBuilder } from './javascript';
+/** JavaScript Type Builder with Static Resolution for TypeScript */
+declare const Type: InstanceType<typeof JavaScriptTypeBuilder>;
+export { JavaScriptTypeBuilder };
+export { Type };

package/build/cjs/type/type/index.js

@@ -0,0 +1,51 @@
+"use strict";
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Type = exports.JavaScriptTypeBuilder = exports.JsonTypeBuilder = void 0;
+// ------------------------------------------------------------------
+// JsonTypeBuilder
+// ------------------------------------------------------------------
+var json_1 = require("./json");
+Object.defineProperty(exports, "JsonTypeBuilder", { enumerable: true, get: function () { return json_1.JsonTypeBuilder; } });
+// ------------------------------------------------------------------
+// JavaScriptTypeBuilder
+// ------------------------------------------------------------------
+const TypeBuilder = __importStar(require("./type"));
+const javascript_1 = require("./javascript");
+Object.defineProperty(exports, "JavaScriptTypeBuilder", { enumerable: true, get: function () { return javascript_1.JavaScriptTypeBuilder; } });
+/** JavaScript Type Builder with Static Resolution for TypeScript */
+const Type = TypeBuilder;
+exports.Type = Type;

package/build/cjs/type/type/javascript.d.ts

@@ -0,0 +1,64 @@
+import { JsonTypeBuilder } from './json';
+import { type TArgument } from '../argument/index';
+import { type TAsyncIterator } from '../async-iterator/index';
+import { type TAwaited } from '../awaited/index';
+import { type TBigInt, type BigIntOptions } from '../bigint/index';
+import { type TConstructor } from '../constructor/index';
+import { type TConstructorParameters } from '../constructor-parameters/index';
+import { type TDate, type DateOptions } from '../date/index';
+import { type TFunction } from '../function/index';
+import { type TInstanceType } from '../instance-type/index';
+import { type TInstantiate } from '../instantiate/index';
+import { type TIterator } from '../iterator/index';
+import { type TParameters } from '../parameters/index';
+import { type TPromise } from '../promise/index';
+import { type TRegExp, RegExpOptions } from '../regexp/index';
+import { type TReturnType } from '../return-type/index';
+import { type TSchema, type SchemaOptions } from '../schema/index';
+import { type TSymbol } from '../symbol/index';
+import { type TUint8Array, type Uint8ArrayOptions } from '../uint8array/index';
+import { type TUndefined } from '../undefined/index';
+import { type TVoid } from '../void/index';
+/** JavaScript Type Builder with Static Resolution for TypeScript */
+export declare class JavaScriptTypeBuilder extends JsonTypeBuilder {
+    /** `[JavaScript]` Creates a Generic Argument Type */
+    Argument<Index extends number>(index: Index): TArgument<Index>;
+    /** `[JavaScript]` Creates a AsyncIterator type */
+    AsyncIterator<Type extends TSchema>(items: Type, options?: SchemaOptions): TAsyncIterator<Type>;
+    /** `[JavaScript]` Constructs a type by recursively unwrapping Promise types */
+    Awaited<Type extends TSchema>(schema: Type, options?: SchemaOptions): TAwaited<Type>;
+    /** `[JavaScript]` Creates a BigInt type */
+    BigInt(options?: BigIntOptions): TBigInt;
+    /** `[JavaScript]` Extracts the ConstructorParameters from the given Constructor type */
+    ConstructorParameters<Type extends TSchema>(schema: Type, options?: SchemaOptions): TConstructorParameters<Type>;
+    /** `[JavaScript]` Creates a Constructor type */
+    Constructor<Parameters extends TSchema[], InstanceType extends TSchema>(parameters: [...Parameters], instanceType: InstanceType, options?: SchemaOptions): TConstructor<Parameters, InstanceType>;
+    /** `[JavaScript]` Creates a Date type */
+    Date(options?: DateOptions): TDate;
+    /** `[JavaScript]` Creates a Function type */
+    Function<Parameters extends TSchema[], ReturnType extends TSchema>(parameters: [...Parameters], returnType: ReturnType, options?: SchemaOptions): TFunction<Parameters, ReturnType>;
+    /** `[JavaScript]` Extracts the InstanceType from the given Constructor type */
+    InstanceType<Type extends TSchema>(schema: Type, options?: SchemaOptions): TInstanceType<Type>;
+    /** `[JavaScript]` Instantiates a type with the given parameters */
+    Instantiate<Type extends TSchema, Parameters extends TSchema[]>(schema: Type, parameters: [...Parameters]): TInstantiate<Type, Parameters>;
+    /** `[JavaScript]` Creates an Iterator type */
+    Iterator<Type extends TSchema>(items: Type, options?: SchemaOptions): TIterator<Type>;
+    /** `[JavaScript]` Extracts the Parameters from the given Function type */
+    Parameters<Type extends TSchema>(schema: Type, options?: SchemaOptions): TParameters<Type>;
+    /** `[JavaScript]` Creates a Promise type */
+    Promise<Type extends TSchema>(item: Type, options?: SchemaOptions): TPromise<Type>;
+    /** `[JavaScript]` Creates a RegExp type */
+    RegExp(pattern: string, options?: RegExpOptions): TRegExp;
+    /** `[JavaScript]` Creates a RegExp type */
+    RegExp(regex: RegExp, options?: RegExpOptions): TRegExp;
+    /** `[JavaScript]` Extracts the ReturnType from the given Function type */
+    ReturnType<Type extends TSchema>(type: Type, options?: SchemaOptions): TReturnType<Type>;
+    /** `[JavaScript]` Creates a Symbol type */
+    Symbol(options?: SchemaOptions): TSymbol;
+    /** `[JavaScript]` Creates a Undefined type */
+    Undefined(options?: SchemaOptions): TUndefined;
+    /** `[JavaScript]` Creates a Uint8Array type */
+    Uint8Array(options?: Uint8ArrayOptions): TUint8Array;
+    /** `[JavaScript]` Creates a Void type */
+    Void(options?: SchemaOptions): TVoid;
+}

package/build/cjs/type/type/javascript.js

@@ -0,0 +1,104 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JavaScriptTypeBuilder = void 0;
+const json_1 = require("./json");
+const index_1 = require("../argument/index");
+const index_2 = require("../async-iterator/index");
+const index_3 = require("../awaited/index");
+const index_4 = require("../bigint/index");
+const index_5 = require("../constructor/index");
+const index_6 = require("../constructor-parameters/index");
+const index_7 = require("../date/index");
+const index_8 = require("../function/index");
+const index_9 = require("../instance-type/index");
+const index_10 = require("../instantiate/index");
+const index_11 = require("../iterator/index");
+const index_12 = require("../parameters/index");
+const index_13 = require("../promise/index");
+const index_14 = require("../regexp/index");
+const index_15 = require("../return-type/index");
+const index_16 = require("../symbol/index");
+const index_17 = require("../uint8array/index");
+const index_18 = require("../undefined/index");
+const index_19 = require("../void/index");
+/** JavaScript Type Builder with Static Resolution for TypeScript */
+class JavaScriptTypeBuilder extends json_1.JsonTypeBuilder {
+    /** `[JavaScript]` Creates a Generic Argument Type */
+    Argument(index) {
+        return (0, index_1.Argument)(index);
+    }
+    /** `[JavaScript]` Creates a AsyncIterator type */
+    AsyncIterator(items, options) {
+        return (0, index_2.AsyncIterator)(items, options);
+    }
+    /** `[JavaScript]` Constructs a type by recursively unwrapping Promise types */
+    Awaited(schema, options) {
+        return (0, index_3.Awaited)(schema, options);
+    }
+    /** `[JavaScript]` Creates a BigInt type */
+    BigInt(options) {
+        return (0, index_4.BigInt)(options);
+    }
+    /** `[JavaScript]` Extracts the ConstructorParameters from the given Constructor type */
+    ConstructorParameters(schema, options) {
+        return (0, index_6.ConstructorParameters)(schema, options);
+    }
+    /** `[JavaScript]` Creates a Constructor type */
+    Constructor(parameters, instanceType, options) {
+        return (0, index_5.Constructor)(parameters, instanceType, options);
+    }
+    /** `[JavaScript]` Creates a Date type */
+    Date(options = {}) {
+        return (0, index_7.Date)(options);
+    }
+    /** `[JavaScript]` Creates a Function type */
+    Function(parameters, returnType, options) {
+        return (0, index_8.Function)(parameters, returnType, options);
+    }
+    /** `[JavaScript]` Extracts the InstanceType from the given Constructor type */
+    InstanceType(schema, options) {
+        return (0, index_9.InstanceType)(schema, options);
+    }
+    /** `[JavaScript]` Instantiates a type with the given parameters */
+    Instantiate(schema, parameters) {
+        return (0, index_10.Instantiate)(schema, parameters);
+    }
+    /** `[JavaScript]` Creates an Iterator type */
+    Iterator(items, options) {
+        return (0, index_11.Iterator)(items, options);
+    }
+    /** `[JavaScript]` Extracts the Parameters from the given Function type */
+    Parameters(schema, options) {
+        return (0, index_12.Parameters)(schema, options);
+    }
+    /** `[JavaScript]` Creates a Promise type */
+    Promise(item, options) {
+        return (0, index_13.Promise)(item, options);
+    }
+    /** `[JavaScript]` Creates a RegExp type */
+    RegExp(unresolved, options) {
+        return (0, index_14.RegExp)(unresolved, options);
+    }
+    /** `[JavaScript]` Extracts the ReturnType from the given Function type */
+    ReturnType(type, options) {
+        return (0, index_15.ReturnType)(type, options);
+    }
+    /** `[JavaScript]` Creates a Symbol type */
+    Symbol(options) {
+        return (0, index_16.Symbol)(options);
+    }
+    /** `[JavaScript]` Creates a Undefined type */
+    Undefined(options) {
+        return (0, index_18.Undefined)(options);
+    }
+    /** `[JavaScript]` Creates a Uint8Array type */
+    Uint8Array(options) {
+        return (0, index_17.Uint8Array)(options);
+    }
+    /** `[JavaScript]` Creates a Void type */
+    Void(options) {
+        return (0, index_19.Void)(options);
+    }
+}
+exports.JavaScriptTypeBuilder = JavaScriptTypeBuilder;

package/build/cjs/type/type/json.d.ts

@@ -0,0 +1,208 @@
+import { type TAny } from '../any/index';
+import { type TArray, type ArrayOptions } from '../array/index';
+import { type TBoolean } from '../boolean/index';
+import { type TComposite } from '../composite/index';
+import { type TConst } from '../const/index';
+import { type TEnum, type TEnumKey, type TEnumValue } from '../enum/index';
+import { type TExclude, type TExcludeFromMappedResult, type TExcludeFromTemplateLiteral } from '../exclude/index';
+import { type TExtends, type TExtendsFromMappedKey, type TExtendsFromMappedResult } from '../extends/index';
+import { type TExtract, type TExtractFromMappedResult, type TExtractFromTemplateLiteral } from '../extract/index';
+import { TIndex, type TIndexPropertyKeys, type TIndexFromMappedKey, type TIndexFromMappedResult, type TIndexFromComputed } from '../indexed/index';
+import { type IntegerOptions, type TInteger } from '../integer/index';
+import { Intersect, type IntersectOptions } from '../intersect/index';
+import { type TCapitalize, type TUncapitalize, type TLowercase, type TUppercase } from '../intrinsic/index';
+import { type TKeyOf } from '../keyof/index';
+import { type TLiteral, type TLiteralValue } from '../literal/index';
+import { type TMappedFunction, type TMapped, type TMappedResult } from '../mapped/index';
+import { type TNever } from '../never/index';
+import { type TNot } from '../not/index';
+import { type TNull } from '../null/index';
+import { type TMappedKey } from '../mapped/index';
+import { TModule } from '../module/index';
+import { type TNumber, type NumberOptions } from '../number/index';
+import { type TObject, type TProperties, type ObjectOptions } from '../object/index';
+import { type TOmit } from '../omit/index';
+import { type TOptionalWithFlag, type TOptionalFromMappedResult } from '../optional/index';
+import { type TPartial, type TPartialFromMappedResult } from '../partial/index';
+import { type TPick } from '../pick/index';
+import { type TReadonlyWithFlag, type TReadonlyFromMappedResult } from '../readonly/index';
+import { type TReadonlyOptional } from '../readonly-optional/index';
+import { type TRecordOrObject } from '../record/index';
+import { type TRecursive, type TThis } from '../recursive/index';
+import { type TRef, type TRefUnsafe } from '../ref/index';
+import { type TRequired, type TRequiredFromMappedResult } from '../required/index';
+import { type TRest } from '../rest/index';
+import { type TSchema, type SchemaOptions } from '../schema/index';
+import { type TString, type StringOptions } from '../string/index';
+import { type TTemplateLiteral, type TTemplateLiteralKind, type TTemplateLiteralSyntax } from '../template-literal/index';
+import { TransformDecodeBuilder } from '../transform/index';
+import { type TTuple } from '../tuple/index';
+import { Union } from '../union/index';
+import { type TUnknown } from '../unknown/index';
+import { type TUnsafe, type UnsafeOptions } from '../unsafe/index';
+/** Json Type Builder with Static Resolution for TypeScript */
+export declare class JsonTypeBuilder {
+    /** `[Json]` Creates a Readonly and Optional property */
+    ReadonlyOptional<Type extends TSchema>(type: Type): TReadonlyOptional<Type>;
+    /** `[Json]` Creates a Readonly property */
+    Readonly<Type extends TMappedResult, Flag extends boolean>(type: Type, enable: Flag): TReadonlyFromMappedResult<Type, Flag>;
+    /** `[Json]` Creates a Readonly property */
+    Readonly<Type extends TSchema, Flag extends boolean>(type: Type, enable: Flag): TReadonlyWithFlag<Type, Flag>;
+    /** `[Json]` Creates a Optional property */
+    Readonly<Type extends TMappedResult>(type: Type): TReadonlyFromMappedResult<Type, true>;
+    /** `[Json]` Creates a Readonly property */
+    Readonly<Type extends TSchema>(type: Type): TReadonlyWithFlag<Type, true>;
+    /** `[Json]` Creates a Optional property */
+    Optional<Type extends TMappedResult, Flag extends boolean>(type: Type, enable: Flag): TOptionalFromMappedResult<Type, Flag>;
+    /** `[Json]` Creates a Optional property */
+    Optional<Type extends TSchema, Flag extends boolean>(type: Type, enable: Flag): TOptionalWithFlag<Type, Flag>;
+    /** `[Json]` Creates a Optional property */
+    Optional<Type extends TMappedResult>(type: Type): TOptionalFromMappedResult<Type, true>;
+    /** `[Json]` Creates a Optional property */
+    Optional<Type extends TSchema>(type: Type): TOptionalWithFlag<Type, true>;
+    /** `[Json]` Creates an Any type */
+    Any(options?: SchemaOptions): TAny;
+    /** `[Json]` Creates an Array type */
+    Array<Type extends TSchema>(items: Type, options?: ArrayOptions): TArray<Type>;
+    /** `[Json]` Creates a Boolean type */
+    Boolean(options?: SchemaOptions): TBoolean;
+    /** `[Json]` Intrinsic function to Capitalize LiteralString types */
+    Capitalize<T extends TSchema>(schema: T, options?: SchemaOptions): TCapitalize<T>;
+    /** `[Json]` Creates a Composite object type */
+    Composite<T extends TSchema[]>(schemas: [...T], options?: ObjectOptions): TComposite<T>;
+    /** `[JavaScript]` Creates a readonly const type from the given value. */
+    Const</* const (not supported in 4.0) */ T>(value: T, options?: SchemaOptions): TConst<T>;
+    /** `[Json]` Creates a Enum type */
+    Enum<V extends TEnumValue, T extends Record<TEnumKey, V>>(item: T, options?: SchemaOptions): TEnum<T>;
+    /** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
+    Exclude<L extends TMappedResult, R extends TSchema>(unionType: L, excludedMembers: R, options?: SchemaOptions): TExcludeFromMappedResult<L, R>;
+    /** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
+    Exclude<L extends TTemplateLiteral, R extends TSchema>(unionType: L, excludedMembers: R, options?: SchemaOptions): TExcludeFromTemplateLiteral<L, R>;
+    /** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
+    Exclude<L extends TSchema, R extends TSchema>(unionType: L, excludedMembers: R, options?: SchemaOptions): TExclude<L, R>;
+    /** `[Json]` Creates a Conditional type */
+    Extends<L extends TMappedResult, R extends TSchema, T extends TSchema, F extends TSchema>(L: L, R: R, T: T, F: F, options?: SchemaOptions): TExtendsFromMappedResult<L, R, T, F>;
+    /** `[Json]` Creates a Conditional type */
+    Extends<L extends TMappedKey, R extends TSchema, T extends TSchema, F extends TSchema>(L: L, R: R, T: T, F: F, options?: SchemaOptions): TExtendsFromMappedKey<L, R, T, F>;
+    /** `[Json]` Creates a Conditional type */
+    Extends<L extends TSchema, R extends TSchema, T extends TSchema, F extends TSchema>(L: L, R: R, T: T, F: F, options?: SchemaOptions): TExtends<L, R, T, F>;
+    /** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
+    Extract<L extends TMappedResult, R extends TSchema>(type: L, union: R, options?: SchemaOptions): TExtractFromMappedResult<L, R>;
+    /** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
+    Extract<L extends TTemplateLiteral, R extends TSchema>(type: L, union: R, options?: SchemaOptions): TExtractFromTemplateLiteral<L, R>;
+    /** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
+    Extract<L extends TSchema, R extends TSchema>(type: L, union: R, options?: SchemaOptions): TExtract<L, R>;
+    /** `[Json]` Returns an Indexed property type for the given keys */
+    Index<Type extends TRef, Key extends TSchema>(type: Type, key: Key, options?: SchemaOptions): TIndexFromComputed<Type, Key>;
+    /** `[Json]` Returns an Indexed property type for the given keys */
+    Index<Type extends TSchema, Key extends TRef>(type: Type, key: Key, options?: SchemaOptions): TIndexFromComputed<Type, Key>;
+    /** `[Json]` Returns an Indexed property type for the given keys */
+    Index<Type extends TRef, Key extends TRef>(type: Type, key: Key, options?: SchemaOptions): TIndexFromComputed<Type, Key>;
+    /** `[Json]` Returns an Indexed property type for the given keys */
+    Index<Type extends TSchema, MappedResult extends TMappedResult>(type: Type, mappedResult: MappedResult, options?: SchemaOptions): TIndexFromMappedResult<Type, MappedResult>;
+    /** `[Json]` Returns an Indexed property type for the given keys */
+    Index<Type extends TSchema, MappedKey extends TMappedKey>(type: Type, mappedKey: MappedKey, options?: SchemaOptions): TIndexFromMappedKey<Type, MappedKey>;
+    /** `[Json]` Returns an Indexed property type for the given keys */
+    Index<Type extends TSchema, Key extends TSchema, PropertyKeys extends PropertyKey[] = TIndexPropertyKeys<Key>>(T: Type, K: Key, options?: SchemaOptions): TIndex<Type, PropertyKeys>;
+    /** `[Json]` Returns an Indexed property type for the given keys */
+    Index<Type extends TSchema, PropertyKeys extends PropertyKey[]>(type: Type, propertyKeys: readonly [...PropertyKeys], options?: SchemaOptions): TIndex<Type, PropertyKeys>;
+    /** `[Json]` Creates an Integer type */
+    Integer(options?: IntegerOptions): TInteger;
+    /** `[Json]` Creates an Intersect type */
+    Intersect<Types extends TSchema[]>(types: [...Types], options?: IntersectOptions): Intersect<Types>;
+    /** `[Json]` Creates a KeyOf type */
+    KeyOf<Type extends TSchema>(type: Type, options?: SchemaOptions): TKeyOf<Type>;
+    /** `[Json]` Creates a Literal type */
+    Literal<LiteralValue extends TLiteralValue>(literalValue: LiteralValue, options?: SchemaOptions): TLiteral<LiteralValue>;
+    /** `[Json]` Intrinsic function to Lowercase LiteralString types */
+    Lowercase<Type extends TSchema>(type: Type, options?: SchemaOptions): TLowercase<Type>;
+    /** `[Json]` Creates a Mapped object type */
+    Mapped<K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<K>, F extends TMappedFunction<I> = TMappedFunction<I>, R extends TMapped<I, F> = TMapped<I, F>>(key: K, map: F, options?: ObjectOptions): R;
+    /** `[Json]` Creates a Mapped object type */
+    Mapped<K extends PropertyKey[], F extends TMappedFunction<K> = TMappedFunction<K>, R extends TMapped<K, F> = TMapped<K, F>>(key: [...K], map: F, options?: ObjectOptions): R;
+    /** `[Json]` Creates a Type Definition Module. */
+    Module<Properties extends TProperties>(properties: Properties): TModule<Properties>;
+    /** `[Json]` Creates a Never type */
+    Never(options?: SchemaOptions): TNever;
+    /** `[Json]` Creates a Not type */
+    Not<T extends TSchema>(type: T, options?: SchemaOptions): TNot<T>;
+    /** `[Json]` Creates a Null type */
+    Null(options?: SchemaOptions): TNull;
+    /** `[Json]` Creates a Number type */
+    Number(options?: NumberOptions): TNumber;
+    /** `[Json]` Creates an Object type */
+    Object<T extends TProperties>(properties: T, options?: ObjectOptions): TObject<T>;
+    /** `[Json]` Constructs a type whose keys are picked from the given type */
+    Omit<Type extends TSchema, Key extends PropertyKey[]>(type: Type, key: readonly [...Key], options?: SchemaOptions): TOmit<Type, Key>;
+    /** `[Json]` Constructs a type whose keys are picked from the given type */
+    Omit<Type extends TSchema, Key extends TSchema>(type: Type, key: Key, options?: SchemaOptions): TOmit<Type, Key>;
+    /** `[Json]` Constructs a type where all properties are optional */
+    Partial<MappedResult extends TMappedResult>(type: MappedResult, options?: SchemaOptions): TPartialFromMappedResult<MappedResult>;
+    /** `[Json]` Constructs a type where all properties are optional */
+    Partial<Type extends TSchema>(type: Type, options?: SchemaOptions): TPartial<Type>;
+    /** `[Json]` Constructs a type whose keys are picked from the given type */
+    Pick<Type extends TSchema, Key extends PropertyKey[]>(type: Type, key: readonly [...Key], options?: SchemaOptions): TPick<Type, Key>;
+    /** `[Json]` Constructs a type whose keys are picked from the given type */
+    Pick<Type extends TSchema, Key extends TSchema>(type: Type, key: Key, options?: SchemaOptions): TPick<Type, Key>;
+    /** `[Json]` Creates a Record type */
+    Record<Key extends TSchema, Value extends TSchema>(key: Key, value: Value, options?: ObjectOptions): TRecordOrObject<Key, Value>;
+    /** `[Json]` Creates a Recursive type */
+    Recursive<T extends TSchema>(callback: (thisType: TThis) => T, options?: SchemaOptions): TRecursive<T>;
+    /** `[Json]` Creates a Ref type.*/
+    Ref<Ref extends string>($ref: Ref, options?: SchemaOptions): TRef<Ref>;
+    /**
+     * @deprecated `[Json]` Creates a Ref type. This signature was deprecated in 0.34.0 where Ref requires callers to pass
+     * a `string` value for the reference (and not a schema).
+     *
+     * To adhere to the 0.34.0 signature, Ref implementations should be updated to the following.
+     *
+     * ```typescript
+     * // pre-0.34.0
+     *
+     * const T = Type.String({ $id: 'T' })
+     *
+     * const R = Type.Ref(T)
+     * ```
+     * should be changed to the following
+     *
+     * ```typescript
+     * // post-0.34.0
+     *
+     * const T = Type.String({ $id: 'T' })
+     *
+     * const R = Type.Unsafe<Static<typeof T>>(Type.Ref('T'))
+     * ```
+     * You can also create a generic function to replicate the pre-0.34.0 signature if required
+     *
+     * ```typescript
+     * const LegacyRef = <T extends TSchema>(schema: T) => Type.Unsafe<Static<T>>(Type.Ref(schema.$id!))
+     * ```
+     */
+    Ref<Type extends TSchema>(type: Type, options?: SchemaOptions): TRefUnsafe<Type>;
+    /** `[Json]` Constructs a type where all properties are required */
+    Required<MappedResult extends TMappedResult>(type: MappedResult, options?: SchemaOptions): TRequiredFromMappedResult<MappedResult>;
+    /** `[Json]` Constructs a type where all properties are required */
+    Required<Type extends TSchema>(type: Type, options?: SchemaOptions): TRequired<Type>;
+    /** `[Json]` Extracts interior Rest elements from Tuple, Intersect and Union types */
+    Rest<Type extends TSchema>(type: Type): TRest<Type>;
+    /** `[Json]` Creates a String type */
+    String(options?: StringOptions): TString;
+    /** `[Json]` Creates a TemplateLiteral type from template dsl string */
+    TemplateLiteral<Syntax extends string>(syntax: Syntax, options?: SchemaOptions): TTemplateLiteralSyntax<Syntax>;
+    /** `[Json]` Creates a TemplateLiteral type */
+    TemplateLiteral<Kinds extends TTemplateLiteralKind[]>(kinds: [...Kinds], options?: SchemaOptions): TTemplateLiteral<Kinds>;
+    /** `[Json]` Creates a Transform type */
+    Transform<Type extends TSchema>(type: Type): TransformDecodeBuilder<Type>;
+    /** `[Json]` Creates a Tuple type */
+    Tuple<Types extends TSchema[]>(types: [...Types], options?: SchemaOptions): TTuple<Types>;
+    /** `[Json]` Intrinsic function to Uncapitalize LiteralString types */
+    Uncapitalize<Type extends TSchema>(type: Type, options?: SchemaOptions): TUncapitalize<Type>;
+    /** `[Json]` Creates a Union type */
+    Union<Types extends TSchema[]>(types: [...Types], options?: SchemaOptions): Union<Types>;
+    /** `[Json]` Creates an Unknown type */
+    Unknown(options?: SchemaOptions): TUnknown;
+    /** `[Json]` Creates a Unsafe type that will infers as the generic argument T */
+    Unsafe<T>(options?: UnsafeOptions): TUnsafe<T>;
+    /** `[Json]` Intrinsic function to Uppercase LiteralString types */
+    Uppercase<T extends TSchema>(schema: T, options?: SchemaOptions): TUppercase<T>;
+}