@sinclair/typebox 0.32.0-dev-1 → 0.32.0-dev-2

package/type/guard/type.js

@@ -1,515 +0,0 @@
-"use strict";
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox/type
-
-The MIT License (MIT)
-
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TSchema = exports.TKind = exports.TVoid = exports.TUnsafe = exports.TUnknown = exports.TUint8Array = exports.TUnion = exports.TUnionLiteral = exports.TUndefined = exports.TTuple = exports.TTransform = exports.TThis = exports.TTemplateLiteral = exports.TSymbol = exports.TString = exports.TRef = exports.TRecursive = exports.TRecord = exports.TPromise = exports.TObject = exports.TNumber = exports.TNull = exports.TNot = exports.TNever = exports.TLiteral = exports.TLiteralBoolean = exports.TLiteralNumber = exports.TLiteralString = exports.TKindOf = exports.TIterator = exports.TIntersect = exports.TInteger = exports.TFunction = exports.TDate = exports.TConstructor = exports.TBoolean = exports.TBigInt = exports.TAsyncIterator = exports.TArray = exports.TAny = exports.TOptional = exports.TReadonly = exports.TypeGuardUnknownTypeError = void 0;
-const ValueGuard = require("./value");
-const index_1 = require("../symbols/index");
-class TypeGuardUnknownTypeError extends Error {
-}
-exports.TypeGuardUnknownTypeError = TypeGuardUnknownTypeError;
-const KnownTypes = [
-    'Any',
-    'Array',
-    'AsyncIterator',
-    'BigInt',
-    'Boolean',
-    'Constructor',
-    'Date',
-    'Enum',
-    'Function',
-    'Integer',
-    'Intersect',
-    'Iterator',
-    'Literal',
-    'Not',
-    'Null',
-    'Number',
-    'Object',
-    'Promise',
-    'Record',
-    'Ref',
-    'String',
-    'Symbol',
-    'TemplateLiteral',
-    'This',
-    'Tuple',
-    'Undefined',
-    'Union',
-    'Uint8Array',
-    'Unknown',
-    'Void',
-];
-function IsPattern(value) {
-    try {
-        new RegExp(value);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function IsControlCharacterFree(value) {
-    if (!ValueGuard.IsString(value))
-        return false;
-    for (let i = 0; i < value.length; i++) {
-        const code = value.charCodeAt(i);
-        if ((code >= 7 && code <= 13) || code === 27 || code === 127) {
-            return false;
-        }
-    }
-    return true;
-}
-function IsAdditionalProperties(value) {
-    return IsOptionalBoolean(value) || (0, index_2.TSchema)(value);
-}
-function IsOptionalBigInt(value) {
-    return ValueGuard.IsUndefined(value) || ValueGuard.IsBigInt(value);
-}
-function IsOptionalNumber(value) {
-    return ValueGuard.IsUndefined(value) || ValueGuard.IsNumber(value);
-}
-function IsOptionalBoolean(value) {
-    return ValueGuard.IsUndefined(value) || ValueGuard.IsBoolean(value);
-}
-function IsOptionalString(value) {
-    return ValueGuard.IsUndefined(value) || ValueGuard.IsString(value);
-}
-function IsOptionalPattern(value) {
-    return ValueGuard.IsUndefined(value) || (ValueGuard.IsString(value) && IsControlCharacterFree(value) && IsPattern(value));
-}
-function IsOptionalFormat(value) {
-    return ValueGuard.IsUndefined(value) || (ValueGuard.IsString(value) && IsControlCharacterFree(value));
-}
-function IsOptionalSchema(value) {
-    return ValueGuard.IsUndefined(value) || (0, index_2.TSchema)(value);
-}
-// ------------------------------------------------------------------
-// Modifiers
-// ------------------------------------------------------------------
-/** Returns true if this value has a Readonly symbol */
-function TReadonly(schema) {
-    return ValueGuard.IsObject(schema) && schema[index_1.ReadonlyKind] === 'Readonly';
-}
-exports.TReadonly = TReadonly;
-/** Returns true if this value has a Optional symbol */
-function TOptional(schema) {
-    return ValueGuard.IsObject(schema) && schema[index_1.OptionalKind] === 'Optional';
-}
-exports.TOptional = TOptional;
-// ------------------------------------------------------------------
-// Types
-// ------------------------------------------------------------------
-/** Returns true if the given value is TAny */
-function TAny(schema) {
-    // prettier-ignore
-    return (TKindOf(schema, 'Any') &&
-        IsOptionalString(schema.$id));
-}
-exports.TAny = TAny;
-/** Returns true if the given value is TArray */
-function TArray(schema) {
-    return (TKindOf(schema, 'Array') &&
-        schema.type === 'array' &&
-        IsOptionalString(schema.$id) &&
-        (0, index_2.TSchema)(schema.items) &&
-        IsOptionalNumber(schema.minItems) &&
-        IsOptionalNumber(schema.maxItems) &&
-        IsOptionalBoolean(schema.uniqueItems) &&
-        IsOptionalSchema(schema.contains) &&
-        IsOptionalNumber(schema.minContains) &&
-        IsOptionalNumber(schema.maxContains));
-}
-exports.TArray = TArray;
-/** Returns true if the given value is TAsyncIterator */
-function TAsyncIterator(schema) {
-    // prettier-ignore
-    return (TKindOf(schema, 'AsyncIterator') &&
-        schema.type === 'AsyncIterator' &&
-        IsOptionalString(schema.$id) &&
-        (0, index_2.TSchema)(schema.items));
-}
-exports.TAsyncIterator = TAsyncIterator;
-/** Returns true if the given value is TBigInt */
-function TBigInt(schema) {
-    // prettier-ignore
-    return (TKindOf(schema, 'BigInt') &&
-        schema.type === 'bigint' &&
-        IsOptionalString(schema.$id) &&
-        IsOptionalBigInt(schema.exclusiveMaximum) &&
-        IsOptionalBigInt(schema.exclusiveMinimum) &&
-        IsOptionalBigInt(schema.maximum) &&
-        IsOptionalBigInt(schema.minimum) &&
-        IsOptionalBigInt(schema.multipleOf));
-}
-exports.TBigInt = TBigInt;
-/** Returns true if the given value is TBoolean */
-function TBoolean(schema) {
-    // prettier-ignore
-    return (TKindOf(schema, 'Boolean') &&
-        schema.type === 'boolean' &&
-        IsOptionalString(schema.$id));
-}
-exports.TBoolean = TBoolean;
-/** Returns true if the given value is TConstructor */
-function TConstructor(schema) {
-    // prettier-ignore
-    return (TKindOf(schema, 'Constructor') &&
-        schema.type === 'Constructor' &&
-        IsOptionalString(schema.$id) &&
-        ValueGuard.IsArray(schema.parameters) &&
-        schema.parameters.every(schema => (0, index_2.TSchema)(schema)) &&
-        (0, index_2.TSchema)(schema.returns));
-}
-exports.TConstructor = TConstructor;
-/** Returns true if the given value is TDate */
-function TDate(schema) {
-    return (TKindOf(schema, 'Date') &&
-        schema.type === 'Date' &&
-        IsOptionalString(schema.$id) &&
-        IsOptionalNumber(schema.exclusiveMaximumTimestamp) &&
-        IsOptionalNumber(schema.exclusiveMinimumTimestamp) &&
-        IsOptionalNumber(schema.maximumTimestamp) &&
-        IsOptionalNumber(schema.minimumTimestamp) &&
-        IsOptionalNumber(schema.multipleOfTimestamp));
-}
-exports.TDate = TDate;
-/** Returns true if the given value is TFunction */
-function TFunction(schema) {
-    // prettier-ignore
-    return (TKindOf(schema, 'Function') &&
-        schema.type === 'Function' &&
-        IsOptionalString(schema.$id) &&
-        ValueGuard.IsArray(schema.parameters) &&
-        schema.parameters.every(schema => (0, index_2.TSchema)(schema)) &&
-        (0, index_2.TSchema)(schema.returns));
-}
-exports.TFunction = TFunction;
-/** Returns true if the given value is TInteger */
-function TInteger(schema) {
-    return (TKindOf(schema, 'Integer') &&
-        schema.type === 'integer' &&
-        IsOptionalString(schema.$id) &&
-        IsOptionalNumber(schema.exclusiveMaximum) &&
-        IsOptionalNumber(schema.exclusiveMinimum) &&
-        IsOptionalNumber(schema.maximum) &&
-        IsOptionalNumber(schema.minimum) &&
-        IsOptionalNumber(schema.multipleOf));
-}
-exports.TInteger = TInteger;
-/** Returns true if the given value is TIntersect */
-function TIntersect(schema) {
-    // prettier-ignore
-    return (TKindOf(schema, 'Intersect') &&
-        (ValueGuard.IsString(schema.type) && schema.type !== 'object' ? false : true) &&
-        ValueGuard.IsArray(schema.allOf) &&
-        schema.allOf.every(schema => (0, index_2.TSchema)(schema) && !TTransform(schema)) &&
-        IsOptionalString(schema.type) &&
-        (IsOptionalBoolean(schema.unevaluatedProperties) || IsOptionalSchema(schema.unevaluatedProperties)) &&
-        IsOptionalString(schema.$id));
-}
-exports.TIntersect = TIntersect;
-/** Returns true if the given value is TIterator */
-function TIterator(schema) {
-    // prettier-ignore
-    return (TKindOf(schema, 'Iterator') &&
-        schema.type === 'Iterator' &&
-        IsOptionalString(schema.$id) &&
-        (0, index_2.TSchema)(schema.items));
-}
-exports.TIterator = TIterator;
-/** Returns true if the given value is a TKind with the given name. */
-function TKindOf(schema, kind) {
-    return ValueGuard.IsObject(schema) && index_1.Kind in schema && schema[index_1.Kind] === kind;
-}
-exports.TKindOf = TKindOf;
-/** Returns true if the given value is TLiteral<string> */
-function TLiteralString(schema) {
-    return (0, index_3.TLiteral)(schema) && ValueGuard.IsString(schema.const);
-}
-exports.TLiteralString = TLiteralString;
-/** Returns true if the given value is TLiteral<number> */
-function TLiteralNumber(schema) {
-    return (0, index_3.TLiteral)(schema) && ValueGuard.IsNumber(schema.const);
-}
-exports.TLiteralNumber = TLiteralNumber;
-/** Returns true if the given value is TLiteral<boolean> */
-function TLiteralBoolean(schema) {
-    return (0, index_3.TLiteral)(schema) && ValueGuard.IsBoolean(schema.const);
-}
-exports.TLiteralBoolean = TLiteralBoolean;
-/** Returns true if the given value is TLiteral */
-function TLiteral(schema) {
-    // prettier-ignore
-    return (TKindOf(schema, 'Literal') &&
-        IsOptionalString(schema.$id) && (ValueGuard.IsBoolean(schema.const) ||
-        ValueGuard.IsNumber(schema.const) ||
-        ValueGuard.IsString(schema.const)));
-}
-exports.TLiteral = TLiteral;
-/** Returns true if the given value is TNever */
-function TNever(schema) {
-    // prettier-ignore
-    return (TKindOf(schema, 'Never') &&
-        ValueGuard.IsObject(schema.not) &&
-        Object.getOwnPropertyNames(schema.not).length === 0);
-}
-exports.TNever = TNever;
-/** Returns true if the given value is TNot */
-function TNot(schema) {
-    // prettier-ignore
-    return (TKindOf(schema, 'Not') &&
-        (0, index_2.TSchema)(schema.not));
-}
-exports.TNot = TNot;
-/** Returns true if the given value is TNull */
-function TNull(schema) {
-    // prettier-ignore
-    return (TKindOf(schema, 'Null') &&
-        schema.type === 'null' &&
-        IsOptionalString(schema.$id));
-}
-exports.TNull = TNull;
-/** Returns true if the given value is TNumber */
-function TNumber(schema) {
-    return (TKindOf(schema, 'Number') &&
-        schema.type === 'number' &&
-        IsOptionalString(schema.$id) &&
-        IsOptionalNumber(schema.exclusiveMaximum) &&
-        IsOptionalNumber(schema.exclusiveMinimum) &&
-        IsOptionalNumber(schema.maximum) &&
-        IsOptionalNumber(schema.minimum) &&
-        IsOptionalNumber(schema.multipleOf));
-}
-exports.TNumber = TNumber;
-/** Returns true if the given value is TObject */
-function TObject(schema) {
-    // prettier-ignore
-    return (TKindOf(schema, 'Object') &&
-        schema.type === 'object' &&
-        IsOptionalString(schema.$id) &&
-        ValueGuard.IsObject(schema.properties) &&
-        Object.entries(schema.properties).every(([key, schema]) => IsControlCharacterFree(key) && (0, index_2.TSchema)(schema)) &&
-        IsAdditionalProperties(schema.additionalProperties) &&
-        IsOptionalNumber(schema.minProperties) &&
-        IsOptionalNumber(schema.maxProperties));
-}
-exports.TObject = TObject;
-/** Returns true if the given value is TPromise */
-function TPromise(schema) {
-    // prettier-ignore
-    return (TKindOf(schema, 'Promise') &&
-        schema.type === 'Promise' &&
-        IsOptionalString(schema.$id) &&
-        (0, index_2.TSchema)(schema.item));
-}
-exports.TPromise = TPromise;
-/** Returns true if the given value is TRecord */
-function TRecord(schema) {
-    // prettier-ignore
-    return (TKindOf(schema, 'Record') &&
-        schema.type === 'object' &&
-        IsOptionalString(schema.$id) &&
-        IsAdditionalProperties(schema.additionalProperties) &&
-        ValueGuard.IsObject(schema.patternProperties) &&
-        ((schema) => {
-            const keys = Object.getOwnPropertyNames(schema.patternProperties);
-            return (keys.length === 1 &&
-                IsPattern(keys[0]) &&
-                ValueGuard.IsObject(schema.patternProperties) &&
-                (0, index_2.TSchema)(schema.patternProperties[keys[0]]));
-        })(schema));
-}
-exports.TRecord = TRecord;
-/** Returns true if this value is TRecursive */
-function TRecursive(schema) {
-    return ValueGuard.IsObject(schema) && index_1.Hint in schema && schema[index_1.Hint] === 'Recursive';
-}
-exports.TRecursive = TRecursive;
-/** Returns true if the given value is TRef */
-function TRef(schema) {
-    // prettier-ignore
-    return (TKindOf(schema, 'Ref') &&
-        IsOptionalString(schema.$id) &&
-        ValueGuard.IsString(schema.$ref));
-}
-exports.TRef = TRef;
-/** Returns true if the given value is TString */
-function TString(schema) {
-    // prettier-ignore
-    return (TKindOf(schema, 'String') &&
-        schema.type === 'string' &&
-        IsOptionalString(schema.$id) &&
-        IsOptionalNumber(schema.minLength) &&
-        IsOptionalNumber(schema.maxLength) &&
-        IsOptionalPattern(schema.pattern) &&
-        IsOptionalFormat(schema.format));
-}
-exports.TString = TString;
-/** Returns true if the given value is TSymbol */
-function TSymbol(schema) {
-    // prettier-ignore
-    return (TKindOf(schema, 'Symbol') &&
-        schema.type === 'symbol' &&
-        IsOptionalString(schema.$id));
-}
-exports.TSymbol = TSymbol;
-/** Returns true if the given value is TTemplateLiteral */
-function TTemplateLiteral(schema) {
-    // prettier-ignore
-    return (TKindOf(schema, 'TemplateLiteral') &&
-        schema.type === 'string' &&
-        ValueGuard.IsString(schema.pattern) &&
-        schema.pattern[0] === '^' &&
-        schema.pattern[schema.pattern.length - 1] === '$');
-}
-exports.TTemplateLiteral = TTemplateLiteral;
-/** Returns true if the given value is TThis */
-function TThis(schema) {
-    // prettier-ignore
-    return (TKindOf(schema, 'This') &&
-        IsOptionalString(schema.$id) &&
-        ValueGuard.IsString(schema.$ref));
-}
-exports.TThis = TThis;
-/** Returns true of this value is TTransform */
-function TTransform(schema) {
-    return ValueGuard.IsObject(schema) && index_1.TransformKind in schema;
-}
-exports.TTransform = TTransform;
-/** Returns true if the given value is TTuple */
-function TTuple(schema) {
-    // prettier-ignore
-    return (TKindOf(schema, 'Tuple') &&
-        schema.type === 'array' &&
-        IsOptionalString(schema.$id) &&
-        ValueGuard.IsNumber(schema.minItems) &&
-        ValueGuard.IsNumber(schema.maxItems) &&
-        schema.minItems === schema.maxItems &&
-        (( // empty
-        ValueGuard.IsUndefined(schema.items) &&
-            ValueGuard.IsUndefined(schema.additionalItems) &&
-            schema.minItems === 0) || (ValueGuard.IsArray(schema.items) &&
-            schema.items.every(schema => (0, index_2.TSchema)(schema)))));
-}
-exports.TTuple = TTuple;
-/** Returns true if the given value is TUndefined */
-function TUndefined(schema) {
-    // prettier-ignore
-    return (TKindOf(schema, 'Undefined') &&
-        schema.type === 'undefined' &&
-        IsOptionalString(schema.$id));
-}
-exports.TUndefined = TUndefined;
-/** Returns true if the given value is TUnion<Literal<string | number>[]> */
-function TUnionLiteral(schema) {
-    return (0, index_4.TUnion)(schema) && schema.anyOf.every((schema) => TLiteralString(schema) || TLiteralNumber(schema));
-}
-exports.TUnionLiteral = TUnionLiteral;
-/** Returns true if the given value is TUnion */
-function TUnion(schema) {
-    // prettier-ignore
-    return (TKindOf(schema, 'Union') &&
-        IsOptionalString(schema.$id) &&
-        ValueGuard.IsObject(schema) &&
-        ValueGuard.IsArray(schema.anyOf) &&
-        schema.anyOf.every(schema => (0, index_2.TSchema)(schema)));
-}
-exports.TUnion = TUnion;
-/** Returns true if the given value is TUint8Array */
-function TUint8Array(schema) {
-    // prettier-ignore
-    return (TKindOf(schema, 'Uint8Array') &&
-        schema.type === 'Uint8Array' &&
-        IsOptionalString(schema.$id) &&
-        IsOptionalNumber(schema.minByteLength) &&
-        IsOptionalNumber(schema.maxByteLength));
-}
-exports.TUint8Array = TUint8Array;
-/** Returns true if the given value is TUnknown */
-function TUnknown(schema) {
-    // prettier-ignore
-    return (TKindOf(schema, 'Unknown') &&
-        IsOptionalString(schema.$id));
-}
-exports.TUnknown = TUnknown;
-/** Returns true if the given value is a raw TUnsafe */
-function TUnsafe(schema) {
-    return TKindOf(schema, 'Unsafe');
-}
-exports.TUnsafe = TUnsafe;
-/** Returns true if the given value is TVoid */
-function TVoid(schema) {
-    // prettier-ignore
-    return (TKindOf(schema, 'Void') &&
-        schema.type === 'void' &&
-        IsOptionalString(schema.$id));
-}
-exports.TVoid = TVoid;
-/** Returns true if the given value is TKind */
-function TKind(schema) {
-    return ValueGuard.IsObject(schema) && index_1.Kind in schema && ValueGuard.IsString(schema[index_1.Kind]) && !KnownTypes.includes(schema[index_1.Kind]);
-}
-exports.TKind = TKind;
-/** Returns true if the given value is TSchema */
-function TSchema(schema) {
-    // prettier-ignore
-    return (ValueGuard.IsObject(schema)) && ((0, index_5.TAny)(schema) ||
-        (0, index_6.TArray)(schema) ||
-        (0, index_7.TBoolean)(schema) ||
-        (0, index_8.TBigInt)(schema) ||
-        (0, index_9.TAsyncIterator)(schema) ||
-        (0, index_10.TConstructor)(schema) ||
-        (0, index_11.TDate)(schema) ||
-        (0, index_12.TFunction)(schema) ||
-        (0, index_13.TInteger)(schema) ||
-        (0, index_14.TIntersect)(schema) ||
-        (0, index_15.TIterator)(schema) ||
-        (0, index_3.TLiteral)(schema) ||
-        (0, index_16.TNever)(schema) ||
-        (0, index_17.TNot)(schema) ||
-        (0, index_18.TNull)(schema) ||
-        (0, index_19.TNumber)(schema) ||
-        (0, index_20.TObject)(schema) ||
-        (0, index_21.TPromise)(schema) ||
-        (0, index_22.TRecord)(schema) ||
-        (0, index_23.TRef)(schema) ||
-        (0, index_24.TString)(schema) ||
-        (0, index_25.TSymbol)(schema) ||
-        (0, index_26.TTemplateLiteral)(schema) ||
-        (0, index_27.TThis)(schema) ||
-        (0, index_28.TTuple)(schema) ||
-        (0, index_29.TUndefined)(schema) ||
-        (0, index_4.TUnion)(schema) ||
-        (0, index_30.TUint8Array)(schema) ||
-        (0, index_31.TUnknown)(schema) ||
-        (0, index_32.TUnsafe)(schema) ||
-        (0, index_33.TVoid)(schema) ||
-        TKind(schema));
-}
-exports.TSchema = TSchema;

package/type/helpers/helpers.d.ts

@@ -1,42 +0,0 @@
-import type { TSchema } from '../schema/index';
-import type { TProperties } from '../object/index';
-import type { TNever } from '../never/index';
-export type TupleToIntersect<T extends any[]> = T extends [infer I] ? I : T extends [infer I, ...infer R] ? I & TupleToIntersect<R> : never;
-export type TupleToUnion<T extends any[]> = {
-    [K in keyof T]: T[K];
-}[number];
-export type UnionToIntersect<U> = (U extends unknown ? (arg: U) => 0 : never) extends (arg: infer I) => 0 ? I : never;
-export type UnionLast<U> = UnionToIntersect<U extends unknown ? (x: U) => 0 : never> extends (x: infer L) => 0 ? L : never;
-export type UnionToTuple<U, L = UnionLast<U>> = [U] extends [never] ? [] : [...UnionToTuple<Exclude<U, L>>, L];
-export type Trim<T> = T extends `${' '}${infer U}` ? Trim<U> : T extends `${infer U}${' '}` ? Trim<U> : T;
-export type Assert<T, E> = T extends E ? T : never;
-export type Evaluate<T> = T extends infer O ? {
-    [K in keyof O]: O[K];
-} : never;
-export type Ensure<T> = T extends infer U ? U : never;
-export type EmptyString = '';
-export type ZeroString = '0';
-type IncrementBase = {
-    m: '9';
-    t: '01';
-    '0': '1';
-    '1': '2';
-    '2': '3';
-    '3': '4';
-    '4': '5';
-    '5': '6';
-    '6': '7';
-    '7': '8';
-    '8': '9';
-    '9': '0';
-};
-type IncrementTake<T extends keyof IncrementBase> = IncrementBase[T];
-type IncrementStep<T extends string> = T extends IncrementBase['m'] ? IncrementBase['t'] : T extends `${infer L extends keyof IncrementBase}${infer R}` ? L extends IncrementBase['m'] ? `${IncrementTake<L>}${IncrementStep<R>}` : `${IncrementTake<L>}${R}` : never;
-type IncrementReverse<T extends string> = T extends `${infer L}${infer R}` ? `${IncrementReverse<R>}${L}` : T;
-export type Increment<T extends string> = IncrementReverse<IncrementStep<IncrementReverse<T>>>;
-/** Increments the given string value + 1 */
-export declare function Increment<T extends string>(T: T): Increment<T>;
-export type AssertProperties<T> = T extends TProperties ? T : TProperties;
-export type AssertRest<T, E extends TSchema[] = TSchema[]> = T extends E ? T : [];
-export type AssertType<T, E extends TSchema = TSchema> = T extends E ? T : TNever;
-export {};

package/type/helpers/index.d.ts

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

package/type/index.d.ts

@@ -1,70 +0,0 @@
-export * from './any/index';
-export * from './array/index';
-export * from './async-iterator/index';
-export * from './awaited/index';
-export * from './bigint/index';
-export * from './boolean/index';
-export * from './clone/index';
-export * from './composite/index';
-export * from './const/index';
-export * from './constructor/index';
-export * from './constructor-parameters/index';
-export * from './date/index';
-export * from './deref/index';
-export * from './discard/index';
-export * from './enum/index';
-export * from './exclude/index';
-export * from './extends/index';
-export * from './extract/index';
-export * from './function/index';
-export * from './guard/index';
-export * from './helpers/index';
-export * from './indexed/index';
-export * from './instance-type/index';
-export * from './integer/index';
-export * from './intersect/index';
-export * from './intrinsic/index';
-export * from './iterator/index';
-export * from './keyof/index';
-export * from './literal/index';
-export * from './mapped/index';
-export * from './modifiers/index';
-export * from './never/index';
-export * from './not/index';
-export * from './null/index';
-export * from './number/index';
-export * from './object/index';
-export * from './omit/index';
-export * from './operators/index';
-export * from './optional/index';
-export * from './parameters/index';
-export * from './partial/index';
-export * from './patterns/index';
-export * from './pick/index';
-export * from './promise/index';
-export * from './readonly/index';
-export * from './readonly-optional/index';
-export * from './record/index';
-export * from './recursive/index';
-export * from './ref/index';
-export * from './regexp/index';
-export * from './registry/index';
-export * from './required/index';
-export * from './rest/index';
-export * from './return-type/index';
-export * from './schema/index';
-export * from './static/index';
-export * from './strict/index';
-export * from './string/index';
-export * from './symbol/index';
-export * from './symbols/index';
-export * from './template-literal/index';
-export * from './transform/index';
-export * from './tuple/index';
-export * from './type/index';
-export * from './uint8array/index';
-export * from './undefined/index';
-export * from './union/index';
-export * from './unknown/index';
-export * from './unsafe/index';
-export * from './void/index';

package/type/indexed/index.d.ts

@@ -1,3 +0,0 @@
-export * from './indexed-key';
-export * from './indexed-type';
-export * from './indexed';

package/type/indexed/indexed-key.d.ts

@@ -1,17 +0,0 @@
-import { type TTemplateLiteral, TemplateLiteralGenerate, IsTemplateLiteralFinite } from '../template-literal/index';
-import { type TLiteral, type TLiteralValue } from '../literal/index';
-import { type TInteger } from '../integer/index';
-import { type TNumber } from '../number/index';
-import { type TSchema } from '../schema/index';
-import { type TUnion } from '../union/index';
-type FromTemplateLiteral<T extends TTemplateLiteral, F = IsTemplateLiteralFinite<T>> = (F extends true ? TemplateLiteralGenerate<T> extends infer R extends string[] ? R : [] : []);
-declare function FromTemplateLiteral<T extends TTemplateLiteral>(T: T): FromTemplateLiteral<T>;
-type FromUnion<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [...IndexedKeyResolve<L>, ...FromUnion<R>] : []);
-declare function FromUnion<T extends TSchema[]>(T: T): FromUnion<T>;
-type FromLiteral<T extends TLiteralValue> = (T extends PropertyKey ? [`${T}`] : []);
-declare function FromLiteral<T extends TLiteralValue>(T: T): FromLiteral<T>;
-export type IndexedKeyResolve<T extends TSchema> = (T extends TTemplateLiteral ? FromTemplateLiteral<T> : T extends TUnion<infer S> ? FromUnion<S> : T extends TLiteral<infer S> ? FromLiteral<S> : T extends TNumber ? ['[number]'] : T extends TInteger ? ['[number]'] : [
-]);
-/** Resolves Indexer String Keys form the given Schema. Th */
-export declare function IndexedKeyResolve<T extends TSchema>(T: T): IndexedKeyResolve<T>;
-export {};