export declare type SpectypesError<X extends string, Y extends string, Suf extends string = ''> = PrettyType<{
    readonly [key in `spectypes error: '${X}' can't appear directly inside '${Y}'${Suf}`]: never;
}>;
export declare type SuccessResult<Value> = {
    readonly tag: 'success';
    readonly success: Value;
};
export declare type FailureResult = {
    readonly tag: 'failure';
    readonly failure: {
        readonly value: unknown;
        readonly errors: ReadonlyArray<{
            readonly issue: string;
            readonly path: ReadonlyArray<number | string>;
        }>;
    };
};
export declare type Result<Value> = FailureResult | SuccessResult<Value>;
export declare type SuccessOf<R extends Result<unknown>> = R extends SuccessResult<infer Success> ? Success : never;
export declare type SpecConfig<Tag extends readonly string[], Kind extends string> = {
    readonly tag: Tag;
    readonly kind: Kind;
};
export declare type Spec<Tag extends readonly string[] = readonly string[], Kind extends string = string, Value = unknown> = ((value: unknown) => Result<Value>) & {
    readonly config?: SpecConfig<Tag, Kind>;
};
export declare type SpecSuccess<TSpec extends Spec> = SuccessOf<ReturnType<TSpec>>;
export declare type SpecTag<TSpec extends Spec> = Required<TSpec>['config'] extends SpecConfig<infer Tag, string> ? Tag : never;
export declare type SpecKind<TSpec extends Spec> = Required<TSpec>['config'] extends SpecConfig<readonly string[], infer Kind> ? Kind : never;
export declare type SpecsTags<Specs extends readonly Spec[]> = Specs extends readonly [
    infer First,
    ...infer Rest
] ? First extends Spec ? Rest extends readonly Spec[] ? readonly [...SpecTag<First>, ...SpecsTags<Rest>] : readonly [] : readonly [] : readonly [];
export declare type HasTag<TSpec extends Spec, Tags extends string> = {
    readonly [Index in keyof SpecTag<TSpec>]: Tags extends SpecTag<TSpec>[Index] ? true : false;
}[number];
export declare type PrettyType<V> = Extract<{
    [K in keyof V]: V[K];
}, unknown>;
export declare type OmitByValue<Rec, Value> = Omit<Rec, {
    readonly [Key in keyof Rec]: Rec[Key] extends Value ? Key : never;
}[keyof Rec]>;
export declare type ObjectValue<Specs extends Record<string, Spec>> = PrettyType<OmitByValue<{
    readonly [Key in keyof Specs]: Specs[Key] extends Spec ? HasTag<Specs[Key], 'optional'> extends true ? never : SpecSuccess<Specs[Key]> : never;
}, never> & OmitByValue<{
    readonly [Key in keyof Specs]?: Specs[Key] extends Spec ? HasTag<Specs[Key], 'optional'> extends true ? SpecSuccess<Specs[Key]> : never : never;
}, never | undefined>>;
export declare type LiteralBase = string | number | boolean | undefined | null;
export declare type InferKind<Specs extends readonly Spec[]> = Specs extends readonly [
    infer First,
    ...infer Rest
] ? First extends Spec<readonly string[], 'transformer', unknown> ? 'transformer' : Rest extends readonly Spec[] ? InferKind<Rest> : 'validator' : 'validator';
export declare type SomeSpec = Spec<[''], '', unknown>;