@gqloom/core 0.10.0 → 0.11.0

package/dist/index.d.cts

@@ -1,484 +1,2 @@
-import { F as FieldOptions, Q as QueryOptions, M as MutationOptions, R as ResolverPayload, S as SubscriptionOptions, G as GraphQLFieldOptions, a as StandardSchemaV1, b as GraphQLSilk, c as MayPromise, d as Query, e as QueryChainFactory, f as QueryFactoryWithChain, g as Mutation, h as MutationChainFactory, i as MutationFactoryWithChain, j as Field, k as FieldChainFactory, l as FieldFactoryWithUtils, m as SubscriptionChainFactory, n as Subscription, o as SubscriptionFactoryWithChain, O as Operation, p as FIELD_HIDDEN, q as ResolverOptionsWithExtensions, r as OmitInUnion, V as ValueOf, s as ResolverOptions, t as FieldOrOperation, u as Resolver, I as IS_RESOLVER, v as Middleware, w as InferInputI, W as WEAVER_CONFIG, B as BaseField } from './context-uzUlbx3r.cjs';
-export { $ as BaseChainFactory, ai as CallableInputParser, D as CallableMiddlewareOptions, _ as ChainFactoryOptions, ae as FieldFactory, a4 as FieldFactoryWithResolve, ag as FieldMeta, a9 as FieldOrOperationType, Z as IChainFactory, aa as InferFieldInput, ab as InferFieldOutput, ah as InferInputO, y as IsAny, a5 as Loom, E as MiddlewareConfig, A as MiddlewareOperation, C as MiddlewareOptions, ad as MutationFactory, a3 as MutationFactoryWithResolve, P as OnlyMemoizationPayload, a8 as OperationType, ac as QueryFactory, a2 as QueryFactoryWithResolve, z as RequireKeys, a0 as ResolvableSubscription, a6 as ResolverOptionsWithParent, K as ResolvingFields, a7 as ResolvingOptions, x as SYMBOLS, af as SubscriptionFactory, a1 as SubscriptionNeedResolve, H as applyMiddlewares, Y as assignContextMap, aj as createInputParser, J as filterMiddlewares, X as getMemoizationMap, L as getResolvingFields, al as getStandardValue, U as isOnlyMemoryPayload, T as onlyMemoization, ak as parseInputValue, N as parseResolvingFields } from './context-uzUlbx3r.cjs';
-import { GraphQLFieldExtensions, GraphQLScalarType, GraphQLObjectType, GraphQLOutputType, GraphQLNullableType, GraphQLList, GraphQLNonNull, GraphQLObjectTypeConfig, GraphQLUnionType, GraphQLInterfaceType, GraphQLInputObjectType, GraphQLFieldMap, GraphQLFieldConfig, GraphQLSchemaConfig, GraphQLNamedType, GraphQLSchema, GraphQLFieldConfigArgumentMap, GraphQLType, GraphQLInputType, GraphQLInterfaceTypeConfig } from 'graphql';
-
-declare function getOperationOptions(resolveOrOptions: ((...args: any) => any) | FieldOptions<any, any, any, any> | QueryOptions<any, any> | MutationOptions<any, any>): any;
-declare function getSubscriptionOptions(subscribeOrOptions: ((payload: ResolverPayload | undefined) => any) | SubscriptionOptions<any, any, any>): SubscriptionOptions<any, any, any>;
-declare function getFieldOptions({ description, deprecationReason, extensions }: GraphQLFieldOptions, extraExtensions?: GraphQLFieldExtensions<any, any, any>): GraphQLFieldOptions;
-
-/**
- * Create a Silk from Scalar.
- */
-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[];
-
-/**
- * Creates a GraphQL query resolver
- * @param output - The output type definition for the query
- * @param resolveOrOptions - Either a resolve function or options object
- * @returns A GraphQL query resolver
- */
-declare const createQuery: (output: GraphQLSilk<any, any>, resolveOrOptions?: ((...args: any) => MayPromise<unknown>) | QueryOptions<any, any>) => Query<any, any> | QueryChainFactory<never, void>;
-/**
- * Factory function for creating GraphQL queries with chainable configuration
- */
-declare const query: QueryFactoryWithChain;
-/**
- * Creates a GraphQL mutation resolver
- * @param output - The output type definition for the mutation
- * @param resolveOrOptions - Either a resolve function or options object
- * @returns A GraphQL mutation resolver
- */
-declare const createMutation: (output: GraphQLSilk<any, any>, resolveOrOptions?: (() => MayPromise<unknown>) | MutationOptions<any, any>) => Mutation<any, any> | MutationChainFactory<never, undefined>;
-/**
- * Factory function for creating GraphQL mutations with chainable configuration
- */
-declare const mutation: MutationFactoryWithChain;
-/**
- * Creates a GraphQL field resolver
- * @param output - The output type definition for the field
- * @param resolveOrOptions - Either a resolve function or options object
- * @returns A GraphQL field resolver
- */
-declare const createField: (output: GraphQLSilk<any, any>, resolveOrOptions?: (() => unknown) | FieldOptions<GraphQLSilk, GraphQLSilk, GraphQLSilk | Record<string, GraphQLSilk> | void, string[] | undefined>) => Field<any, any, any, any> | FieldChainFactory<never, undefined, undefined>;
-/**
- * Factory function for creating GraphQL fields with chainable configuration
- */
-declare const field: FieldFactoryWithUtils;
-/**
- * Default subscription resolver that returns the source value
- * @param source - The source value to resolve
- */
-declare const defaultSubscriptionResolve: (source: any) => any;
-/**
- * Creates a GraphQL subscription resolver
- * @param output - The output type definition for the subscription
- * @returns A subscription chain factory
- */
-declare function createSubscription(output: GraphQLSilk<any, any>): SubscriptionChainFactory;
-/**
- * Creates a GraphQL subscription resolver with subscribe function
- * @param output - The output type definition for the subscription
- * @param subscribeOrOptions - Either a subscribe function or options object
- * @returns A GraphQL subscription resolver
- */
-declare function createSubscription(output: GraphQLSilk<any, any>, subscribeOrOptions: (() => MayPromise<AsyncIterator<unknown>>) | SubscriptionOptions<any, any, any>): Subscription<any, any, any>;
-/**
- * Factory function for creating GraphQL subscriptions with chainable configuration
- */
-declare const subscription: SubscriptionFactoryWithChain;
-declare const resolver: ResolverFactory;
-/**
- * Collection of factory functions for creating GraphQL operations
- */
-declare const loom: {
-    query: QueryFactoryWithChain;
-    resolver: ResolverFactory;
-    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>;
-}
-/**
- * Base class for chain resolvers
- * @template TFields - The fields or operations to resolve
- */
-declare class ChainResolver<TFields extends Record<string, FieldOrOperation | typeof FIELD_HIDDEN>> implements Resolver {
-    protected meta: {
-        [IS_RESOLVER]: true;
-        fields: TFields;
-        options?: ResolverOptionsWithExtensions;
-    };
-    /**
-     * Creates a new chain resolver
-     * @param fields - The fields or operations to resolve
-     * @param options - Optional resolver options
-     */
-    constructor(fields: TFields, options?: ResolverOptionsWithExtensions<any>);
-    /**
-     * Gets the metadata for the resolver
-     */
-    get "~meta"(): typeof this.meta;
-    /**
-     * Adds middleware functions to the resolver
-     * @param middlewares - The middleware functions to add
-     */
-    use(...middlewares: Middleware<OmitInUnion<ValueOf<TFields>, typeof FIELD_HIDDEN>>[]): this;
-    toExecutor(...middlewares: Middleware[]): Executor<TFields>;
-    protected toExecutorOperation(field: FieldOrOperation | typeof FIELD_HIDDEN, executorMiddlewares: Middleware[]): ((...args: any) => any) | undefined;
-}
-/**
- * Class for resolving object types
- * @template TParent - The parent type
- * @template TFields - The fields to resolve
- */
-declare class ObjectChainResolver<TParent extends GraphQLSilk, TFields extends Record<string, FieldOrOperation | typeof FIELD_HIDDEN>> extends ChainResolver<TFields> {
-    protected meta: {
-        [IS_RESOLVER]: true;
-        fields: TFields;
-        parent: TParent;
-        options?: ResolverOptionsWithExtensions;
-    };
-    /**
-     * 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"(): typeof this.meta;
-    /**
-     * 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;
-};
-
-/**
- * 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;
-}
-
-declare function pascalCase(str: string): string;
-declare function capitalize<T extends string>(str: T): Capitalize<T>;
-declare function screamingSnakeCase(str: string): string;
-
-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;
-
-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>);
-}
-
-interface SchemaWeaver {
-    vendor: string;
-    getGraphQLType: (schema: any) => GraphQLOutputType;
-}
-declare function isSchemaVendorWeaver(some: any): some is SchemaWeaver;
-
-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;
-
-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;
-
-interface CoreSchemaWeaverConfigOptions extends GraphQLSchemaConfig {
-    getInputObjectName?: (name: string) => string;
-    weaverContext?: WeaverContext;
-}
-interface CoreSchemaWeaverConfig extends WeaverConfig, CoreSchemaWeaverConfigOptions {
-    [WEAVER_CONFIG]: "gqloom.core.schema";
-}
-
-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;
-
-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;
-
-declare function ensureInterfaceType(gqlType: GraphQLOutputType, interfaceConfig?: Partial<GraphQLInterfaceTypeConfig<any, any>>): GraphQLInterfaceType;
-
-interface GQLoomExtensions {
-    defaultValue?: any;
-    gqloom?: GQLoomExtensionAttribute;
-    directives?: DirectiveItem[] | DirectiveRecord;
-}
-interface DirectiveItem {
-    name: string;
-    args?: Record<string, any>;
-}
-type DirectiveRecord = Record<string, Record<string, any>>;
-interface GQLoomExtensionAttribute {
-    directives?: string[];
-}
-
-export { BaseField, type BatchLoadFn, ChainResolver, type CoreSchemaWeaverConfig, type CoreSchemaWeaverConfigOptions, type DirectiveItem, type DirectiveRecord, EasyDataLoader, type Executor, Field, FieldChainFactory, FieldFactoryWithUtils, FieldOptions, FieldOrOperation, type GQLoomExtensionAttribute, type GQLoomExtensions, type GlobalWeaverContext, GraphQLFieldOptions, GraphQLSchemaLoom, GraphQLSilk, InferInputI, type ListSilk, LoomDataLoader, LoomObjectType, MayPromise, Middleware, Mutation, MutationChainFactory, MutationFactoryWithChain, MutationOptions, type NonNullSilk, type NullableSilk, OPERATION_OBJECT_NAMES, ObjectChainResolver, OmitInUnion, Operation, Query, QueryChainFactory, QueryFactoryWithChain, QueryOptions, Resolver, type ResolverFactory, ResolverOptions, ResolverOptionsWithExtensions, ResolverPayload, type SchemaWeaver, StandardSchemaV1, Subscription, SubscriptionChainFactory, SubscriptionFactoryWithChain, SubscriptionOptions, type ToExecutorProps, ValueOf, type WeaverConfig, type WeaverContext, capitalize, collectName, collectNames, createField, createMutation, createQuery, createSubscription, deepMerge, defaultSubscriptionResolve, ensureInputObjectType, ensureInputType, ensureInterfaceType, field, getCacheType, getFieldOptions, getGraphQLType, getOperationOptions, getSubscriptionOptions, initWeaverContext, inputToArgs, isSchemaVendorWeaver, isSilk, listSilk, loom, mapValue, markErrorLocation, markLocation, meta, mutation, nonNullSilk, notNullish, nullableSilk, parseSilk, pascalCase, provideWeaverContext, query, resolver, screamingSnakeCase, silk, subscription, toObjMap, tryIn, weave, weaverContext };
+import { 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, nonNullSilk, notNullish, nullableSilk, onlyMemoization, parseInputValue, parseResolvingFields, parseSilk, pascalCase, provideWeaverContext, query, resolver, screamingSnakeCase, silk, subscription, symbols_d_exports, toObjMap, tryIn, types_loom_d_exports, weave, weaverContext } from "./index-DUqXX1Tm.cjs";
+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, types_loom_d_exports as Loom, 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, symbols_d_exports as SYMBOLS, 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, nonNullSilk, notNullish, nullableSilk, onlyMemoization, parseInputValue, parseResolvingFields, parseSilk, pascalCase, provideWeaverContext, query, resolver, screamingSnakeCase, silk, subscription, toObjMap, tryIn, weave, weaverContext };