graphql-modules 3.1.2-alpha-20260121024117-e03d9c26de1cfd3971986f82b995963e1cc77056 → 3.1.2-alpha-20260121025807-95ab4fb1994c3cf68c88a7cf234efd8f99f92ed1

package/typings/application/types.d.ts

@@ -0,0 +1,130 @@
+import { execute, subscribe, DocumentNode, GraphQLSchema, ExecutionResult } from 'graphql';
+import type { Provider, Injector } from '../di';
+import type { Resolvers, Module, MockedModule } from '../module/types';
+import type { MiddlewareMap } from '../shared/middleware';
+import type { ApolloRequestContext } from './apollo';
+import type { Single } from '../shared/types';
+import type { InternalAppContext } from './application';
+type Execution = typeof execute;
+type Subscription = typeof subscribe;
+export type ApolloExecutor = (requestContext: ApolloRequestContext) => Promise<ExecutionResult>;
+export interface MockedApplication extends Application {
+    replaceModule(mockedModule: MockedModule): MockedApplication;
+    addProviders(providers: ApplicationConfig['providers']): MockedApplication;
+}
+/**
+ * @api
+ * A return type of `createApplication` function.
+ */
+export interface Application {
+    /**
+     * A list of type definitions defined by modules.
+     */
+    readonly typeDefs: DocumentNode[];
+    /**
+     * An object with resolve functions defined by modules.
+     */
+    readonly resolvers?: Single<Resolvers>;
+    /**
+     * Ready to use GraphQLSchema object combined from modules.
+     */
+    readonly schema: GraphQLSchema;
+    /**
+     * The application (Singleton) injector.
+     */
+    readonly injector: Injector;
+    /**
+     * Take over control of GraphQL Operation
+     */
+    createOperationController(input: {
+        context: any;
+        autoDestroy?: boolean;
+    }): OperationController;
+    /**
+     * Creates a `subscribe` function that runs the subscription phase of GraphQL.
+     * Important when using GraphQL Subscriptions.
+     */
+    createSubscription(options?: {
+        subscribe?: typeof subscribe;
+        controller?: OperationController;
+    }): Subscription;
+    /**
+     * Creates a `execute` function that runs the execution phase of GraphQL.
+     * Important when using GraphQL Queries and Mutations.
+     */
+    createExecution(options?: {
+        execute?: typeof execute;
+        controller?: OperationController;
+    }): Execution;
+    /**
+     * @deprecated Use `createApolloExecutor`, `createExecution` and `createSubscription` methods instead.
+     */
+    createSchemaForApollo(): GraphQLSchema;
+    /**
+     * Experimental
+     */
+    createApolloExecutor(options?: {
+        controller?: OperationController;
+    }): ApolloExecutor;
+    /**
+     * @internal
+     */
+    ɵfactory(config?: ApplicationConfig | undefined): Application;
+    /**
+     * @internal
+     */
+    ɵconfig: ApplicationConfig;
+}
+export interface OperationController {
+    /**
+     * Destroys
+     */
+    destroy(): void;
+    /**
+     * @internal
+     */
+    ɵdestroy(): void;
+    context: InternalAppContext;
+    /**
+     * Operation Injector (application)
+     */
+    injector: Injector;
+}
+/**
+ * @api
+ * Application's configuration object. Represents the first argument of `createApplication` function.
+ */
+export interface ApplicationConfig {
+    /**
+     * A list of GraphQL Modules
+     */
+    modules: Module[];
+    /**
+     * A list of Providers - read the ["Providers and Tokens"](./di/providers) chapter.
+     */
+    providers?: Provider[] | (() => Provider[]);
+    /**
+     * A map of middlewares - read the ["Middlewares"](./advanced/middlewares) chapter.
+     */
+    middlewares?: MiddlewareMap;
+    /**
+     * Creates a GraphQLSchema object out of typeDefs and resolvers
+     *
+     * @example
+     *
+     * ```typescript
+     * import { createApplication } from 'graphql-modules';
+     * import { makeExecutableSchema } from '@graphql-tools/schema';
+     *
+     * const app = createApplication({
+     *   modules: [],
+     *   schemaBuilder: makeExecutableSchema
+     * })
+     * ```
+     */
+    schemaBuilder?(input: {
+        typeDefs: DocumentNode[];
+        resolvers: Record<string, any>[];
+    }): GraphQLSchema;
+}
+export {};

package/typings/di/decorators.d.ts

@@ -0,0 +1,11 @@
+import { Type, ProviderOptions, InjectionToken } from './providers';
+import { Injector } from './injector';
+export declare function Injectable(options?: ProviderOptions): ClassDecorator;
+type ParameterDecorator = (target: Object, propertyKey: string | symbol | undefined, parameterIndex: number) => void;
+export declare function Optional(): ParameterDecorator;
+export declare function Inject(type: Type<any> | InjectionToken<any>): ParameterDecorator;
+export type ExecutionContext = {
+    injector: Injector;
+} & GraphQLModules.ModuleContext;
+export declare function ExecutionContext(): PropertyDecorator;
+export {};

package/typings/di/errors.d.ts

@@ -0,0 +1,16 @@
+import { InjectableParamMetadata } from './metadata';
+import { Type, InjectionToken } from './providers';
+import { ReflectiveInjector } from './injector';
+import { Key } from './registry';
+export declare function invalidProviderError(provider: any): Error;
+export declare function noInjectableError(type: Type<any>): Error;
+export declare function noAnnotationError(typeOrFunc: Type<any> | InjectionToken<any> | Function, params: InjectableParamMetadata[]): Error;
+export declare function cyclicDependencyError(injector: ReflectiveInjector, key: Key): InjectionError;
+export declare function noProviderError(injector: ReflectiveInjector, key: Key): InjectionError;
+export declare function instantiationError(injector: ReflectiveInjector, originalException: any, key: Key): InjectionError;
+export interface InjectionError extends Error {
+    keys: Key[];
+    injectors: ReflectiveInjector[];
+    constructResolvingMessage: (this: InjectionError) => string;
+    addKey(key: Key): void;
+}

package/typings/di/forward-ref.d.ts

@@ -0,0 +1,7 @@
+import { Type } from './providers';
+export type ForwardRefFn<T> = () => T;
+/**
+ * Useful in "circular dependencies of modules" situation
+ */
+export declare function forwardRef<T>(forwardRefFn: ForwardRefFn<T>): Type<any>;
+export declare function resolveForwardRef(type: any): any;

package/typings/di/index.d.ts

@@ -0,0 +1,5 @@
+export { Injectable, Optional, Inject, ExecutionContext } from './decorators';
+export { forwardRef } from './forward-ref';
+export { InjectionToken, Type, Provider, AbstractType, ValueProvider, ClassProvider, Factory, FactoryProvider, TypeProvider, ProviderOptions, Scope, onlySingletonProviders, onlyOperationProviders, } from './providers';
+export { Injector, ReflectiveInjector } from './injector';
+export { InjectionError } from './errors';

package/typings/di/injector.d.ts

@@ -0,0 +1,50 @@
+import { Type, InjectionToken, Provider, AbstractType } from './providers';
+import { ResolvedProvider, GlobalProviderMap } from './resolution';
+import { Key } from './registry';
+import { ExecutionContext } from './decorators';
+type ExecutionContextGetter = () => ExecutionContext | never;
+export declare abstract class Injector {
+    abstract get<T>(token: Type<T> | InjectionToken<T> | AbstractType<T>, notFoundValue?: any): T;
+}
+export declare class ReflectiveInjector implements Injector {
+    displayName: string;
+    _constructionCounter: number;
+    _providers: ResolvedProvider[];
+    _globalProvidersMap: GlobalProviderMap;
+    private _executionContextGetter;
+    private _fallbackParent;
+    private _parent;
+    private _keyIds;
+    private _objs;
+    constructor({ name, providers, parent, fallbackParent, globalProvidersMap, }: {
+        name: string;
+        proxy?: boolean;
+        providers: ResolvedProvider[];
+        parent?: Injector | null;
+        fallbackParent?: Injector | null;
+        globalProvidersMap?: GlobalProviderMap;
+    });
+    static createFromResolved({ name, providers, parent, fallbackParent, globalProvidersMap, }: {
+        name: string;
+        providers: ResolvedProvider[];
+        parent?: Injector;
+        fallbackParent?: Injector;
+        globalProvidersMap?: GlobalProviderMap;
+    }): ReflectiveInjector;
+    static resolve(providers: Provider[]): ResolvedProvider[];
+    get parent(): Injector | null;
+    get fallbackParent(): Injector | null;
+    get(token: any, notFoundValue?: any): any;
+    setExecutionContextGetter(getter: ExecutionContextGetter): void;
+    private _getByKey;
+    _isObjectDefinedByKeyId(keyId: number): boolean;
+    _getObjByKeyId(keyId: number): any;
+    _throwOrNull(key: Key, notFoundValue: any): any;
+    instantiateAll(): void;
+    private _instantiateProvider;
+    private _getByDependency;
+    private _new;
+    private _getMaxNumberOfObjects;
+    toString(): string;
+}
+export {};

package/typings/di/metadata.d.ts

@@ -0,0 +1,12 @@
+import { Type, ProviderOptions, InjectionToken } from './providers';
+export declare const INJECTABLE: unique symbol;
+export interface InjectableParamMetadata {
+    type: Type<any> | InjectionToken<any>;
+    optional: boolean;
+}
+export interface InjectableMetadata {
+    params: InjectableParamMetadata[];
+    options?: ProviderOptions;
+}
+export declare function readInjectableMetadata(type: Type<any>, throwOnMissing?: boolean): InjectableMetadata;
+export declare function ensureInjectableMetadata(type: Type<any>): void;

package/typings/di/providers.d.ts

@@ -0,0 +1,44 @@
+export declare const Type: FunctionConstructor;
+export declare class InjectionToken<T> {
+    private _desc;
+    constructor(_desc: string);
+    toString(): string;
+}
+export declare function isToken(v: any): v is InjectionToken<any>;
+export declare function isType(v: any): v is Type<any>;
+export interface AbstractType<T> extends Function {
+    prototype: T;
+}
+export interface Type<T> extends Function {
+    new (...args: any[]): T;
+}
+export interface ValueProvider<T> extends BaseProvider<T> {
+    useValue: T;
+}
+export interface ClassProvider<T> extends BaseProvider<T> {
+    useClass: Type<T>;
+}
+export type Factory<T> = (...args: any[]) => T;
+export interface FactoryProvider<T> extends BaseProvider<T> {
+    useFactory: Factory<T>;
+    deps?: any[];
+}
+export interface BaseProvider<T> extends ProviderOptions {
+    provide: Type<T> | InjectionToken<T> | AbstractType<T>;
+}
+export interface TypeProvider<T> extends Type<T> {
+}
+export type Provider<T = any> = TypeProvider<T> | ValueProvider<T> | ClassProvider<T> | FactoryProvider<T>;
+export interface ProviderOptions {
+    scope?: Scope;
+    executionContextIn?: Array<string | symbol>;
+    global?: boolean;
+}
+export declare enum Scope {
+    Singleton = 0,
+    Operation = 1
+}
+export declare function onlySingletonProviders(providers?: Provider[]): Provider[];
+export declare function onlyOperationProviders(providers?: Provider[]): Provider[];
+export declare function isClassProvider(provider: any): provider is ClassProvider<any>;
+export declare function isFactoryProvider(provider: any): provider is FactoryProvider<any>;

package/typings/di/registry.d.ts

@@ -0,0 +1,11 @@
+import { Type } from './providers';
+export declare class Key {
+    token: Type<any>;
+    id: number;
+    constructor(token: Type<any>, id: number);
+    /**
+     * Returns a stringified token.
+     */
+    get displayName(): string;
+    static get(token: Object): Key;
+}

package/typings/di/resolution.d.ts

@@ -0,0 +1,63 @@
+import { Provider, ValueProvider, ClassProvider, FactoryProvider } from './providers';
+import { Key } from './registry';
+import { ReflectiveInjector } from './injector';
+export type NormalizedProvider<T = any> = ValueProvider<T> | ClassProvider<T> | FactoryProvider<T>;
+export type GlobalProviderMap = {
+    has(key: Key['id']): boolean;
+    get(key: Key['id']): ReflectiveInjector;
+};
+export declare class ResolvedProvider {
+    key: Key;
+    factory: ResolvedFactory;
+    constructor(key: Key, factory: ResolvedFactory);
+}
+export declare class ResolvedFactory {
+    /**
+     * Factory function which can return an instance of an object represented by a key.
+     */
+    factory: Function;
+    /**
+     * Arguments (dependencies) to the `factory` function.
+     */
+    dependencies: Dependency[];
+    /**
+     * Methods invoked within ExecutionContext.
+     */
+    executionContextIn: Array<string | symbol>;
+    /**
+     * Has onDestroy hook
+     */
+    hasOnDestroyHook: boolean;
+    /**
+     * Is Global
+     */
+    isGlobal: boolean;
+    constructor(
+    /**
+     * Factory function which can return an instance of an object represented by a key.
+     */
+    factory: Function, 
+    /**
+     * Arguments (dependencies) to the `factory` function.
+     */
+    dependencies: Dependency[], 
+    /**
+     * Methods invoked within ExecutionContext.
+     */
+    executionContextIn: Array<string | symbol>, 
+    /**
+     * Has onDestroy hook
+     */
+    hasOnDestroyHook: boolean, 
+    /**
+     * Is Global
+     */
+    isGlobal: boolean);
+}
+export declare class Dependency {
+    key: Key;
+    optional: boolean;
+    constructor(key: Key, optional: boolean);
+    static fromKey(key: Key): Dependency;
+}
+export declare function resolveProviders(providers: Provider[]): ResolvedProvider[];

package/typings/di/utils.d.ts

@@ -0,0 +1,8 @@
+export declare const ERROR_TYPE = "diType";
+export declare const ERROR_ORIGINAL_ERROR = "diOriginalError";
+export declare const ERROR_LOGGER = "diErrorLogger";
+export declare function getType(error: Error): Function;
+export declare function getOriginalError(error: Error): Error;
+export declare function getErrorLogger(error: Error): (console: Console, ...values: any[]) => void;
+export declare function wrappedError(message: string, originalError: any): Error;
+export declare function stringify(token: any): string;

package/typings/index.d.ts

@@ -0,0 +1,13 @@
+export { createApplication } from './application/application';
+export * from './application/tokens';
+export * from './application/types';
+export { createModule } from './module/module';
+export * from './module/types';
+export * from './module/metadata';
+export * from './module/tokens';
+export { Injector, Inject, Injectable, Optional, ExecutionContext, Provider, ProviderOptions, FactoryProvider, ClassProvider, ValueProvider, TypeProvider, forwardRef, InjectionToken, Scope, } from './di';
+export { Middleware, MiddlewareContext } from './shared/middleware';
+import './shared/types';
+export { gql } from './shared/gql';
+export * from './shared/di';
+export * from './testing';

package/typings/module/factory.d.ts

@@ -0,0 +1,16 @@
+import { Module, ModuleConfig, Resolvers } from './types';
+import { ReflectiveInjector } from '../di';
+import { ResolvedProvider } from './../di/resolution';
+import { MiddlewareMap } from '../shared/middleware';
+import { Single } from '../shared/types';
+export type ResolvedModule = {
+    injector: ReflectiveInjector;
+    singletonProviders: Array<ResolvedProvider>;
+    operationProviders: Array<ResolvedProvider>;
+    resolvers?: Single<Resolvers>;
+} & Omit<Module, 'factory'>;
+export type ModuleFactory = (app: {
+    injector: ReflectiveInjector;
+    middlewares: MiddlewareMap;
+}) => ResolvedModule;
+export declare function moduleFactory(config: ModuleConfig): Module;

package/typings/module/metadata.d.ts

@@ -0,0 +1,12 @@
+import { DocumentNode } from 'graphql';
+import { ModuleConfig } from './types';
+import { ID } from '../shared/types';
+export type Registry = Record<string, string[]>;
+export interface ModuleMetadata {
+    id: ID;
+    typeDefs: DocumentNode[];
+    implements?: Registry;
+    extends?: Registry;
+    dirname?: string;
+}
+export declare function metadataFactory(typeDefs: DocumentNode[], config: ModuleConfig): ModuleMetadata;

package/typings/module/module.d.ts

@@ -0,0 +1,22 @@
+import { ModuleConfig } from './types';
+/**
+ * @api
+ * Creates a Module, an element used by Application. Accepts `ModuleConfig`.
+ *
+ * @example
+ *
+ * ```typescript
+ * import { createModule, gql } from 'graphql-modules';
+ *
+ * export const usersModule = createModule({
+ *   id: 'users',
+ *   typeDefs: gql`
+ *     // GraphQL SDL
+ *   `,
+ *   resolvers: {
+ *     // ...
+ *   }
+ * });
+ * ```
+ */
+export declare function createModule(config: ModuleConfig): import("./types").Module;

package/typings/module/resolvers.d.ts

@@ -0,0 +1,13 @@
+import { GraphQLFieldExtensions } from 'graphql';
+import { ModuleConfig } from './types';
+import { ModuleMetadata } from './metadata';
+import { ResolveFn, ID } from './../shared/types';
+import { MiddlewareMap } from '../shared/middleware';
+interface ResolverMetadata {
+    moduleId: ID;
+}
+export declare function createResolvers(config: ModuleConfig, metadata: ModuleMetadata, app: {
+    middlewareMap: MiddlewareMap;
+}): Record<string, any>;
+export declare function readResolverMetadata(resolver: ResolveFn | GraphQLFieldExtensions<any, any, any>): ResolverMetadata;
+export {};

package/typings/module/tokens.d.ts

@@ -0,0 +1,18 @@
+import { InjectionToken } from '../di';
+/**
+ * @api
+ * `MODULE_ID` is an InjectionToken representing module's ID
+ *
+ * @example
+ * ```typescript
+ * import { MODULE_ID, Inject, Injectable } from 'graphql-modules';
+ *
+ * (A)Injectable()
+ * export class Data {
+ *   constructor((A)Inject(MODULE_ID) moduleId: string) {
+ *     console.log(`Data used in ${moduleId} module`)
+ *   }
+ * }
+ * ```
+ */
+export declare const MODULE_ID: InjectionToken<string>;

package/typings/module/type-defs.d.ts

@@ -0,0 +1,7 @@
+import { DocumentNode } from 'graphql';
+import { ModuleConfig } from './types';
+/**
+ * Create a list of DocumentNode objects based on Module's config.
+ * Add a location, so we get richer errors.
+ */
+export declare function createTypeDefs(config: ModuleConfig): DocumentNode[];

package/typings/module/types.d.ts

@@ -0,0 +1,51 @@
+import { DocumentNode } from 'graphql';
+import { ModuleFactory } from './factory';
+import { ID, Plural } from '../shared/types';
+import { ModuleMetadata } from './metadata';
+import { Provider } from '../di';
+import { MiddlewareMap } from '../shared/middleware';
+export type TypeDefs = Plural<DocumentNode>;
+export type Resolvers = Plural<Record<string, any>>;
+/**
+ * @api
+ * Module's configuration object. Represents the first argument of `createModule` function.
+ */
+export interface ModuleConfig {
+    /**
+     * Unique identifier of a module
+     */
+    id: ID;
+    /**
+     * Pass `__dirname` variable as a value to get better error messages.
+     */
+    dirname?: string;
+    /**
+     * An object or a list of GraphQL type definitions (SDL).
+     */
+    typeDefs: TypeDefs;
+    /**
+     * An object or a list of GraphQL resolve functions.
+     */
+    resolvers?: Resolvers;
+    /**
+     * A map of middlewares - read the ["Middlewares"](./advanced/middlewares) chapter.
+     */
+    middlewares?: MiddlewareMap;
+    /**
+     * A list of Providers - read the ["Providers and Tokens"](./di/providers) chapter.
+     */
+    providers?: Provider[] | (() => Provider[]);
+}
+export interface Module {
+    id: ID;
+    typeDefs: DocumentNode[];
+    metadata: ModuleMetadata;
+    factory: ModuleFactory;
+    config: ModuleConfig;
+}
+export interface MockedModule extends Module {
+    /**
+     * @internal
+     */
+    ɵoriginalModule: Module;
+}

package/typings/shared/di.d.ts

@@ -0,0 +1,3 @@
+export interface OnDestroy {
+    onDestroy(): void;
+}

package/typings/shared/errors.d.ts

@@ -0,0 +1,36 @@
+import { ID } from './types';
+declare const ModuleNonUniqueIdError_base: ErrorConstructor;
+export declare class ModuleNonUniqueIdError extends ModuleNonUniqueIdError_base {
+    constructor(message: string, ...rest: string[]);
+}
+declare const ModuleDuplicatedError_base: ErrorConstructor;
+export declare class ModuleDuplicatedError extends ModuleDuplicatedError_base {
+    constructor(message: string, ...rest: string[]);
+}
+declare const ExtraResolverError_base: ErrorConstructor;
+export declare class ExtraResolverError extends ExtraResolverError_base {
+    constructor(message: string, ...rest: string[]);
+}
+declare const ExtraMiddlewareError_base: ErrorConstructor;
+export declare class ExtraMiddlewareError extends ExtraMiddlewareError_base {
+    constructor(message: string, ...rest: string[]);
+}
+declare const ResolverDuplicatedError_base: ErrorConstructor;
+export declare class ResolverDuplicatedError extends ResolverDuplicatedError_base {
+    constructor(message: string, ...rest: string[]);
+}
+declare const ResolverInvalidError_base: ErrorConstructor;
+export declare class ResolverInvalidError extends ResolverInvalidError_base {
+    constructor(message: string, ...rest: string[]);
+}
+declare const NonDocumentNodeError_base: ErrorConstructor;
+export declare class NonDocumentNodeError extends NonDocumentNodeError_base {
+    constructor(message: string, ...rest: string[]);
+}
+export declare function useLocation({ dirname, id }: {
+    id: ID;
+    dirname?: string;
+}): string;
+export declare function ExtendableBuiltin<T extends Function>(cls: T): T;
+export declare function composeMessage(...lines: string[]): string;
+export {};

package/typings/shared/gql.d.ts

@@ -0,0 +1,2 @@
+import { DocumentNode } from 'graphql';
+export declare function gql(literals: ReadonlyArray<string> | Readonly<string>): DocumentNode;

package/typings/shared/middleware.d.ts

@@ -0,0 +1,21 @@
+import { GraphQLResolveInfo } from 'graphql';
+import { ModuleMetadata } from './../module/metadata';
+export type Next<T = any> = () => Promise<T>;
+export type Middleware<TContext = MiddlewareContext> = (context: TContext, next: Next) => Promise<any>;
+export declare function compose<TContext>(middleware: Array<Middleware<TContext>>): (context: TContext, next: Next) => Promise<any>;
+export interface MiddlewareContext {
+    root: any;
+    args: {
+        [argName: string]: any;
+    };
+    context: GraphQLModules.ModuleContext;
+    info: GraphQLResolveInfo;
+}
+export type MiddlewareMap = {
+    [type: string]: {
+        [field: string]: Middleware[];
+    };
+};
+export declare function createMiddleware(path: string[], middlewareMap?: MiddlewareMap): (context: MiddlewareContext, next: Next) => Promise<any>;
+export declare function mergeMiddlewareMaps(app: MiddlewareMap, mod: MiddlewareMap): MiddlewareMap;
+export declare function validateMiddlewareMap(middlewareMap: MiddlewareMap, metadata: ModuleMetadata): void;

package/typings/shared/types.d.ts

@@ -0,0 +1,22 @@
+import { GraphQLFieldResolver, GraphQLTypeResolver } from 'graphql';
+import { Injector } from '../di';
+export type ID = string;
+export type Nil = undefined | null;
+export type Maybe<T> = T | Nil;
+export type Plural<T> = T | T[];
+export type Single<T> = T extends Array<infer R> ? R : T;
+export type ValueOrPromise<T> = T | Promise<T>;
+export type ResolveFn<TContext = GraphQLModules.Context> = GraphQLFieldResolver<any, TContext, Record<string, any>>;
+export type ResolveTypeFn<TContext = GraphQLModules.Context> = GraphQLTypeResolver<any, TContext>;
+declare global {
+    namespace GraphQLModules {
+        type ModuleContext = {
+            injector: Injector;
+            moduleId: ID;
+        } & GlobalContext;
+        type AppContext = Omit<ModuleContext, 'moduleId'>;
+        type Context = ModuleContext;
+        interface GlobalContext {
+        }
+    }
+}

package/typings/shared/utils.d.ts

@@ -0,0 +1,12 @@
+export declare function flatten<T>(arr: T[]): T extends (infer A)[] ? A[] : T[];
+export declare function isDefined<T>(val: T | null | undefined): val is T;
+export declare function isNil<T>(val: T | null | undefined): val is null | undefined;
+export declare function isObject(val: any): boolean;
+export declare function isPrimitive(val: any): val is number | string | boolean | symbol | bigint;
+export declare function isAsyncIterable(obj: any): obj is AsyncIterableIterator<any>;
+export declare function tapAsyncIterator<T, TAsyncIterableIterator extends AsyncIterableIterator<T>>(iterable: TAsyncIterableIterator, doneCallback: () => void): TAsyncIterableIterator;
+export declare function once(cb: () => void): () => void;
+export declare function share<T, A>(factory: (arg?: A) => T): (arg?: A) => T;
+export declare function uniqueId(isNotUsed: (id: string) => boolean): string;
+export declare function isNotSchema<T>(obj: any): obj is T;
+export declare function merge<S extends object, T extends object>(source: S, target: T): S & T;

package/typings/testing/di.d.ts

@@ -0,0 +1,2 @@
+import { ValueProvider } from './../di/providers';
+export declare function provideEmpty<T = any>(token: ValueProvider<T>['provide']): ValueProvider<T>;

package/typings/testing/graphql.d.ts

@@ -0,0 +1,14 @@
+import type { DocumentNode, ExecutionArgs, ExecutionResult } from 'graphql';
+import type { TypedDocumentNode } from '@graphql-typed-document-node/core';
+import type { Application, OperationController } from '../application/types';
+import type { ValueOrPromise } from '../shared/types';
+export declare function execute<TResult = {
+    [key: string]: any;
+}, TVariables = {
+    [key: string]: any;
+}>(app: Application, inputs: Omit<ExecutionArgs, 'schema'> & {
+    document: DocumentNode | TypedDocumentNode<TResult, TVariables>;
+    variableValues?: TVariables;
+}, options?: {
+    controller?: OperationController;
+}): ValueOrPromise<ExecutionResult<TResult>>;