gqtx/types.d.ts

import * as graphql from 'graphql';
declare type PromiseOrValue<T> = Promise<T> | T;
declare type Maybe<T> = T | null | undefined;
export declare type OutputType<Ctx, Src> = Scalar<Src> | Enum<Src> | ObjectType<Ctx, Src> | Union<Ctx, Src> | Interface<Ctx, Src> | ListType<Ctx, Src> | NonNullType<Ctx, Src>;
interface ListType<Ctx, Src> extends List<Ctx, OutputType<Ctx, Src>> {
}
interface NonNullType<Ctx, Src> extends NonNull<Ctx, OutputType<Ctx, Src>> {
}
export declare type InputType<Src> = Scalar<Src> | Enum<Src> | InputObject<Src> | ListInputType<Src> | NonNullInputType<Src>;
interface ListInputType<Src> extends ListInput<InputType<Src>> {
}
interface NonNullInputType<Src> extends NonNullInput<InputType<Src>> {
}
export declare type AllType<Ctx> = OutputType<Ctx, any> | InputType<any>;
export declare type Scalar<Src> = {
    kind: 'Scalar';
    graphqlTypeConfig: graphql.GraphQLScalarTypeConfig<Src, JSON>;
} | {
    kind: 'Scalar';
    builtInType: graphql.GraphQLScalarType;
};
export declare type Enum<Src> = {
    kind: 'Enum';
    name: string;
    description?: string;
    values: Array<EnumValue<Src>>;
};
export declare type EnumValue<Src> = {
    name: string;
    description?: string;
    deprecationReason?: string;
    value: Src;
};
export declare type List<Ctx, Src> = {
    kind: 'List';
    ofType: OutputType<Ctx, Src>;
};
export declare type NonNull<Ctx, Src> = {
    kind: 'NonNull';
    ofType: OutputType<Ctx, Src>;
};
export declare type ListInput<Src> = {
    kind: 'ListInput';
    ofType: InputType<Src>;
};
export declare type NonNullInput<Src> = {
    kind: 'NonNullInput';
    ofType: InputType<Src>;
};
export declare type Argument<Src> = {
    kind: 'Argument';
    type: InputType<Src>;
    description?: string;
};
export declare type DefaultArgument<Src> = {
    kind: 'DefaultArgument';
    type: InputType<Src>;
    description?: string;
    default: Src;
};
export declare type ArgMap<T> = {
    [K in keyof T]: DefaultArgument<T[K]> | Argument<T[K]>;
};
export declare type ArgMapValue<TArg> = TArg extends DefaultArgument<infer Src> ? Src : TArg extends Argument<infer Src> ? Src extends null ? Maybe<Src> : Src : never;
export declare type TOfArgMap<TArgMap> = {
    [K in keyof TArgMap]: ArgMapValue<TArgMap[K]>;
};
export declare type Field<Ctx, Src, Out, TArg extends object = {}> = {
    kind: 'Field';
    name: string;
    description?: string;
    type: OutputType<Ctx, Out>;
    args: ArgMap<TArg>;
    deprecationReason?: string;
    resolve: (src: Src, args: TOfArgMap<ArgMap<TArg>>, ctx: Ctx, info: graphql.GraphQLResolveInfo) => Out | Promise<Out>;
    extensions?: Record<string, any>;
};
export declare type AbstractField<Ctx, Out> = {
    kind: 'AbstractField';
    name: string;
    description?: string;
    deprecationReason?: string;
    type: OutputType<Ctx, Out>;
};
export declare type ObjectType<Ctx, Src> = {
    kind: 'ObjectType';
    name: string;
    description?: string;
    deprecationReason?: string;
    interfaces: Array<Interface<Ctx, any>>;
    fieldsFn: () => Array<Field<Ctx, Src, any, any>>;
    isTypeOf?: (src: any, ctx: Ctx, info: graphql.GraphQLResolveInfo) => boolean | Promise<boolean>;
    extensions?: Record<string, any>;
};
export declare type InputField<Src> = {
    type: InputType<Src>;
    description?: string;
};
export declare type InputFieldMap<T> = {
    [K in keyof T]: InputField<T[K]>;
};
export declare type InputObject<Src> = {
    kind: 'InputObject';
    name: string;
    description?: string;
    fieldsFn: () => InputFieldMap<Src>;
};
declare type ResolveType<Src, Ctx> = (src: Src, ctx: Ctx, info: graphql.GraphQLResolveInfo) => PromiseOrValue<Maybe<ObjectType<Ctx, Src | null> | string>>;
export declare type Interface<Ctx, Src> = {
    kind: 'Interface';
    name: string;
    description?: string;
    interfaces: Array<Interface<Ctx, any>>;
    fieldsFn: () => Array<AbstractField<Ctx, any>>;
    resolveType?: ResolveType<Src, Ctx>;
};
export declare type Union<Ctx, Src> = {
    kind: 'Union';
    name: string;
    types: Array<ObjectType<Ctx, Src>>;
    resolveType: ResolveType<Src, Ctx>;
};
export declare type SubscriptionObject<Ctx, RootSrc> = {
    kind: 'SubscriptionObject';
    name: string;
    fields: Array<SubscriptionField<Ctx, RootSrc, any, any>>;
};
export declare type SubscriptionField<Ctx, RootSrc, TArg, Out> = {
    kind: 'SubscriptionField';
    name: string;
    description?: string;
    type: OutputType<Ctx, Out>;
    args: ArgMap<TArg>;
    deprecationReason?: string;
    subscribe: (source: RootSrc, args: TOfArgMap<ArgMap<TArg>>, ctx: Ctx, info: graphql.GraphQLResolveInfo) => PromiseOrValue<AsyncIterator<Out>>;
    resolve?: (source: RootSrc, args: TOfArgMap<ArgMap<TArg>>, ctx: Ctx, info: graphql.GraphQLResolveInfo) => PromiseOrValue<Out>;
};
export declare type Schema<Ctx, RootSrc = undefined> = {
    query: ObjectType<Ctx, RootSrc>;
    mutation?: ObjectType<Ctx, RootSrc>;
    subscription?: SubscriptionObject<Ctx, RootSrc>;
    types?: ObjectType<Ctx, any>[];
    directives?: graphql.GraphQLDirective[];
};
export {};