@gqloom/core 0.2.0

package/dist/index.d.ts

@@ -0,0 +1,577 @@
+import { GraphQLOutputType, GraphQLObjectTypeConfig, GraphQLFieldConfig, GraphQLResolveInfo, GraphQLScalarType, GraphQLObjectType, GraphQLUnionType, GraphQLInterfaceType, GraphQLInputObjectType, GraphQLSchemaConfig, GraphQLFieldMap, GraphQLNamedType, GraphQLSchema, GraphQLFieldConfigArgumentMap, GraphQLType, GraphQLInputType, GraphQLInterfaceTypeConfig, GraphQLFieldExtensions, GraphQLObjectTypeExtensions } from 'graphql';
+import { AsyncLocalStorage } from 'async_hooks';
+
+type MayPromise<T> = T | Promise<T>;
+type IsAny<T> = 0 extends 1 & T ? true : false;
+/**
+ * @example
+ * ```TypeScript
+ * type A = { a?: { b?: { c: string } } }
+ * type B = InferPropertyType<A, "a"> // { b?: { c: string } }
+ * type C = InferPropertyType<A, "a.b"> // { c: string }
+ * ```
+ */
+type InferPropertyType<T, K extends string> = K extends `${infer K1}.${infer K2}` ? K1 extends keyof T ? InferPropertyType<NonNullable<T[K1]>, K2> : never : K extends keyof T ? T[K] : never;
+/**
+ * @example
+ * ```TypeScript
+ * type C = { c: string }
+ * type A = WrapPropertyType<"a", C> // { a: C }
+ * type B = WrapPropertyType<"a.b", C> // { a: { b: C } }
+ * ```
+ */
+type WrapPropertyType<TKey extends string, TProperty> = TKey extends `${infer TFirst}.${infer TRest}` ? {
+    [K in TFirst]: WrapPropertyType<TRest, TProperty>;
+} : {
+    [K in TKey]: TProperty;
+};
+type ObjectOrNever<T> = T extends object ? T : never;
+type ValueOf<T extends object> = T[keyof T];
+
+type InputSchema<TBaseSchema> = TBaseSchema | Record<string, TBaseSchema> | undefined;
+type InputSchemaToSilk<TSchemaIO extends AbstractSchemaIO, TInput extends InputSchema<TSchemaIO[0]>> = TInput extends undefined ? undefined : TInput extends TSchemaIO[0] ? SchemaToSilk<TSchemaIO, TInput> : {
+    [K in keyof TInput]: TInput[K] extends TSchemaIO[0] ? SchemaToSilk<TSchemaIO, TInput[K]> : never;
+};
+type InferInputI<TInput extends object | undefined, TSchemaIO extends AbstractSchemaIO> = TInput extends undefined ? undefined : TInput extends TSchemaIO[0] ? ObjectOrNever<InferSchemaI<TInput, TSchemaIO>> : {
+    [K in keyof TInput]: InferSchemaI<TInput[K], TSchemaIO>;
+};
+type InferInputO<TInput extends object | undefined, TSchemaIO extends AbstractSchemaIO> = TInput extends undefined ? undefined : TInput extends TSchemaIO[0] ? ObjectOrNever<InferSchemaO<TInput, TSchemaIO>> : {
+    [K in keyof TInput]: InferSchemaO<TInput[K], TSchemaIO>;
+};
+interface CallableInputParser<TSchema extends InputSchema<GraphQLSilk>> {
+    /**
+     * input schema
+     */
+    schema: TSchema;
+    /**
+     *  Origin value to parse
+     */
+    value: InferInputI<TSchema, GraphQLSilkIO>;
+    /**
+     * Parse the input and return the
+     */
+    (): Promise<InferInputO<TSchema, GraphQLSilkIO>>;
+    /**
+     * Result of parsing. Set it to `undefined` then the parser will run again.
+     */
+    result: InferInputO<TSchema, GraphQLSilkIO> | undefined;
+}
+declare function createInputParser<TSchema extends InputSchema<GraphQLSilk> | undefined>(schema: TSchema, value: InferInputI<TSchema, GraphQLSilkIO>): CallableInputParser<TSchema>;
+declare function parseInputValue<TSchema extends InputSchema<GraphQLSilk> | undefined>(inputSchema: TSchema, input: any): MayPromise<InferInputO<TSchema, GraphQLSilkIO>>;
+
+/**
+ * The symbol to get GraphQL type for schema
+ */
+declare const GET_GRAPHQL_TYPE: unique symbol;
+/**
+ * The symbol to validate and transform input to output
+ */
+declare const PARSE: unique symbol;
+/**
+ * The symbol to get and store weaver config
+ */
+declare const WEAVER_CONFIG: unique symbol;
+/**
+ * The symbol to get resolver options
+ */
+declare const RESOLVER_OPTIONS_KEY: unique symbol;
+/**
+ * The symbol to assign a WeakMap to an object
+ */
+declare const CONTEXT_MEMORY_MAP_KEY: unique symbol;
+
+declare const symbols_CONTEXT_MEMORY_MAP_KEY: typeof CONTEXT_MEMORY_MAP_KEY;
+declare const symbols_GET_GRAPHQL_TYPE: typeof GET_GRAPHQL_TYPE;
+declare const symbols_PARSE: typeof PARSE;
+declare const symbols_RESOLVER_OPTIONS_KEY: typeof RESOLVER_OPTIONS_KEY;
+declare const symbols_WEAVER_CONFIG: typeof WEAVER_CONFIG;
+declare namespace symbols {
+  export { symbols_CONTEXT_MEMORY_MAP_KEY as CONTEXT_MEMORY_MAP_KEY, symbols_GET_GRAPHQL_TYPE as GET_GRAPHQL_TYPE, symbols_PARSE as PARSE, symbols_RESOLVER_OPTIONS_KEY as RESOLVER_OPTIONS_KEY, symbols_WEAVER_CONFIG as WEAVER_CONFIG };
+}
+
+interface GraphQLSilk<TOutput = any, TInput = any> {
+    /**
+     * GraphQL type for schema
+     */
+    [GET_GRAPHQL_TYPE]: () => GraphQLOutputType;
+    /**
+     * validate and transform input to output
+     */
+    [PARSE]?: (input: TInput) => MayPromise<TOutput>;
+    /**
+     * Input and output type.
+     *
+     * @internal
+     */
+    readonly "~types"?: {
+        readonly input: TInput;
+        readonly output: TOutput;
+    };
+}
+type AbstractSchemaIO = [
+    baseSchema: object,
+    inputPath: string,
+    outputPath: string
+];
+type GraphQLSilkIO = [
+    object: GraphQLSilk,
+    input: "~types.input",
+    output: "~types.output"
+];
+type InferSilkI<T extends GraphQLSilk> = NonNullable<T["~types"]>["input"];
+type InferSilkO<T extends GraphQLSilk> = NonNullable<T["~types"]>["output"];
+type InferSchemaI<TSchema, TSchemaIO extends AbstractSchemaIO> = InferPropertyType<TSchema, TSchemaIO[1]>;
+type InferSchemaO<TSchema, TSchemaIO extends AbstractSchemaIO> = InferPropertyType<TSchema, TSchemaIO[2]>;
+type SchemaToSilk<TSchemaIO extends AbstractSchemaIO, TSchema extends TSchemaIO[0]> = GraphQLSilk<InferSchemaO<TSchema, TSchemaIO>, InferSchemaI<TSchema, TSchemaIO>>;
+interface ResolverOptions<TField extends GenericFieldOrOperation = GenericFieldOrOperation> {
+    middlewares?: Middleware<TField>[];
+}
+interface ResolverOptionsWithExtensions<TField extends GenericFieldOrOperation = GenericFieldOrOperation> extends ResolverOptions<TField>, Pick<GraphQLObjectTypeConfig<any, any>, "extensions"> {
+}
+interface ResolverOptionsWithParent<TField extends GenericFieldOrOperation = GenericFieldOrOperation> extends ResolverOptionsWithExtensions<TField> {
+    parent?: TField extends FieldOrOperation<infer TParent, any, any, any> ? TParent : undefined;
+}
+interface ResolvingOptions extends Pick<ResolverOptions, "middlewares"> {
+}
+type OperationType = "query" | "mutation" | "subscription";
+type FieldOrOperationType = "field" | OperationType;
+interface GraphQLFieldOptions extends Pick<GraphQLFieldConfig<any, any>, "description" | "deprecationReason" | "extensions"> {
+}
+/**
+ * Operation or Field for resolver.
+ */
+interface FieldOrOperation<TParent extends undefined | GraphQLSilk, TOutput extends GraphQLSilk, TInput extends InputSchema<GraphQLSilk> | undefined = undefined, TType extends FieldOrOperationType = FieldOrOperationType> extends GraphQLFieldOptions {
+    type: TType;
+    input: TInput;
+    output: TOutput;
+    resolve: TType extends "field" ? (parent: InferSilkO<NonNullable<TParent>>, input: InferInputI<TInput, GraphQLSilkIO>, options?: ResolvingOptions) => Promise<InferSilkO<TOutput>> : TType extends "subscription" ? (value: any, input: InferInputI<TInput, GraphQLSilkIO>) => Promise<InferSilkO<TOutput>> : (input: InferInputI<TInput, GraphQLSilkIO>, options?: ResolvingOptions) => Promise<InferSilkO<TOutput>>;
+    subscribe?: TType extends "subscription" ? (input: InferInputI<TInput, GraphQLSilkIO>, options?: ResolvingOptions) => MayPromise<AsyncIterator<any>> : undefined;
+}
+type GenericFieldOrOperation = FieldOrOperation<any, any, any, any>;
+type InferFieldParent<TField extends GenericFieldOrOperation> = TField extends FieldOrOperation<infer TParent, any, any, any> ? TParent : never;
+type InferFieldInput<TField extends GenericFieldOrOperation> = TField extends FieldOrOperation<any, any, infer TInput, any> ? TInput : never;
+type InferFieldOutput<TField extends GenericFieldOrOperation> = TField extends FieldOrOperation<any, infer TOutput, any, any> ? TOutput : never;
+/**
+ * Options for creating a GraphQL Query or Mutation.
+ */
+interface QueryMutationOptions<TSchemaIO extends AbstractSchemaIO, TOutput extends TSchemaIO[0], TInput extends InputSchema<TSchemaIO[0]> = undefined> extends ResolverOptions<FieldOrOperation<undefined, SchemaToSilk<TSchemaIO, TOutput>, InputSchemaToSilk<TSchemaIO, TInput>, "query" | "mutation">>, GraphQLFieldOptions {
+    input?: TInput;
+    resolve: (input: InferInputO<TInput, TSchemaIO>) => MayPromise<InferSchemaO<TOutput, TSchemaIO>>;
+}
+/**
+ * Function to create a GraphQL query or mutation.
+ */
+interface QueryMutationBobbin<TSchemaIO extends AbstractSchemaIO> {
+    <TOutput extends TSchemaIO[0], TInput extends InputSchema<TSchemaIO[0]> = undefined>(output: TOutput, resolveOrOptions: (() => MayPromise<InferSchemaO<TOutput, TSchemaIO>>) | QueryMutationOptions<TSchemaIO, TOutput, TInput>): FieldOrOperation<undefined, SchemaToSilk<TSchemaIO, TOutput>, InputSchemaToSilk<TSchemaIO, TInput>, "query" | "mutation">;
+}
+/**
+ * Options for External Filed of existing GraphQL Object.
+ */
+interface FieldOptions<TSchemaIO extends AbstractSchemaIO, TParent extends TSchemaIO[0], TOutput extends TSchemaIO[0], TInput extends InputSchema<TSchemaIO[0]> = undefined> extends ResolverOptions<FieldOrOperation<SchemaToSilk<TSchemaIO, TParent>, SchemaToSilk<TSchemaIO, TOutput>, InputSchemaToSilk<TSchemaIO, TInput>, "field">>, GraphQLFieldOptions {
+    input?: TInput;
+    resolve: (parent: InferSchemaO<TParent, TSchemaIO>, input: InferInputO<TInput, TSchemaIO>) => MayPromise<InferSchemaO<TOutput, TSchemaIO>>;
+}
+/**
+ * Function to create a GraphQL Field.
+ */
+interface FieldBobbin<TSchemaIO extends AbstractSchemaIO> {
+    <TParent extends TSchemaIO[0], TOutput extends TSchemaIO[0], TInput extends InputSchema<TSchemaIO[0]> = undefined>(output: TOutput, resolveOrOptions: ((parent: InferSchemaO<TParent, TSchemaIO>) => MayPromise<InferSchemaO<TOutput, TSchemaIO>>) | FieldOptions<TSchemaIO, TParent, TOutput, TInput>): FieldOrOperation<SchemaToSilk<TSchemaIO, TParent>, SchemaToSilk<TSchemaIO, TOutput>, InputSchemaToSilk<TSchemaIO, TInput>, "field">;
+}
+/**
+ * Options for creating a GraphQL Subscription.
+ */
+interface SubscriptionOptions<TSchemaIO extends AbstractSchemaIO, TOutput extends TSchemaIO[0], TInput extends InputSchema<TSchemaIO[0]> = undefined, TValue = InferSchemaO<TOutput, TSchemaIO>> extends ResolverOptions<Subscription<SchemaToSilk<TSchemaIO, TOutput>, InputSchemaToSilk<TSchemaIO, TInput>, TValue>>, GraphQLFieldOptions {
+    input?: TInput;
+    subscribe: (input: InferInputO<TInput, TSchemaIO>) => MayPromise<AsyncIterator<TValue>>;
+    resolve?: (value: TValue, input: InferInputO<TInput, TSchemaIO>) => MayPromise<InferSchemaO<TOutput, TSchemaIO>>;
+}
+interface Subscription<TOutput extends GraphQLSilk, TInput extends InputSchema<GraphQLSilk> = undefined, TValue = InferSilkO<TOutput>> extends FieldOrOperation<undefined, TOutput, TInput, "subscription"> {
+    resolve: (value: TValue, input: InferInputI<TInput, GraphQLSilkIO>) => Promise<InferSilkO<TOutput>>;
+    subscribe: (input: InferInputI<TInput, GraphQLSilkIO>, options?: ResolvingOptions) => MayPromise<AsyncIterator<TValue>>;
+}
+/**
+ * Function to create a GraphQL subscription.
+ */
+interface SubscriptionBobbin<TSchemaIO extends AbstractSchemaIO> {
+    <TOutput extends TSchemaIO[0], TInput extends InputSchema<TSchemaIO[0]> = undefined, TValue = InferSchemaO<TOutput, TSchemaIO>>(output: TOutput, subscribeOrOptions: (() => MayPromise<AsyncIterator<InferSchemaO<TOutput, TSchemaIO>>>) | SubscriptionOptions<TSchemaIO, TOutput, TInput, TValue>): Subscription<SchemaToSilk<TSchemaIO, TOutput>, InputSchemaToSilk<TSchemaIO, TInput>, TValue>;
+}
+interface ResolverBobbin<TSchemaIO extends AbstractSchemaIO> {
+    of<TParent extends TSchemaIO[0], TOperations extends Record<string, FieldOrOperation<SchemaToSilk<TSchemaIO, TParent>, any, any> | FieldOrOperation<undefined, any, any, OperationType>>>(parent: TParent, operationOrFields: TOperations, options?: ResolverOptionsWithExtensions<ValueOf<TOperations>>): TOperations;
+    <TOperations extends Record<string, FieldOrOperation<undefined, any, any, OperationType>>>(operations: TOperations, options?: ResolverOptions<ValueOf<TOperations>>): TOperations;
+}
+
+declare function getOperationOptions<T extends FieldOrOperationType = OperationType>(resolveOrOptions: T extends "field" ? ((parent: any) => any) | FieldOptions<any, any, any, any> : (() => any) | QueryMutationOptions<any, any, any>): T extends "field" ? FieldOptions<any, any, any, any> : QueryMutationOptions<any, any, any>;
+declare function getSubscriptionOptions(subscribeOrOptions: (() => any) | SubscriptionOptions<any, any, any, any>): SubscriptionOptions<any, any, any, any>;
+declare function getFieldOptions({ description, deprecationReason, extensions, }: GraphQLFieldOptions): GraphQLFieldOptions;
+
+interface MiddlewarePayload<TField extends GenericFieldOrOperation = FieldOrOperation<any, any, any, any>> {
+    outputSilk: InferSilkO<InferFieldOutput<TField>>;
+    parent: TField extends FieldOrOperation<infer TParent, any, any, any> ? TParent extends undefined ? undefined : InferSilkO<NonNullable<TParent>> : never;
+    parseInput: TField extends FieldOrOperation<any, any, infer TInput, any> ? CallableInputParser<TInput> : undefined;
+    type: FieldOrOperationType;
+}
+type Middleware<TField extends GenericFieldOrOperation = FieldOrOperation<any, any, any, any>> = (next: () => MayPromise<InferSilkO<InferFieldOutput<TField>>>, payload: MiddlewarePayload<TField>) => MayPromise<InferSilkO<InferFieldOutput<TField>>>;
+declare function applyMiddlewares<TField extends GenericFieldOrOperation = FieldOrOperation<any, any, any, any>>(middlewares: Middleware[], resolveFunction: () => MayPromise<InferSilkO<InferFieldOutput<TField>>>, payload: MiddlewarePayload<TField>): Promise<InferSilkO<InferFieldOutput<TField>>>;
+declare function compose<T>(...lists: (T[] | undefined)[]): T[];
+
+/**
+ * Detailed payload of the current resolver
+ */
+interface ResolverPayload<TContext extends object = object, TField extends FieldOrOperation<any, any, any, any> = FieldOrOperation<any, any, any, any>> {
+    /**
+     * The previous object, which for a field on the root Query type is often not used.
+     */
+    readonly root: any;
+    /**
+     * The payload provided to the field in the GraphQL query.
+     */
+    readonly args: Record<string, any>;
+    /**
+     * The resolved value of the field, or an error.
+     */
+    readonly context: TContext;
+    /**
+     * The source object that contains the field in the parent type.
+     */
+    readonly info: GraphQLResolveInfo;
+    /**
+     * The field that is being resolved.
+     */
+    readonly field: TField;
+}
+/**
+ * Empty Resolver Arguments that only store the memoization
+ */
+interface OnlyMemoizationPayload {
+    memoization: WeakMap<WeakKey, any>;
+    isMemoization: true;
+}
+/**
+ * Create an empty memoization payload for the resolver
+ * @returns the empty memoization payload
+ */
+declare function onlyMemoization(): OnlyMemoizationPayload;
+declare function isOnlyMemoryPayload(payload: ResolverPayload | OnlyMemoizationPayload): payload is OnlyMemoizationPayload;
+/**
+ * the AsyncLocalStorage instance to store the resolver payload
+ */
+declare const resolverPayloadStorage: AsyncLocalStorage<OnlyMemoizationPayload | ResolverPayload<object, FieldOrOperation<any, any, any, any>>>;
+/**
+ * use detailed payload of the current resolver
+ * @returns the resolver payload
+ */
+declare function useResolverPayload(): ResolverPayload | undefined;
+/**
+ * use context of the current resolver
+ * @returns the context of the current resolver
+ */
+declare function useContext<TContextType = object>(): TContextType;
+/**
+ * use the MemoizationMap of the current context
+ */
+declare function useMemoizationMap(): WeakMap<WeakKey, any> | undefined;
+interface ContextMemoryContainer {
+    [CONTEXT_MEMORY_MAP_KEY]?: WeakMap<WeakKey, any>;
+}
+interface ContextMemoryOptions {
+    getMemoizationMap: () => WeakMap<WeakKey, any> | undefined;
+    key: WeakKey;
+}
+/**
+ * Create a memoization in context to store the result of a getter function
+ */
+declare class ContextMemoization<T> implements ContextMemoryOptions {
+    readonly getter: () => T;
+    constructor(getter: () => T, options?: Partial<ContextMemoryOptions>);
+    getMemoizationMap: () => WeakMap<WeakKey, any> | undefined;
+    readonly key: WeakKey;
+    /**
+     * Get the value in memoization or call the getter function
+     * @returns the value of the getter function
+     */
+    get(): T;
+    /**
+     * Clear the memoization
+     * @returns true if the memoization is cleared, undefined if the context is not found
+     */
+    clear(): boolean | undefined;
+    /**
+     * Check if the memoization exists
+     * @returns true if the memoization exists, undefined if the context is not found
+     */
+    exists(): boolean | undefined;
+    /**
+     * Set a new value to the memoization
+     * @param value  the new value to set
+     * @returns the memoization map or undefined if the context is not found
+     */
+    set(value: T): WeakMap<WeakKey, any> | undefined;
+    static assignMemoizationMap(target: ContextMemoryContainer): WeakMap<WeakKey, any>;
+}
+/**
+ * Async Memoization with a callable function
+ */
+interface CallableContextMemoization<T> extends Pick<ContextMemoization<T>, "get" | "set" | "clear" | "exists" | "getter"> {
+    (): T;
+}
+/**
+ * Create a memoization in context to store the result of a getter function
+ */
+declare function createMemoization<T>(...args: ConstructorParameters<typeof ContextMemoization<T>>): CallableContextMemoization<T>;
+
+/**
+ * Creates an object map with the same keys as `map` and values generated by
+ * running each value of `record` thru `fn`.
+ */
+declare function mapValue<T, V>(record: Record<string, T>, fn: (value: T, key: string) => V | typeof mapValue.SKIP): Record<string, V>;
+declare namespace mapValue {
+    var SKIP: unique symbol;
+}
+declare function toObjMap<T>(obj: Maybe<ReadOnlyObjMapLike<T>>): ReadOnlyObjMap<T>;
+declare function notNullish<T>(x: T | undefined | null): x is T;
+declare function deepMerge<T extends Record<string, any>>(...objects: (T | null | undefined)[]): T;
+type Maybe<T> = null | undefined | T;
+type ReadOnlyObjMapLike<T> = ReadOnlyObjMap<T> | {
+    readonly [key: string]: T;
+};
+interface ReadOnlyObjMap<T> {
+    readonly [key: string]: T;
+}
+
+declare function markErrorLocation<TError>(error: TError, ...locations: string[]): TError;
+declare function tryIn<T>(func: () => T, ...locations: string[]): T;
+/**
+ * mark message with location
+ * @param message origin message
+ * @param locations where error happened
+ * @returns message with location
+ * @example markLocation("error", "banana") // "[banana] hello"
+ * @example markLocation("error", fruit, banana) // "[fruit.banana] error"
+ * @example markLocation("[banana] error", "fruit") // "[fruit.banana] error"
+ * @example markLocation("[fruit.banana] error", "favorite") // "[favorite.fruit.banana] error"
+ */
+declare function markLocation(message: string, ...locations: string[]): string;
+
+/**
+ * Create a Silk from Scalar.
+ */
+declare function silk<TScalar extends GraphQLScalarType>(type: TScalar, parse?: (input: InferScalarExternal<TScalar>) => MayPromise<InferScalarInternal<TScalar>>): GraphQLSilk<InferScalarInternal<TScalar> | undefined, InferScalarInternal<TScalar> | undefined>;
+/**
+ * Create a GraphQLSilk Object.
+ */
+declare function silk<TOutput, TInput = TOutput>(type: GraphQLOutputType, parse?: (input: TInput) => MayPromise<TOutput>): GraphQLSilk<TOutput, TInput>;
+declare namespace silk {
+    var parse: typeof parseSilk;
+    var getType: typeof getGraphQLType;
+    var nonNull: typeof nonNullSilk;
+    var list: typeof listSilk;
+    var nullable: typeof nullableSilk;
+}
+type NonNullSilk<TSilk extends GraphQLSilk<any, any>> = GraphQLSilk<NonNullable<InferSilkO<TSilk>>, NonNullable<InferSilkI<TSilk>>>;
+/**
+ * Non-nullable Silk.
+ */
+declare function nonNullSilk<TSilk extends GraphQLSilk<any, any>>(origin: TSilk): NonNullSilk<TSilk>;
+type ListSilk<TSilk extends GraphQLSilk<any, any>> = GraphQLSilk<EnsureArray<InferSilkO<TSilk>>, EnsureArray<InferSilkO<TSilk>>>;
+/**
+ * List Silk.
+ */
+declare function listSilk<TSilk extends GraphQLSilk<any, any>>(origin: TSilk): ListSilk<TSilk>;
+type NullableSilk<TSilk extends GraphQLSilk<any, any>> = GraphQLSilk<InferSilkO<TSilk> | null | undefined, InferSilkI<TSilk>>;
+/**
+ * Nullable Silk.
+ */
+declare function nullableSilk<TSilk extends GraphQLSilk<any, any>>(origin: TSilk): NullableSilk<TSilk>;
+/**
+ * Get GraphQL Output Type from Silk.
+ * @param silk GraphQL Silk
+ * @returns GraphQL Output Type
+ */
+declare function getGraphQLType(silk: GraphQLSilk): GraphQLOutputType;
+/**
+ * Validate and transform input to output
+ * @param silk silk GraphQL Silk
+ * @param input
+ * @returns output
+ */
+declare function parseSilk<TSilk extends GraphQLSilk>(silk: TSilk, input: InferSilkI<TSilk>): MayPromise<InferSilkO<TSilk>>;
+declare function isSilk(target: any): target is GraphQLSilk;
+type InferScalarInternal<T extends GraphQLScalarType> = T extends GraphQLScalarType<infer TInternal> ? TInternal : never;
+type InferScalarExternal<T extends GraphQLScalarType> = T extends GraphQLScalarType<any, infer TExternal> ? TExternal : never;
+type EnsureArray<T> = T extends Array<infer U> ? U[] : T[];
+
+declare const silkQuery: QueryMutationBobbin<GraphQLSilkIO>;
+declare const silkMutation: QueryMutationBobbin<GraphQLSilkIO>;
+declare const silkField: FieldBobbin<GraphQLSilkIO>;
+declare const defaultSubscriptionResolve: (source: any) => any;
+declare const silkSubscription: SubscriptionBobbin<GraphQLSilkIO>;
+declare const ResolverOptionsMap: WeakMap<object, ResolverOptionsWithParent<GenericFieldOrOperation>>;
+declare function baseResolver(operations: Record<string, FieldOrOperation<any, any, any>>, options: ResolverOptionsWithParent | undefined): Record<string, FieldOrOperation<any, any, any, FieldOrOperationType>>;
+declare const silkResolver: ResolverBobbin<GraphQLSilkIO>;
+declare const loom: {
+    query: QueryMutationBobbin<GraphQLSilkIO>;
+    resolver: ResolverBobbin<GraphQLSilkIO>;
+    field: FieldBobbin<GraphQLSilkIO>;
+    subscription: SubscriptionBobbin<GraphQLSilkIO>;
+    mutation: QueryMutationBobbin<GraphQLSilkIO>;
+};
+
+declare function createResolverBobbin<TSchemaIO extends AbstractSchemaIO>(toSilk: (schema: TSchemaIO[0]) => GraphQLSilk): ResolverBobbin<TSchemaIO>;
+declare function createFieldBobbin<TSchemaIO extends AbstractSchemaIO>(toSilk: (schema: TSchemaIO[0]) => GraphQLSilk, isSchema: (schema: InputSchema<TSchemaIO[0]>) => boolean): FieldBobbin<TSchemaIO>;
+declare function createQueryBobbin<TSchemaIO extends AbstractSchemaIO>(toSilk: (schema: TSchemaIO[0]) => GraphQLSilk, isSchema: (schema: InputSchema<TSchemaIO[0]>) => boolean): QueryMutationBobbin<TSchemaIO>;
+declare function createMutationBobbin<TSchemaIO extends AbstractSchemaIO>(toSilk: (schema: TSchemaIO[0]) => GraphQLSilk, isSchema: (schema: InputSchema<TSchemaIO[0]>) => boolean): QueryMutationBobbin<TSchemaIO>;
+declare function createSubscriptionBobbin<TSchemaIO extends AbstractSchemaIO>(toSilk: (schema: TSchemaIO[0]) => GraphQLSilk, isSchema: (schema: InputSchema<TSchemaIO[0]>) => boolean): SubscriptionBobbin<TSchemaIO>;
+declare function createLoom<TSchemaIO extends AbstractSchemaIO>(toSilk: (schema: TSchemaIO[0]) => GraphQLSilk, isSchema: (schema: InputSchema<TSchemaIO[0]>) => boolean): {
+    query: QueryMutationBobbin<TSchemaIO>;
+    mutation: QueryMutationBobbin<TSchemaIO>;
+    field: FieldBobbin<TSchemaIO>;
+    resolver: ResolverBobbin<TSchemaIO>;
+    subscription: SubscriptionBobbin<TSchemaIO>;
+};
+
+interface WeaverContext {
+    loomObjectMap: Map<GraphQLObjectType, LoomObjectType>;
+    loomUnionMap: Map<GraphQLUnionType, GraphQLUnionType>;
+    inputMap: Map<GraphQLObjectType | GraphQLInterfaceType, GraphQLInputObjectType>;
+    interfaceMap: Map<GraphQLObjectType, GraphQLInterfaceType>;
+    configs: Map<string | symbol, WeaverConfig>;
+    getConfig: <TConfig extends WeaverConfig>(key: TConfig[typeof WEAVER_CONFIG]) => TConfig | undefined;
+    setConfig<TConfig extends WeaverConfig>(config: TConfig): void;
+    deleteConfig: <TConfig extends WeaverConfig>(key: TConfig[typeof WEAVER_CONFIG]) => void;
+    namedTypes: Map<string, GraphQLOutputType>;
+    memoNamedType<TGraphQLType extends GraphQLOutputType = GraphQLOutputType>(gqlType: TGraphQLType): TGraphQLType;
+    getNamedType<T extends GraphQLOutputType>(name: string): T | undefined;
+    names: WeakMap<object, string>;
+}
+interface WeaverConfig {
+    [WEAVER_CONFIG]: string | symbol;
+}
+declare function initWeaverContext(): WeaverContext;
+type GlobalContextRequiredKeys = "names" | "getConfig" | "setConfig" | "getNamedType" | "memoNamedType";
+interface GlobalWeaverContext extends Partial<Omit<WeaverContext, GlobalContextRequiredKeys>>, Pick<WeaverContext, GlobalContextRequiredKeys> {
+    value?: WeaverContext;
+    useConfig<TConfig extends WeaverConfig, TCallback extends () => any>(config: TConfig, callback: TCallback): ReturnType<TCallback>;
+    GraphQLTypes: WeakMap<object, GraphQLOutputType>;
+    getGraphQLType<TGraphQLType extends GraphQLOutputType = GraphQLOutputType>(origin: object): TGraphQLType | undefined;
+    memoGraphQLType<TGraphQLType extends GraphQLOutputType = GraphQLOutputType>(origin: object, gqlType: TGraphQLType): TGraphQLType;
+}
+declare const weaverContext: GlobalWeaverContext;
+declare function provideWeaverContext<T>(func: () => T, value: WeaverContext | undefined): T;
+/**
+ * collect names for schemas
+ * @param namesList - names to collect
+ * @returns namesRecord
+ */
+declare function collectNames<TRecords extends Record<string, object>[]>(...namesList: TRecords): UnionToIntersection<TRecords[number]>;
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+
+type SilkFieldOrOperation = FieldOrOperation<any, any, any, any>;
+interface FieldConvertOptions {
+    optionsForResolving?: ResolvingOptions;
+}
+type SilkResolver = Record<string, FieldOrOperation<any, any, any, any>>;
+interface CoreSchemaWeaverConfigOptions extends GraphQLSchemaConfig {
+    getInputObjectName?: (name: string) => string;
+    weaverContext?: WeaverContext;
+}
+interface CoreSchemaWeaverConfig extends WeaverConfig, CoreSchemaWeaverConfigOptions {
+    [WEAVER_CONFIG]: "gqloom.core.schema";
+}
+
+declare class LoomObjectType extends GraphQLObjectType {
+    extraFields: Map<string, SilkFieldOrOperation>;
+    weaverContext: WeaverContext;
+    resolverOptions?: ResolvingOptions;
+    constructor(objectOrGetter: string | GraphQLObjectType | GraphQLObjectTypeConfig<any, any> | (() => GraphQLObjectType | GraphQLObjectTypeConfig<any, any>), options?: {
+        weaverContext?: WeaverContext;
+        resolverOptions?: ResolvingOptions;
+    });
+    addField(name: string, resolver: SilkFieldOrOperation): void;
+    mergeExtensions(extensions: GraphQLObjectTypeConfig<any, any>["extensions"]): void;
+    private extraField?;
+    getFields(): GraphQLFieldMap<any, any>;
+    protected mapToFieldConfig(map: Map<string, SilkFieldOrOperation>): Record<string, GraphQLFieldConfig<any, any>>;
+    toFieldConfig(field: SilkFieldOrOperation): GraphQLFieldConfig<any, any>;
+    protected provideForResolve(field: SilkFieldOrOperation): Pick<GraphQLFieldConfig<any, any>, "resolve"> | undefined;
+    protected provideForSubscribe(field: SilkFieldOrOperation): Pick<GraphQLFieldConfig<any, any>, "subscribe"> | undefined;
+    protected getCacheType(gqlType: GraphQLOutputType): GraphQLOutputType;
+    get options(): {
+        resolverOptions: ResolvingOptions | undefined;
+        weaverContext: WeaverContext;
+    };
+}
+declare function getCacheType(gqlType: GraphQLOutputType, options?: {
+    weaverContext?: WeaverContext;
+    resolverOptions?: ResolvingOptions;
+}): GraphQLOutputType;
+
+interface SchemaWeaverParameters extends Partial<Record<"query" | "mutation" | "subscription", LoomObjectType>>, Pick<GraphQLSchemaConfig, "types"> {
+}
+declare class SchemaWeaver {
+    query?: LoomObjectType;
+    mutation?: LoomObjectType;
+    subscription?: LoomObjectType;
+    types?: GraphQLNamedType[] | null;
+    context: WeaverContext;
+    resolverOptions?: ResolvingOptions;
+    /**
+     * Create a Schema Weaver config object
+     * @param config Schema Weaver config options
+     * @returns a Schema Weaver config object
+     */
+    static config(config: CoreSchemaWeaverConfigOptions): CoreSchemaWeaverConfig;
+    constructor({ query, mutation, subscription, types }?: SchemaWeaverParameters, context?: WeaverContext);
+    use(...middlewares: Middleware[]): this;
+    add(resolver: SilkResolver): this;
+    addType(silk: GraphQLSilk): this;
+    setConfig<TConfig extends WeaverConfig>(config: TConfig): this;
+    weaveGraphQLSchema(): GraphQLSchema;
+    protected addResolver(resolver: SilkResolver): this;
+    protected getOperationObject(type: "query" | "mutation" | "subscription"): LoomObjectType;
+    protected get fieldOptions(): {
+        resolverOptions: ResolvingOptions | undefined;
+        weaverContext: WeaverContext;
+    };
+    static optionsFrom(...inputs: (SilkResolver | Middleware | WeaverConfig | GraphQLSilk)[]): {
+        context: WeaverContext | undefined;
+        configs: Set<WeaverConfig>;
+        middlewares: Set<Middleware>;
+        resolvers: Set<SilkResolver>;
+        silks: Set<GraphQLSilk<any, any>>;
+    };
+    /**
+     * Weave a GraphQL Schema from resolvers
+     * @param inputs Resolvers, Global Middlewares or WeaverConfigs
+     * @returns GraphQ LSchema
+     */
+    static weave(...inputs: (SilkResolver | Middleware | WeaverConfig | GraphQLSilk)[]): GraphQLSchema;
+}
+/**
+ * Weave a GraphQL Schema from resolvers
+ * @param inputs Resolvers, Global Middlewares or WeaverConfigs
+ * @returns GraphQ LSchema
+ */
+declare const weave: typeof SchemaWeaver.weave;
+
+declare function inputToArgs(input: InputSchema<GraphQLSilk>): GraphQLFieldConfigArgumentMap | undefined;
+declare function ensureInputType(silkOrType: GraphQLType | GraphQLSilk): GraphQLInputType;
+declare function ensureInputObjectType(object: GraphQLObjectType | GraphQLInterfaceType | GraphQLInputObjectType): GraphQLInputObjectType;
+
+declare function ensureInterfaceType(gqlType: GraphQLOutputType, interfaceConfig?: GraphQLInterfaceTypeConfig<any, any>): GraphQLInterfaceType;
+
+interface GQLoomExtensions {
+    defaultValue?: any;
+    gqloom?: GQLoomExtensionAttribute;
+    directives?: DirectiveItem[] | DirectiveRecord;
+}
+interface DirectiveItem {
+    name: string;
+    args?: Record<string, any>;
+}
+type DirectiveRecord = Record<string, Record<string, any>>;
+interface GQLoomExtensionAttribute {
+    directives?: string[];
+}
+declare function mergeExtensions(...extensionsList: (Readonly<GraphQLFieldExtensions<any, any, any> | GraphQLObjectTypeExtensions | GQLoomExtensions> | null | undefined)[]): GraphQLFieldExtensions<any, any, any>;
+
+export { type AbstractSchemaIO, type CallableContextMemoization, type CallableInputParser, ContextMemoization, type CoreSchemaWeaverConfig, type CoreSchemaWeaverConfigOptions, type DirectiveItem, type DirectiveRecord, type FieldBobbin, type FieldConvertOptions, type FieldOptions, type FieldOrOperation, type FieldOrOperationType, type GQLoomExtensionAttribute, type GQLoomExtensions, type GenericFieldOrOperation, type GlobalWeaverContext, type GraphQLFieldOptions, type GraphQLSilk, type GraphQLSilkIO, type InferFieldInput, type InferFieldOutput, type InferFieldParent, type InferInputI, type InferInputO, type InferPropertyType, type InferSchemaI, type InferSchemaO, type InferSilkI, type InferSilkO, type InputSchema, type InputSchemaToSilk, type IsAny, type ListSilk, LoomObjectType, type MayPromise, type Middleware, type MiddlewarePayload, type NonNullSilk, type NullableSilk, type ObjectOrNever, type OnlyMemoizationPayload, type OperationType, type QueryMutationBobbin, type QueryMutationOptions, type ResolverBobbin, type ResolverOptions, ResolverOptionsMap, type ResolverOptionsWithExtensions, type ResolverOptionsWithParent, type ResolverPayload, type ResolvingOptions, symbols as SYMBOLS, type SchemaToSilk, SchemaWeaver, type SilkFieldOrOperation, type SilkResolver, type Subscription, type SubscriptionBobbin, type SubscriptionOptions, type ValueOf, type WeaverConfig, type WeaverContext, type WrapPropertyType, applyMiddlewares, baseResolver, collectNames, compose, createFieldBobbin, createInputParser, createLoom, createMemoization, createMutationBobbin, createQueryBobbin, createResolverBobbin, createSubscriptionBobbin, deepMerge, defaultSubscriptionResolve, ensureInputObjectType, ensureInputType, ensureInterfaceType, getCacheType, getFieldOptions, getGraphQLType, getOperationOptions, getSubscriptionOptions, initWeaverContext, inputToArgs, isOnlyMemoryPayload, isSilk, listSilk, loom, mapValue, markErrorLocation, markLocation, mergeExtensions, nonNullSilk, notNullish, nullableSilk, onlyMemoization, parseInputValue, parseSilk, provideWeaverContext, resolverPayloadStorage, silk, silkField, silkMutation, silkQuery, silkResolver, silkSubscription, toObjMap, tryIn, useContext, useMemoizationMap, useResolverPayload, weave, weaverContext };