declare const TypeSymbol: unique symbol;
interface SchemaType<T = unknown> {
    type: string;
    [TypeSymbol]: T;
}
declare type TypeOf<T> = T extends SchemaType<infer U> ? U : never;

declare type ValidationIssue = {
    type: 'INVALID_SCHEMA' | 'INVALID_TYPE' | 'INVALID_VALUE';
    message: string;
    path: string;
} | {
    type: 'NO_UNION_TYPE_MATCH';
    message: string;
    path: string;
    candidateIssues: ValidationIssue[][];
};
declare const validate: (schema: SchemaType, value: unknown) => ValidationIssue[];

declare const assert: <T extends SchemaType<unknown>>(schema: T, value: unknown) => asserts value is TypeOf<T>;

declare const code: (schema: SchemaType) => string;

declare const is: <T extends SchemaType<unknown>>(schema: T, value: unknown) => value is TypeOf<T>;

interface ModifiedType<T extends SchemaType, U = TypeOf<T>> extends SchemaType<U> {
    type: 'modified';
    item: T;
    optional?: true;
    readonly?: true;
}

interface ReadonlyOptionalType<T extends SchemaType> extends ModifiedType<T> {
    optional: true;
    readonly: true;
}

interface ReadonlyType<T extends SchemaType> extends ModifiedType<T> {
    readonly: true;
}
declare type ReadonlyWrapped<T extends SchemaType> = T extends ReadonlyType<infer _> ? T : T extends OptionalType<infer U> ? ReadonlyOptionalType<U> : ReadonlyType<T>;
declare const readonly: <T extends SchemaType<unknown>>(item: T) => ReadonlyWrapped<T>;

interface OptionalType<T extends SchemaType> extends ModifiedType<T, TypeOf<T> | undefined> {
    optional: true;
}
declare type OptionalWrapped<T extends SchemaType> = T extends OptionalType<infer _> ? T : T extends ReadonlyType<infer U> ? ReadonlyOptionalType<U> : OptionalType<T>;
declare const optional: <T extends SchemaType<unknown>>(item: T) => OptionalWrapped<T>;

interface AnyType extends SchemaType<any> {
    type: 'any';
}
declare const any: () => AnyType;

interface ArrayType<T extends SchemaType> extends SchemaType<TypeOf<T>[]> {
    type: 'array';
    items: T;
}
declare const array: <T extends SchemaType<unknown>>(items: T) => ArrayType<T>;

interface BigintType extends SchemaType<bigint> {
    type: 'bigint';
}
declare const bigint: () => BigintType;

interface BooleanType extends SchemaType<boolean> {
    type: 'boolean';
}
declare const boolean: () => BooleanType;

declare type Tail<T extends any[]> = ((...t: T) => void) extends (h: any, ...r: infer R) => void ? R : never;
declare type Last<T extends any[]> = T[Exclude<keyof T, keyof Tail<T>>];
declare type Prepend<Tuple extends any[], Addend> = ((_: Addend, ..._1: Tuple) => any) extends (..._: infer Result) => any ? Result : never;
declare type Reverse<Tuple extends any[], Prefix extends any[] = []> = {
    0: Prefix;
    1: ((..._: Tuple) => any) extends (_: infer First, ..._1: infer Next) => any ? Reverse<Next, Prepend<Prefix, First>> : never;
}[Tuple extends [any, ...any[]] ? 1 : 0];
declare type TypeOfTuple<T extends SchemaType[]> = {
    [K in keyof T]: TypeOf<T[K]>;
};
interface FunctionType<Args extends SchemaType[]> extends SchemaType<(...args: Reverse<Tail<Reverse<TypeOfTuple<Args>>>>) => TypeOf<Last<Args>>> {
    type: 'function';
    args: Args;
}
declare const functionType: <Args extends SchemaType<unknown>[]>(...args: Args) => FunctionType<Args>;

interface IntersectionType<Left extends SchemaType, Right extends SchemaType> extends SchemaType<TypeOf<Left> & TypeOf<Right>> {
    type: 'intersection';
    left: Left;
    right: Right;
}
declare const intersection: <Left extends SchemaType<unknown>, Right extends SchemaType<unknown>>(left: Left, right: Right) => IntersectionType<Left, Right>;

declare type PrimitiveType = bigint | boolean | null | number | string | undefined;
declare type InferredLiteralType<U extends PrimitiveType = PrimitiveType> = U | {
    [name: string]: InferredLiteralType<U>;
} | [] | [InferredLiteralType<U>] | [InferredLiteralType<U>, ...InferredLiteralType<U>[]];
interface LiteralType<T extends InferredLiteralType> extends SchemaType<T> {
    type: 'literal';
    value: T;
}
declare const literal: <U extends PrimitiveType, T extends InferredLiteralType<U>>(value: T) => LiteralType<T>;

interface LiteralUnionType<T extends InferredLiteralType[]> extends SchemaType<T[number]> {
    type: 'literalUnion';
    values: T;
}
declare const literalUnion: <U extends PrimitiveType, T extends InferredLiteralType<U>[]>(...values: T) => LiteralUnionType<T>;

interface NullType extends SchemaType<null> {
    type: 'null';
}
declare const nullType: () => NullType;

interface NumberOptions {
    multipleOf?: number;
    maximum?: number;
    exclusiveMaximum?: number;
    minimum?: number;
    exclusiveMinimum?: number;
}
interface NumberType extends SchemaType<number> {
    type: 'number';
    options: NumberOptions;
}
declare const number: (options?: NumberOptions) => NumberType;

declare type Identity<T> = T;
declare type Flatten<T extends object> = Identity<{
    [k in keyof T]: T[k];
}>;
declare type ObjectProperties = {
    [key: string]: SchemaType;
};
declare type ReadonlyProps<T extends ObjectProperties> = {
    [K in keyof T]: T[K] extends ReadonlyType<infer _> | ReadonlyOptionalType<infer _> ? K : never;
}[keyof T];
declare type TypeFromObjectProperties<T extends ObjectProperties> = Flatten<{
    [K in keyof T]+?: TypeOf<T[K]>;
} & {
    +readonly [K in ReadonlyProps<T>]?: TypeOf<T[K]>;
} & {
    [K in RequiredProps<T>]: TypeOf<T[K]>;
}>;
declare type OptionalProps<T extends ObjectProperties> = {
    [K in keyof T]: T[K] extends OptionalType<infer _> | ReadonlyOptionalType<infer _> ? K : never;
}[keyof T];
declare type RequiredProps<T extends ObjectProperties> = Exclude<keyof T, OptionalProps<T>>;
interface ObjectType<T extends ObjectProperties = ObjectProperties> extends SchemaType<TypeFromObjectProperties<T>> {
    type: 'object';
    properties: T;
    strict: boolean;
}
declare const object: <T extends ObjectProperties>(properties: T, strict?: boolean) => ObjectType<T>;

interface RecordType<T extends SchemaType> extends SchemaType<Record<string, TypeOf<T>>> {
    type: 'record';
    additionalProperties: T;
}
declare const record: <T extends SchemaType<unknown>>(type: T) => RecordType<T>;

interface StringOptions {
    maxLength?: number;
    minLength?: number;
    pattern?: string;
}
interface StringType extends SchemaType<string> {
    type: 'string';
    options: StringOptions;
}
declare const string: (options?: StringOptions) => StringType;

declare type TypeOfTuple$1<T extends SchemaType[]> = {
    [K in keyof T]: TypeOf<T[K]>;
};
interface TupleType<T extends SchemaType[]> extends SchemaType<TypeOfTuple$1<T>> {
    type: 'tuple';
    items: T;
}
declare const tuple: <T extends SchemaType<unknown>[]>(...items: T) => TupleType<T>;

interface UndefinedType extends SchemaType<undefined> {
    type: 'undefined';
}
declare const undefined$1: () => UndefinedType;

declare type TypeOfUnion<T extends SchemaType[]> = {
    [K in keyof T]: TypeOf<T[K]>;
}[number];
interface UnionType<T extends SchemaType[]> extends SchemaType<TypeOfUnion<T>> {
    type: 'union';
    oneOf: T;
}
declare const union: <T extends SchemaType<unknown>[]>(...items: T) => UnionType<T>;

interface UnknownType extends SchemaType<unknown> {
    type: 'unknown';
}
declare const unknown: () => UnknownType;

interface VoidType extends SchemaType<void> {
    type: 'void';
}
declare const voidType: () => VoidType;

export { AnyType, ArrayType, BigintType, BooleanType, FunctionType, IntersectionType, LiteralType, LiteralUnionType, ModifiedType, NullType, NumberType, ObjectProperties, ObjectType, OptionalType, ReadonlyOptionalType, ReadonlyType, RecordType, SchemaType, StringType, TupleType, TypeOf, UndefinedType, UnionType, UnknownType, ValidationIssue, VoidType, any, array, assert, bigint, boolean, code, functionType as function, intersection, is, literal, literalUnion, nullType as null, number, object, optional, readonly, record, string, tuple, undefined$1 as undefined, union, unknown, validate, voidType as void };