import * as t from "io-ts";
import { Dictionary } from "lodash";
import { GraphQLInputType, GraphQLOutputType } from "graphql";
/** Convenience utility types */
export declare const MappedRT: <RT1 extends t.Mixed, RT2 extends t.Mixed = RT1>(mapped: RT1, stored: RT2) => t.TypeC<{
    stored: RT2;
    mapped: RT1;
}>;
export declare const MaybeMappedRT: <RT1 extends t.Mixed, RT2 extends t.Mixed = RT1>(mapped: RT1, stored: RT2) => t.UnionC<[RT1, t.TypeC<{
    stored: RT2;
    mapped: RT1;
}>]>;
export declare type Maybe<T> = null | undefined | T;
export declare type NNil<T> = Exclude<T, undefined | null>;
export interface Dict<T = any> extends Dictionary<T> {
}
export interface Lazy<T> {
    (): T;
}
export declare type MaybeLazy<T> = T | Lazy<T>;
export declare type MaybePromise<T> = T | Promise<T>;
export declare type MaybeArray<T> = T | T[];
export declare type MaybeArrayItem<T extends MaybeArray<any>> = T extends MaybeArray<infer I> ? I : never;
export interface Factory<T> {
    (...args: any[]): T;
}
export interface Newable<T> {
    new (...args: any[]): T;
}
export declare type StrKey<T> = keyof T & string;
export declare type IdxKey<T> = keyof T & number;
export declare type Normalizer<PreNormalizedT, NormalizedT> = (v: PreNormalizedT) => NormalizedT;
export declare type MandateProps<T, P extends keyof T> = Omit<T, P> & {
    [K in keyof Pick<T, P>]-?: T[K];
};
export declare type ReturnType<T extends (...args: any[]) => any> = T extends (...args: any[]) => infer R ? R : any;
export declare type Fn<A extends any[] = any[], R = any> = (...args: A) => R;
export declare type TypeGuard<S> = (v: any) => v is S;
export declare type Omit<T, K> = Pick<T, Exclude<keyof T, K>>;
export declare type ReplaceWith<TSource, TKey, TSub = never> = {
    [K in keyof TSource]: K extends TKey ? TSub : TSource[K];
};
export declare type MakeOptional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
export interface Mapped<TMapped, TStored = TMapped> {
    mapped: TMapped;
    stored: TStored;
}
export declare type MaybeMapped<T> = T | Mapped<T>;
export declare type KeyOf<T> = keyof T;
export declare type ValueOf<T> = T[KeyOf<T>];
/**
 * Runtime type representation to validate if a value is instance of a class
 */
export declare class InstanceType<T> extends t.Type<T> {
    readonly _tag: "InstanceType";
    constructor(Ctor: Newable<T>);
}
export declare const InstanceOf: <T>(Ctor: Newable<T>) => InstanceType<T>;
export declare const IOType: InstanceType<t.Type<any>>;
export declare type MakePartial<T extends object, K extends keyof T> = Partial<Pick<T, K>> & Omit<T, K>;
export declare const GQLInputType: t.Type<GraphQLInputType, GraphQLInputType, unknown>;
export declare const GQLOutputType: t.Type<GraphQLOutputType, GraphQLOutputType, unknown>;
export declare const RegExpType: t.Type<RegExp, RegExp, unknown>;
export declare type ExtendsWitness<U extends T, T> = U;
interface _MultiSelectionItem<TTgt, TCtx> {
    selection(): TTgt;
    shouldUse(ctx: TCtx): Promise<boolean>;
}
export declare type MultiSelectionItem<TTgt, TCtx> = MakeOptional<_MultiSelectionItem<TTgt, TCtx>, "shouldUse">;
export declare type MultiSelection<TTgt, TCtx, TMember extends MultiSelectionItem<TTgt, TCtx> = MultiSelectionItem<TTgt, TCtx>> = Dictionary<TMember>;
export declare type Interceptor<T> = (i: T) => T;
export declare type PartialDeep<T> = {
    [P in keyof T]?: T[P] extends Array<infer U> ? Array<PartialDeep<U>> : T[P] extends ReadonlyArray<infer U> ? ReadonlyArray<PartialDeep<U>> : PartialDeep<T[P]>;
};
export declare type Predicate<T> = (i: T) => boolean;
export {};