@gqloom/core 0.8.4 → 0.9.1

package/dist/context-DsvT0-C6.d.ts

@@ -0,0 +1,766 @@
+import { GraphQLOutputType, GraphQLObjectTypeConfig, GraphQLFieldConfig, GraphQLResolveInfo } 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;
+type RequireKeys<T, TKey extends string | number | symbol> = {
+    [P in keyof T as P extends TKey ? P : never]-?: T[P];
+} & {
+    [P in keyof T as P extends TKey ? never : P]: T[P];
+};
+
+/** 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_MAP_KEY: unique symbol;
+/**
+ * The symbol to set fields to be hidden
+ */
+declare const FIELD_HIDDEN: unique symbol;
+
+declare const symbols_CONTEXT_MAP_KEY: typeof CONTEXT_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_MAP_KEY as CONTEXT_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> | void> = TInput extends void ? void : TInput extends GraphQLSilk ? StandardSchemaV1.InferInput<TInput> : TInput extends Record<string, GraphQLSilk> ? {
+    [K in keyof TInput]: StandardSchemaV1.InferInput<TInput[K]>;
+} : void;
+type InferInputO<TInput extends GraphQLSilk | Record<string, GraphQLSilk> | void> = TInput extends void ? void : 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> | void> {
+    /**
+     * 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> | void>(schema: TSchema, value: InferInputI<TSchema>): CallableInputParser<TSchema>;
+declare function parseInputValue<TSchema extends GraphQLSilk | Record<string, GraphQLSilk> | void>(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 for chain factory that provides methods to configure GraphQL field options
+ * @template TOutput - The output type of the GraphQL field
+ * @template TInput - The input type of the GraphQL field, can be a single type or a record of types
+ */
+interface IChainFactory<TOutput extends GraphQLSilk, TInput extends GraphQLSilk | Record<string, GraphQLSilk> | void = void> {
+    /**
+     * Sets the description for the GraphQL field
+     * @param description - The description text for the field
+     */
+    description(description: GraphQLFieldOptions["description"]): this;
+    /**
+     * Sets the deprecation reason for the GraphQL field
+     * @param deprecationReason - The reason why this field is deprecated
+     */
+    deprecationReason(deprecationReason: GraphQLFieldOptions["deprecationReason"]): this;
+    /**
+     * Sets custom extensions for the GraphQL field
+     * @param extensions - Custom extensions to be added to the field
+     */
+    extensions(extensions: GraphQLFieldOptions["extensions"]): this;
+    /**
+     * Sets the output type for the GraphQL field
+     * @template TOutputNew - The new output type
+     * @param output - The output type definition
+     */
+    output<TOutputNew extends GraphQLSilk>(output: TOutputNew): IChainFactory<TOutputNew, TInput>;
+    /**
+     * Sets the input type for the GraphQL field
+     * @template TInputNew - The new input type
+     * @param input - The input type definition
+     */
+    input<TInputNew extends GraphQLSilk | Record<string, GraphQLSilk>>(input: TInputNew): IChainFactory<TOutput, TInputNew>;
+}
+/**
+ * Options for configuring a chain factory
+ */
+interface ChainFactoryOptions extends FieldMeta {
+    /** Middleware functions to be applied to the field */
+    middlewares?: Middleware[];
+}
+/**
+ * Base class for all chain factories
+ * @template TField - The type of field being created
+ */
+declare abstract class BaseChainFactory<TField extends BaseField = any> {
+    protected readonly options?: Partial<ChainFactoryOptions> | undefined;
+    /**
+     * Returns the available methods for the chain factory
+     */
+    static methods(): {
+        description: (description: GraphQLFieldOptions["description"]) => BaseChainFactory<any>;
+        deprecationReason: (deprecationReason: GraphQLFieldOptions["deprecationReason"]) => BaseChainFactory<any>;
+        extensions: (extensions: GraphQLFieldOptions["extensions"]) => BaseChainFactory<any>;
+    };
+    /**
+     * Creates a new instance of the chain factory
+     * @param options - Configuration options for the factory
+     */
+    constructor(options?: Partial<ChainFactoryOptions> | undefined);
+    /**
+     * Creates a clone of the current factory with new options
+     * @param options - New options to apply to the clone
+     */
+    protected abstract clone(options?: Partial<ChainFactoryOptions>): this;
+    /**
+     * Sets the description for the field
+     * @param description - The description text
+     */
+    description(description: GraphQLFieldOptions["description"]): this;
+    /**
+     * Sets the deprecation reason for the field
+     * @param deprecationReason - The reason for deprecation
+     */
+    deprecationReason(deprecationReason: GraphQLFieldOptions["deprecationReason"]): this;
+    /**
+     * Sets custom extensions for the field
+     * @param extensions - Custom extensions to add
+     */
+    extensions(extensions: GraphQLFieldOptions["extensions"]): this;
+    /**
+     * Adds middleware functions to the field
+     * @param middlewares - Middleware functions to add
+     */
+    use(...middlewares: Middleware<TField>[]): this;
+}
+/**
+ * Factory for creating field resolvers with chainable configuration
+ * @template TOutput - The output type of the field
+ * @template TInput - The input type of the field
+ * @template TDependencies - The dependencies of the field
+ */
+declare class FieldChainFactory<TOutput extends GraphQLSilk = never, TInput extends GraphQLSilk | Record<string, GraphQLSilk> | undefined = undefined, TDependencies extends string[] | undefined = undefined> extends BaseChainFactory<Field<any, TOutput, TInput, TDependencies>> implements IChainFactory<TOutput, TInput> {
+    /**
+     * Returns the available methods for the field chain factory
+     */
+    static methods(): FieldChainFactory<never, undefined>;
+    /**
+     * Creates a clone of the current factory with new options
+     * @param options - New options to apply to the clone
+     */
+    protected clone(options?: Partial<ChainFactoryOptions>): this;
+    /**
+     * Sets the output type for the field
+     * @template TOutputNew - The new output type
+     * @param output - The output type definition
+     */
+    output<TOutputNew extends GraphQLSilk>(output: TOutputNew): FieldChainFactory<TOutputNew, TInput, TDependencies>;
+    /**
+     * Sets the input type for the field
+     * @template TInputNew - The new input type
+     * @param input - The input type definition
+     */
+    input<TInputNew extends GraphQLSilk | Record<string, GraphQLSilk>>(input: TInputNew): FieldChainFactory<TOutput, TInputNew, TDependencies>;
+    /**
+     * Specifies the dependencies for the field
+     * @template TDependencies - The dependencies type
+     * @param dependencies - The dependencies to add
+     */
+    derivedFrom<const TDependencies extends string[]>(...dependencies: TDependencies): FieldChainFactory<TOutput, TInput, TDependencies>;
+    /**
+     * Sets the resolve function for the field
+     * @template TParent - The parent type
+     * @param resolve - The resolve function
+     */
+    resolve<TParent extends GraphQLSilk>(resolve: (parent: TDependencies extends string[] ? RequireKeys<NonNullable<StandardSchemaV1.InferOutput<TParent>>, TDependencies[number]> : NonNullable<StandardSchemaV1.InferOutput<TParent>>, input: InferInputO<TInput>, payload: ResolverPayload | undefined) => MayPromise<StandardSchemaV1.InferOutput<TOutput>>): Field<TParent, TOutput, TInput, TDependencies>;
+    /**
+     * Creates a field resolver that uses DataLoader for batch loading data.
+     * This method is particularly useful for optimizing performance when dealing with multiple data requests
+     * by batching them together and handling caching automatically.
+     *
+     * @template TParent - The parent type that extends GraphQLSilk
+     * @param resolve - A function that handles batch loading of data. The function receives:
+     *   - When no input type is defined: An array of parent objects
+     *   - When input type is defined: An array of tuples containing [parent, input]
+     *   - An array of resolver payloads
+     * @returns A GraphQL field resolver that implements batch loading
+     */
+    load<TParent extends GraphQLSilk>(resolve: (parameters: InferInputO<TInput> extends void | undefined ? InferParent<TParent, TDependencies>[] : [
+        parent: InferParent<TParent, TDependencies>,
+        input: InferInputO<TInput>
+    ][], payloads: (ResolverPayload | undefined)[]) => MayPromise<NonNullable<StandardSchemaV1.InferOutput<TOutput>>[]>): Field<TParent, TOutput, TInput, TDependencies>;
+}
+type InferParent<TParent extends GraphQLSilk, TDependencies extends string[] | undefined = undefined> = TDependencies extends string[] ? RequireKeys<NonNullable<StandardSchemaV1.InferOutput<TParent>>, TDependencies[number]> : NonNullable<StandardSchemaV1.InferOutput<TParent>>;
+/**
+ * Factory for creating query resolvers with chainable configuration
+ * @template TOutput - The output type of the query
+ * @template TInput - The input type of the query
+ */
+declare class QueryChainFactory<TOutput extends GraphQLSilk = never, TInput extends GraphQLSilk | Record<string, GraphQLSilk> | void = void> extends BaseChainFactory<Query<TOutput, TInput>> implements IChainFactory<TOutput, TInput> {
+    /**
+     * Returns the available methods for the query chain factory
+     * @returns An object containing all available methods
+     */
+    static methods(): QueryChainFactory<never, void>;
+    /**
+     * Creates a clone of the current factory with new options
+     * @param options - New options to apply to the clone
+     * @returns A new instance of QueryChainFactory with the updated options
+     */
+    protected clone(options?: Partial<ChainFactoryOptions>): this;
+    /**
+     * Sets the output type for the query
+     * @template TOutputNew - The new output type
+     * @param output - The output type definition
+     * @returns A new QueryChainFactory instance with the updated output type
+     */
+    output<TOutputNew extends GraphQLSilk>(output: TOutputNew): QueryChainFactory<TOutputNew, TInput>;
+    /**
+     * Sets the input type for the query
+     * @template TInputNew - The new input type
+     * @param input - The input type definition
+     * @returns A new QueryChainFactory instance with the updated input type
+     */
+    input<TInputNew extends GraphQLSilk | Record<string, GraphQLSilk>>(input: TInputNew): QueryChainFactory<TOutput, TInputNew>;
+    /**
+     * Sets the resolve function for the query
+     * @param resolve - The resolve function that processes the input and returns the output
+     * @returns A GraphQL query resolver
+     * @throws {Error} If output type is not set
+     */
+    resolve(resolve: (input: InferInputO<TInput>, payload: ResolverPayload | undefined) => MayPromise<StandardSchemaV1.InferOutput<TOutput>>): Query<TOutput, TInput>;
+}
+/**
+ * Factory for creating mutation resolvers with chainable configuration
+ * @template TOutput - The output type of the mutation
+ * @template TInput - The input type of the mutation
+ */
+declare class MutationChainFactory<TOutput extends GraphQLSilk = never, TInput extends GraphQLSilk | Record<string, GraphQLSilk> | undefined = undefined> extends BaseChainFactory<Mutation<TOutput, TInput>> implements IChainFactory<TOutput, TInput> {
+    /**
+     * Returns the available methods for the mutation chain factory
+     * @returns An object containing all available methods
+     */
+    static methods(): MutationChainFactory<never, undefined>;
+    /**
+     * Creates a clone of the current factory with new options
+     * @param options - New options to apply to the clone
+     * @returns A new instance of MutationChainFactory with the updated options
+     */
+    protected clone(options?: Partial<ChainFactoryOptions>): this;
+    /**
+     * Sets the output type for the mutation
+     * @template TOutputNew - The new output type
+     * @param output - The output type definition
+     * @returns A new MutationChainFactory instance with the updated output type
+     */
+    output<TOutputNew extends GraphQLSilk>(output: TOutputNew): MutationChainFactory<TOutputNew, TInput>;
+    /**
+     * Sets the input type for the mutation
+     * @template TInputNew - The new input type
+     * @param input - The input type definition
+     * @returns A new MutationChainFactory instance with the updated input type
+     */
+    input<TInputNew extends GraphQLSilk | Record<string, GraphQLSilk>>(input: TInputNew): MutationChainFactory<TOutput, TInputNew>;
+    /**
+     * Sets the resolve function for the mutation
+     * @param resolve - The resolve function that processes the input and returns the output
+     * @returns A GraphQL mutation resolver
+     * @throws {Error} If output type is not set
+     */
+    resolve(resolve: (input: InferInputO<TInput>, payload: ResolverPayload | undefined) => MayPromise<StandardSchemaV1.InferOutput<TOutput>>): Mutation<TOutput, TInput>;
+}
+/**
+ * Factory for creating subscription resolvers with chainable configuration
+ * @template TOutput - The output type of the subscription
+ * @template TInput - The input type of the subscription
+ */
+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> {
+    /**
+     * Returns the available methods for the subscription chain factory
+     * @returns An object containing all available methods
+     */
+    static methods(): SubscriptionChainFactory<never, undefined>;
+    /**
+     * Creates a clone of the current factory with new options
+     * @param options - New options to apply to the clone
+     * @returns A new instance of SubscriptionChainFactory with the updated options
+     */
+    protected clone(options?: Partial<ChainFactoryOptions>): this;
+    /**
+     * Sets the output type for the subscription
+     * @template TOutputNew - The new output type
+     * @param output - The output type definition
+     * @returns A new SubscriptionChainFactory instance with the updated output type
+     */
+    output<TOutputNew extends GraphQLSilk>(output: TOutputNew): SubscriptionChainFactory<TOutputNew, TInput>;
+    /**
+     * Sets the input type for the subscription
+     * @template TInputNew - The new input type
+     * @param input - The input type definition
+     * @returns A new SubscriptionChainFactory instance with the updated input type
+     */
+    input<TInputNew extends GraphQLSilk | Record<string, GraphQLSilk>>(input: TInputNew): SubscriptionChainFactory<TOutput, TInputNew>;
+    /**
+     * Sets the subscribe function for the subscription
+     * @template TValue - The value type of the subscription
+     * @param subscribe - The subscribe function that returns an AsyncIterator
+     * @returns A subscription resolver that can be further configured with a resolve function
+     * @throws {Error} If output type is not set
+     */
+    subscribe<TValue = StandardSchemaV1.InferOutput<TOutput>>(subscribe: (input: InferInputO<TInput>, payload: ResolverPayload | undefined) => MayPromise<AsyncIterator<TValue>>): TValue extends StandardSchemaV1.InferOutput<TOutput> ? ResolvableSubscription<TOutput, TInput, TValue> : SubscriptionNeedResolve<TOutput, TInput, TValue>;
+}
+/**
+ * Interface for a subscription that can be resolved
+ * @template TOutput - The output type of the subscription
+ * @template TInput - The input type of the subscription
+ * @template TValue - The value type of the subscription
+ */
+interface ResolvableSubscription<TOutput extends GraphQLSilk, TInput extends GraphQLSilk | Record<string, GraphQLSilk> | undefined = undefined, TValue = StandardSchemaV1.InferOutput<TOutput>> extends Subscription<TOutput, TInput, TValue> {
+    /**
+     * Sets the resolve function for the subscription
+     * @param resolve - The resolve function
+     */
+    resolve(resolve: (value: TValue, input: InferInputO<TInput>, payload: ResolverPayload | undefined) => MayPromise<StandardSchemaV1.InferOutput<TOutput>>): Subscription<TOutput, TInput, TValue>;
+}
+/**
+ * A subscription that can not be resolved yet, still needs to be resolved.
+ * Interface for a subscription that needs to be resolved
+ * @template TOutput - The output type of the subscription
+ * @template TInput - The input type of the subscription
+ * @template TValue - The value type of the subscription
+ */
+interface SubscriptionNeedResolve<TOutput extends GraphQLSilk, TInput extends GraphQLSilk | Record<string, GraphQLSilk> | undefined = undefined, TValue = StandardSchemaV1.InferOutput<TOutput>> {
+    /**
+     * Sets the resolve function for the subscription
+     * @param resolve - The resolve function
+     */
+    resolve(resolve: (value: TValue, input: InferInputO<TInput>, payload: ResolverPayload | undefined) => 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, string[] | undefined>> {
+    protected output: TOutput;
+    protected readonly options: FieldOptions<TParent, TOutput, undefined, string[] | undefined>;
+    get "~meta"(): Field<TParent, TOutput, undefined, string[] | undefined>["~meta"];
+    constructor(output: TOutput, options: FieldOptions<TParent, TOutput, undefined, string[] | 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> | void;
+    middlewares?: Middleware[];
+    dependencies?: string[];
+    resolve: (...args: any) => MayPromise<any>;
+}
+interface BaseField {
+    readonly "~meta": FieldMeta;
+}
+interface Field<TParent extends GraphQLSilk, TOutput extends GraphQLSilk, TInput extends GraphQLSilk | Record<string, GraphQLSilk> | void = void, TDependencies extends string[] | undefined = undefined> extends BaseField {
+    "~meta": {
+        operation: "field";
+        output: TOutput;
+        input: TInput;
+        middlewares?: Middleware[];
+        dependencies?: TDependencies;
+        types?: {
+            parent: ReSilk<TParent>;
+        };
+        resolve: (parent: StandardSchemaV1.InferOutput<NonNullable<TParent>>, input: InferInputO<TInput>, payload: ResolverPayload | void) => Promise<StandardSchemaV1.InferOutput<TOutput>>;
+    } & GraphQLFieldOptions;
+}
+interface Query<TOutput extends GraphQLSilk, TInput extends GraphQLSilk | Record<string, GraphQLSilk> | void = void> extends BaseField {
+    "~meta": {
+        operation: "query";
+        parent?: undefined;
+        output: TOutput;
+        input: TInput;
+        middlewares?: Middleware[];
+        resolve: (input: InferInputO<TInput>, payload: ResolverPayload | void) => Promise<StandardSchemaV1.InferOutput<TOutput>>;
+    } & GraphQLFieldOptions;
+}
+interface Mutation<TOutput extends GraphQLSilk, TInput extends GraphQLSilk | Record<string, GraphQLSilk> | void = void> extends BaseField {
+    "~meta": {
+        operation: "mutation";
+        parent?: undefined;
+        output: TOutput;
+        input: TInput;
+        middlewares?: Middleware[];
+        resolve: (input: InferInputO<TInput>, payload: ResolverPayload | void) => Promise<StandardSchemaV1.InferOutput<TOutput>>;
+    } & GraphQLFieldOptions;
+}
+interface Subscription<TOutput extends GraphQLSilk, TInput extends GraphQLSilk | Record<string, GraphQLSilk> | void = void, TValue = StandardSchemaV1.InferOutput<TOutput>> extends BaseField {
+    "~meta": {
+        operation: "subscription";
+        parent?: undefined;
+        output: TOutput;
+        input: TInput;
+        middlewares?: Middleware[];
+        types?: {
+            value: TValue;
+        } & GraphQLFieldOptions;
+        resolve: (value: TValue, input: InferInputO<TInput>, payload: ResolverPayload | void) => MayPromise<StandardSchemaV1.InferOutput<TOutput>>;
+        subscribe: (input: InferInputO<TInput>, payload: ResolverPayload | void) => 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> | void> | Mutation<GraphQLSilk, GraphQLSilk | Record<string, GraphQLSilk> | void> | Subscription<GraphQLSilk, GraphQLSilk | Record<string, GraphQLSilk> | void, any>;
+type FieldOrOperation = Field<GraphQLSilk, GraphQLSilk, GraphQLSilk | Record<string, GraphQLSilk> | void, string[] | 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> | void = void, TDependencies extends string[] | undefined = undefined> = Field<TParent, TOutput, TInput, TDependencies>;
+type typesLoom_FieldMeta = FieldMeta;
+type typesLoom_FieldOrOperation = FieldOrOperation;
+type typesLoom_Mutation<TOutput extends GraphQLSilk, TInput extends GraphQLSilk | Record<string, GraphQLSilk> | void = void> = Mutation<TOutput, TInput>;
+type typesLoom_Operation = Operation;
+type typesLoom_Query<TOutput extends GraphQLSilk, TInput extends GraphQLSilk | Record<string, GraphQLSilk> | void = void> = Query<TOutput, TInput>;
+type typesLoom_Resolver = Resolver;
+type typesLoom_Subscription<TOutput extends GraphQLSilk, TInput extends GraphQLSilk | Record<string, GraphQLSilk> | void = void, 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, any> ? TParent : undefined;
+}
+interface ResolvingOptions extends Pick<ResolverOptions, "middlewares"> {
+    payload: ResolverPayload | undefined;
+}
+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> | void = void> extends ResolverOptions<Query<TOutput, TInput>>, GraphQLFieldOptions {
+    input?: TInput;
+    resolve: (input: InferInputO<TInput>, payload: ResolverPayload | undefined) => 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>, payload: ResolverPayload | undefined) => MayPromise<StandardSchemaV1.InferOutput<TOutput>>;
+}
+/**
+ * Function to create a GraphQL query.
+ */
+interface QueryFactory {
+    <TOutput extends GraphQLSilk>(output: TOutput, resolve: (input: void, payload: ResolverPayload | undefined) => MayPromise<StandardSchemaV1.InferOutput<TOutput>>): Query<TOutput, void>;
+    <TOutput extends GraphQLSilk, TInput extends GraphQLSilk | Record<string, GraphQLSilk> | void = void>(output: TOutput, options: QueryOptions<TOutput, TInput>): Query<TOutput, TInput>;
+    <TOutput extends GraphQLSilk>(output: TOutput): QueryChainFactory<TOutput, void>;
+}
+interface QueryFactoryWithChain extends QueryFactory, QueryChainFactory<never, void> {
+}
+/**
+ * Function to create a GraphQL mutation.
+ */
+interface MutationFactory {
+    <TOutput extends GraphQLSilk>(output: TOutput, resolve: (input: void, payload: ResolverPayload | undefined) => 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> | void = void, TDependencies extends string[] | undefined = undefined> extends ResolverOptions<Field<TParent, TOutput, TInput, TDependencies>>, GraphQLFieldOptions {
+    input?: TInput;
+    dependencies?: TDependencies;
+    resolve: (parent: TDependencies extends string[] ? RequireKeys<NonNullable<StandardSchemaV1.InferOutput<TParent>>, TDependencies[number]> : NonNullable<StandardSchemaV1.InferOutput<TParent>>, input: InferInputO<TInput>, payload: ResolverPayload | undefined) => 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>, input: void, payload: ResolverPayload | undefined) => MayPromise<StandardSchemaV1.InferOutput<TOutput>>): Field<TParent, TOutput, undefined, undefined>;
+    <TParent extends GraphQLSilk, TOutput extends GraphQLSilk>(output: TOutput, options: FieldOptions<TParent, TOutput, undefined, undefined>): Field<TParent, TOutput, undefined, undefined>;
+    <TParent extends GraphQLSilk, TOutput extends GraphQLSilk, TInput extends GraphQLSilk | Record<string, GraphQLSilk> | undefined>(output: TOutput, options: FieldOptions<TParent, TOutput, TInput, undefined> & {
+        input: TInput;
+    }): Field<TParent, TOutput, TInput, undefined>;
+    <TParent extends GraphQLSilk, TOutput extends GraphQLSilk, const TDependencies extends string[] | undefined>(output: TOutput, options: FieldOptions<TParent, TOutput, undefined, TDependencies> & {
+        dependencies: TDependencies;
+    }): Field<TParent, TOutput, undefined, TDependencies>;
+    <TParent extends GraphQLSilk, TOutput extends GraphQLSilk, TInput extends GraphQLSilk | Record<string, GraphQLSilk> | undefined, TDependencies extends string[] | undefined>(output: TOutput, options: FieldOptions<TParent, TOutput, TInput, TDependencies> & {
+        input: TInput;
+        dependencies: TDependencies;
+    }): Field<TParent, TOutput, TInput, TDependencies>;
+    <TOutput extends GraphQLSilk>(output: TOutput): FieldChainFactory<TOutput, undefined, undefined>;
+}
+interface FieldFactoryWithUtils extends FieldFactory, FieldChainFactory<never, undefined, 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>, payload: ResolverPayload | undefined) => MayPromise<AsyncIterator<TValue>>;
+    resolve?: (value: TValue, input: InferInputO<TInput>, payload: ResolverPayload | undefined) => MayPromise<StandardSchemaV1.InferOutput<TOutput>>;
+}
+/**
+ * Function to create a GraphQL subscription.
+ */
+interface SubscriptionFactory {
+    <TOutput extends GraphQLSilk, TValue = StandardSchemaV1.InferOutput<TOutput>>(output: TOutput, subscribe: (payload: ResolverPayload | undefined) => 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> {
+}
+/**
+ * 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;
+}
+
+/**
+ * The operation of the field:
+ * - `field`
+ * - `query`
+ * - `mutation`
+ * - `subscription.resolve`
+ * - `subscription.subscribe`
+ * - `resolveReference`
+ */
+type MiddlewareOperation = "field" | "query" | "mutation" | "subscription.resolve" | "subscription.subscribe" | "resolveReference";
+interface MiddlewareOptions<TField extends BaseField = BaseField> {
+    /** The Output Silk */
+    outputSilk: StandardSchemaV1.InferOutput<InferFieldOutput<TField>>;
+    /** The previous object. */
+    parent: InferFieldParent<TField>;
+    /** A function to parse the input */
+    parseInput: CallableInputParser<TField["~meta"]["input"]>;
+    /** The executing operation */
+    operation: MiddlewareOperation;
+    /** The payload of the resolver */
+    payload: ResolverPayload | undefined;
+}
+type InferFieldParent<TField extends BaseField> = TField extends Field<infer TParent, any, any, infer TDependencies> ? TDependencies extends string[] ? RequireKeys<NonNullable<StandardSchemaV1.InferOutput<TParent>>, TDependencies[number]> : NonNullable<StandardSchemaV1.InferOutput<TParent>> : undefined;
+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>>>;
+}
+interface MiddlewareConfig {
+    /** The operations to apply the middleware to. */
+    operations?: MiddlewareOperation[];
+}
+interface Middleware<TField extends BaseField = any> extends Partial<MiddlewareConfig> {
+    (options: CallableMiddlewareOptions<TField>): MayPromise<StandardSchemaV1.InferOutput<InferFieldOutput<TField>>>;
+}
+declare function applyMiddlewares<TField extends BaseField = BaseField>(options: MiddlewareOptions<TField>, resolveFunction: () => MayPromise<StandardSchemaV1.InferOutput<InferFieldOutput<TField>>>, middlewares: Middleware[]): Promise<StandardSchemaV1.InferOutput<InferFieldOutput<TField>>>;
+declare function filterMiddlewares(operation: MiddlewareOperation, ...middlewareList: (Middleware | Iterable<Middleware> | undefined | null)[]): Middleware[];
+
+/**
+ * Represents the state of field resolution in a GraphQL query.
+ */
+interface ResolvingFields {
+    /**
+     * Fields explicitly requested in the GraphQL query
+     */
+    requestedFields: Set<string>;
+    /**
+     * Fields that are derived from other fields (computed fields)
+     */
+    derivedFields: Set<string>;
+    /**
+     * Fields that derived fields depend on
+     */
+    derivedDependencies: Set<string>;
+    /**
+     * Final set of fields that need to be resolved, after processing derived fields
+     */
+    selectedFields: Set<string>;
+}
+/**
+ * Analyzes and processes field resolution in a GraphQL query.
+ *
+ * @param payload - The resolver payload containing the current field resolution context
+ * @returns An object containing sets of different field types
+ */
+declare function getResolvingFields(payload: Pick<ResolverPayload, "info">): ResolvingFields;
+/**
+ * Parses the GraphQL resolve info to extract all requested fields.
+ * Returns a Set of field paths where nested fields are represented as 'parent.field'.
+ * Supports @include, @skip directives, fragments, and variables.
+ *
+ * @param info - The GraphQL resolve info object containing the query information
+ * @param maxDepth - Maximum depth of nested fields to parse (default: 1)
+ * @returns A Set of field paths
+ */
+declare function parseResolvingFields(info: GraphQLResolveInfo, maxDepth?: number): Set<string>;
+
+/**
+ * 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: OnlyMemoizationPayload | Pick<ResolverPayload, "context">): payload is OnlyMemoizationPayload;
+declare function getMemoizationMap(payload: OnlyMemoizationPayload | Pick<ResolverPayload, "context">): WeakMap<WeakKey, any>;
+interface ContextMemoryContainer {
+    [CONTEXT_MAP_KEY]?: WeakMap<WeakKey, any>;
+}
+declare function assignContextMap(target: ContextMemoryContainer): WeakMap<WeakKey, any>;
+
+export { BaseChainFactory as $, type MiddlewareOperation as A, type BaseField as B, type MiddlewareOptions as C, type CallableMiddlewareOptions as D, type MiddlewareConfig as E, type FieldOptions as F, type GraphQLFieldOptions as G, applyMiddlewares as H, IS_RESOLVER as I, filterMiddlewares as J, type ResolvingFields as K, getResolvingFields as L, type MutationOptions as M, parseResolvingFields as N, type Operation as O, type OnlyMemoizationPayload as P, type QueryOptions as Q, type ResolverPayload as R, type SubscriptionOptions as S, onlyMemoization as T, isOnlyMemoryPayload as U, type ValueOf as V, WEAVER_CONFIG as W, getMemoizationMap as X, assignContextMap as Y, type IChainFactory as Z, type ChainFactoryOptions as _, StandardSchemaV1 as a, type ResolvableSubscription as a0, type SubscriptionNeedResolve as a1, QueryFactoryWithResolve as a2, MutationFactoryWithResolve as a3, FieldFactoryWithResolve as a4, typesLoom as a5, type ResolverOptionsWithParent as a6, type ResolvingOptions as a7, type OperationType as a8, type FieldOrOperationType as a9, type InferFieldInput as aa, type InferFieldOutput as ab, type QueryFactory as ac, type MutationFactory as ad, type FieldFactory as ae, type SubscriptionFactory as af, type FieldMeta as ag, type InferInputO as ah, type CallableInputParser as ai, createInputParser as aj, parseInputValue as ak, getStandardValue as al, type GraphQLSilk as b, type MayPromise as c, type Query as d, QueryChainFactory as e, type QueryFactoryWithChain as f, type Mutation as g, MutationChainFactory as h, type MutationFactoryWithChain as i, type Field as j, FieldChainFactory as k, type FieldFactoryWithUtils as l, SubscriptionChainFactory as m, type Subscription as n, type SubscriptionFactoryWithChain as o, FIELD_HIDDEN as p, type ResolverOptionsWithExtensions as q, type OmitInUnion as r, type ResolverOptions as s, type FieldOrOperation as t, type Resolver as u, type Middleware as v, type InferInputI as w, symbols as x, type IsAny as y, type RequireKeys as z };