type-graphql

const defaultPrintSchemaOptions: PrintSchemaOptions;

const Float: any;

const graphQLPeerDependencyVersion: string;

const ID: any;

const Int: any;

Arg: {
    (name: string, options?: ArgOptions): ParameterDecorator;
    (
        name: string,
        returnTypeFunc: ReturnTypeFunc,
        options?: ArgOptions
    ): ParameterDecorator;
};

Args: {
    (): ParameterDecorator;
    (options: ValidateOptions): ParameterDecorator;
    (
        paramTypeFunction: ReturnTypeFunc,
        options?: ValidateOptions
    ): ParameterDecorator;
};

ArgsType: () => ClassDecorator;

Authorized: {
    (): MethodPropClassDecorator;
    <RoleType = string>(roles: readonly RoleType[]): MethodPropClassDecorator;
    <RoleType = string>(...roles: readonly RoleType[]): MethodPropClassDecorator;
};

buildSchema: (options: BuildSchemaOptions) => Promise<GraphQLSchema>;

buildSchemaSync: (options: BuildSchemaOptions) => GraphQLSchema;

buildTypeDefsAndResolvers: (
    options: BuildSchemaOptions
) => Promise<{ typeDefs: string; resolvers: import('..').ResolversMap }>;

buildTypeDefsAndResolversSync: (options: BuildSchemaOptions) => {
    typeDefs: string;
    resolvers: import('..').ResolversMap;
};

createMethodMiddlewareDecorator: <TContextType extends object = object>(
    resolver: MiddlewareFn<TContextType>
) => MethodDecorator;

createParameterDecorator: <TContextType extends object = object>(
    resolver: ParameterResolver<TContextType>,
    paramOptions?: CustomParameterOptions
) => ParameterDecorator;

createResolverClassMiddlewareDecorator: <TContextType extends object = object>(
    resolver: MiddlewareFn<TContextType>
) => ClassDecorator;

createResolversMap: (schema: GraphQLSchema) => ResolversMap;

createUnionType: <T extends readonly ClassType<object, any[]>[]>(
    config: UnionTypeConfig<T>
) => UnionFromClasses<T>;

Ctx: (propertyName?: string) => ParameterDecorator;

Directive: (
    sdl: string
) => MethodAndPropDecorator & ClassDecorator & ParameterDecorator;

emitSchemaDefinitionFile: (
    schemaFilePath: string,
    schema: GraphQLSchema,
    options?: PrintSchemaOptions
) => Promise<void>;

emitSchemaDefinitionFileSync: (
    schemaFilePath: string,
    schema: GraphQLSchema,
    options?: PrintSchemaOptions
) => void;

ensureInstalledCorrectGraphQLPackage: () => void;

Extensions: (
    extensions: ExtensionsMetadata
) => MethodAndPropDecorator & ClassDecorator;

Field: {
    (): MethodAndPropDecorator;
    (options: FieldOptions): MethodAndPropDecorator;
    (
        returnTypeFunction?: ReturnTypeFunc,
        options?: FieldOptions
    ): MethodAndPropDecorator;
};

FieldResolver: {
    (): MethodDecorator;
    (options: AdvancedOptions): MethodDecorator;
    (
        returnTypeFunction?: ReturnTypeFunc,
        options?: AdvancedOptions
    ): MethodDecorator;
};

getMetadataStorage: () => MetadataStorage;

Info: () => ParameterDecorator;

InputType: {
    (): ClassDecorator;
    (options: DescriptionOptions): ClassDecorator;
    (name: string, options?: DescriptionOptions): ClassDecorator;
};

InterfaceType: {
    (): ClassDecorator;
    (options: InterfaceTypeOptions): ClassDecorator;
    (name: string, options?: InterfaceTypeOptions): ClassDecorator;
};

Mutation: {
    (): MethodDecorator;
    (options: AdvancedOptions): MethodDecorator;
    (returnTypeFunc: ReturnTypeFunc, options?: AdvancedOptions): MethodDecorator;
};

ObjectType: {
    (): ClassDecorator;
    (options: ObjectTypeOptions): ClassDecorator;
    (name: string, options?: ObjectTypeOptions): ClassDecorator;
};

Query: {
    (): MethodDecorator;
    (options: AdvancedOptions): MethodDecorator;
    (returnTypeFunc: ReturnTypeFunc, options?: AdvancedOptions): MethodDecorator;
};

registerEnumType: <TEnum extends object>(
    enumObj: TEnum,
    enumConfig: EnumConfig<TEnum>
) => void;

Resolver: {
    (): ClassDecorator;
    (typeFunc: ClassTypeResolver): ClassDecorator;
    (objectType: ClassType<object, any[]>): ClassDecorator;
};

Root: (propertyName?: string) => ParameterDecorator;

Subscription: {
    (options: SubscriptionOptions): MethodDecorator;
    (returnTypeFunc: ReturnTypeFunc, options: SubscriptionOptions): MethodDecorator;
};

UseMiddleware: {
    (middlewares: Array<Middleware<any>>): MethodPropClassDecorator;
    (...middlewares: Middleware<any>[]): MethodPropClassDecorator;
};

type ArgOptions = DecoratorTypeOptions &
    DescriptionOptions &
    ValidateOptions &
    DeprecationOptions;

type ArgsDictionary = Record<string, any>;

type AuthChecker<TContextType extends object = object, TRoleType = string> =
    | AuthCheckerFn<TContextType, TRoleType>
    | ClassType<AuthCheckerInterface<TContextType, TRoleType>>;

type AuthCheckerFn<TContextType extends object = object, TRoleType = string> = (
    resolverData: ResolverData<TContextType>,
    roles: TRoleType[]
) => boolean | Promise<boolean>;

type AuthMode = 'error' | 'null';

type BuildSchemaOptions = {
    /** Array of resolvers classes to resolver files */
    resolvers: NonEmptyArray<Function>;
    /**
     * Path to the file to where emit the schema
     * or config object with print schema options
     * or `true` for the default `./schema.graphql` one
     */
    emitSchemaFile?: string | boolean | EmitSchemaFileOptions;
} & Omit<SchemaGeneratorOptions, 'resolvers'>;

type ClassType<
    T extends object = object,
    Arguments extends unknown[] = any[]
> = Constructor<T, Arguments> & {
    prototype: T;
};

type Complexity = ComplexityEstimator | number;

type Constructor<T extends object, Arguments extends unknown[] = any[]> = new (
    ...arguments_: Arguments
) => T;

type ContainerGetter<TContext extends object> = (
    resolverData: ResolverData<TContext>
) => ContainerType;

type EnumResolver = Record<string, string | number>;

type Except<
    ObjectType,
    KeysType extends keyof ObjectType,
    Options extends ExceptOptions = {
        requireExactProps: false;
    }
> = {
    [KeyType in keyof ObjectType as Filter<KeyType, KeysType>]: ObjectType[KeyType];
} & (Options['requireExactProps'] extends true
    ? Partial<Record<KeysType, never>>
    : {});

type FieldOptions = AdvancedOptions & {
    /** Set to `true` to disable auth and all middlewares stack for this field resolver */
    simple?: boolean;
};

type InputTypeOptions = DescriptionOptions;

type InterfaceTypeOptions = DescriptionOptions &
    ResolveTypeOptions &
    ImplementsClassOptions & {
        /**
         * Set to false to prevent emitting in schema all object types
         * that implements this interface type.
         */
        autoRegisterImplementations?: boolean;
    };

type IsEqual<A, B> = (<G>() => G extends A ? 1 : 2) extends <G>() => G extends B
    ? 1
    : 2
    ? true
    : false;

type Maybe<T> = T | null | undefined;

type MaybePromise<T> = Promise<T> | T;

type MergeExclusive<FirstType, SecondType> = FirstType | SecondType extends object
    ?
          | (Without<FirstType, SecondType> & SecondType)
          | (Without<SecondType, FirstType> & FirstType)
    : FirstType | SecondType;

type MiddlewareFn<TContext extends object = object> = (
    action: ResolverData<TContext>,
    next: NextFn
) => Promise<any>;

type NextFn = () => Promise<any>;

type NonEmptyArray<T> = readonly [T, ...T[]] | [T, ...T[]];

type ObjectTypeOptions = DescriptionOptions &
    ImplementsClassOptions & {
        /** Set to `true` to disable auth and all middlewares stack for all this Object Type fields resolvers */
        simpleResolvers?: boolean;
    };

type ParameterDecorator = (
    target: Object,
    propertyKey: string | symbol, // Removed 'undefined' from TS 5.0
    parameterIndex: number
) => void;

type ResolverInterface<T extends object> = {
    [P in keyof T]?: (root: T, ...args: any[]) => T[P] | Promise<T[P]>;
};

type ResolverObject<TSource = any, TContext = any> = Record<
    string,
    ResolverOptions<TSource, TContext> | GraphQLFieldResolver<TSource, TContext>
>;

type ResolversMap<TSource = any, TContext = any> = Record<
    string,
    | ResolverObject<TSource, TContext>
    | ResolverOptions<TSource, TContext>
    | GraphQLScalarType
    | EnumResolver
>;

type SetRequired<BaseType, Keys extends keyof BaseType> = Simplify<
    Except<BaseType, Keys> & Required<Pick<BaseType, Keys>>
>;

type Simplify<T> = {
    [KeyType in keyof T]: T[KeyType];
} & {};

type SubscriptionOptions = AdvancedOptions &
    MergeExclusive<PubSubOptions, SubscribeOptions>;

type TypeResolver<TSource, TContext> = (
    ...args: Parameters<GraphQLTypeResolver<TSource, TContext>>
) => MaybePromise<Maybe<string | ClassType>>;

type ValidatorFn<TContext extends object = object> = (
    /**
     * The value of the argument.
     * It can by of any type, which means:
     * - undefined or null (if the argument is nullable)
     * - primitive type (string, number, boolean)
     * - underlying scalar type (Date, Buffer, etc.)
     * - object type (arg type class instance)
     * - array type (array of any of the above)
     */
    argValue: any | undefined,
    argType: TypeValue,
    resolverData: ResolverData<TContext>
) => void | Promise<void>;