@gqloom/core 0.10.1 → 0.11.0

package/dist/index-GSWAHvDy.d.ts

@@ -0,0 +1,1253 @@
+import { GraphQLFieldConfig, GraphQLFieldConfigArgumentMap, GraphQLFieldExtensions, GraphQLFieldMap, GraphQLInputObjectType, GraphQLInputType, GraphQLInterfaceType, GraphQLInterfaceTypeConfig, GraphQLList, GraphQLNamedType, GraphQLNonNull, GraphQLNullableType, GraphQLObjectType, GraphQLObjectTypeConfig, GraphQLOutputType, GraphQLResolveInfo, GraphQLScalarType, GraphQLSchema, GraphQLSchemaConfig, GraphQLType, GraphQLUnionType } from "graphql";
+
+//#region src/utils/types.d.ts
+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] };
+//#endregion
+//#region ../../node_modules/.pnpm/@standard-schema+spec@1.0.0/node_modules/@standard-schema/spec/dist/index.d.ts
+/** 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 {};
+}
+declare namespace symbols_d_exports {
+  export { CONTEXT_MAP_KEY, FIELD_HIDDEN, GET_GRAPHQL_TYPE, IS_RESOLVER, RESOLVER_OPTIONS_KEY, WEAVER_CONFIG };
+}
+/**
+ * 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;
+/**
+ * Set fields to be hidden
+ */
+declare const FIELD_HIDDEN = false;
+//#endregion
+//#region src/resolver/input.d.ts
+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>>;
+  /**
+   * Set the result's value of parsing
+   */
+  setResult(value: InferInputO<TSchema>): void;
+  /**
+   * Clear the result of parsing, the parser will run again to get the result.
+   */
+  clearResult(): void;
+}
+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;
+//#endregion
+//#region src/resolver/resolver-chain-factory.d.ts
+/**
+ * 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.
+   * @returns A GraphQL field resolver that implements batch loading
+   */
+  load<TParent extends GraphQLSilk>(resolve: (parents: InferParent<TParent, TDependencies>[], input: InferInputO<TInput>, payloads: (ResolverPayload | undefined)[]) => MayPromise<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 outputSilk: TOutput;
+  protected readonly options: QueryOptions<TOutput, TInput>;
+  get "~meta"(): Query<TOutput, TInput>["~meta"];
+  constructor(outputSilk: TOutput, options: QueryOptions<TOutput, TInput>);
+  protected clone(options?: Partial<QueryOptions<TOutput, TInput>> | undefined): this;
+  input<TInputNew extends GraphQLSilk<TInputO>>(input: TInputNew): QueryFactoryWithResolve<TInputO, TOutput, TInputNew>;
+  output<TOutputNew extends GraphQLSilk>(output: TOutputNew, transform: (output: StandardSchemaV1.InferOutput<TOutput>) => MayPromise<StandardSchemaV1.InferOutput<TOutputNew>>): QueryFactoryWithResolve<TInputO, TOutputNew, TInput>;
+}
+declare class MutationFactoryWithResolve<TInputO, TOutput extends GraphQLSilk, TInput extends GraphQLSilk<TInputO>> extends BaseChainFactory<Query<TOutput, TInput>> implements Mutation<TOutput, TInput> {
+  protected outputSilk: TOutput;
+  protected readonly options: MutationOptions<TOutput, TInput>;
+  get "~meta"(): Mutation<TOutput, TInput>["~meta"];
+  constructor(outputSilk: TOutput, options: MutationOptions<TOutput, TInput>);
+  protected clone(options?: Partial<MutationOptions<TOutput, TInput>> | undefined): this;
+  input<TInputNew extends GraphQLSilk<TInputO>>(input: TInputNew): MutationFactoryWithResolve<TInputO, TOutput, TInputNew>;
+  output<TOutputNew extends GraphQLSilk>(output: TOutputNew, transform: (output: StandardSchemaV1.InferOutput<TOutput>) => MayPromise<StandardSchemaV1.InferOutput<TOutputNew>>): MutationFactoryWithResolve<TInputO, TOutputNew, TInput>;
+}
+declare class FieldFactoryWithResolve<TParent extends GraphQLSilk, TOutput extends GraphQLSilk, TInputO = never, TInput extends GraphQLSilk<TInputO> | void = void> extends BaseChainFactory<Field<TParent, TOutput, TInput, string[] | undefined>> {
+  protected outputSilk: TOutput;
+  protected readonly options: FieldOptions<TParent, TOutput, TInput, string[] | undefined>;
+  get "~meta"(): Field<TParent, TOutput, TInput, string[] | undefined>["~meta"];
+  constructor(outputSilk: TOutput, options: FieldOptions<TParent, TOutput, TInput, string[] | undefined>);
+  protected clone(options?: Partial<FieldOptions<TParent, TOutput, TInput, string[] | undefined>> | undefined): this;
+  input<TInputNew extends GraphQLSilk<TInputO>>(input: TInputNew): FieldFactoryWithResolve<TParent, TOutput, TInputO, TInputNew>;
+  output<TOutputNew extends GraphQLSilk>(output: TOutputNew, transform: (output: StandardSchemaV1.InferOutput<TOutput>) => MayPromise<StandardSchemaV1.InferOutput<TOutputNew>>): FieldFactoryWithResolve<TParent, TOutputNew, TInputO, TInput>;
+}
+declare namespace types_loom_d_exports {
+  export { BaseField, Field, FieldMeta, FieldOrOperation, Mutation, Operation, Query, Resolver, Subscription };
+}
+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"]>;
+//#endregion
+//#region src/resolver/types.d.ts
+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;
+}
+//#endregion
+//#region src/utils/args.d.ts
+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;
+//#endregion
+//#region src/resolver/silk.d.ts
+/**
+ * Create a Silk from Scalar.
+ */
+declare function silk<TScalar extends GraphQLVariants<GraphQLScalarType>>(type: TScalar | (() => TScalar), validate?: (value: InferScalarExternalByVariants<TScalar>) => StandardSchemaV1.Result<InferScalarExternalByVariants<TScalar>> | Promise<StandardSchemaV1.Result<InferScalarInternalByVariants<TScalar>>>): GraphQLSilk<InferScalarInternalByVariants<TScalar>, InferScalarInternalByVariants<TScalar>>;
+/**
+ * Create a GraphQLSilk Object.
+ */
+declare function silk<TObject extends GraphQLVariants<GraphQLObjectType>>(type: TObject | (() => TObject), validate?: (value: InferObjectSourceByVariants<TObject>) => StandardSchemaV1.Result<InferObjectSourceByVariants<TObject>> | Promise<StandardSchemaV1.Result<InferObjectSourceByVariants<TObject>>>): GraphQLSilk<InferObjectSourceByVariants<TObject>, InferObjectSourceByVariants<TObject>>;
+/**
+ * Create a GraphQLSilk Object.
+ */
+declare function silk<TOutput, TInput = TOutput>(type: GraphQLOutputType | (() => GraphQLOutputType), validate?: (value: TInput) => StandardSchemaV1.Result<TOutput> | Promise<StandardSchemaV1.Result<TOutput>>): GraphQLSilk<TOutput, TInput>;
+declare namespace silk {
+  var parse: typeof parseSilk;
+  var getType: typeof getGraphQLType;
+  var nonNull: typeof nonNullSilk;
+  var list: typeof listSilk;
+  var nullable: typeof nullableSilk;
+}
+type NonNullSilk<TSilk extends GraphQLSilk<any, any>> = GraphQLSilk<NonNullable<StandardSchemaV1.InferOutput<TSilk>>, NonNullable<StandardSchemaV1.InferInput<TSilk>>>;
+/**
+ * Non-nullable Silk.
+ */
+declare function nonNullSilk<TSilk extends GraphQLSilk<any, any>>(origin: TSilk): NonNullSilk<TSilk>;
+type ListSilk<TSilk extends GraphQLSilk<any, any>> = GraphQLSilk<EnsureArray<StandardSchemaV1.InferOutput<TSilk>>, EnsureArray<StandardSchemaV1.InferOutput<TSilk>>>;
+/**
+ * List Silk.
+ */
+declare function listSilk<TSilk extends GraphQLSilk<any, any>>(origin: TSilk): ListSilk<TSilk>;
+type NullableSilk<TSilk extends GraphQLSilk<any, any>> = GraphQLSilk<StandardSchemaV1.InferOutput<TSilk> | null | undefined, StandardSchemaV1.InferInput<TSilk>>;
+/**
+ * Nullable Silk.
+ */
+declare function nullableSilk<TSilk extends GraphQLSilk<any, any>>(origin: TSilk): NullableSilk<TSilk>;
+/**
+ * Get GraphQL Output Type from Silk.
+ * @param silk GraphQL Silk
+ * @returns GraphQL Output Type
+ */
+declare function getGraphQLType(silk: GraphQLSilk): GraphQLOutputType;
+/**
+ * Validate and transform input to output
+ * @param silk silk GraphQL Silk
+ * @param input
+ * @returns output
+ */
+declare function parseSilk<TSilk extends GraphQLSilk>(silk: TSilk, input: StandardSchemaV1.InferInput<TSilk>): MayPromise<StandardSchemaV1.Result<StandardSchemaV1.InferOutput<TSilk>>>;
+declare function isSilk(target: any): target is GraphQLSilk;
+type GraphQLVariants<TSource extends GraphQLNullableType> = TSource | GraphQLList<TSource> | GraphQLList<GraphQLNonNull<TSource>> | GraphQLNonNull<TSource> | GraphQLNonNull<GraphQLList<TSource>> | GraphQLNonNull<GraphQLList<GraphQLNonNull<TSource>>>;
+type InferScalarInternalByVariants<T extends GraphQLVariants<GraphQLScalarType>> = T extends GraphQLNonNull<infer U> ? U extends GraphQLVariants<GraphQLScalarType> ? NonNullable<InferScalarInternalByVariants<U>> : never : T extends GraphQLList<infer U> ? U extends GraphQLVariants<GraphQLScalarType> ? InferScalarInternalByVariants<U>[] : never : T extends GraphQLScalarType<infer TInternal, any> ? TInternal | null | undefined : never;
+type InferScalarExternalByVariants<T extends GraphQLVariants<GraphQLScalarType>> = T extends GraphQLNonNull<infer U> ? U extends GraphQLVariants<GraphQLScalarType> ? NonNullable<InferScalarExternalByVariants<U>> : never : T extends GraphQLList<infer U> ? U extends GraphQLVariants<GraphQLScalarType> ? InferScalarExternalByVariants<U>[] : never : T extends GraphQLScalarType<any, infer TExternal> ? TExternal | null | undefined : never;
+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[];
+//#endregion
+//#region src/resolver/resolver.d.ts
+/**
+ * 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$1: 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$1: MutationFactoryWithChain;
+/**
+ * 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>) => FieldChainFactory<never, undefined, undefined> | Field<any, any, any, any>;
+/**
+ * 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$1: SubscriptionFactoryWithChain;
+declare const resolver: ResolverFactory;
+/**
+ * Collection of factory functions for creating GraphQL operations
+ */
+declare const loom: {
+  query: QueryFactoryWithChain;
+  resolver: ResolverFactory;
+  field: FieldFactoryWithUtils;
+  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 {
+  /**
+   * 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>;
+}
+interface ResolverMeta<TFields extends Record<string, FieldOrOperation | typeof FIELD_HIDDEN>> {
+  [IS_RESOLVER]: true;
+  fields: TFields;
+  options?: ResolverOptionsWithExtensions;
+}
+/**
+ * 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: ResolverMeta<TFields>;
+  /**
+   * 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"(): ResolverMeta<TFields>;
+  /**
+   * Adds middleware functions to the resolver
+   * @param middlewares - The middleware functions to add
+   */
+  use(...middlewares: Middleware<OmitInUnion<ValueOf<TFields>, typeof FIELD_HIDDEN>>[]): this;
+  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: ResolverMeta<TFields> & {
+    parent: TParent;
+  };
+  /**
+   * Creates a new object chain resolver
+   * @param parent - The parent type definition
+   * @param fields - The fields to resolve
+   * @param options - Optional resolver options
+   */
+  constructor(parent: TParent, fields: TFields, options?: ResolverOptionsWithExtensions<any>);
+  /**
+   * Gets the metadata for the resolver
+   */
+  get "~meta"(): ResolverMeta<TFields> & {
+    parent: TParent;
+  };
+  /**
+   * Sets custom extensions for the resolver
+   * @param extensions - The extensions to add
+   */
+  extensions(extensions: Pick<GraphQLObjectTypeConfig<any, any>, "extensions">["extensions"]): this;
+}
+/**
+ * Type for the executor of a resolver
+ * @template TFields - The fields or operations to resolve
+ */
+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 };
+//#endregion
+//#region src/utils/middleware.d.ts
+/**
+ * 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[];
+//#endregion
+//#region src/utils/object.d.ts
+/**
+ * Creates an object map with the same keys as `map` and values generated by
+ * running each value of `record` thru `fn`.
+ */
+declare function mapValue<T, V>(record: Record<string, T>, fn: (value: T, key: string) => V | typeof mapValue.SKIP): Record<string, V>;
+declare namespace mapValue {
+  var SKIP: unique symbol;
+}
+declare function toObjMap<T>(obj: Maybe<ReadOnlyObjMapLike<T>>): ReadOnlyObjMap<T>;
+declare function notNullish<T>(x: T | undefined | null): x is T;
+declare function deepMerge<T extends Record<string, any>>(...objects: (T | null | undefined)[]): T;
+/**
+ * Wraps the provided data in an object with a single key `"~meta"`.
+ *
+ * @template T - The type of the data to be wrapped.
+ * @param {T} data - The data to be wrapped.
+ * @returns {{ "~meta": T }} - An object with a single key `"~meta"` containing the provided data.
+ * @example
+ * const originalData = { key: "value" };
+ * const metaData = meta(originalData);
+ * console.log(metaData); // Output: { "~meta": { key: "value" } }
+ */
+declare function meta<T>(data: T): {
+  "~meta": T;
+};
+type Maybe<T> = null | undefined | T;
+type ReadOnlyObjMapLike<T> = ReadOnlyObjMap<T> | {
+  readonly [key: string]: T;
+};
+interface ReadOnlyObjMap<T> {
+  readonly [key: string]: T;
+}
+//#endregion
+//#region src/utils/parse-resolving-fields.d.ts
+/**
+ * Represents the state of field resolution in a GraphQL query.
+ */
+interface ResolvingFields {
+  /**
+   * Fields explicitly requested in the GraphQL query
+   */
+  requestedFields: ReadonlySet<string>;
+  /**
+   * Fields that are derived from other fields (computed fields)
+   */
+  derivedFields: ReadonlySet<string>;
+  /**
+   * Fields that derived fields depend on
+   */
+  derivedDependencies: ReadonlySet<string>;
+  /**
+   * Final set of fields that need to be resolved, after processing derived fields
+   */
+  selectedFields: ReadonlySet<string>;
+}
+/**
+ * Analyzes and processes field resolution in a GraphQL query deeply.
+ *
+ * @param payload - The resolver payload containing the current field resolution context
+ * @param [maxDepth=Infinity] - Maximum depth of nested fields to parse
+ * @returns A map of field paths to their resolving fields
+ */
+declare function getDeepResolvingFields(payload: Pick<ResolverPayload, "info">, maxDepth?: number): Map<string, ResolvingFields>;
+/**
+ * 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>;
+//#endregion
+//#region src/utils/string.d.ts
+declare function pascalCase(str: string): string;
+declare function capitalize<T extends string>(str: T): Capitalize<T>;
+declare function screamingSnakeCase(str: string): string;
+//#endregion
+//#region src/utils/error.d.ts
+declare function markErrorLocation<TError>(error: TError, ...locations: string[]): TError;
+declare function tryIn<T>(func: () => T, ...locations: string[]): T;
+/**
+ * mark message with location
+ * @param message origin message
+ * @param locations where error happened
+ * @returns message with location
+ * @example markLocation("error", "banana") // "[banana] hello"
+ * @example markLocation("error", fruit, banana) // "[fruit.banana] error"
+ * @example markLocation("[banana] error", "fruit") // "[fruit.banana] error"
+ * @example markLocation("[fruit.banana] error", "favorite") // "[favorite.fruit.banana] error"
+ */
+declare function markLocation(message: string, ...locations: string[]): string;
+//#endregion
+//#region src/utils/loader.d.ts
+type BatchLoadFn<TKey, TData> = (keys: TKey[]) => Promise<(TData | Error)[]>;
+/**
+ * GraphQL Loom built-in data loader.
+ */
+declare abstract class LoomDataLoader<TKey, TData> {
+  protected abstract batchLoad(keys: TKey[]): Promise<(TData | Error)[]>;
+  protected results: Map<TKey, Promise<TData>>;
+  protected resolvers: Map<TKey, [resolve: (value: TData | PromiseLike<TData>) => void, reject: (reason?: any) => void]>;
+  constructor();
+  /**
+   * Load data for a given key.
+   * @param key - The key to load data for.
+   * @returns A promise that resolves to the loaded data.
+   */
+  load(key: TKey): Promise<TData>;
+  /**
+   * Clear the cache and reset the loader.
+   */
+  clear(): void;
+  protected executeBatchLoad(): Promise<void>;
+  protected nextTickPromise?: Promise<void>;
+  protected nextTickBatchLoad(): Promise<void>;
+  static nextTick(): Promise<void>;
+}
+declare class EasyDataLoader<TKey, TData> extends LoomDataLoader<TKey, TData> {
+  protected readonly batchLoadFn: BatchLoadFn<TKey, TData>;
+  protected batchLoad(keys: TKey[]): Promise<(TData | Error)[]>;
+  constructor(batchLoadFn: BatchLoadFn<TKey, TData>);
+}
+//#endregion
+//#region src/utils/context.d.ts
+/**
+ * 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>;
+//#endregion
+//#region src/schema/schema-weaver.d.ts
+interface SchemaWeaver {
+  vendor: string;
+  getGraphQLType: (schema: any) => GraphQLOutputType;
+}
+declare function isSchemaVendorWeaver(some: any): some is SchemaWeaver;
+//#endregion
+//#region src/schema/weaver-context.d.ts
+interface WeaverContext {
+  id: number;
+  loomObjectMap: Map<GraphQLObjectType, LoomObjectType>;
+  loomUnionMap: Map<GraphQLUnionType, GraphQLUnionType>;
+  inputMap: Map<GraphQLObjectType | GraphQLInterfaceType, GraphQLInputObjectType>;
+  interfaceMap: Map<GraphQLObjectType, GraphQLInterfaceType>;
+  configs: Map<string | symbol, WeaverConfig>;
+  getConfig: <TConfig extends WeaverConfig>(key: TConfig[typeof WEAVER_CONFIG]) => TConfig | undefined;
+  setConfig<TConfig extends WeaverConfig>(config: TConfig): void;
+  deleteConfig: <TConfig extends WeaverConfig>(key: TConfig[typeof WEAVER_CONFIG]) => void;
+  namedTypes: Map<string, GraphQLOutputType>;
+  memoNamedType<TGraphQLType extends GraphQLOutputType = GraphQLOutputType>(gqlType: TGraphQLType): TGraphQLType;
+  getNamedType<T extends GraphQLOutputType>(name: string): T | undefined;
+  names: WeakMap<object, string>;
+  vendorWeavers: Map<string, SchemaWeaver>;
+}
+interface WeaverConfig {
+  [WEAVER_CONFIG]: string | symbol;
+  vendorWeaver?: SchemaWeaver;
+}
+declare function initWeaverContext(): WeaverContext;
+declare namespace initWeaverContext {
+  var increasingID: number;
+}
+type GlobalContextRequiredKeys = "names" | "getConfig" | "setConfig" | "deleteConfig" | "getNamedType" | "memoNamedType";
+interface GlobalWeaverContext extends Partial<Omit<WeaverContext, GlobalContextRequiredKeys>>, Pick<WeaverContext, GlobalContextRequiredKeys> {
+  value?: WeaverContext;
+  useConfig<TConfig extends WeaverConfig, TCallback extends () => any>(config: TConfig, callback: TCallback): ReturnType<TCallback>;
+  GraphQLTypes: WeakMap<object, GraphQLOutputType>;
+  getGraphQLType<TGraphQLType extends GraphQLOutputType = GraphQLOutputType>(origin: object): TGraphQLType | undefined;
+  memoGraphQLType<TGraphQLType extends GraphQLOutputType = GraphQLOutputType>(origin: object, gqlType: TGraphQLType): TGraphQLType;
+}
+declare const weaverContext: GlobalWeaverContext;
+declare function provideWeaverContext<T>(func: () => T, value: WeaverContext | undefined): T;
+declare namespace provideWeaverContext {
+  var inherit: <T>(func: () => T) => () => T;
+}
+/**
+ * collect names for schemas
+ * @param namesList - names to collect
+ * @returns namesRecord
+ */
+declare function collectNames<TRecords extends Record<string, object>[]>(...namesList: TRecords): UnionToIntersection<TRecords[number]>;
+/**
+ * collect name for schema
+ * @param name - name for
+ * @param schema - schema to be named
+ * @returns schema
+ */
+declare function collectName<TSchema extends object>(name: string, schema: TSchema): TSchema;
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
+//#endregion
+//#region src/schema/object.d.ts
+declare class LoomObjectType extends GraphQLObjectType {
+  protected extraFields: Map<string, BaseField>;
+  protected hiddenFields: Set<string>;
+  static AUTO_ALIASING: "__gqloom_auto_aliasing";
+  protected weaverContext: WeaverContext;
+  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;
+    globalOptions?: ResolverOptions;
+  });
+  protected hasExplicitName?: boolean;
+  protected _aliases: string[];
+  get aliases(): string[];
+  addAlias(name: string): void;
+  protected renameByAliases(): void;
+  hideField(name: string): 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, 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: ResolverOptions<FieldOrOperation> | undefined;
+    weaverContext: WeaverContext;
+  };
+}
+declare const OPERATION_OBJECT_NAMES: Set<string>;
+declare function getCacheType(gqlType: GraphQLOutputType, options?: {
+  weaverContext?: WeaverContext;
+  resolverOptions?: ResolverOptions;
+  fieldName?: string;
+  parent?: LoomObjectType;
+}): GraphQLOutputType;
+//#endregion
+//#region src/schema/types.d.ts
+interface CoreSchemaWeaverConfigOptions extends GraphQLSchemaConfig {
+  getInputObjectName?: (name: string) => string;
+  weaverContext?: WeaverContext;
+}
+interface CoreSchemaWeaverConfig extends WeaverConfig, CoreSchemaWeaverConfigOptions {
+  [WEAVER_CONFIG]: "gqloom.core.schema";
+}
+//#endregion
+//#region src/schema/schema-loom.d.ts
+interface SchemaWeaverParameters extends Partial<Record<"query" | "mutation" | "subscription", LoomObjectType>>, Pick<GraphQLSchemaConfig, "types"> {}
+declare class GraphQLSchemaLoom {
+  query?: LoomObjectType;
+  mutation?: LoomObjectType;
+  subscription?: LoomObjectType;
+  types: Set<GraphQLNamedType>;
+  context: WeaverContext;
+  resolverOptions?: ResolverOptions;
+  /**
+   * Create a Schema Weaver config object
+   * @param config Schema Weaver config options
+   * @returns a Schema Weaver config object
+   */
+  static config(config: CoreSchemaWeaverConfigOptions): CoreSchemaWeaverConfig;
+  constructor({
+    query,
+    mutation,
+    subscription,
+    types
+  }?: SchemaWeaverParameters, context?: WeaverContext);
+  use(...middlewares: Middleware[]): this;
+  add(resolver: 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, modifyParent?: (parent: LoomObjectType) => LoomObjectType): this;
+  protected getOperationObject(type: "query" | "mutation" | "subscription"): LoomObjectType;
+  protected get fieldOptions(): ConstructorParameters<typeof LoomObjectType>[1];
+  static optionsFrom(...inputs: (Resolver | Middleware | SchemaWeaver | WeaverConfig | GraphQLSilk)[]): {
+    context: WeaverContext | undefined;
+    configs: Set<WeaverConfig>;
+    middlewares: Set<Middleware<any>>;
+    resolvers: Set<Resolver>;
+    silks: Set<GraphQLSilk<any, any>>;
+    weavers: Set<SchemaWeaver>;
+  };
+  /**
+   * Weave a GraphQL Schema from resolvers
+   * @param inputs Resolvers, Global Middlewares, WeaverConfigs Or SchemaWeaver
+   * @returns GraphQL Schema
+   */
+  static weave(...inputs: (Resolver | Middleware | SchemaWeaver | WeaverConfig | GraphQLSilk)[]): GraphQLSchema;
+}
+/**
+ * Weave a GraphQL Schema from resolvers
+ * @param inputs Resolvers, Global Middlewares or WeaverConfigs
+ * @returns GraphQL Schema
+ */
+declare const weave: typeof GraphQLSchemaLoom.weave;
+//#endregion
+//#region src/schema/input.d.ts
+interface EnsureInputOptions {
+  fieldName?: string;
+}
+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;
+//#endregion
+//#region src/schema/interface.d.ts
+declare function ensureInterfaceType(gqlType: GraphQLOutputType, interfaceConfig?: Partial<GraphQLInterfaceTypeConfig<any, any>>): GraphQLInterfaceType;
+//#endregion
+//#region src/schema/extensions.d.ts
+interface GQLoomExtensions {
+  defaultValue?: any;
+  gqloom?: GQLoomExtensionAttribute;
+  directives?: DirectiveItem[] | DirectiveRecord;
+}
+interface DirectiveItem {
+  name: string;
+  args?: Record<string, any>;
+}
+type DirectiveRecord = Record<string, Record<string, any>>;
+interface GQLoomExtensionAttribute {
+  directives?: string[];
+}
+//#endregion
+export { BaseChainFactory, BaseField, BatchLoadFn, CallableInputParser, CallableMiddlewareOptions, ChainFactoryOptions, ChainResolver, CoreSchemaWeaverConfig, CoreSchemaWeaverConfigOptions, DirectiveItem, DirectiveRecord, EasyDataLoader, Executor, Field, FieldChainFactory, FieldFactory, FieldFactoryWithResolve, FieldFactoryWithUtils, FieldMeta, FieldOptions, FieldOrOperation, FieldOrOperationType, GQLoomExtensionAttribute, GQLoomExtensions, GlobalWeaverContext, GraphQLFieldOptions, GraphQLSchemaLoom, GraphQLSilk, IChainFactory, InferFieldInput, InferFieldOutput, InferInputI, InferInputO, IsAny, ListSilk, LoomDataLoader, LoomObjectType, MayPromise, Middleware, MiddlewareConfig, MiddlewareOperation, MiddlewareOptions, Mutation, MutationChainFactory, MutationFactory, MutationFactoryWithChain, MutationFactoryWithResolve, MutationOptions, NonNullSilk, NullableSilk, OPERATION_OBJECT_NAMES, ObjectChainResolver, OmitInUnion, OnlyMemoizationPayload, Operation, OperationType, Query, QueryChainFactory, QueryFactory, QueryFactoryWithChain, QueryFactoryWithResolve, QueryOptions, RequireKeys, ResolvableSubscription, Resolver, ResolverFactory, ResolverMeta, ResolverOptions, ResolverOptionsWithExtensions, ResolverOptionsWithParent, ResolverPayload, ResolvingFields, ResolvingOptions, SchemaWeaver, StandardSchemaV1, Subscription, SubscriptionChainFactory, SubscriptionFactory, SubscriptionFactoryWithChain, SubscriptionNeedResolve, SubscriptionOptions, ToExecutorProps, ValueOf, WeaverConfig, WeaverContext, applyMiddlewares, assignContextMap, capitalize, collectName, collectNames, createField, createInputParser, createMutation, createQuery, createSubscription, deepMerge, defaultSubscriptionResolve, ensureInputObjectType, ensureInputType, ensureInterfaceType, field, filterMiddlewares, getCacheType, getDeepResolvingFields, getFieldOptions, getGraphQLType, getMemoizationMap, getOperationOptions, getResolvingFields, getStandardValue, getSubscriptionOptions, initWeaverContext, inputToArgs, isOnlyMemoryPayload, isSchemaVendorWeaver, isSilk, listSilk, loom, mapValue, markErrorLocation, markLocation, meta, mutation$1 as mutation, nonNullSilk, notNullish, nullableSilk, onlyMemoization, parseInputValue, parseResolvingFields, parseSilk, pascalCase, provideWeaverContext, query$1 as query, resolver, screamingSnakeCase, silk, subscription$1 as subscription, symbols_d_exports, toObjMap, tryIn, types_loom_d_exports, weave, weaverContext };