@sinclair/typebox 0.31.28 → 0.32.0-dev-2

package/esm/type/guard/type.mjs

@@ -0,0 +1,469 @@
+/*--------------------------------------------------------------------------
+
+@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.
+
+---------------------------------------------------------------------------*/
+import * as ValueGuard from './value.mjs';
+import { Kind, Hint, TransformKind, ReadonlyKind, OptionalKind } from '../symbols/index.mjs';
+export class TypeGuardUnknownTypeError extends Error {
+}
+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) || 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) || TSchema(value);
+}
+// ------------------------------------------------------------------
+// Modifiers
+// ------------------------------------------------------------------
+/** Returns true if this value has a Readonly symbol */
+export function TReadonly(schema) {
+    return ValueGuard.IsObject(schema) && schema[ReadonlyKind] === 'Readonly';
+}
+/** Returns true if this value has a Optional symbol */
+export function TOptional(schema) {
+    return ValueGuard.IsObject(schema) && schema[OptionalKind] === 'Optional';
+}
+// ------------------------------------------------------------------
+// Types
+// ------------------------------------------------------------------
+/** Returns true if the given value is TAny */
+export function TAny(schema) {
+    // prettier-ignore
+    return (TKindOf(schema, 'Any') &&
+        IsOptionalString(schema.$id));
+}
+/** Returns true if the given value is TArray */
+export function TArray(schema) {
+    return (TKindOf(schema, 'Array') &&
+        schema.type === 'array' &&
+        IsOptionalString(schema.$id) &&
+        TSchema(schema.items) &&
+        IsOptionalNumber(schema.minItems) &&
+        IsOptionalNumber(schema.maxItems) &&
+        IsOptionalBoolean(schema.uniqueItems) &&
+        IsOptionalSchema(schema.contains) &&
+        IsOptionalNumber(schema.minContains) &&
+        IsOptionalNumber(schema.maxContains));
+}
+/** Returns true if the given value is TAsyncIterator */
+export function TAsyncIterator(schema) {
+    // prettier-ignore
+    return (TKindOf(schema, 'AsyncIterator') &&
+        schema.type === 'AsyncIterator' &&
+        IsOptionalString(schema.$id) &&
+        TSchema(schema.items));
+}
+/** Returns true if the given value is TBigInt */
+export 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));
+}
+/** Returns true if the given value is TBoolean */
+export function TBoolean(schema) {
+    // prettier-ignore
+    return (TKindOf(schema, 'Boolean') &&
+        schema.type === 'boolean' &&
+        IsOptionalString(schema.$id));
+}
+/** Returns true if the given value is TConstructor */
+export function TConstructor(schema) {
+    // prettier-ignore
+    return (TKindOf(schema, 'Constructor') &&
+        schema.type === 'Constructor' &&
+        IsOptionalString(schema.$id) &&
+        ValueGuard.IsArray(schema.parameters) &&
+        schema.parameters.every(schema => TSchema(schema)) &&
+        TSchema(schema.returns));
+}
+/** Returns true if the given value is TDate */
+export 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));
+}
+/** Returns true if the given value is TFunction */
+export function TFunction(schema) {
+    // prettier-ignore
+    return (TKindOf(schema, 'Function') &&
+        schema.type === 'Function' &&
+        IsOptionalString(schema.$id) &&
+        ValueGuard.IsArray(schema.parameters) &&
+        schema.parameters.every(schema => TSchema(schema)) &&
+        TSchema(schema.returns));
+}
+/** Returns true if the given value is TInteger */
+export 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));
+}
+/** Returns true if the given value is TIntersect */
+export 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 => TSchema(schema) && !TTransform(schema)) &&
+        IsOptionalString(schema.type) &&
+        (IsOptionalBoolean(schema.unevaluatedProperties) || IsOptionalSchema(schema.unevaluatedProperties)) &&
+        IsOptionalString(schema.$id));
+}
+/** Returns true if the given value is TIterator */
+export function TIterator(schema) {
+    // prettier-ignore
+    return (TKindOf(schema, 'Iterator') &&
+        schema.type === 'Iterator' &&
+        IsOptionalString(schema.$id) &&
+        TSchema(schema.items));
+}
+/** Returns true if the given value is a TKind with the given name. */
+export function TKindOf(schema, kind) {
+    return ValueGuard.IsObject(schema) && Kind in schema && schema[Kind] === kind;
+}
+/** Returns true if the given value is TLiteral<string> */
+export function TLiteralString(schema) {
+    return TLiteral(schema) && ValueGuard.IsString(schema.const);
+}
+/** Returns true if the given value is TLiteral<number> */
+export function TLiteralNumber(schema) {
+    return TLiteral(schema) && ValueGuard.IsNumber(schema.const);
+}
+/** Returns true if the given value is TLiteral<boolean> */
+export function TLiteralBoolean(schema) {
+    return TLiteral(schema) && ValueGuard.IsBoolean(schema.const);
+}
+/** Returns true if the given value is TLiteral */
+export function TLiteral(schema) {
+    // prettier-ignore
+    return (TKindOf(schema, 'Literal') &&
+        IsOptionalString(schema.$id) && (ValueGuard.IsBoolean(schema.const) ||
+        ValueGuard.IsNumber(schema.const) ||
+        ValueGuard.IsString(schema.const)));
+}
+/** Returns true if the given value is TNever */
+export function TNever(schema) {
+    // prettier-ignore
+    return (TKindOf(schema, 'Never') &&
+        ValueGuard.IsObject(schema.not) &&
+        Object.getOwnPropertyNames(schema.not).length === 0);
+}
+/** Returns true if the given value is TNot */
+export function TNot(schema) {
+    // prettier-ignore
+    return (TKindOf(schema, 'Not') &&
+        TSchema(schema.not));
+}
+/** Returns true if the given value is TNull */
+export function TNull(schema) {
+    // prettier-ignore
+    return (TKindOf(schema, 'Null') &&
+        schema.type === 'null' &&
+        IsOptionalString(schema.$id));
+}
+/** Returns true if the given value is TNumber */
+export 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));
+}
+/** Returns true if the given value is TObject */
+export 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) && TSchema(schema)) &&
+        IsAdditionalProperties(schema.additionalProperties) &&
+        IsOptionalNumber(schema.minProperties) &&
+        IsOptionalNumber(schema.maxProperties));
+}
+/** Returns true if the given value is TPromise */
+export function TPromise(schema) {
+    // prettier-ignore
+    return (TKindOf(schema, 'Promise') &&
+        schema.type === 'Promise' &&
+        IsOptionalString(schema.$id) &&
+        TSchema(schema.item));
+}
+/** Returns true if the given value is TRecord */
+export 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) &&
+                TSchema(schema.patternProperties[keys[0]]));
+        })(schema));
+}
+/** Returns true if this value is TRecursive */
+export function TRecursive(schema) {
+    return ValueGuard.IsObject(schema) && Hint in schema && schema[Hint] === 'Recursive';
+}
+/** Returns true if the given value is TRef */
+export function TRef(schema) {
+    // prettier-ignore
+    return (TKindOf(schema, 'Ref') &&
+        IsOptionalString(schema.$id) &&
+        ValueGuard.IsString(schema.$ref));
+}
+/** Returns true if the given value is TString */
+export 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));
+}
+/** Returns true if the given value is TSymbol */
+export function TSymbol(schema) {
+    // prettier-ignore
+    return (TKindOf(schema, 'Symbol') &&
+        schema.type === 'symbol' &&
+        IsOptionalString(schema.$id));
+}
+/** Returns true if the given value is TTemplateLiteral */
+export 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] === '$');
+}
+/** Returns true if the given value is TThis */
+export function TThis(schema) {
+    // prettier-ignore
+    return (TKindOf(schema, 'This') &&
+        IsOptionalString(schema.$id) &&
+        ValueGuard.IsString(schema.$ref));
+}
+/** Returns true of this value is TTransform */
+export function TTransform(schema) {
+    return ValueGuard.IsObject(schema) && TransformKind in schema;
+}
+/** Returns true if the given value is TTuple */
+export 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 => TSchema(schema)))));
+}
+/** Returns true if the given value is TUndefined */
+export function TUndefined(schema) {
+    // prettier-ignore
+    return (TKindOf(schema, 'Undefined') &&
+        schema.type === 'undefined' &&
+        IsOptionalString(schema.$id));
+}
+/** Returns true if the given value is TUnion<Literal<string | number>[]> */
+export function TUnionLiteral(schema) {
+    return TUnion(schema) && schema.anyOf.every((schema) => TLiteralString(schema) || TLiteralNumber(schema));
+}
+/** Returns true if the given value is TUnion */
+export function TUnion(schema) {
+    // prettier-ignore
+    return (TKindOf(schema, 'Union') &&
+        IsOptionalString(schema.$id) &&
+        ValueGuard.IsObject(schema) &&
+        ValueGuard.IsArray(schema.anyOf) &&
+        schema.anyOf.every(schema => TSchema(schema)));
+}
+/** Returns true if the given value is TUint8Array */
+export function TUint8Array(schema) {
+    // prettier-ignore
+    return (TKindOf(schema, 'Uint8Array') &&
+        schema.type === 'Uint8Array' &&
+        IsOptionalString(schema.$id) &&
+        IsOptionalNumber(schema.minByteLength) &&
+        IsOptionalNumber(schema.maxByteLength));
+}
+/** Returns true if the given value is TUnknown */
+export function TUnknown(schema) {
+    // prettier-ignore
+    return (TKindOf(schema, 'Unknown') &&
+        IsOptionalString(schema.$id));
+}
+/** Returns true if the given value is a raw TUnsafe */
+export function TUnsafe(schema) {
+    return TKindOf(schema, 'Unsafe');
+}
+/** Returns true if the given value is TVoid */
+export function TVoid(schema) {
+    // prettier-ignore
+    return (TKindOf(schema, 'Void') &&
+        schema.type === 'void' &&
+        IsOptionalString(schema.$id));
+}
+/** Returns true if the given value is TKind */
+export function TKind(schema) {
+    return ValueGuard.IsObject(schema) && Kind in schema && ValueGuard.IsString(schema[Kind]) && !KnownTypes.includes(schema[Kind]);
+}
+/** Returns true if the given value is TSchema */
+export function TSchema(schema) {
+    // prettier-ignore
+    return (ValueGuard.IsObject(schema)) && (TAny(schema) ||
+        TArray(schema) ||
+        TBoolean(schema) ||
+        TBigInt(schema) ||
+        TAsyncIterator(schema) ||
+        TConstructor(schema) ||
+        TDate(schema) ||
+        TFunction(schema) ||
+        TInteger(schema) ||
+        TIntersect(schema) ||
+        TIterator(schema) ||
+        TLiteral(schema) ||
+        TNever(schema) ||
+        TNot(schema) ||
+        TNull(schema) ||
+        TNumber(schema) ||
+        TObject(schema) ||
+        TPromise(schema) ||
+        TRecord(schema) ||
+        TRef(schema) ||
+        TString(schema) ||
+        TSymbol(schema) ||
+        TTemplateLiteral(schema) ||
+        TThis(schema) ||
+        TTuple(schema) ||
+        TUndefined(schema) ||
+        TUnion(schema) ||
+        TUint8Array(schema) ||
+        TUnknown(schema) ||
+        TUnsafe(schema) ||
+        TVoid(schema) ||
+        TKind(schema));
+}

package/esm/type/guard/value.d.mts

@@ -0,0 +1,28 @@
+/** Returns true if this value is an async iterator */
+export declare function IsAsyncIterator(value: unknown): value is AsyncIterableIterator<unknown>;
+/** Returns true if this value is an array */
+export declare function IsArray(value: unknown): value is unknown[];
+/** Returns true if this value is bigint */
+export declare function IsBigInt(value: unknown): value is bigint;
+/** Returns true if this value is a boolean */
+export declare function IsBoolean(value: unknown): value is boolean;
+/** Returns true if this value is a Date object */
+export declare function IsDate(value: unknown): value is Date;
+/** Returns true if this value is a function */
+export declare function IsFunction(value: unknown): value is Function;
+/** Returns true if this value is an iterator */
+export declare function IsIterator(value: unknown): value is IterableIterator<unknown>;
+/** Returns true if this value is null */
+export declare function IsNull(value: unknown): value is null;
+/** Returns true if this value is number */
+export declare function IsNumber(value: unknown): value is number;
+/** Returns true if this value is an object */
+export declare function IsObject(value: unknown): value is Record<PropertyKey, unknown>;
+/** Returns true if this value is string */
+export declare function IsString(value: unknown): value is string;
+/** Returns true if this value is symbol */
+export declare function IsSymbol(value: unknown): value is symbol;
+/** Returns true if this value is a Uint8Array */
+export declare function IsUint8Array(value: unknown): value is Uint8Array;
+/** Returns true if this value is undefined */
+export declare function IsUndefined(value: unknown): value is undefined;

package/esm/type/guard/value.mjs

@@ -0,0 +1,83 @@
+/*--------------------------------------------------------------------------
+
+@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.
+
+---------------------------------------------------------------------------*/
+/** Returns true if this value is an async iterator */
+export function IsAsyncIterator(value) {
+    return IsObject(value) && !IsArray(value) && !IsUint8Array(value) && Symbol.asyncIterator in value;
+}
+/** Returns true if this value is an array */
+export function IsArray(value) {
+    return Array.isArray(value);
+}
+/** Returns true if this value is bigint */
+export function IsBigInt(value) {
+    return typeof value === 'bigint';
+}
+/** Returns true if this value is a boolean */
+export function IsBoolean(value) {
+    return typeof value === 'boolean';
+}
+/** Returns true if this value is a Date object */
+export function IsDate(value) {
+    return value instanceof globalThis.Date;
+}
+/** Returns true if this value is a function */
+export function IsFunction(value) {
+    return typeof value === 'function';
+}
+/** Returns true if this value is an iterator */
+export function IsIterator(value) {
+    return IsObject(value) && !IsArray(value) && !IsUint8Array(value) && Symbol.iterator in value;
+}
+/** Returns true if this value is null */
+export function IsNull(value) {
+    return value === null;
+}
+/** Returns true if this value is number */
+export function IsNumber(value) {
+    return typeof value === 'number';
+}
+/** Returns true if this value is an object */
+export function IsObject(value) {
+    return typeof value === 'object' && value !== null;
+}
+/** Returns true if this value is string */
+export function IsString(value) {
+    return typeof value === 'string';
+}
+/** Returns true if this value is symbol */
+export function IsSymbol(value) {
+    return typeof value === 'symbol';
+}
+/** Returns true if this value is a Uint8Array */
+export function IsUint8Array(value) {
+    return value instanceof globalThis.Uint8Array;
+}
+/** Returns true if this value is undefined */
+export function IsUndefined(value) {
+    return value === undefined;
+}

package/esm/type/helpers/helpers.d.mts

@@ -0,0 +1,42 @@
+import type { TSchema } from '../schema/index.mjs';
+import type { TProperties } from '../object/index.mjs';
+import type { TNever } from '../never/index.mjs';
+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/esm/type/helpers/helpers.mjs

@@ -0,0 +1,31 @@
+/*--------------------------------------------------------------------------
+
+@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.
+
+---------------------------------------------------------------------------*/
+/** Increments the given string value + 1 */
+export function Increment(T) {
+    return (parseInt(T) + 1).toString();
+}

package/esm/type/helpers/index.d.mts

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

package/esm/type/helpers/index.mjs

@@ -0,0 +1,28 @@
+/*--------------------------------------------------------------------------
+
+@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.
+
+---------------------------------------------------------------------------*/
+export * from './helpers.mjs';