/**
 * Used internally to verify that some type is enum-like.
 * A type is enum-like if all its properties are of type number or string.
 * @template V - Type of the enum value.
 * @template K - String literal union of all keys of the enum-like type.
 */
export declare type EnumLike<V extends number | string, K extends string> = {
    [P in K]: V;
};
/**
 * Extracts only keys of type T that are assignable to type `string`.
 * This is necessary starting with TypeScript 2.9 because keyof T can now
 * include `number` and `symbol` types.
 */
export declare type StringKeyOf<T> = Extract<keyof T, string>;
/**
 * Utility type that matches values of an object and return the matching keys
 */
export declare type MatchValues<T, V> = Extract<{
    [K in keyof T]: {
        key: K;
        type: T[K];
    };
}[keyof T], {
    key: string;
    type: V;
}> extends {
    key: infer K;
} ? (K extends keyof T ? K : never) : never;
/**
 * Utility type that omit keys of a type
 */
export declare type Omit<T, K> = Pick<T, Exclude<keyof T, K>>;
export declare type IsNever<T> = T extends never ? true : false;
/**
 * Utility type that make specified fields required and the rest optional
 */
export declare type RequiredKeys<T, R extends keyof T> = ({
    map: {
        [K in R]-?: T[K];
    } & {
        [K in Exclude<keyof T, R>]?: T[K];
    };
}) extends {
    map: infer U;
} ? {
    [K in keyof U]: U[K];
} : never;
/**
 * Utility type that optionalize object keys that have optional values
 */
export declare type Optionalize<T> = RequiredKeys<T, MatchValues<{
    [K in keyof T]: T[K] extends never ? false : (Extract<T[K], undefined> extends never ? (T[K] extends {} ? (keyof T[K] extends never ? false : (Partial<T[K]> extends T[K] ? false : true)) : true) : false);
}, true>>;
/**
 * Utility type that make specified fields optional and the rest required
 */
export declare type PartialKeys<T, R extends keyof T> = RequiredKeys<T, Exclude<keyof T, R>>;
/**
 * Wrap a value inside a function
 */
export declare type Thunk<T> = (() => T) | T;
/**
 * Schema scalar type parser map for encode and decode
 */
export declare type SchemaScalarTypeConfig<T = any, O = any> = {
    /**
     * Decode from Facebook Graph JSON type to JavaScript type
     * @param value
     */
    decode: (value: O) => T;
    /**
     * Encode from Javascript type to Facebook Graph JSON type
     * @param value
     */
    encode: (value: T) => O;
};
/**
 * All scalar types mapped to their parsers
 */
export declare type SchemaScalarTypeMap = {
    [K in keyof typeof schemaScalarTypes]: SchemaScalarTypeConfig;
};
/**
 * All singular scalar types accepted on schema
 */
export declare type SchemaScalarType = keyof SchemaScalarTypeMap;
export declare type SchemaObjectTypeFieldValue<T extends SchemaFieldDefinition<any> = SchemaFieldDefinition<any>> = T extends SchemaFieldDefinition<infer V> ? Thunk<Extract<V, string>> | T : never;
/**
 * Inferable schema field map
 */
export declare type SchemaObjectTypeFieldMap<T extends SchemaObjectTypeFieldValue<any> = SchemaObjectTypeFieldValue<any>> = Record<string, T>;
/**
 * Schema enum type
 */
export interface SchemaEnumType<T extends EnumLike<number | string, StringKeyOf<T>> = any> {
    name: string;
    enum: T;
}
/**
 * Schema natural object type
 */
export interface SchemaObjectType<F extends SchemaObjectTypeFieldMap<any> = SchemaObjectTypeFieldMap<any>> {
    name: string;
    fields: F;
}
/**
 * Schema object output type field map
 */
export declare type SchemaObjectOutputTypeFieldMap<T = any> = SchemaObjectTypeFieldMap<SchemaOutputTypeFieldDefinition<T>>;
/**
 * Schema object output type field map for connection objects
 */
export declare type SchemaObjectConnectionOutputTypeFieldMap<T = any> = SchemaObjectOutputTypeFieldMap<T> & {
    data: SchemaOutputTypeFieldDefinition<T> & {
        list: true;
    };
};
export declare type SchemaObjectInputTypeFieldMap<T = any> = SchemaObjectTypeFieldMap<SchemaInputTypeFieldDefinition<T>>;
/**
 * Schema object type
 */
export declare type SchemaObjectOutputType<T = any> = SchemaCommonObjectOutputType<T> | SchemaObjectConnectionOutputType<T>;
/**
 * Schema normal object output type (not an edge)
 */
export interface SchemaCommonObjectOutputType<T = any> extends SchemaObjectType<SchemaObjectOutputTypeFieldMap<T>> {
    connection?: false;
}
/**
 * Schema connection object output type
 */
export interface SchemaObjectConnectionOutputType<T = any> extends SchemaObjectType<SchemaObjectOutputTypeFieldMap<T>> {
    connection: true;
    fields: SchemaObjectConnectionOutputTypeFieldMap<T>;
}
/**
 * Schema output type
 */
export declare type SchemaOutputType = SchemaScalarType | SchemaEnumType | SchemaObjectOutputType;
/**
 * Schema object input type
 */
export interface SchemaObjectInputType<T = any> extends SchemaObjectType<SchemaObjectInputTypeFieldMap<T>> {
}
/**
 * Schema input type
 */
export declare type SchemaInputType = SchemaScalarType | SchemaEnumType | SchemaObjectInputType;
/**
 * Schema field type definition
 */
export interface SchemaFieldDefinition<T = any> {
    /**
     * Rather the field is nullable
     */
    nullable?: true | false;
    /**
     * Rather the field is a list
     */
    list?: true | false;
    /**
     * Rather the field item is nullable
     */
    nullableItem?: this extends {
        list: true;
    } ? true | false : false;
    /**
     * The field type
     */
    type: Thunk<T>;
}
/**
 * Schema input type field definition
 */
export interface SchemaInputTypeFieldDefinition<T = any> extends SchemaFieldDefinition<T> {
}
/**
 * Schema field definition
 */
export interface SchemaOutputTypeFieldDefinition<T = any> extends SchemaFieldDefinition<T> {
    /**
     * If fields is present even if not selected
     */
    core?: true | false;
    /**
     * If field is present when no field is selected
     */
    default?: true | false;
    /**
     * The field modifiers
     */
    modifiers?: SchemaObjectInputTypeFieldMap<T>;
}
/**
 * Transforms schema scalar type to it's JavaScript type
 */
export declare type TransformSchemaScalarType<STM extends SchemaScalarTypeMap, K extends SchemaScalarType, DECODE extends true | false = true> = STM[K] extends SchemaScalarTypeConfig ? ReturnType<(DECODE extends true ? STM[K]['decode'] : STM[K]['encode'])> : never;
/**
 * Transforms schema nullable item to JavaScript type
 */
export declare type TransformSchemaListItemType<T, S> = S extends {
    list: true;
    nullableItem: true;
} ? T | undefined : T;
/**
 * Transforms schema list to javascript type
 */
export declare type TransformSchemaListType<T, S> = S extends {
    list: true;
} ? TransformSchemaListItemType<T, S>[] : T;
/**
 * Transforms schema nullable to javascript type
 */
export declare type TransformSchemaNullableType<T, S> = S extends {
    nullable: true;
} ? TransformSchemaListType<T, S> | undefined : TransformSchemaListType<T, S>;
/**
 * Transforms schema field
 */
export declare type TransformSchemaFieldType<STM extends SchemaScalarTypeMap, S, DECODE extends true | false = true> = S extends Thunk<SchemaScalarType> ? TransformSchemaType<STM, S, DECODE> : (S extends SchemaFieldDefinition<infer T> ? TransformSchemaNullableType<TransformSchemaType<STM, T, DECODE>, S> : never);
export declare type TransformSchemaFieldMapType<STM extends SchemaScalarTypeMap, F, DECODE extends true | false = true> = F extends SchemaObjectTypeFieldMap ? PartialKeys<{
    [K in keyof F]: TransformSchemaFieldType<STM, F[K], DECODE>;
}, MatchValues<F, {
    nullable: true;
}>> : never;
/**
 * Transforms any schema type to it's javascript single type
 */
export declare type TransformSchemaType<STM extends SchemaScalarTypeMap, S, DECODE extends true | false = true> = S extends Thunk<infer S> ? (S extends SchemaScalarType ? TransformSchemaScalarType<STM, S, DECODE> : (S extends SchemaEnumType ? keyof S['enum'] : (S extends SchemaObjectType<infer F> ? TransformSchemaFieldMapType<STM, F, DECODE> : never))) : never;
export declare type FormatSchemaExecution<T extends {
    modifiers: any;
    fields: any;
}, SUB extends true | false = false> = ({
    format: Optionalize<T>;
}) extends {
    format: infer U;
} ? (SUB extends true ? (Partial<U> extends U ? (SUB extends true ? (null | U) : U) : U) : U) : never;
/**
 * Format schema selection
 */
/**
 * Schema modifiers selection
 */
export declare type SchemaModifierExecution<STM extends SchemaScalarTypeMap, M> = keyof M extends never ? never : TransformSchemaFieldMapType<STM, M>;
/**
 * Schema field selection
 */
export declare type SchemaFieldExecution<STM extends SchemaScalarTypeMap, S, SUB extends true | false = false> = S extends Thunk<SchemaScalarType> ? SchemaExecution<STM, S, never, SUB> : (S extends SchemaFieldDefinition<infer T> ? (S extends {
    modifiers: infer M;
} ? SchemaExecution<STM, T, M, SUB> : SchemaExecution<STM, T, never, SUB>) : never);
/**
 * Schema selection
 */
export declare type SchemaExecution<STM extends SchemaScalarTypeMap, S, M = never, SUB extends true | false = false> = S extends Thunk<infer S> ? (S extends SchemaScalarType | SchemaEnumType ? FormatSchemaExecution<{
    modifiers: SchemaModifierExecution<STM, M>;
    fields: never;
}, SUB> : (S extends {
    connection: true;
    fields: {
        data: infer D;
    };
} ? (D extends {
    type: Thunk<SchemaObjectType<infer F>>;
} ? FormatSchemaExecution<{
    modifiers: SchemaModifierExecution<STM, M>;
    fields: RequiredKeys<{
        [K in keyof F]: SchemaFieldExecution<STM, F[K], true>;
    }, MatchValues<F, {
        required: true;
    }>>;
}, SUB> : FormatSchemaExecution<{
    modifiers: SchemaModifierExecution<STM, M>;
    fields: never;
}, SUB>) : (S extends SchemaObjectType<infer F> ? FormatSchemaExecution<{
    modifiers: SchemaModifierExecution<STM, M>;
    fields: RequiredKeys<{
        [K in keyof F]: SchemaFieldExecution<STM, F[K], true>;
    }, MatchValues<F, {
        required: true;
    }>>;
}, SUB> : never))) : never;
export declare type SchemaObjectTypeFieldMapFilterRecursion<STM extends SchemaScalarTypeMap, F, M, MM> = F extends SchemaObjectTypeFieldMap ? (({
    data: Pick<F, MatchValues<Required<F>, M>>;
}) extends {
    data: infer D;
} ? (keyof D extends never ? {} : {
    [K in keyof D]: SchemaObjectTypeFieldFilterRecursion<STM, D[K], IsNever<MM> extends true ? M : MM, never>;
}) : never) : never;
export declare type SchemaObjectTypeFieldFilterRecursion<STM extends SchemaScalarTypeMap, S, M, MM> = S extends Thunk<SchemaScalarType> ? SchemaObjectTypeFieldFilterMatch<STM, S, M, MM> : (S extends SchemaFieldDefinition<infer T> ? Omit<S, 'type'> & {
    type: SchemaObjectTypeFieldFilterMatch<STM, T, M, MM>;
} : never);
export declare type SchemaObjectTypeFieldFilter<STM extends SchemaScalarTypeMap, S, M, MM> = S extends Thunk<SchemaScalarType> ? SchemaObjectTypeFieldFilterMatch<STM, S, M, MM> : (S extends SchemaFieldDefinition<infer T> ? Omit<S, 'type'> & {
    type: SchemaObjectTypeFieldFilterMatch<STM, T, M, MM>;
} : never);
/**
 * Filter schema type based on field definition
 */
export declare type SchemaObjectTypeFieldFilterMatch<STM extends SchemaScalarTypeMap, S, M, MM> = S extends Thunk<infer S> ? (S extends SchemaScalarType | SchemaEnumType ? S : (S extends SchemaObjectType<infer F> ? (S extends {
    connection: true;
    fields: {
        data: infer D;
    };
} ? Omit<S, 'fields'> & {
    fields: {
        data: SchemaObjectTypeFieldFilter<STM, D, M, MM>;
    } & Omit<F, 'data'>;
} : Omit<S, 'fields'> & {
    fields: SchemaObjectTypeFieldMapFilterRecursion<STM, F, M, MM>;
}) : never)) : never;
/**
 * Format schema to default execution
 */
export declare type FormatSchemaDefaultOutput<STM extends SchemaScalarTypeMap, F> = SchemaObjectTypeFieldMapFilterRecursion<STM, F, {
    default: true;
} | {
    core: true;
}, never>;
export declare type FormatSchemaCoreOutput<STM extends SchemaScalarTypeMap, F> = SchemaObjectTypeFieldMapFilterRecursion<STM, F, {
    core: true;
}, {
    default: true;
} | {
    core: true;
}>;
export declare type FormatSchemaFieldOutput<STM extends SchemaScalarTypeMap, S, P> = S extends Thunk<SchemaScalarType> ? FormatSchemaOutput<STM, S, P> : (S extends SchemaFieldDefinition<infer T> ? Omit<S, 'type'> & {
    type: FormatSchemaOutput<STM, T, P>;
} : never);
export declare type FormatSchemaFieldMapOutput<STM extends SchemaScalarTypeMap, F, P> = F extends SchemaObjectTypeFieldMap ? (P extends {
    fields: {};
} ? (Exclude<keyof P['fields'], Exclude<keyof P['fields'], keyof F>> extends never ? FormatSchemaDefaultOutput<STM, F> : (({
    data: Pick<F, Exclude<keyof F, Exclude<keyof F, keyof P['fields']>>>;
}) extends {
    data: infer D;
} ? (keyof D extends string ? (({
    core: FormatSchemaCoreOutput<STM, F>;
}) extends {
    core: infer C;
} ? ({
    [K in keyof D]: FormatSchemaFieldOutput<STM, D[K], K extends keyof P['fields'] ? P['fields'][K] : never>;
} & Omit<C, keyof D> & {
    [K in Exclude<keyof P['fields'], keyof F>]: {
        type: never;
    };
}) : never) : FormatSchemaDefaultOutput<STM, F>) : never)) : FormatSchemaDefaultOutput<STM, F>) : never;
export declare type FormatSchemaOutput<STM extends SchemaScalarTypeMap, S, P> = S extends Thunk<infer S> ? (S extends SchemaScalarType | SchemaEnumType ? S : (S extends SchemaObjectType<infer F> ? (S extends {
    connection: true;
    fields: {
        data: infer D;
    };
} ? Omit<S, 'fields'> & {
    fields: ({
        data: FormatSchemaFieldOutput<STM, D, P>;
    } & (P extends {
        modifiers: {
            summary: (infer SMF)[];
        };
    } ? (FormatSchemaCoreOutput<STM, Omit<F, 'data' | 'summary'>> & (F extends {
        summary: infer SM;
    } ? {
        summary: FormatSchemaFieldOutput<STM, SM, {
            fields: {
                [K in Extract<SMF, string>]: null;
            };
        }>;
    } : {})) : FormatSchemaCoreOutput<STM, Omit<F, 'data'>>));
} : Omit<S, 'fields'> & {
    fields: FormatSchemaFieldMapOutput<STM, F, P>;
}) : never)) : never;
export declare type SchemaFields<S> = S extends Thunk<infer S> ? (S extends SchemaScalarType | SchemaEnumType ? never : (S extends SchemaObjectType<infer F> ? keyof F : never)) : never;
export declare type SchemaField<S, K extends string> = S extends Thunk<infer S> ? (S extends SchemaScalarType | SchemaEnumType ? never : (S extends SchemaObjectType<infer F> ? (F[K] extends SchemaFieldDefinition<infer T> ? T : F[K]) : never)) : never;
export declare type SchemaPathTuples = [string] | [string, string] | [string, string, string] | [string, string, string, string];
export declare type SchemaPath<S extends Thunk<SchemaObjectType<any>>, P extends SchemaPathTuples> = P extends [string] ? SchemaField<S, P[0]> : (P extends [string, string] ? SchemaField<SchemaField<S, P[0]>, P[1]> : (P extends [string, string, string] ? SchemaField<SchemaField<SchemaField<S, P[0]>, P[1]>, P[2]> : (P extends [string, string, string, string] ? SchemaField<SchemaField<SchemaField<SchemaField<S, P[0]>, P[1]>, P[2]>, P[3]> : never)));
export declare type SchemaThunkObjectType<F> = Thunk<SchemaObjectType<F>>;
export declare function getSchemaPath<S extends Thunk<SchemaObjectType<any>>, P extends SchemaPathTuples>(type: S, ...path: P): SchemaPath<S, P>;
export declare const schemaScalarTypes: {
    String: {
        decode: (value: any) => string;
        encode: (value: string) => any;
    };
    Any: {
        decode: (value: any) => any;
        encode: (value: any) => any;
    };
    Float: {
        decode: (value: any) => number;
        encode: (value: number) => any;
    };
    Int: {
        decode: (value: any) => number;
        encode: (value: number) => any;
    };
    ID: {
        decode: (value: any) => string;
        encode: (value: string) => any;
    };
    DateTime: {
        decode: (value: any) => Date;
        encode: (value: Date) => any;
    };
    Boolean: {
        decode: (value: any) => boolean;
        encode: (value: boolean) => any;
    };
};
export declare const Type: {
    [K in keyof typeof schemaScalarTypes]: K;
} & {
    true: true;
    false: true;
    modifiers<T extends SchemaObjectInputTypeFieldMap>(modifiers: T): T;
    inputField<T extends SchemaInputTypeFieldDefinition>(field: T): T;
    outputField<T extends SchemaOutputTypeFieldDefinition>(field: T): T;
    ConnectionObjectType<F extends SchemaObjectOutputTypeFieldMap>(name: string, fields: F): SchemaObjectType<F> & {
        connection: true;
    };
    ObjectType: {
        <T extends SchemaObjectType, F extends SchemaObjectOutputTypeFieldMap>(name: string, mixin: () => T[], fields: F): SchemaObjectType<T['fields'] & F>;
        <T extends SchemaObjectType>(name: string, mixin: () => T[]): SchemaObjectType<T['fields']>;
        <F extends SchemaObjectOutputTypeFieldMap>(name: string, fields: F): SchemaObjectType<F>;
    };
    InputType: {
        <T extends SchemaObjectType, F extends {
            [name: string]: SchemaInputTypeFieldDefinition;
        } = {}>(name: string, mixin: () => T[], fields?: F): SchemaObjectType<T['fields'] & F>;
        <F extends {
            [name: string]: SchemaInputTypeFieldDefinition;
        }>(name: string, fields: F): SchemaObjectType<F>;
    };
    EnumType<T extends EnumLike<number | string, StringKeyOf<T>>>(name: string, enumerator: T): SchemaEnumType<T>;
};
export declare function isThunkType<T = any>(type: any): type is () => T;
export declare function isScalarType(type: any): type is keyof SchemaScalarTypeMap;
export declare function isEnumType(type: any): type is SchemaEnumType;
export declare function isObjectType<T = any>(type: any): type is SchemaObjectType<SchemaObjectTypeFieldMap<T>>;
export declare function isObjectTypeFieldDefinition<T = any>(field: any): field is SchemaFieldDefinition<T>;
export declare function getSchemaType<T = any>(type: Thunk<T>): T;
export declare function getSchemaFieldType<T = any>(field: Thunk<Extract<T, string>> | SchemaFieldDefinition<T>): typeof field extends Thunk<Extract<infer R, string>> | SchemaFieldDefinition<infer R> ? R : never;
export declare function transformSchemaType<STM extends SchemaScalarTypeMap, T = any, DECODE extends true | false = true>(scalarTypes: STM, type: Thunk<T>, value: any, decode?: DECODE): TransformSchemaType<STM, Thunk<T>, DECODE>;