import { Result } from "../result";
import { TypedKind } from "../kind";
import { Comment, Either, Intersection, Projection, Type, TypeImpl } from "../type";
import { GetType } from "../get-type";
export declare class MissingKey<T extends Type<any>> {
    readonly type: T;
    constructor(type: T);
}
export declare class OptionalKey<T extends Type<any>> {
    readonly type: T;
    constructor(type: T);
}
type WrapperOrType<T> = T extends MissingKey<infer Inner> ? Inner : T extends OptionalKey<infer Inner> ? Inner : T;
type RawDict<V> = {
    [key: string]: V;
};
type ObjectField = {
    readonly checker: TypedKind<any>;
    readonly allowsMissing: boolean;
};
type ObjectFields = {
    [key: string]: ObjectField;
    [key: symbol]: ObjectField;
};
type ObjectShape = {
    readonly fields: ObjectFields;
    readonly exact: boolean;
    readonly requirePlainObject: boolean;
    readonly rest?: TypedKind<any>;
};
export type MissingIssue = {
    readonly kind: "missing";
    readonly subject: "object";
};
export type UnknownPropertyIssue = {
    readonly kind: "unknown-property";
    readonly subject: "object";
};
declare abstract class MergeableType<T> extends TypeImpl<T> {
    private readonly objectShape;
    constructor(objectShape: ObjectShape);
    check(val: any): Result<T>;
    sliceResult(val: any): Result<T>;
    protected merge<Incoming>(type: TypedKind<Incoming>): TypedKind<T & Incoming> | undefined;
    protected project(val: any): Projection<T>;
}
export declare class Dict<V> extends MergeableType<RawDict<V>> {
    readonly namedKey: string;
    readonly valueType: TypedKind<V>;
    constructor(v: Type<V>, namedKey?: string);
    keyName(key: string): Dict<V>;
}
export declare function dict<V>(v: Type<V>): Dict<V>;
export type FieldDef = Type<any> | MissingKey<any> | OptionalKey<any>;
export type TypeStruct = {
    [key: string]: FieldDef;
    [key: symbol]: FieldDef;
};
type OptionalPropertyNames<T extends TypeStruct> = {
    [K in keyof T]: T[K] extends MissingKey<any> ? K : T[K] extends OptionalKey<any> ? K : never;
}[keyof T];
type UnwrapTypes<T extends TypeStruct> = {
    [K in keyof T]: GetType<WrapperOrType<T[K]>>;
};
export type UnwrappedTypeStruct<T extends TypeStruct> = Pick<UnwrapTypes<T>, Exclude<keyof T, OptionalPropertyNames<T>>> & Partial<Pick<UnwrapTypes<T>, OptionalPropertyNames<T>>>;
export type TypeStructFor<T> = {
    [K in keyof T]: Type<T[K]>;
};
export type StructFor<T> = Struct<TypeStructFor<T>>;
export declare function keyType<T extends Type<any>>(box: MissingKey<T> | OptionalKey<T> | T): T;
export declare function allowsMissing<T extends Type<any>>(box: MissingKey<T> | T): box is MissingKey<T>;
export declare function allowsOptional<T extends Type<any>>(box: MissingKey<T> | T): box is OptionalKey<T>;
export declare class Struct<T extends TypeStruct> extends MergeableType<UnwrappedTypeStruct<T>> {
    readonly definition: T;
    readonly exact: boolean;
    constructor(definition: T, exact: boolean);
}
export declare function subtype<T extends TypeStruct>(def: T): Struct<T>;
export declare function exact<T extends TypeStruct>(def: T): Struct<T>;
export declare function optional<T extends Type<any>>(check: T): OptionalKey<T>;
export declare function allowMissing<T extends Type<any>>(check: T): MissingKey<T>;
type MakeOptional<T extends FieldDef> = T extends Type<any> ? OptionalKey<T> : T extends MissingKey<infer K> ? OptionalKey<K> : T;
type DeepPartialTypeStruct<T extends TypeStruct> = {
    [K in keyof T]: T[K] extends Struct<infer T2> ? OptionalKey<Struct<DeepPartialTypeStruct<T2>>> : MakeOptional<T[K]>;
};
type PartialTypeStruct<T extends TypeStruct> = {
    [K in keyof T]: MakeOptional<T[K]>;
};
export declare class PartialStruct<T extends TypeStruct> extends MergeableType<UnwrappedTypeStruct<PartialTypeStruct<T>>> {
    readonly struct: Struct<T>;
    private readonly hiddenTypeStruct;
    constructor(struct: Struct<T>);
    reify(): Struct<PartialTypeStruct<T>>;
}
export declare function deepPartial<T extends TypeStruct>(ogstruct: Struct<T>): PartialStruct<DeepPartialTypeStruct<T>>;
type ObjectOperand = Dict<any> | Struct<any> | PartialStruct<any>;
type MergeableKind = ObjectOperand | MergeIntersect<any>;
export declare class MergeIntersect<T> extends MergeableType<T> {
    readonly operands: ReadonlyArray<ObjectOperand>;
    constructor(operands: ReadonlyArray<MergeableKind>);
}
export declare const Nested: readonly [typeof Struct, typeof PartialStruct, typeof Dict, typeof Either, typeof Intersection, typeof MergeIntersect, typeof Comment];
export type NestedType = InstanceType<(typeof Nested)[number]>;
export declare function partial<T extends TypeStruct>(struct: Struct<T>): PartialStruct<T>;
export {};