@gqloom/core 0.8.4 → 0.9.1

package/dist/index.d.ts

@@ -1,398 +1,10 @@
-import * as graphql from 'graphql';
-import { GraphQLOutputType, GraphQLObjectTypeConfig, GraphQLFieldConfig, GraphQLScalarType, GraphQLObjectType, GraphQLNullableType, GraphQLList, GraphQLNonNull, GraphQLResolveInfo, GraphQLUnionType, GraphQLInterfaceType, GraphQLInputObjectType, GraphQLFieldMap, GraphQLSchemaConfig, GraphQLNamedType, GraphQLSchema, GraphQLFieldConfigArgumentMap, GraphQLType, GraphQLInputType, GraphQLInterfaceTypeConfig } from 'graphql';
-import * as graphql_jsutils_Maybe from 'graphql/jsutils/Maybe';
-import { AsyncLocalStorage } from 'async_hooks';
+import { F as FieldOptions, Q as QueryOptions, M as MutationOptions, R as ResolverPayload, S as SubscriptionOptions, G as GraphQLFieldOptions, a as StandardSchemaV1, b as GraphQLSilk, c as MayPromise, d as Query, e as QueryChainFactory, f as QueryFactoryWithChain, g as Mutation, h as MutationChainFactory, i as MutationFactoryWithChain, j as Field, k as FieldChainFactory, l as FieldFactoryWithUtils, m as SubscriptionChainFactory, n as Subscription, o as SubscriptionFactoryWithChain, O as Operation, p as FIELD_HIDDEN, q as ResolverOptionsWithExtensions, r as OmitInUnion, V as ValueOf, s as ResolverOptions, t as FieldOrOperation, u as Resolver, I as IS_RESOLVER, v as Middleware, w as InferInputI, W as WEAVER_CONFIG, B as BaseField } from './context-DsvT0-C6.js';
+export { $ as BaseChainFactory, ai as CallableInputParser, D as CallableMiddlewareOptions, _ as ChainFactoryOptions, ae as FieldFactory, a4 as FieldFactoryWithResolve, ag as FieldMeta, a9 as FieldOrOperationType, Z as IChainFactory, aa as InferFieldInput, ab as InferFieldOutput, ah as InferInputO, y as IsAny, a5 as Loom, E as MiddlewareConfig, A as MiddlewareOperation, C as MiddlewareOptions, ad as MutationFactory, a3 as MutationFactoryWithResolve, P as OnlyMemoizationPayload, a8 as OperationType, ac as QueryFactory, a2 as QueryFactoryWithResolve, z as RequireKeys, a0 as ResolvableSubscription, a6 as ResolverOptionsWithParent, K as ResolvingFields, a7 as ResolvingOptions, x as SYMBOLS, af as SubscriptionFactory, a1 as SubscriptionNeedResolve, H as applyMiddlewares, Y as assignContextMap, aj as createInputParser, J as filterMiddlewares, X as getMemoizationMap, L as getResolvingFields, al as getStandardValue, U as isOnlyMemoryPayload, T as onlyMemoization, ak as parseInputValue, N as parseResolvingFields } from './context-DsvT0-C6.js';
+import { GraphQLFieldExtensions, GraphQLScalarType, GraphQLObjectType, GraphQLOutputType, GraphQLNullableType, GraphQLList, GraphQLNonNull, GraphQLObjectTypeConfig, GraphQLUnionType, GraphQLInterfaceType, GraphQLInputObjectType, GraphQLFieldMap, GraphQLFieldConfig, GraphQLSchemaConfig, GraphQLNamedType, GraphQLSchema, GraphQLFieldConfigArgumentMap, GraphQLType, GraphQLInputType, GraphQLInterfaceTypeConfig } from 'graphql';
 
-type MayPromise<T> = T | Promise<T>;
-type IsAny<T> = 0 extends 1 & T ? true : false;
-type ValueOf<T extends object> = T[keyof T];
-type OmitInUnion<TUnion, TOmit> = TUnion extends infer T ? T extends TOmit ? never : T : never;
-
-/** The Standard Schema interface. */
-interface StandardSchemaV1<Input = unknown, Output = Input> {
-    /** The Standard Schema properties. */
-    readonly "~standard": StandardSchemaV1.Props<Input, Output>;
-}
-declare namespace StandardSchemaV1 {
-    /** The Standard Schema properties interface. */
-    export interface Props<Input = unknown, Output = Input> {
-        /** The version number of the standard. */
-        readonly version: 1;
-        /** The vendor name of the schema library. */
-        readonly vendor: string;
-        /** Validates unknown input values. */
-        readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>;
-        /** Inferred types associated with the schema. */
-        readonly types?: Types<Input, Output> | undefined;
-    }
-    /** The result interface of the validate function. */
-    export type Result<Output> = SuccessResult<Output> | FailureResult;
-    /** The result interface if validation succeeds. */
-    export interface SuccessResult<Output> {
-        /** The typed output value. */
-        readonly value: Output;
-        /** The non-existent issues. */
-        readonly issues?: undefined;
-    }
-    /** The result interface if validation fails. */
-    export interface FailureResult {
-        /** The issues of failed validation. */
-        readonly issues: ReadonlyArray<Issue>;
-    }
-    /** The issue interface of the failure output. */
-    export interface Issue {
-        /** The error message of the issue. */
-        readonly message: string;
-        /** The path of the issue, if any. */
-        readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
-    }
-    /** The path segment interface of the issue. */
-    export interface PathSegment {
-        /** The key representing a path segment. */
-        readonly key: PropertyKey;
-    }
-    /** The Standard Schema types interface. */
-    export interface Types<Input = unknown, Output = Input> {
-        /** The input type of the schema. */
-        readonly input: Input;
-        /** The output type of the schema. */
-        readonly output: Output;
-    }
-    /** Infers the input type of a Standard Schema. */
-    export type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["input"];
-    /** Infers the output type of a Standard Schema. */
-    export type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["output"];
-    export {  };
-}
-
-/**
- * The symbol to get GraphQL type for schema
- */
-declare const GET_GRAPHQL_TYPE: 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 check if an object is a resolver
- */
-declare const IS_RESOLVER: unique symbol;
-/**
- * The symbol to assign a WeakMap to an object
- */
-declare const CONTEXT_MEMORY_MAP_KEY: unique symbol;
-/**
- * The symbol to set fields to be hidden
- */
-declare const FIELD_HIDDEN: unique symbol;
-
-declare const symbols_CONTEXT_MEMORY_MAP_KEY: typeof CONTEXT_MEMORY_MAP_KEY;
-declare const symbols_FIELD_HIDDEN: typeof FIELD_HIDDEN;
-declare const symbols_GET_GRAPHQL_TYPE: typeof GET_GRAPHQL_TYPE;
-declare const symbols_IS_RESOLVER: typeof IS_RESOLVER;
-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_FIELD_HIDDEN as FIELD_HIDDEN, symbols_GET_GRAPHQL_TYPE as GET_GRAPHQL_TYPE, symbols_IS_RESOLVER as IS_RESOLVER, symbols_RESOLVER_OPTIONS_KEY as RESOLVER_OPTIONS_KEY, symbols_WEAVER_CONFIG as WEAVER_CONFIG };
-}
-
-type InferInputI<TInput extends GraphQLSilk | Record<string, GraphQLSilk> | undefined> = TInput extends undefined ? undefined : TInput extends GraphQLSilk ? StandardSchemaV1.InferInput<TInput> : TInput extends Record<string, GraphQLSilk> ? {
-    [K in keyof TInput]: StandardSchemaV1.InferInput<TInput[K]>;
-} : undefined;
-type InferInputO<TInput extends GraphQLSilk | Record<string, GraphQLSilk> | undefined> = TInput extends undefined ? undefined : TInput extends GraphQLSilk ? StandardSchemaV1.InferOutput<TInput> : TInput extends Record<string, GraphQLSilk> ? {
-    [K in keyof TInput]: StandardSchemaV1.InferOutput<TInput[K]>;
-} : never;
-interface CallableInputParser<TSchema extends GraphQLSilk | Record<string, GraphQLSilk> | undefined> {
-    /**
-     * input schema
-     */
-    schema: TSchema;
-    /**
-     *  Origin value to parse
-     */
-    value: InferInputI<TSchema>;
-    /**
-     * Parse the input and return the standard result
-     */
-    (): Promise<StandardSchemaV1.Result<InferInputO<TSchema>>>;
-    /**
-     * Result of parsing. Set it to `undefined` then the parser will run again.
-     */
-    result: StandardSchemaV1.Result<InferInputO<TSchema>> | undefined;
-    /**
-     * Parse the input and return the result
-     */
-    getResult(): Promise<InferInputO<TSchema>>;
-}
-declare function createInputParser<TSchema extends GraphQLSilk | Record<string, GraphQLSilk> | undefined>(schema: TSchema, value: InferInputI<TSchema>): CallableInputParser<TSchema>;
-declare function parseInputValue<TSchema extends GraphQLSilk | Record<string, GraphQLSilk> | undefined>(inputSchema: TSchema, input: any): MayPromise<StandardSchemaV1.Result<InferInputO<TSchema>>>;
-declare function getStandardValue<T>(result: StandardSchemaV1.Result<T>): T;
-declare function getStandardValue<T>(result?: StandardSchemaV1.Result<T>): T | undefined;
-declare function getStandardValue<T>(result: StandardSchemaV1.Result<T> | null): T | null;
-
-interface IChainFactory<TOutput extends GraphQLSilk, TInput extends GraphQLSilk | Record<string, GraphQLSilk> | undefined = undefined> {
-    description(description: GraphQLFieldOptions["description"]): this;
-    deprecationReason(deprecationReason: GraphQLFieldOptions["deprecationReason"]): this;
-    extensions(extensions: GraphQLFieldOptions["extensions"]): this;
-    output<TOutputNew extends GraphQLSilk>(output: TOutputNew): IChainFactory<TOutputNew, TInput>;
-    input<TInputNew extends GraphQLSilk | Record<string, GraphQLSilk>>(input: TInputNew): IChainFactory<TOutput, TInputNew>;
-}
-interface ChainFactoryOptions extends FieldMeta {
-    middlewares?: Middleware[];
-}
-declare abstract class BaseChainFactory<TField extends BaseField = any> {
-    protected readonly options?: Partial<ChainFactoryOptions> | undefined;
-    static methods(): {
-        description: (description: graphql_jsutils_Maybe.Maybe<string>) => BaseChainFactory<any>;
-        deprecationReason: (deprecationReason: graphql_jsutils_Maybe.Maybe<string>) => BaseChainFactory<any>;
-        extensions: (extensions: graphql_jsutils_Maybe.Maybe<Readonly<graphql.GraphQLFieldExtensions<any, any, any>>>) => BaseChainFactory<any>;
-    };
-    constructor(options?: Partial<ChainFactoryOptions> | undefined);
-    protected abstract clone(options?: Partial<ChainFactoryOptions>): this;
-    description(description: GraphQLFieldOptions["description"]): this;
-    deprecationReason(deprecationReason: GraphQLFieldOptions["deprecationReason"]): this;
-    extensions(extensions: GraphQLFieldOptions["extensions"]): this;
-    use(...middlewares: Middleware<TField>[]): this;
-}
-declare class FieldChainFactory<TOutput extends GraphQLSilk = never, TInput extends GraphQLSilk | Record<string, GraphQLSilk> | undefined = undefined> extends BaseChainFactory<Field<any, TOutput, TInput>> implements IChainFactory<TOutput, TInput> {
-    static methods(): FieldChainFactory<never, undefined>;
-    protected clone(options?: Partial<ChainFactoryOptions>): this;
-    output<TOutputNew extends GraphQLSilk>(output: TOutputNew): FieldChainFactory<TOutputNew, TInput>;
-    input<TInputNew extends GraphQLSilk | Record<string, GraphQLSilk>>(input: TInputNew): FieldChainFactory<TOutput, TInputNew>;
-    resolve<TParent extends GraphQLSilk>(resolve: (parent: StandardSchemaV1.InferOutput<TParent>, input: InferInputO<TInput>) => MayPromise<StandardSchemaV1.InferOutput<TOutput>>): Field<TParent, TOutput, TInput>;
-    load<TParent extends GraphQLSilk>(resolve: (parents: StandardSchemaV1.InferOutput<TParent>[], input: InferInputO<TInput>) => MayPromise<StandardSchemaV1.InferOutput<TOutput>[]>): Field<TParent, TOutput, TInput>;
-}
-declare class QueryChainFactory<TOutput extends GraphQLSilk = never, TInput extends GraphQLSilk | Record<string, GraphQLSilk> | undefined = undefined> extends BaseChainFactory<Query<TOutput, TInput>> implements IChainFactory<TOutput, TInput> {
-    static methods(): QueryChainFactory<never, undefined>;
-    protected clone(options?: Partial<ChainFactoryOptions>): this;
-    output<TOutputNew extends GraphQLSilk>(output: TOutputNew): QueryChainFactory<TOutputNew, TInput>;
-    input<TInputNew extends GraphQLSilk | Record<string, GraphQLSilk>>(input: TInputNew): QueryChainFactory<TOutput, TInputNew>;
-    resolve(resolve: (input: InferInputO<TInput>) => MayPromise<StandardSchemaV1.InferOutput<TOutput>>): Query<TOutput, TInput>;
-}
-declare class MutationChainFactory<TOutput extends GraphQLSilk = never, TInput extends GraphQLSilk | Record<string, GraphQLSilk> | undefined = undefined> extends BaseChainFactory<Mutation<TOutput, TInput>> implements IChainFactory<TOutput, TInput> {
-    static methods(): MutationChainFactory<never, undefined>;
-    protected clone(options?: Partial<ChainFactoryOptions>): this;
-    output<TOutputNew extends GraphQLSilk>(output: TOutputNew): MutationChainFactory<TOutputNew, TInput>;
-    input<TInputNew extends GraphQLSilk | Record<string, GraphQLSilk>>(input: TInputNew): MutationChainFactory<TOutput, TInputNew>;
-    resolve(resolve: (input: InferInputO<TInput>) => MayPromise<StandardSchemaV1.InferOutput<TOutput>>): Mutation<TOutput, TInput>;
-}
-declare class SubscriptionChainFactory<TOutput extends GraphQLSilk = never, TInput extends GraphQLSilk | Record<string, GraphQLSilk> | undefined = undefined> extends BaseChainFactory<Subscription<TOutput, TInput, any>> implements IChainFactory<TOutput, TInput> {
-    static methods(): SubscriptionChainFactory<never, undefined>;
-    protected clone(options?: Partial<ChainFactoryOptions>): this;
-    output<TOutputNew extends GraphQLSilk>(output: TOutputNew): SubscriptionChainFactory<TOutputNew, TInput>;
-    input<TInputNew extends GraphQLSilk | Record<string, GraphQLSilk>>(input: TInputNew): SubscriptionChainFactory<TOutput, TInputNew>;
-    subscribe<TValue = StandardSchemaV1.InferOutput<TOutput>>(subscribe: (input: InferInputO<TInput>) => MayPromise<AsyncIterator<TValue>>): TValue extends StandardSchemaV1.InferOutput<TOutput> ? ResolvableSubscription<TOutput, TInput, TValue> : SubscriptionNeedResolve<TOutput, TInput, TValue>;
-}
-interface ResolvableSubscription<TOutput extends GraphQLSilk, TInput extends GraphQLSilk | Record<string, GraphQLSilk> | undefined = undefined, TValue = StandardSchemaV1.InferOutput<TOutput>> extends Subscription<TOutput, TInput, TValue> {
-    resolve(resolve: (value: TValue, input: InferInputO<TInput>) => MayPromise<StandardSchemaV1.InferOutput<TOutput>>): Subscription<TOutput, TInput, TValue>;
-}
-interface SubscriptionNeedResolve<TOutput extends GraphQLSilk, TInput extends GraphQLSilk | Record<string, GraphQLSilk> | undefined = undefined, TValue = StandardSchemaV1.InferOutput<TOutput>> {
-    resolve(resolve: (value: TValue, input: InferInputO<TInput>) => MayPromise<StandardSchemaV1.InferOutput<TOutput>>): Subscription<TOutput, TInput, TValue>;
-}
-declare class QueryFactoryWithResolve<TInputO, TOutput extends GraphQLSilk, TInput extends GraphQLSilk<TInputO>> extends BaseChainFactory<Query<TOutput, TInput>> implements Query<TOutput, TInput> {
-    protected output: TOutput;
-    protected readonly options: QueryOptions<TOutput, TInput>;
-    get "~meta"(): Query<TOutput, TInput>["~meta"];
-    constructor(output: TOutput, options: QueryOptions<TOutput, TInput>);
-    protected clone(options?: Partial<typeof this.options> | undefined): this;
-    input<TInputNew extends GraphQLSilk<TInputO>>(input: TInputNew): QueryFactoryWithResolve<TInputO, TOutput, TInputNew>;
-}
-declare class MutationFactoryWithResolve<TInputO, TOutput extends GraphQLSilk, TInput extends GraphQLSilk<TInputO>> extends BaseChainFactory<Query<TOutput, TInput>> implements Mutation<TOutput, TInput> {
-    protected output: TOutput;
-    protected readonly options: MutationOptions<TOutput, TInput>;
-    get "~meta"(): Mutation<TOutput, TInput>["~meta"];
-    constructor(output: TOutput, options: MutationOptions<TOutput, TInput>);
-    protected clone(options?: Partial<typeof this.options> | undefined): this;
-    input<TInputNew extends GraphQLSilk<TInputO>>(input: TInputNew): MutationFactoryWithResolve<TInputO, TOutput, TInputNew>;
-}
-declare class FieldFactoryWithResolve<TParent extends GraphQLSilk, TOutput extends GraphQLSilk> extends BaseChainFactory<Field<TParent, TOutput, undefined>> {
-    protected output: TOutput;
-    protected readonly options: FieldOptions<TParent, TOutput, undefined>;
-    get "~meta"(): Field<TParent, TOutput, undefined>["~meta"];
-    constructor(output: TOutput, options: FieldOptions<TParent, TOutput, undefined>);
-    protected clone(options?: Partial<typeof this.options> | undefined): this;
-}
-
-interface FieldMeta extends GraphQLFieldOptions {
-    operation: "field" | "query" | "mutation" | "subscription";
-    output: GraphQLSilk;
-    input: GraphQLSilk | Record<string, GraphQLSilk> | undefined;
-    resolve: (...args: any) => MayPromise<any>;
-}
-interface BaseField {
-    readonly "~meta": FieldMeta;
-}
-interface Field<TParent extends GraphQLSilk, TOutput extends GraphQLSilk, TInput extends GraphQLSilk | Record<string, GraphQLSilk> | undefined = undefined> extends BaseField {
-    "~meta": {
-        operation: "field";
-        output: TOutput;
-        input: TInput;
-        types?: {
-            parent: ReSilk<TParent>;
-        };
-        resolve: (parent: StandardSchemaV1.InferOutput<NonNullable<TParent>>, input: InferInputI<TInput>, options?: ResolvingOptions) => Promise<StandardSchemaV1.InferOutput<TOutput>>;
-    } & GraphQLFieldOptions;
-}
-interface Query<TOutput extends GraphQLSilk, TInput extends GraphQLSilk | Record<string, GraphQLSilk> | undefined = undefined> extends BaseField {
-    "~meta": {
-        operation: "query";
-        parent?: undefined;
-        output: TOutput;
-        input: TInput;
-        resolve: (input: InferInputI<TInput>, options?: ResolvingOptions) => Promise<StandardSchemaV1.InferOutput<TOutput>>;
-    } & GraphQLFieldOptions;
-}
-interface Mutation<TOutput extends GraphQLSilk, TInput extends GraphQLSilk | Record<string, GraphQLSilk> | undefined = undefined> extends BaseField {
-    "~meta": {
-        operation: "mutation";
-        parent?: undefined;
-        output: TOutput;
-        input: TInput;
-        resolve: (input: InferInputI<TInput>, options?: ResolvingOptions) => Promise<StandardSchemaV1.InferOutput<TOutput>>;
-    } & GraphQLFieldOptions;
-}
-interface Subscription<TOutput extends GraphQLSilk, TInput extends GraphQLSilk | Record<string, GraphQLSilk> | undefined = undefined, TValue = StandardSchemaV1.InferOutput<TOutput>> extends BaseField {
-    "~meta": {
-        operation: "subscription";
-        parent?: undefined;
-        output: TOutput;
-        input: TInput;
-        types?: {
-            value: TValue;
-        } & GraphQLFieldOptions;
-        resolve: (value: TValue, input: InferInputI<TInput>, options?: ResolvingOptions) => MayPromise<StandardSchemaV1.InferOutput<TOutput>>;
-        subscribe: (input: InferInputI<TInput>, options?: ResolvingOptions) => MayPromise<AsyncIterator<TValue>>;
-    } & GraphQLFieldOptions;
-}
-interface Resolver {
-    readonly "~meta": {
-        [IS_RESOLVER]: true;
-        fields: Record<string, BaseField | typeof FIELD_HIDDEN>;
-        options?: ResolverOptionsWithExtensions<any>;
-        parent?: GraphQLSilk;
-    };
-}
-type Operation = Query<GraphQLSilk, GraphQLSilk | Record<string, GraphQLSilk> | undefined> | Mutation<GraphQLSilk, GraphQLSilk | Record<string, GraphQLSilk> | undefined> | Subscription<GraphQLSilk, GraphQLSilk | Record<string, GraphQLSilk> | undefined, any>;
-type FieldOrOperation = Field<GraphQLSilk, GraphQLSilk, GraphQLSilk | Record<string, GraphQLSilk> | undefined> | Operation;
-type ReSilk<T extends GraphQLSilk> = GraphQLSilk<NonNullable<T["~standard"]["types"]>["output"], NonNullable<T["~standard"]["types"]>["input"]>;
-
-type typesLoom_BaseField = BaseField;
-type typesLoom_Field<TParent extends GraphQLSilk, TOutput extends GraphQLSilk, TInput extends GraphQLSilk | Record<string, GraphQLSilk> | undefined = undefined> = Field<TParent, TOutput, TInput>;
-type typesLoom_FieldMeta = FieldMeta;
-type typesLoom_FieldOrOperation = FieldOrOperation;
-type typesLoom_Mutation<TOutput extends GraphQLSilk, TInput extends GraphQLSilk | Record<string, GraphQLSilk> | undefined = undefined> = Mutation<TOutput, TInput>;
-type typesLoom_Operation = Operation;
-type typesLoom_Query<TOutput extends GraphQLSilk, TInput extends GraphQLSilk | Record<string, GraphQLSilk> | undefined = undefined> = Query<TOutput, TInput>;
-type typesLoom_Resolver = Resolver;
-type typesLoom_Subscription<TOutput extends GraphQLSilk, TInput extends GraphQLSilk | Record<string, GraphQLSilk> | undefined = undefined, TValue = StandardSchemaV1.InferOutput<TOutput>> = Subscription<TOutput, TInput, TValue>;
-declare namespace typesLoom {
-  export type { typesLoom_BaseField as BaseField, typesLoom_Field as Field, typesLoom_FieldMeta as FieldMeta, typesLoom_FieldOrOperation as FieldOrOperation, typesLoom_Mutation as Mutation, typesLoom_Operation as Operation, typesLoom_Query as Query, typesLoom_Resolver as Resolver, typesLoom_Subscription as Subscription };
-}
-
-interface GraphQLSilk<TOutput = any, TInput = any> extends StandardSchemaV1<TInput, TOutput> {
-    /**
-     * GraphQL type for schema
-     */
-    [GET_GRAPHQL_TYPE]?: () => GraphQLOutputType;
-}
-interface ResolverOptions<TField extends FieldOrOperation = FieldOrOperation> {
-    middlewares?: Middleware<TField>[];
-}
-interface ResolverOptionsWithExtensions<TField extends FieldOrOperation = FieldOrOperation> extends ResolverOptions<TField>, Pick<GraphQLObjectTypeConfig<any, any>, "extensions"> {
-}
-interface ResolverOptionsWithParent<TField extends FieldOrOperation = FieldOrOperation> extends ResolverOptionsWithExtensions<TField> {
-    parent?: TField extends Field<infer TParent, 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"> {
-}
-type InferFieldInput<TField extends BaseField> = TField["~meta"]["input"];
-type InferFieldOutput<TField extends BaseField> = TField["~meta"]["output"];
-/**
- * Options for creating a GraphQL Query.
- */
-interface QueryOptions<TOutput extends GraphQLSilk, TInput extends GraphQLSilk | Record<string, GraphQLSilk> | undefined = undefined> extends ResolverOptions<Query<TOutput, TInput>>, GraphQLFieldOptions {
-    input?: TInput;
-    resolve: (input: InferInputO<TInput>) => MayPromise<StandardSchemaV1.InferOutput<TOutput>>;
-}
-/**
- * Options for creating a GraphQL Mutation.
- */
-interface MutationOptions<TOutput extends GraphQLSilk, TInput extends GraphQLSilk | Record<string, GraphQLSilk> | undefined = undefined> extends ResolverOptions<Mutation<TOutput, TInput>>, GraphQLFieldOptions {
-    input?: TInput;
-    resolve: (input: InferInputO<TInput>) => MayPromise<StandardSchemaV1.InferOutput<TOutput>>;
-}
-/**
- * Function to create a GraphQL query.
- */
-interface QueryFactory {
-    <TOutput extends GraphQLSilk>(output: TOutput, resolve: () => MayPromise<StandardSchemaV1.InferOutput<TOutput>>): Query<TOutput, undefined>;
-    <TOutput extends GraphQLSilk, TInput extends GraphQLSilk | Record<string, GraphQLSilk> | undefined = undefined>(output: TOutput, options: QueryOptions<TOutput, TInput>): Query<TOutput, TInput>;
-    <TOutput extends GraphQLSilk>(output: TOutput): QueryChainFactory<TOutput, undefined>;
-}
-interface QueryFactoryWithChain extends QueryFactory, QueryChainFactory<never, undefined> {
-}
-/**
- * Function to create a GraphQL mutation.
- */
-interface MutationFactory {
-    <TOutput extends GraphQLSilk>(output: TOutput, resolve: () => MayPromise<StandardSchemaV1.InferOutput<TOutput>>): Mutation<TOutput, undefined>;
-    <TOutput extends GraphQLSilk, TInput extends GraphQLSilk | Record<string, GraphQLSilk> | undefined = undefined>(output: TOutput, options: MutationOptions<TOutput, TInput>): Mutation<TOutput, TInput>;
-    <TOutput extends GraphQLSilk>(output: TOutput): MutationChainFactory<TOutput, undefined>;
-}
-/**
- * Function to create a GraphQL mutation.
- */
-interface MutationFactoryWithChain extends MutationFactory, MutationChainFactory<never, undefined> {
-}
-/**
- * Options for External Filed of existing GraphQL Object.
- */
-interface FieldOptions<TParent extends GraphQLSilk, TOutput extends GraphQLSilk, TInput extends GraphQLSilk | Record<string, GraphQLSilk> | undefined = undefined> extends ResolverOptions<Field<TParent, TOutput, TInput>>, GraphQLFieldOptions {
-    input?: TInput;
-    resolve: (parent: StandardSchemaV1.InferOutput<TParent>, input: InferInputO<TInput>) => MayPromise<StandardSchemaV1.InferOutput<TOutput>>;
-}
-/**
- * Function to create a GraphQL Field.
- */
-interface FieldFactory {
-    <TParent extends GraphQLSilk, TOutput extends GraphQLSilk>(output: TOutput, resolve: (parent: StandardSchemaV1.InferOutput<TParent>) => MayPromise<StandardSchemaV1.InferOutput<TOutput>>): Field<TParent, TOutput, undefined>;
-    <TParent extends GraphQLSilk, TOutput extends GraphQLSilk, TInput extends GraphQLSilk | Record<string, GraphQLSilk> | undefined = undefined>(output: TOutput, options: FieldOptions<TParent, TOutput, TInput>): Field<TParent, TOutput, TInput>;
-    <TOutput extends GraphQLSilk>(output: TOutput): FieldChainFactory<TOutput, undefined>;
-}
-interface FieldFactoryWithUtils extends FieldFactory, FieldChainFactory<never, undefined> {
-    /** Set fields to be hidden in GraphQL Schema */
-    hidden: typeof FIELD_HIDDEN;
-}
-/**
- * Options for creating a GraphQL Subscription.
- */
-interface SubscriptionOptions<TOutput extends GraphQLSilk, TInput extends GraphQLSilk | Record<string, GraphQLSilk> | undefined = undefined, TValue = StandardSchemaV1.InferOutput<TOutput>> extends ResolverOptions<Subscription<TOutput, TInput, TValue>>, GraphQLFieldOptions {
-    input?: TInput;
-    subscribe: (input: InferInputO<TInput>) => MayPromise<AsyncIterator<TValue>>;
-    resolve?: (value: TValue, input: InferInputO<TInput>) => MayPromise<StandardSchemaV1.InferOutput<TOutput>>;
-}
-/**
- * Function to create a GraphQL subscription.
- */
-interface SubscriptionFactory {
-    <TOutput extends GraphQLSilk, TValue = StandardSchemaV1.InferOutput<TOutput>>(output: TOutput, subscribe: () => MayPromise<AsyncIterator<StandardSchemaV1.InferOutput<TOutput>>>): Subscription<TOutput, undefined, TValue>;
-    <TOutput extends GraphQLSilk, TInput extends GraphQLSilk | Record<string, GraphQLSilk> | undefined = undefined, TValue = StandardSchemaV1.InferOutput<TOutput>>(output: TOutput, options: SubscriptionOptions<TOutput, TInput, TValue>): Subscription<TOutput, TInput, TValue>;
-    <TOutput extends GraphQLSilk>(output: TOutput): SubscriptionChainFactory<TOutput, undefined>;
-}
-interface SubscriptionFactoryWithChain extends SubscriptionFactory, SubscriptionChainFactory<never, undefined> {
-}
-
-declare function getOperationOptions(resolveOrOptions: ((...args: any) => any) | FieldOptions<any, any, any> | QueryOptions<any, any> | MutationOptions<any, any>): any;
-declare function getSubscriptionOptions(subscribeOrOptions: (() => any) | SubscriptionOptions<any, any, any>): SubscriptionOptions<any, any, any>;
-declare function getFieldOptions({ description, deprecationReason, extensions, }: GraphQLFieldOptions): GraphQLFieldOptions;
+declare function getOperationOptions(resolveOrOptions: ((...args: any) => any) | FieldOptions<any, any, any, any> | QueryOptions<any, any> | MutationOptions<any, any>): any;
+declare function getSubscriptionOptions(subscribeOrOptions: ((payload: ResolverPayload | undefined) => any) | SubscriptionOptions<any, any, any>): SubscriptionOptions<any, any, any>;
+declare function getFieldOptions({ description, deprecationReason, extensions }: GraphQLFieldOptions, extraExtensions?: GraphQLFieldExtensions<any, any, any>): GraphQLFieldOptions;
 
 /**
  * Create a Silk from Scalar.
@@ -448,17 +60,65 @@ type InferScalarExternalByVariants<T extends GraphQLVariants<GraphQLScalarType>>
 type InferObjectSourceByVariants<T extends GraphQLVariants<GraphQLObjectType>> = T extends GraphQLNonNull<infer U> ? U extends GraphQLVariants<GraphQLObjectType> ? NonNullable<InferObjectSourceByVariants<U>> : never : T extends GraphQLList<infer U> ? U extends GraphQLVariants<GraphQLObjectType> ? InferObjectSourceByVariants<U>[] : never : T extends GraphQLObjectType<infer TSource> ? TSource | null | undefined : never;
 type EnsureArray<T> = T extends Array<infer U> ? U[] : T[];
 
-declare const createQuery: (output: GraphQLSilk<any, any>, resolveOrOptions?: (() => MayPromise<unknown>) | QueryOptions<any, any>) => Query<any, any> | QueryChainFactory<never, undefined>;
+/**
+ * Creates a GraphQL query resolver
+ * @param output - The output type definition for the query
+ * @param resolveOrOptions - Either a resolve function or options object
+ * @returns A GraphQL query resolver
+ */
+declare const createQuery: (output: GraphQLSilk<any, any>, resolveOrOptions?: ((...args: any) => MayPromise<unknown>) | QueryOptions<any, any>) => Query<any, any> | QueryChainFactory<never, void>;
+/**
+ * Factory function for creating GraphQL queries with chainable configuration
+ */
 declare const query: QueryFactoryWithChain;
+/**
+ * Creates a GraphQL mutation resolver
+ * @param output - The output type definition for the mutation
+ * @param resolveOrOptions - Either a resolve function or options object
+ * @returns A GraphQL mutation resolver
+ */
 declare const createMutation: (output: GraphQLSilk<any, any>, resolveOrOptions?: (() => MayPromise<unknown>) | MutationOptions<any, any>) => Mutation<any, any> | MutationChainFactory<never, undefined>;
+/**
+ * Factory function for creating GraphQL mutations with chainable configuration
+ */
 declare const mutation: MutationFactoryWithChain;
-declare const createField: (output: GraphQLSilk<any, any>, resolveOrOptions?: FieldOptions<any, any, any> | ((parent: unknown) => unknown) | undefined) => Field<any, any, any> | FieldChainFactory<never, undefined>;
+/**
+ * Creates a GraphQL field resolver
+ * @param output - The output type definition for the field
+ * @param resolveOrOptions - Either a resolve function or options object
+ * @returns A GraphQL field resolver
+ */
+declare const createField: (output: GraphQLSilk<any, any>, resolveOrOptions?: (() => unknown) | FieldOptions<GraphQLSilk, GraphQLSilk, GraphQLSilk | Record<string, GraphQLSilk> | void, string[] | undefined>) => Field<any, any, any, any> | FieldChainFactory<never, undefined, undefined>;
+/**
+ * Factory function for creating GraphQL fields with chainable configuration
+ */
 declare const field: FieldFactoryWithUtils;
+/**
+ * Default subscription resolver that returns the source value
+ * @param source - The source value to resolve
+ */
 declare const defaultSubscriptionResolve: (source: any) => any;
+/**
+ * Creates a GraphQL subscription resolver
+ * @param output - The output type definition for the subscription
+ * @returns A subscription chain factory
+ */
 declare function createSubscription(output: GraphQLSilk<any, any>): SubscriptionChainFactory;
+/**
+ * Creates a GraphQL subscription resolver with subscribe function
+ * @param output - The output type definition for the subscription
+ * @param subscribeOrOptions - Either a subscribe function or options object
+ * @returns A GraphQL subscription resolver
+ */
 declare function createSubscription(output: GraphQLSilk<any, any>, subscribeOrOptions: (() => MayPromise<AsyncIterator<unknown>>) | SubscriptionOptions<any, any, any>): Subscription<any, any, any>;
+/**
+ * Factory function for creating GraphQL subscriptions with chainable configuration
+ */
 declare const subscription: SubscriptionFactoryWithChain;
 declare const resolver: ResolverFactory;
+/**
+ * Collection of factory functions for creating GraphQL operations
+ */
 declare const loom: {
     query: QueryFactoryWithChain;
     resolver: ResolverFactory;
@@ -466,21 +126,67 @@ declare const loom: {
     subscription: SubscriptionFactoryWithChain;
     mutation: MutationFactoryWithChain;
 };
+/**
+ * Properties for creating an executor
+ */
+interface ToExecutorProps {
+    /** WeakMap for memoization */
+    memoization?: WeakMap<WeakKey, any>;
+}
+/**
+ * Factory interface for creating GraphQL resolvers
+ */
 interface ResolverFactory {
-    of<TParent extends GraphQLSilk, TFields extends Record<string, Field<TParent, any, any> | Operation | typeof FIELD_HIDDEN>>(parent: TParent, fields: TFields, options?: ResolverOptionsWithExtensions<OmitInUnion<ValueOf<TFields>, typeof FIELD_HIDDEN>>): ObjectChainResolver<TParent, TFields>;
+    /**
+     * Creates a resolver for an object type
+     * @template TParent - The parent type
+     * @template TFields - The fields of the object type
+     * @param parent - The parent type definition
+     * @param fields - The fields to resolve
+     * @param options - Optional resolver options
+     */
+    of<TParent extends GraphQLSilk, TFields extends Record<string, Field<TParent, any, any, any> | Operation | typeof FIELD_HIDDEN>>(parent: TParent, fields: TFields, options?: ResolverOptionsWithExtensions<OmitInUnion<ValueOf<TFields>, typeof FIELD_HIDDEN>>): ObjectChainResolver<TParent, TFields>;
+    /**
+     * Creates a resolver for operations
+     * @template TFields - The operations to resolve
+     * @param operations - The operations to resolve
+     * @param options - Optional resolver options
+     */
     <TFields extends Record<string, Operation>>(operations: TFields, options?: ResolverOptions<ValueOf<TFields>>): ChainResolver<TFields>;
 }
+/**
+ * Base class for chain resolvers
+ * @template TFields - The fields or operations to resolve
+ */
 declare class ChainResolver<TFields extends Record<string, FieldOrOperation | typeof FIELD_HIDDEN>> implements Resolver {
     protected meta: {
         [IS_RESOLVER]: true;
         fields: TFields;
         options?: ResolverOptionsWithExtensions;
     };
+    /**
+     * Creates a new chain resolver
+     * @param fields - The fields or operations to resolve
+     * @param options - Optional resolver options
+     */
     constructor(fields: TFields, options?: ResolverOptionsWithExtensions<any>);
+    /**
+     * Gets the metadata for the resolver
+     */
     get "~meta"(): typeof this.meta;
+    /**
+     * Adds middleware functions to the resolver
+     * @param middlewares - The middleware functions to add
+     */
     use(...middlewares: Middleware<OmitInUnion<ValueOf<TFields>, typeof FIELD_HIDDEN>>[]): this;
-    toExecutor(): Executor<TFields>;
+    toExecutor(...middlewares: Middleware[]): Executor<TFields>;
+    protected toExecutorOperation(field: FieldOrOperation | typeof FIELD_HIDDEN, executorMiddlewares: Middleware[]): ((...args: any) => any) | undefined;
 }
+/**
+ * Class for resolving object types
+ * @template TParent - The parent type
+ * @template TFields - The fields to resolve
+ */
 declare class ObjectChainResolver<TParent extends GraphQLSilk, TFields extends Record<string, FieldOrOperation | typeof FIELD_HIDDEN>> extends ChainResolver<TFields> {
     protected meta: {
         [IS_RESOLVER]: true;
@@ -488,138 +194,30 @@ declare class ObjectChainResolver<TParent extends GraphQLSilk, TFields extends R
         parent: TParent;
         options?: ResolverOptionsWithExtensions;
     };
-    constructor(parent: TParent, fields: TFields, options?: ResolverOptionsWithExtensions<any>);
-    get "~meta"(): typeof this.meta;
-    extensions(extensions: Pick<GraphQLObjectTypeConfig<any, any>, "extensions">["extensions"]): this;
-}
-type Executor<TFields extends Record<string, FieldOrOperation | typeof FIELD_HIDDEN>> = {
-    [K in keyof TFields]: TFields[K] extends FieldOrOperation ? TFields[K]["~meta"]["resolve"] : never;
-};
-
-interface MiddlewareOptions<TField extends BaseField = BaseField> {
-    /** The Output Silk of the field */
-    outputSilk: StandardSchemaV1.InferOutput<InferFieldOutput<TField>>;
-    /** The previous object, which for a field on the root Query type is often not used. */
-    parent: TField extends Field<GraphQLSilk, GraphQLSilk, GraphQLSilk | Record<string, GraphQLSilk> | undefined> ? StandardSchemaV1.InferOutput<NonNullable<TField["~meta"]["types"]>["parent"]> : undefined;
-    /** A function to parse the input of the field */
-    parseInput: CallableInputParser<TField["~meta"]["input"]>;
-    /** The operation of the field: `query`, `mutation`, `subscription` or `field` */
-    operation: BaseField["~meta"]["operation"];
-}
-interface CallableMiddlewareOptions<TField extends BaseField = BaseField> extends MiddlewareOptions<TField> {
-    /** The function to call next in the middleware chain. */
-    next: () => MayPromise<StandardSchemaV1.InferOutput<InferFieldOutput<TField>>>;
-    /** The function to call next in the middleware chain. */
-    (): MayPromise<StandardSchemaV1.InferOutput<InferFieldOutput<TField>>>;
-}
-type Middleware<TField extends BaseField = any> = (options: CallableMiddlewareOptions<TField>) => MayPromise<StandardSchemaV1.InferOutput<InferFieldOutput<TField>>>;
-declare function applyMiddlewares<TField extends BaseField = BaseField>(middlewares: Middleware[], resolveFunction: () => MayPromise<StandardSchemaV1.InferOutput<InferFieldOutput<TField>>>, options: MiddlewareOptions<TField>): Promise<StandardSchemaV1.InferOutput<InferFieldOutput<TField>>>;
-declare function compose<T>(...lists: (T[] | undefined)[]): T[];
-
-/**
- * Detailed payload of the current resolver
- */
-interface ResolverPayload<TContext extends object = object, TField extends BaseField = BaseField> {
-    /**
-     * The previous object, which for a field on the root Query type is often not used.
-     */
-    readonly root: any;
-    /**
-     * The arguments 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;
-    /**
-     * A custom object each resolver can read from/write to.
-     */
-    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<ResolverPayload<object, BaseField> | OnlyMemoizationPayload>;
-/**
- * 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
+     * Creates a new object chain resolver
+     * @param parent - The parent type definition
+     * @param fields - The fields to resolve
+     * @param options - Optional resolver options
      */
-    get(): T;
-    /**
-     * Clear the memoization
-     * @returns true if the memoization is cleared, undefined if the context is not found
-     */
-    clear(): boolean | undefined;
+    constructor(parent: TParent, fields: TFields, options?: ResolverOptionsWithExtensions<any>);
     /**
-     * Check if the memoization exists
-     * @returns true if the memoization exists, undefined if the context is not found
+     * Gets the metadata for the resolver
      */
-    exists(): boolean | undefined;
+    get "~meta"(): typeof this.meta;
     /**
-     * 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
+     * Sets custom extensions for the resolver
+     * @param extensions - The extensions to add
      */
-    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;
+    extensions(extensions: Pick<GraphQLObjectTypeConfig<any, any>, "extensions">["extensions"]): this;
 }
 /**
- * Create a memoization in context to store the result of a getter function
+ * Type for the executor of a resolver
+ * @template TFields - The fields or operations to resolve
  */
-declare function createMemoization<T>(...args: ConstructorParameters<typeof ContextMemoization<T>>): CallableContextMemoization<T>;
+type Executor<TFields extends Record<string, FieldOrOperation | typeof FIELD_HIDDEN>> = {
+    [K in keyof TFields]: TFields[K] extends Field<infer TParent, infer TOutput, infer TInput, string[] | undefined> ? (parent: StandardSchemaV1.InferOutput<TParent>, args: InferInputI<TInput>, payload: ResolverPayload | void) => Promise<StandardSchemaV1.InferOutput<TOutput>> : TFields[K] extends Query<infer TOutput, infer TInput> ? (args: InferInputI<TInput>, payload: ResolverPayload | void) => Promise<StandardSchemaV1.InferOutput<TOutput>> : TFields[K] extends Mutation<infer TOutput, infer TInput> ? (args: InferInputI<TInput>, payload: ResolverPayload | void) => Promise<StandardSchemaV1.InferOutput<TOutput>> : never;
+};
 
 /**
  * Creates an object map with the same keys as `map` and values generated by
@@ -754,10 +352,14 @@ declare class LoomObjectType extends GraphQLObjectType {
     protected hiddenFields: Set<string>;
     static AUTO_ALIASING: "__gqloom_auto_aliasing";
     protected weaverContext: WeaverContext;
-    protected resolverOptions?: ResolvingOptions;
+    protected globalOptions?: ResolverOptions;
+    /**
+     * field name -> resolver
+     */
+    protected resolvers: Map<string, Resolver>;
     constructor(objectOrGetter: string | GraphQLObjectType | GraphQLObjectTypeConfig<any, any> | (() => GraphQLObjectType | GraphQLObjectTypeConfig<any, any>), options?: {
         weaverContext?: WeaverContext;
-        resolverOptions?: ResolvingOptions;
+        globalOptions?: ResolverOptions;
     });
     protected hasExplicitName?: boolean;
     protected _aliases: string[];
@@ -765,31 +367,28 @@ declare class LoomObjectType extends GraphQLObjectType {
     addAlias(name: string): void;
     protected renameByAliases(): void;
     hideField(name: string): void;
-    addField(name: string, resolver: BaseField): void;
+    addField(name: string, field: BaseField, resolver: Resolver | undefined): void;
     mergeExtensions(extensions: GraphQLObjectTypeConfig<any, any>["extensions"]): void;
     private extraFieldMap?;
     getFields(): GraphQLFieldMap<any, any>;
     protected mapToFieldConfig(map: Map<string, BaseField>): Record<string, GraphQLFieldConfig<any, any>>;
-    toFieldConfig(field: BaseField, fieldName?: string): GraphQLFieldConfig<any, any>;
-    protected provideForResolve(field: BaseField): Pick<GraphQLFieldConfig<any, any>, "resolve"> | undefined;
-    protected provideForSubscribe(field: BaseField | Subscription<any, any, any>): Pick<GraphQLFieldConfig<any, any>, "subscribe"> | undefined;
+    toFieldConfig(field: BaseField, fieldName: string): GraphQLFieldConfig<any, any>;
+    protected provideForResolve(field: BaseField, fieldName: string): GraphQLFieldConfig<any, any>["resolve"];
+    protected provideForSubscribe(field: BaseField | Subscription<any, any, any>, fieldName: string): GraphQLFieldConfig<any, any>["subscribe"] | undefined;
     protected getCacheType(gqlType: GraphQLOutputType, fieldName?: string): GraphQLOutputType;
     get options(): {
-        resolverOptions: ResolvingOptions | undefined;
+        resolverOptions: ResolverOptions<FieldOrOperation> | undefined;
         weaverContext: WeaverContext;
     };
 }
 declare const OPERATION_OBJECT_NAMES: Set<string>;
 declare function getCacheType(gqlType: GraphQLOutputType, options?: {
     weaverContext?: WeaverContext;
-    resolverOptions?: ResolvingOptions;
+    resolverOptions?: ResolverOptions;
     fieldName?: string;
     parent?: LoomObjectType;
 }): GraphQLOutputType;
 
-interface FieldConvertOptions {
-    optionsForResolving?: ResolvingOptions;
-}
 interface CoreSchemaWeaverConfigOptions extends GraphQLSchemaConfig {
     getInputObjectName?: (name: string) => string;
     weaverContext?: WeaverContext;
@@ -806,7 +405,7 @@ declare class GraphQLSchemaLoom {
     subscription?: LoomObjectType;
     types: Set<GraphQLNamedType>;
     context: WeaverContext;
-    resolverOptions?: ResolvingOptions;
+    resolverOptions?: ResolverOptions;
     /**
      * Create a Schema Weaver config object
      * @param config Schema Weaver config options
@@ -815,21 +414,18 @@ declare class GraphQLSchemaLoom {
     static config(config: CoreSchemaWeaverConfigOptions): CoreSchemaWeaverConfig;
     constructor({ query, mutation, subscription, types }?: SchemaWeaverParameters, context?: WeaverContext);
     use(...middlewares: Middleware[]): this;
-    add(resolver: Resolver): this;
+    add(resolver: Resolver, modifyParent?: (parent: LoomObjectType) => LoomObjectType): this;
     addVendor(weaver: SchemaWeaver): this;
     addType(silk: GraphQLSilk): this;
     setConfig<TConfig extends WeaverConfig>(config: TConfig): this;
     weaveGraphQLSchema(): GraphQLSchema;
-    protected addResolver(resolver: Resolver): this;
+    protected addResolver(resolver: Resolver, modifyParent?: (parent: LoomObjectType) => LoomObjectType): this;
     protected getOperationObject(type: "query" | "mutation" | "subscription"): LoomObjectType;
-    protected get fieldOptions(): {
-        resolverOptions: ResolvingOptions | undefined;
-        weaverContext: WeaverContext;
-    };
+    protected get fieldOptions(): ConstructorParameters<typeof LoomObjectType>[1];
     static optionsFrom(...inputs: (Resolver | Middleware | SchemaWeaver | WeaverConfig | GraphQLSilk)[]): {
         context: WeaverContext | undefined;
         configs: Set<WeaverConfig>;
-        middlewares: Set<Middleware>;
+        middlewares: Set<Middleware<any>>;
         resolvers: Set<Resolver>;
         silks: Set<GraphQLSilk<any, any>>;
         weavers: Set<SchemaWeaver>;
@@ -851,7 +447,7 @@ declare const weave: typeof GraphQLSchemaLoom.weave;
 interface EnsureInputOptions {
     fieldName?: string;
 }
-declare function inputToArgs(input: GraphQLSilk | Record<string, GraphQLSilk> | undefined, options: EnsureInputOptions | undefined): GraphQLFieldConfigArgumentMap | undefined;
+declare function inputToArgs(input: GraphQLSilk | Record<string, GraphQLSilk> | undefined | void, options: EnsureInputOptions | undefined): GraphQLFieldConfigArgumentMap | undefined;
 declare function ensureInputType(silkOrType: GraphQLType | GraphQLSilk, options: EnsureInputOptions | undefined): GraphQLInputType;
 declare function ensureInputObjectType(object: GraphQLObjectType | GraphQLInterfaceType | GraphQLInputObjectType, options: EnsureInputOptions | undefined): GraphQLInputObjectType;
 
@@ -871,4 +467,4 @@ interface GQLoomExtensionAttribute {
     directives?: string[];
 }
 
-export { BaseChainFactory, type BaseField, type BatchLoadFn, type CallableContextMemoization, type CallableInputParser, type CallableMiddlewareOptions, type ChainFactoryOptions, ChainResolver, ContextMemoization, type CoreSchemaWeaverConfig, type CoreSchemaWeaverConfigOptions, type DirectiveItem, type DirectiveRecord, EasyDataLoader, type Field, FieldChainFactory, type FieldConvertOptions, type FieldFactory, FieldFactoryWithResolve, type FieldFactoryWithUtils, type FieldMeta, type FieldOptions, type FieldOrOperation, type FieldOrOperationType, type GQLoomExtensionAttribute, type GQLoomExtensions, type GlobalWeaverContext, type GraphQLFieldOptions, GraphQLSchemaLoom, type GraphQLSilk, type IChainFactory, type InferFieldInput, type InferFieldOutput, type InferInputI, type InferInputO, type IsAny, type ListSilk, typesLoom as Loom, LoomObjectType, type MayPromise, type Middleware, type MiddlewareOptions, type Mutation, MutationChainFactory, type MutationFactory, type MutationFactoryWithChain, MutationFactoryWithResolve, type MutationOptions, type NonNullSilk, type NullableSilk, OPERATION_OBJECT_NAMES, ObjectChainResolver, type OmitInUnion, type OnlyMemoizationPayload, type Operation, type OperationType, type Query, QueryChainFactory, type QueryFactory, type QueryFactoryWithChain, QueryFactoryWithResolve, type QueryOptions, type ResolvableSubscription, type Resolver, type ResolverFactory, type ResolverOptions, type ResolverOptionsWithExtensions, type ResolverOptionsWithParent, type ResolverPayload, type ResolvingOptions, symbols as SYMBOLS, type SchemaWeaver, StandardSchemaV1, type Subscription, SubscriptionChainFactory, type SubscriptionFactory, type SubscriptionFactoryWithChain, type SubscriptionNeedResolve, type SubscriptionOptions, type ValueOf, type WeaverConfig, type WeaverContext, applyMiddlewares, capitalize, collectName, collectNames, compose, createField, createInputParser, createMemoization, createMutation, createQuery, createSubscription, deepMerge, defaultSubscriptionResolve, ensureInputObjectType, ensureInputType, ensureInterfaceType, field, getCacheType, getFieldOptions, getGraphQLType, getOperationOptions, getStandardValue, getSubscriptionOptions, initWeaverContext, inputToArgs, isOnlyMemoryPayload, isSchemaVendorWeaver, isSilk, listSilk, loom, mapValue, markErrorLocation, markLocation, meta, mutation, nonNullSilk, notNullish, nullableSilk, onlyMemoization, parseInputValue, parseSilk, pascalCase, provideWeaverContext, query, resolver, resolverPayloadStorage, screamingSnakeCase, silk, subscription, toObjMap, tryIn, useContext, useMemoizationMap, useResolverPayload, weave, weaverContext };
+export { BaseField, type BatchLoadFn, ChainResolver, type CoreSchemaWeaverConfig, type CoreSchemaWeaverConfigOptions, type DirectiveItem, type DirectiveRecord, EasyDataLoader, Field, FieldChainFactory, FieldFactoryWithUtils, FieldOptions, FieldOrOperation, type GQLoomExtensionAttribute, type GQLoomExtensions, type GlobalWeaverContext, GraphQLFieldOptions, GraphQLSchemaLoom, GraphQLSilk, InferInputI, type ListSilk, LoomObjectType, MayPromise, Middleware, Mutation, MutationChainFactory, MutationFactoryWithChain, MutationOptions, type NonNullSilk, type NullableSilk, OPERATION_OBJECT_NAMES, ObjectChainResolver, OmitInUnion, Operation, Query, QueryChainFactory, QueryFactoryWithChain, QueryOptions, Resolver, type ResolverFactory, ResolverOptions, ResolverOptionsWithExtensions, ResolverPayload, type SchemaWeaver, StandardSchemaV1, Subscription, SubscriptionChainFactory, SubscriptionFactoryWithChain, SubscriptionOptions, type ToExecutorProps, ValueOf, type WeaverConfig, type WeaverContext, capitalize, collectName, collectNames, createField, createMutation, createQuery, createSubscription, deepMerge, defaultSubscriptionResolve, ensureInputObjectType, ensureInputType, ensureInterfaceType, field, getCacheType, getFieldOptions, getGraphQLType, getOperationOptions, getSubscriptionOptions, initWeaverContext, inputToArgs, isSchemaVendorWeaver, isSilk, listSilk, loom, mapValue, markErrorLocation, markLocation, meta, mutation, nonNullSilk, notNullish, nullableSilk, parseSilk, pascalCase, provideWeaverContext, query, resolver, screamingSnakeCase, silk, subscription, toObjMap, tryIn, weave, weaverContext };