@gqloom/core 0.2.2 → 0.4.0

package/dist/index.d.ts

@@ -1,6 +1,108 @@
-import { GraphQLOutputType, GraphQLObjectTypeConfig, GraphQLFieldConfig, GraphQLResolveInfo, GraphQLScalarType, GraphQLObjectType, GraphQLUnionType, GraphQLInterfaceType, GraphQLInputObjectType, GraphQLSchemaConfig, GraphQLFieldMap, GraphQLNamedType, GraphQLSchema, GraphQLFieldConfigArgumentMap, GraphQLType, GraphQLInputType, GraphQLInterfaceTypeConfig, GraphQLFieldExtensions, GraphQLObjectTypeExtensions } from 'graphql';
+import { GraphQLOutputType, GraphQLObjectTypeConfig, GraphQLFieldConfig, GraphQLResolveInfo, GraphQLScalarType, GraphQLObjectType, GraphQLUnionType, GraphQLInterfaceType, GraphQLInputObjectType, GraphQLSchemaConfig, GraphQLFieldMap, GraphQLNamedType, GraphQLSchema, GraphQLFieldConfigArgumentMap, GraphQLType, GraphQLInputType, GraphQLInterfaceTypeConfig } from 'graphql';
 import { AsyncLocalStorage } from 'async_hooks';
 
+declare namespace v1 {
+    /**
+     * The Standard Schema interface.
+     */
+    interface StandardSchema<Input = unknown, Output = Input> {
+        /**
+         * The Standard Schema properties.
+         */
+        readonly "~standard": StandardSchemaProps<Input, Output>;
+    }
+    /**
+     * The Standard Schema properties interface.
+     */
+    interface StandardSchemaProps<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) => StandardResult<Output> | Promise<StandardResult<Output>>;
+        /**
+         * Inferred types associated with the schema.
+         */
+        readonly types?: StandardTypes<Input, Output> | undefined;
+    }
+    /**
+     * The result interface of the validate function.
+     */
+    type StandardResult<Output> = StandardSuccessResult<Output> | StandardFailureResult;
+    /**
+     * The result interface if validation succeeds.
+     */
+    interface StandardSuccessResult<Output> {
+        /**
+         * The typed output value.
+         */
+        readonly value: Output;
+        /**
+         * The non-existent issues.
+         */
+        readonly issues?: undefined;
+    }
+    /**
+     * The result interface if validation fails.
+     */
+    interface StandardFailureResult {
+        /**
+         * The issues of failed validation.
+         */
+        readonly issues: ReadonlyArray<StandardIssue>;
+    }
+    /**
+     * The issue interface of the failure output.
+     */
+    interface StandardIssue {
+        /**
+         * The error message of the issue.
+         */
+        readonly message: string;
+        /**
+         * The path of the issue, if any.
+         */
+        readonly path?: ReadonlyArray<PropertyKey | StandardPathSegment> | undefined;
+    }
+    /**
+     * The path segment interface of the issue.
+     */
+    interface StandardPathSegment {
+        /**
+         * The key representing a path segment.
+         */
+        readonly key: PropertyKey;
+    }
+    /**
+     * The base types interface of Standard Schema.
+     */
+    interface StandardTypes<Input, Output> {
+        /**
+         * 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.
+     */
+    type InferInput<Schema extends StandardSchema> = NonNullable<Schema["~standard"]["types"]>["input"];
+    /**
+     * Infers the output type of a Standard Schema.
+     */
+    type InferOutput<Schema extends StandardSchema> = NonNullable<Schema["~standard"]["types"]>["output"];
+}
+
 type MayPromise<T> = T | Promise<T>;
 type IsAny<T> = 0 extends 1 & T ? true : false;
 /**
@@ -28,6 +130,36 @@ type WrapPropertyType<TKey extends string, TProperty> = TKey extends `${infer TF
 type ObjectOrNever<T> = T extends object ? T : never;
 type ValueOf<T extends object> = T[keyof T];
 
+/**
+ * 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 assign a WeakMap to an object
+ */
+declare const CONTEXT_MEMORY_MAP_KEY: unique symbol;
+/**
+ * The symbol to set fields to be hidden
+ */
+declare const FIELD_HIDDEN: unique symbol;
+
+declare const symbols_CONTEXT_MEMORY_MAP_KEY: typeof CONTEXT_MEMORY_MAP_KEY;
+declare const symbols_FIELD_HIDDEN: typeof FIELD_HIDDEN;
+declare const symbols_GET_GRAPHQL_TYPE: typeof GET_GRAPHQL_TYPE;
+declare const symbols_RESOLVER_OPTIONS_KEY: typeof RESOLVER_OPTIONS_KEY;
+declare const symbols_WEAVER_CONFIG: typeof WEAVER_CONFIG;
+declare namespace symbols {
+  export { symbols_CONTEXT_MEMORY_MAP_KEY as CONTEXT_MEMORY_MAP_KEY, symbols_FIELD_HIDDEN as FIELD_HIDDEN, symbols_GET_GRAPHQL_TYPE as GET_GRAPHQL_TYPE, symbols_RESOLVER_OPTIONS_KEY as RESOLVER_OPTIONS_KEY, symbols_WEAVER_CONFIG as WEAVER_CONFIG };
+}
+
 type InputSchema<TBaseSchema> = TBaseSchema | Record<string, TBaseSchema> | undefined;
 type InputSchemaToSilk<TSchemaIO extends AbstractSchemaIO, TInput extends InputSchema<TSchemaIO[0]>> = TInput extends undefined ? undefined : TInput extends TSchemaIO[0] ? SchemaToSilk<TSchemaIO, TInput> : {
     [K in keyof TInput]: TInput[K] extends TSchemaIO[0] ? SchemaToSilk<TSchemaIO, TInput[K]> : never;
@@ -50,63 +182,23 @@ interface CallableInputParser<TSchema extends InputSchema<GraphQLSilk>> {
     /**
      * Parse the input and return the
      */
-    (): Promise<InferInputO<TSchema, GraphQLSilkIO>>;
+    (): Promise<v1.StandardResult<InferInputO<TSchema, GraphQLSilkIO>>>;
     /**
      * Result of parsing. Set it to `undefined` then the parser will run again.
      */
-    result: InferInputO<TSchema, GraphQLSilkIO> | undefined;
+    result: v1.StandardResult<InferInputO<TSchema, GraphQLSilkIO>> | undefined;
 }
 declare function createInputParser<TSchema extends InputSchema<GraphQLSilk> | undefined>(schema: TSchema, value: InferInputI<TSchema, GraphQLSilkIO>): CallableInputParser<TSchema>;
-declare function parseInputValue<TSchema extends InputSchema<GraphQLSilk> | undefined>(inputSchema: TSchema, input: any): MayPromise<InferInputO<TSchema, GraphQLSilkIO>>;
+declare function parseInputValue<TSchema extends InputSchema<GraphQLSilk> | undefined>(inputSchema: TSchema, input: any): MayPromise<v1.StandardResult<InferInputO<TSchema, GraphQLSilkIO>>>;
+declare function getStandardValue<T>(result: v1.StandardResult<T>): T;
+declare function getStandardValue<T>(result?: v1.StandardResult<T>): T | undefined;
+declare function getStandardValue<T>(result: v1.StandardResult<T> | null): T | null;
 
-/**
- * The symbol to get GraphQL type for schema
- */
-declare const GET_GRAPHQL_TYPE: unique symbol;
-/**
- * The symbol to validate and transform input to output
- */
-declare const PARSE: unique symbol;
-/**
- * The symbol to get and store weaver config
- */
-declare const WEAVER_CONFIG: unique symbol;
-/**
- * The symbol to get resolver options
- */
-declare const RESOLVER_OPTIONS_KEY: unique symbol;
-/**
- * The symbol to assign a WeakMap to an object
- */
-declare const CONTEXT_MEMORY_MAP_KEY: unique symbol;
-
-declare const symbols_CONTEXT_MEMORY_MAP_KEY: typeof CONTEXT_MEMORY_MAP_KEY;
-declare const symbols_GET_GRAPHQL_TYPE: typeof GET_GRAPHQL_TYPE;
-declare const symbols_PARSE: typeof PARSE;
-declare const symbols_RESOLVER_OPTIONS_KEY: typeof RESOLVER_OPTIONS_KEY;
-declare const symbols_WEAVER_CONFIG: typeof WEAVER_CONFIG;
-declare namespace symbols {
-  export { symbols_CONTEXT_MEMORY_MAP_KEY as CONTEXT_MEMORY_MAP_KEY, symbols_GET_GRAPHQL_TYPE as GET_GRAPHQL_TYPE, symbols_PARSE as PARSE, symbols_RESOLVER_OPTIONS_KEY as RESOLVER_OPTIONS_KEY, symbols_WEAVER_CONFIG as WEAVER_CONFIG };
-}
-
-interface GraphQLSilk<TOutput = any, TInput = any> {
+interface GraphQLSilk<TOutput = any, TInput = any> extends v1.StandardSchema<TInput, TOutput> {
     /**
      * GraphQL type for schema
      */
-    [GET_GRAPHQL_TYPE]: () => GraphQLOutputType;
-    /**
-     * validate and transform input to output
-     */
-    [PARSE]?: (input: TInput) => MayPromise<TOutput>;
-    /**
-     * Input and output type.
-     *
-     * @internal
-     */
-    readonly "~types"?: {
-        readonly input: TInput;
-        readonly output: TOutput;
-    };
+    [GET_GRAPHQL_TYPE]?: () => GraphQLOutputType;
 }
 type AbstractSchemaIO = [
     baseSchema: object,
@@ -115,11 +207,9 @@ type AbstractSchemaIO = [
 ];
 type GraphQLSilkIO = [
     object: GraphQLSilk,
-    input: "~types.input",
-    output: "~types.output"
+    input: "~standard.types.input",
+    output: "~standard.types.output"
 ];
-type InferSilkI<T extends GraphQLSilk> = NonNullable<T["~types"]>["input"];
-type InferSilkO<T extends GraphQLSilk> = NonNullable<T["~types"]>["output"];
 type InferSchemaI<TSchema, TSchemaIO extends AbstractSchemaIO> = InferPropertyType<TSchema, TSchemaIO[1]>;
 type InferSchemaO<TSchema, TSchemaIO extends AbstractSchemaIO> = InferPropertyType<TSchema, TSchemaIO[2]>;
 type SchemaToSilk<TSchemaIO extends AbstractSchemaIO, TSchema extends TSchemaIO[0]> = GraphQLSilk<InferSchemaO<TSchema, TSchemaIO>, InferSchemaI<TSchema, TSchemaIO>>;
@@ -144,7 +234,7 @@ interface FieldOrOperation<TParent extends undefined | GraphQLSilk, TOutput exte
     type: TType;
     input: TInput;
     output: TOutput;
-    resolve: TType extends "field" ? (parent: InferSilkO<NonNullable<TParent>>, input: InferInputI<TInput, GraphQLSilkIO>, options?: ResolvingOptions) => Promise<InferSilkO<TOutput>> : TType extends "subscription" ? (value: any, input: InferInputI<TInput, GraphQLSilkIO>) => Promise<InferSilkO<TOutput>> : (input: InferInputI<TInput, GraphQLSilkIO>, options?: ResolvingOptions) => Promise<InferSilkO<TOutput>>;
+    resolve: TType extends "field" ? (parent: v1.InferOutput<NonNullable<TParent>>, input: InferInputI<TInput, GraphQLSilkIO>, options?: ResolvingOptions) => Promise<v1.InferOutput<TOutput>> : TType extends "subscription" ? (value: any, input: InferInputI<TInput, GraphQLSilkIO>) => Promise<v1.InferOutput<TOutput>> : (input: InferInputI<TInput, GraphQLSilkIO>, options?: ResolvingOptions) => Promise<v1.InferOutput<TOutput>>;
     subscribe?: TType extends "subscription" ? (input: InferInputI<TInput, GraphQLSilkIO>, options?: ResolvingOptions) => MayPromise<AsyncIterator<any>> : undefined;
 }
 type GenericFieldOrOperation = FieldOrOperation<any, any, any, any>;
@@ -159,10 +249,16 @@ interface QueryMutationOptions<TSchemaIO extends AbstractSchemaIO, TOutput exten
     resolve: (input: InferInputO<TInput, TSchemaIO>) => MayPromise<InferSchemaO<TOutput, TSchemaIO>>;
 }
 /**
- * Function to create a GraphQL query or mutation.
+ * Function to create a GraphQL query.
  */
-interface QueryMutationBobbin<TSchemaIO extends AbstractSchemaIO> {
-    <TOutput extends TSchemaIO[0], TInput extends InputSchema<TSchemaIO[0]> = undefined>(output: TOutput, resolveOrOptions: (() => MayPromise<InferSchemaO<TOutput, TSchemaIO>>) | QueryMutationOptions<TSchemaIO, TOutput, TInput>): FieldOrOperation<undefined, SchemaToSilk<TSchemaIO, TOutput>, InputSchemaToSilk<TSchemaIO, TInput>, "query" | "mutation">;
+interface QueryFactory<TSchemaIO extends AbstractSchemaIO> {
+    <TOutput extends TSchemaIO[0], TInput extends InputSchema<TSchemaIO[0]> = undefined>(output: TOutput, resolveOrOptions: (() => MayPromise<InferSchemaO<TOutput, TSchemaIO>>) | QueryMutationOptions<TSchemaIO, TOutput, TInput>): FieldOrOperation<undefined, SchemaToSilk<TSchemaIO, TOutput>, InputSchemaToSilk<TSchemaIO, TInput>, "query">;
+}
+/**
+ * Function to create a GraphQL mutation.
+ */
+interface MutationFactory<TSchemaIO extends AbstractSchemaIO> {
+    <TOutput extends TSchemaIO[0], TInput extends InputSchema<TSchemaIO[0]> = undefined>(output: TOutput, resolveOrOptions: (() => MayPromise<InferSchemaO<TOutput, TSchemaIO>>) | QueryMutationOptions<TSchemaIO, TOutput, TInput>): FieldOrOperation<undefined, SchemaToSilk<TSchemaIO, TOutput>, InputSchemaToSilk<TSchemaIO, TInput>, "mutation">;
 }
 /**
  * Options for External Filed of existing GraphQL Object.
@@ -174,9 +270,13 @@ interface FieldOptions<TSchemaIO extends AbstractSchemaIO, TParent extends TSche
 /**
  * Function to create a GraphQL Field.
  */
-interface FieldBobbin<TSchemaIO extends AbstractSchemaIO> {
+interface FieldFactory<TSchemaIO extends AbstractSchemaIO> {
     <TParent extends TSchemaIO[0], TOutput extends TSchemaIO[0], TInput extends InputSchema<TSchemaIO[0]> = undefined>(output: TOutput, resolveOrOptions: ((parent: InferSchemaO<TParent, TSchemaIO>) => MayPromise<InferSchemaO<TOutput, TSchemaIO>>) | FieldOptions<TSchemaIO, TParent, TOutput, TInput>): FieldOrOperation<SchemaToSilk<TSchemaIO, TParent>, SchemaToSilk<TSchemaIO, TOutput>, InputSchemaToSilk<TSchemaIO, TInput>, "field">;
 }
+interface FieldFactoryWithUtils<TSchemaIO extends AbstractSchemaIO> extends FieldFactory<TSchemaIO> {
+    /** Set fields to be hidden in GraphQL Schema */
+    hidden: typeof FIELD_HIDDEN;
+}
 /**
  * Options for creating a GraphQL Subscription.
  */
@@ -185,20 +285,21 @@ interface SubscriptionOptions<TSchemaIO extends AbstractSchemaIO, TOutput extend
     subscribe: (input: InferInputO<TInput, TSchemaIO>) => MayPromise<AsyncIterator<TValue>>;
     resolve?: (value: TValue, input: InferInputO<TInput, TSchemaIO>) => MayPromise<InferSchemaO<TOutput, TSchemaIO>>;
 }
-interface Subscription<TOutput extends GraphQLSilk, TInput extends InputSchema<GraphQLSilk> = undefined, TValue = InferSilkO<TOutput>> extends FieldOrOperation<undefined, TOutput, TInput, "subscription"> {
-    resolve: (value: TValue, input: InferInputI<TInput, GraphQLSilkIO>) => Promise<InferSilkO<TOutput>>;
+interface Subscription<TOutput extends GraphQLSilk, TInput extends InputSchema<GraphQLSilk> = undefined, TValue = v1.InferOutput<TOutput>> extends FieldOrOperation<undefined, TOutput, TInput, "subscription"> {
+    resolve: (value: TValue, input: InferInputI<TInput, GraphQLSilkIO>) => Promise<v1.InferOutput<TOutput>>;
     subscribe: (input: InferInputI<TInput, GraphQLSilkIO>, options?: ResolvingOptions) => MayPromise<AsyncIterator<TValue>>;
 }
 /**
  * Function to create a GraphQL subscription.
  */
-interface SubscriptionBobbin<TSchemaIO extends AbstractSchemaIO> {
+interface SubscriptionFactory<TSchemaIO extends AbstractSchemaIO> {
     <TOutput extends TSchemaIO[0], TInput extends InputSchema<TSchemaIO[0]> = undefined, TValue = InferSchemaO<TOutput, TSchemaIO>>(output: TOutput, subscribeOrOptions: (() => MayPromise<AsyncIterator<InferSchemaO<TOutput, TSchemaIO>>>) | SubscriptionOptions<TSchemaIO, TOutput, TInput, TValue>): Subscription<SchemaToSilk<TSchemaIO, TOutput>, InputSchemaToSilk<TSchemaIO, TInput>, TValue>;
 }
-interface ResolverBobbin<TSchemaIO extends AbstractSchemaIO> {
-    of<TParent extends TSchemaIO[0], TOperations extends Record<string, FieldOrOperation<SchemaToSilk<TSchemaIO, TParent>, any, any> | FieldOrOperation<undefined, any, any, OperationType>>>(parent: TParent, operationOrFields: TOperations, options?: ResolverOptionsWithExtensions<ValueOf<TOperations>>): TOperations;
+interface ResolverFactory<TSchemaIO extends AbstractSchemaIO> {
+    of<TParent extends TSchemaIO[0], TOperations extends Record<string, FieldOrOperation<SchemaToSilk<TSchemaIO, TParent>, any, any> | FieldOrOperation<undefined, any, any, OperationType> | typeof FIELD_HIDDEN>>(parent: TParent, operationOrFields: TOperations, options?: ResolverOptionsWithExtensions<OmitInUnion<ValueOf<TOperations>, typeof FIELD_HIDDEN>>): TOperations;
     <TOperations extends Record<string, FieldOrOperation<undefined, any, any, OperationType>>>(operations: TOperations, options?: ResolverOptions<ValueOf<TOperations>>): TOperations;
 }
+type OmitInUnion<TUnion, TOmit> = TUnion extends infer T ? T extends TOmit ? never : T : never;
 
 declare function getOperationOptions<T extends FieldOrOperationType = OperationType>(resolveOrOptions: T extends "field" ? ((parent: any) => any) | FieldOptions<any, any, any, any> : (() => any) | QueryMutationOptions<any, any, any>): T extends "field" ? FieldOptions<any, any, any, any> : QueryMutationOptions<any, any, any>;
 declare function getSubscriptionOptions(subscribeOrOptions: (() => any) | SubscriptionOptions<any, any, any, any>): SubscriptionOptions<any, any, any, any>;
@@ -206,16 +307,16 @@ declare function getFieldOptions({ description, deprecationReason, extensions, }
 
 interface MiddlewarePayload<TField extends GenericFieldOrOperation = FieldOrOperation<any, any, any, any>> {
     /** The Output Silk of the field */
-    outputSilk: InferSilkO<InferFieldOutput<TField>>;
+    outputSilk: v1.InferOutput<InferFieldOutput<TField>>;
     /** The previous object, which for a field on the root Query type is often not used. */
-    parent: TField extends FieldOrOperation<infer TParent, any, any, any> ? TParent extends undefined ? undefined : InferSilkO<NonNullable<TParent>> : never;
+    parent: TField extends FieldOrOperation<infer TParent, any, any, any> ? TParent extends undefined ? undefined : v1.InferOutput<NonNullable<TParent>> : never;
     /** A function to parse the input of the field */
     parseInput: TField extends FieldOrOperation<any, any, infer TInput, any> ? CallableInputParser<TInput> : undefined;
     /** The type of the field: `query`, `mutation`, `subscription` or `field` */
     type: FieldOrOperationType;
 }
-type Middleware<TField extends GenericFieldOrOperation = FieldOrOperation<any, any, any, any>> = (next: () => MayPromise<InferSilkO<InferFieldOutput<TField>>>, payload: MiddlewarePayload<TField>) => MayPromise<InferSilkO<InferFieldOutput<TField>>>;
-declare function applyMiddlewares<TField extends GenericFieldOrOperation = FieldOrOperation<any, any, any, any>>(middlewares: Middleware[], resolveFunction: () => MayPromise<InferSilkO<InferFieldOutput<TField>>>, payload: MiddlewarePayload<TField>): Promise<InferSilkO<InferFieldOutput<TField>>>;
+type Middleware<TField extends GenericFieldOrOperation = FieldOrOperation<any, any, any, any>> = (next: () => MayPromise<v1.InferOutput<InferFieldOutput<TField>>>, payload: MiddlewarePayload<TField>) => MayPromise<v1.InferOutput<InferFieldOutput<TField>>>;
+declare function applyMiddlewares<TField extends GenericFieldOrOperation = FieldOrOperation<any, any, any, any>>(middlewares: Middleware[], resolveFunction: () => MayPromise<v1.InferOutput<InferFieldOutput<TField>>>, payload: MiddlewarePayload<TField>): Promise<v1.InferOutput<InferFieldOutput<TField>>>;
 declare function compose<T>(...lists: (T[] | undefined)[]): T[];
 
 /**
@@ -359,11 +460,11 @@ declare function markLocation(message: string, ...locations: string[]): string;
 /**
  * Create a Silk from Scalar.
  */
-declare function silk<TScalar extends GraphQLScalarType>(type: TScalar, parse?: (input: InferScalarExternal<TScalar>) => MayPromise<InferScalarInternal<TScalar>>): GraphQLSilk<InferScalarInternal<TScalar> | undefined, InferScalarInternal<TScalar> | undefined>;
+declare function silk<TScalar extends GraphQLScalarType>(type: TScalar | (() => TScalar), parse?: (value: InferScalarExternal<TScalar>) => v1.StandardResult<InferScalarExternal<TScalar>> | Promise<v1.StandardResult<InferScalarInternal<TScalar>>>): GraphQLSilk<InferScalarInternal<TScalar> | undefined, InferScalarInternal<TScalar> | undefined>;
 /**
  * Create a GraphQLSilk Object.
  */
-declare function silk<TOutput, TInput = TOutput>(type: GraphQLOutputType, parse?: (input: TInput) => MayPromise<TOutput>): GraphQLSilk<TOutput, TInput>;
+declare function silk<TOutput, TInput = TOutput>(type: GraphQLOutputType | (() => GraphQLOutputType), validate?: (value: TInput) => v1.StandardResult<TOutput> | Promise<v1.StandardResult<TOutput>>): GraphQLSilk<TOutput, TInput>;
 declare namespace silk {
     var parse: typeof parseSilk;
     var getType: typeof getGraphQLType;
@@ -371,17 +472,17 @@ declare namespace silk {
     var list: typeof listSilk;
     var nullable: typeof nullableSilk;
 }
-type NonNullSilk<TSilk extends GraphQLSilk<any, any>> = GraphQLSilk<NonNullable<InferSilkO<TSilk>>, NonNullable<InferSilkI<TSilk>>>;
+type NonNullSilk<TSilk extends GraphQLSilk<any, any>> = GraphQLSilk<NonNullable<v1.InferOutput<TSilk>>, NonNullable<v1.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<InferSilkO<TSilk>>, EnsureArray<InferSilkO<TSilk>>>;
+type ListSilk<TSilk extends GraphQLSilk<any, any>> = GraphQLSilk<EnsureArray<v1.InferOutput<TSilk>>, EnsureArray<v1.InferOutput<TSilk>>>;
 /**
  * List Silk.
  */
 declare function listSilk<TSilk extends GraphQLSilk<any, any>>(origin: TSilk): ListSilk<TSilk>;
-type NullableSilk<TSilk extends GraphQLSilk<any, any>> = GraphQLSilk<InferSilkO<TSilk> | null | undefined, InferSilkI<TSilk>>;
+type NullableSilk<TSilk extends GraphQLSilk<any, any>> = GraphQLSilk<v1.InferOutput<TSilk> | null | undefined, v1.InferInput<TSilk>>;
 /**
  * Nullable Silk.
  */
@@ -398,42 +499,49 @@ declare function getGraphQLType(silk: GraphQLSilk): GraphQLOutputType;
  * @param input
  * @returns output
  */
-declare function parseSilk<TSilk extends GraphQLSilk>(silk: TSilk, input: InferSilkI<TSilk>): MayPromise<InferSilkO<TSilk>>;
+declare function parseSilk<TSilk extends GraphQLSilk>(silk: TSilk, input: v1.InferInput<TSilk>): MayPromise<v1.StandardResult<v1.InferOutput<TSilk>>>;
 declare function isSilk(target: any): target is GraphQLSilk;
 type InferScalarInternal<T extends GraphQLScalarType> = T extends GraphQLScalarType<infer TInternal> ? TInternal : never;
 type InferScalarExternal<T extends GraphQLScalarType> = T extends GraphQLScalarType<any, infer TExternal> ? TExternal : never;
 type EnsureArray<T> = T extends Array<infer U> ? U[] : T[];
 
-declare const silkQuery: QueryMutationBobbin<GraphQLSilkIO>;
-declare const silkMutation: QueryMutationBobbin<GraphQLSilkIO>;
-declare const silkField: FieldBobbin<GraphQLSilkIO>;
+declare const query: QueryFactory<GraphQLSilkIO>;
+declare const mutation: MutationFactory<GraphQLSilkIO>;
+declare const field: FieldFactoryWithUtils<GraphQLSilkIO>;
 declare const defaultSubscriptionResolve: (source: any) => any;
-declare const silkSubscription: SubscriptionBobbin<GraphQLSilkIO>;
+declare const subscription: SubscriptionFactory<GraphQLSilkIO>;
 declare const ResolverOptionsMap: WeakMap<object, ResolverOptionsWithParent<GenericFieldOrOperation>>;
 declare function baseResolver(operations: Record<string, FieldOrOperation<any, any, any>>, options: ResolverOptionsWithParent | undefined): Record<string, FieldOrOperation<any, any, any, FieldOrOperationType>>;
-declare const silkResolver: ResolverBobbin<GraphQLSilkIO>;
+declare const resolver: ResolverFactory<GraphQLSilkIO>;
 declare const loom: {
-    query: QueryMutationBobbin<GraphQLSilkIO>;
-    resolver: ResolverBobbin<GraphQLSilkIO>;
-    field: FieldBobbin<GraphQLSilkIO>;
-    subscription: SubscriptionBobbin<GraphQLSilkIO>;
-    mutation: QueryMutationBobbin<GraphQLSilkIO>;
+    query: QueryFactory<GraphQLSilkIO>;
+    resolver: ResolverFactory<GraphQLSilkIO>;
+    field: FieldFactoryWithUtils<GraphQLSilkIO>;
+    subscription: SubscriptionFactory<GraphQLSilkIO>;
+    mutation: MutationFactory<GraphQLSilkIO>;
 };
 
-declare function createResolverBobbin<TSchemaIO extends AbstractSchemaIO>(toSilk: (schema: TSchemaIO[0]) => GraphQLSilk): ResolverBobbin<TSchemaIO>;
-declare function createFieldBobbin<TSchemaIO extends AbstractSchemaIO>(toSilk: (schema: TSchemaIO[0]) => GraphQLSilk, isSchema: (schema: InputSchema<TSchemaIO[0]>) => boolean): FieldBobbin<TSchemaIO>;
-declare function createQueryBobbin<TSchemaIO extends AbstractSchemaIO>(toSilk: (schema: TSchemaIO[0]) => GraphQLSilk, isSchema: (schema: InputSchema<TSchemaIO[0]>) => boolean): QueryMutationBobbin<TSchemaIO>;
-declare function createMutationBobbin<TSchemaIO extends AbstractSchemaIO>(toSilk: (schema: TSchemaIO[0]) => GraphQLSilk, isSchema: (schema: InputSchema<TSchemaIO[0]>) => boolean): QueryMutationBobbin<TSchemaIO>;
-declare function createSubscriptionBobbin<TSchemaIO extends AbstractSchemaIO>(toSilk: (schema: TSchemaIO[0]) => GraphQLSilk, isSchema: (schema: InputSchema<TSchemaIO[0]>) => boolean): SubscriptionBobbin<TSchemaIO>;
+declare function createResolverFactory<TSchemaIO extends AbstractSchemaIO>(toSilk: (schema: TSchemaIO[0]) => GraphQLSilk): ResolverFactory<TSchemaIO>;
+declare function createFieldFactory<TSchemaIO extends AbstractSchemaIO>(toSilk: (schema: TSchemaIO[0]) => GraphQLSilk, isSchema: (schema: InputSchema<TSchemaIO[0]>) => boolean): FieldFactoryWithUtils<TSchemaIO>;
+declare function createQueryFactory<TSchemaIO extends AbstractSchemaIO>(toSilk: (schema: TSchemaIO[0]) => GraphQLSilk, isSchema: (schema: InputSchema<TSchemaIO[0]>) => boolean): QueryFactory<TSchemaIO>;
+declare function createMutationFactory<TSchemaIO extends AbstractSchemaIO>(toSilk: (schema: TSchemaIO[0]) => GraphQLSilk, isSchema: (schema: InputSchema<TSchemaIO[0]>) => boolean): MutationFactory<TSchemaIO>;
+declare function createSubscriptionFactory<TSchemaIO extends AbstractSchemaIO>(toSilk: (schema: TSchemaIO[0]) => GraphQLSilk, isSchema: (schema: InputSchema<TSchemaIO[0]>) => boolean): SubscriptionFactory<TSchemaIO>;
 declare function createLoom<TSchemaIO extends AbstractSchemaIO>(toSilk: (schema: TSchemaIO[0]) => GraphQLSilk, isSchema: (schema: InputSchema<TSchemaIO[0]>) => boolean): {
-    query: QueryMutationBobbin<TSchemaIO>;
-    mutation: QueryMutationBobbin<TSchemaIO>;
-    field: FieldBobbin<TSchemaIO>;
-    resolver: ResolverBobbin<TSchemaIO>;
-    subscription: SubscriptionBobbin<TSchemaIO>;
+    query: QueryFactory<TSchemaIO>;
+    mutation: MutationFactory<TSchemaIO>;
+    field: FieldFactoryWithUtils<TSchemaIO>;
+    resolver: ResolverFactory<TSchemaIO>;
+    subscription: SubscriptionFactory<TSchemaIO>;
 };
 
+interface SchemaVendorWeaver {
+    vendor: string;
+    getGraphQLType: (schema: any) => GraphQLOutputType;
+}
+declare function isSchemaVendorWeaver(some: any): some is SchemaVendorWeaver;
+
 interface WeaverContext {
+    id: number;
     loomObjectMap: Map<GraphQLObjectType, LoomObjectType>;
     loomUnionMap: Map<GraphQLUnionType, GraphQLUnionType>;
     inputMap: Map<GraphQLObjectType | GraphQLInterfaceType, GraphQLInputObjectType>;
@@ -446,11 +554,16 @@ interface WeaverContext {
     memoNamedType<TGraphQLType extends GraphQLOutputType = GraphQLOutputType>(gqlType: TGraphQLType): TGraphQLType;
     getNamedType<T extends GraphQLOutputType>(name: string): T | undefined;
     names: WeakMap<object, string>;
+    vendorWeavers: Map<string, SchemaVendorWeaver>;
 }
 interface WeaverConfig {
     [WEAVER_CONFIG]: string | symbol;
+    vendorWeaver?: SchemaVendorWeaver;
 }
 declare function initWeaverContext(): WeaverContext;
+declare namespace initWeaverContext {
+    var increasingID: number;
+}
 type GlobalContextRequiredKeys = "names" | "getConfig" | "setConfig" | "getNamedType" | "memoNamedType";
 interface GlobalWeaverContext extends Partial<Omit<WeaverContext, GlobalContextRequiredKeys>>, Pick<WeaverContext, GlobalContextRequiredKeys> {
     value?: WeaverContext;
@@ -461,19 +574,29 @@ interface GlobalWeaverContext extends Partial<Omit<WeaverContext, GlobalContextR
 }
 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;
 
 type SilkFieldOrOperation = FieldOrOperation<any, any, any, any>;
 interface FieldConvertOptions {
     optionsForResolving?: ResolvingOptions;
 }
-type SilkResolver = Record<string, FieldOrOperation<any, any, any, any>>;
+type SilkResolver = Record<string, FieldOrOperation<any, any, any, any> | typeof FIELD_HIDDEN>;
 interface CoreSchemaWeaverConfigOptions extends GraphQLSchemaConfig {
     getInputObjectName?: (name: string) => string;
     weaverContext?: WeaverContext;
@@ -483,16 +606,18 @@ interface CoreSchemaWeaverConfig extends WeaverConfig, CoreSchemaWeaverConfigOpt
 }
 
 declare class LoomObjectType extends GraphQLObjectType {
-    extraFields: Map<string, SilkFieldOrOperation>;
-    weaverContext: WeaverContext;
-    resolverOptions?: ResolvingOptions;
+    protected extraFields: Map<string, SilkFieldOrOperation>;
+    protected hiddenFields: Set<string>;
+    protected weaverContext: WeaverContext;
+    protected resolverOptions?: ResolvingOptions;
     constructor(objectOrGetter: string | GraphQLObjectType | GraphQLObjectTypeConfig<any, any> | (() => GraphQLObjectType | GraphQLObjectTypeConfig<any, any>), options?: {
         weaverContext?: WeaverContext;
         resolverOptions?: ResolvingOptions;
     });
+    hideField(name: string): void;
     addField(name: string, resolver: SilkFieldOrOperation): void;
     mergeExtensions(extensions: GraphQLObjectTypeConfig<any, any>["extensions"]): void;
-    private extraField?;
+    private extraFieldMap?;
     getFields(): GraphQLFieldMap<any, any>;
     protected mapToFieldConfig(map: Map<string, SilkFieldOrOperation>): Record<string, GraphQLFieldConfig<any, any>>;
     toFieldConfig(field: SilkFieldOrOperation): GraphQLFieldConfig<any, any>;
@@ -527,6 +652,7 @@ declare class SchemaWeaver {
     constructor({ query, mutation, subscription, types }?: SchemaWeaverParameters, context?: WeaverContext);
     use(...middlewares: Middleware[]): this;
     add(resolver: SilkResolver): this;
+    addVendor(weaver: SchemaVendorWeaver): this;
     addType(silk: GraphQLSilk): this;
     setConfig<TConfig extends WeaverConfig>(config: TConfig): this;
     weaveGraphQLSchema(): GraphQLSchema;
@@ -536,19 +662,20 @@ declare class SchemaWeaver {
         resolverOptions: ResolvingOptions | undefined;
         weaverContext: WeaverContext;
     };
-    static optionsFrom(...inputs: (SilkResolver | Middleware | WeaverConfig | GraphQLSilk)[]): {
+    static optionsFrom(...inputs: (SilkResolver | Middleware | SchemaVendorWeaver | WeaverConfig | GraphQLSilk)[]): {
         context: WeaverContext | undefined;
         configs: Set<WeaverConfig>;
         middlewares: Set<Middleware>;
         resolvers: Set<SilkResolver>;
         silks: Set<GraphQLSilk<any, any>>;
+        weavers: Set<SchemaVendorWeaver>;
     };
     /**
      * Weave a GraphQL Schema from resolvers
      * @param inputs Resolvers, Global Middlewares or WeaverConfigs
      * @returns GraphQ LSchema
      */
-    static weave(...inputs: (SilkResolver | Middleware | WeaverConfig | GraphQLSilk)[]): GraphQLSchema;
+    static weave(...inputs: (SilkResolver | Middleware | SchemaVendorWeaver | WeaverConfig | GraphQLSilk)[]): GraphQLSchema;
 }
 /**
  * Weave a GraphQL Schema from resolvers
@@ -576,6 +703,5 @@ type DirectiveRecord = Record<string, Record<string, any>>;
 interface GQLoomExtensionAttribute {
     directives?: string[];
 }
-declare function mergeExtensions(...extensionsList: (Readonly<GraphQLFieldExtensions<any, any, any> | GraphQLObjectTypeExtensions | GQLoomExtensions> | null | undefined)[]): GraphQLFieldExtensions<any, any, any>;
 
-export { type AbstractSchemaIO, type CallableContextMemoization, type CallableInputParser, ContextMemoization, type CoreSchemaWeaverConfig, type CoreSchemaWeaverConfigOptions, type DirectiveItem, type DirectiveRecord, type FieldBobbin, type FieldConvertOptions, type FieldOptions, type FieldOrOperation, type FieldOrOperationType, type GQLoomExtensionAttribute, type GQLoomExtensions, type GenericFieldOrOperation, type GlobalWeaverContext, type GraphQLFieldOptions, type GraphQLSilk, type GraphQLSilkIO, type InferFieldInput, type InferFieldOutput, type InferFieldParent, type InferInputI, type InferInputO, type InferPropertyType, type InferSchemaI, type InferSchemaO, type InferSilkI, type InferSilkO, type InputSchema, type InputSchemaToSilk, type IsAny, type ListSilk, LoomObjectType, type MayPromise, type Middleware, type MiddlewarePayload, type NonNullSilk, type NullableSilk, type ObjectOrNever, type OnlyMemoizationPayload, type OperationType, type QueryMutationBobbin, type QueryMutationOptions, type ResolverBobbin, type ResolverOptions, ResolverOptionsMap, type ResolverOptionsWithExtensions, type ResolverOptionsWithParent, type ResolverPayload, type ResolvingOptions, symbols as SYMBOLS, type SchemaToSilk, SchemaWeaver, type SilkFieldOrOperation, type SilkResolver, type Subscription, type SubscriptionBobbin, type SubscriptionOptions, type ValueOf, type WeaverConfig, type WeaverContext, type WrapPropertyType, applyMiddlewares, baseResolver, collectNames, compose, createFieldBobbin, createInputParser, createLoom, createMemoization, createMutationBobbin, createQueryBobbin, createResolverBobbin, createSubscriptionBobbin, deepMerge, defaultSubscriptionResolve, ensureInputObjectType, ensureInputType, ensureInterfaceType, getCacheType, getFieldOptions, getGraphQLType, getOperationOptions, getSubscriptionOptions, initWeaverContext, inputToArgs, isOnlyMemoryPayload, isSilk, listSilk, loom, mapValue, markErrorLocation, markLocation, mergeExtensions, nonNullSilk, notNullish, nullableSilk, onlyMemoization, parseInputValue, parseSilk, provideWeaverContext, resolverPayloadStorage, silk, silkField, silkMutation, silkQuery, silkResolver, silkSubscription, toObjMap, tryIn, useContext, useMemoizationMap, useResolverPayload, weave, weaverContext };
+export { type AbstractSchemaIO, type CallableContextMemoization, type CallableInputParser, ContextMemoization, type CoreSchemaWeaverConfig, type CoreSchemaWeaverConfigOptions, type DirectiveItem, type DirectiveRecord, type FieldConvertOptions, type FieldFactory, type FieldFactoryWithUtils, type FieldOptions, type FieldOrOperation, type FieldOrOperationType, type GQLoomExtensionAttribute, type GQLoomExtensions, type GenericFieldOrOperation, type GlobalWeaverContext, type GraphQLFieldOptions, type GraphQLSilk, type GraphQLSilkIO, type InferFieldInput, type InferFieldOutput, type InferFieldParent, type InferInputI, type InferInputO, type InferPropertyType, type InferSchemaI, type InferSchemaO, type InputSchema, type InputSchemaToSilk, type IsAny, type ListSilk, LoomObjectType, type MayPromise, type Middleware, type MiddlewarePayload, type MutationFactory, type NonNullSilk, type NullableSilk, type ObjectOrNever, type OnlyMemoizationPayload, type OperationType, type QueryFactory, type QueryMutationOptions, type ResolverFactory, type ResolverOptions, ResolverOptionsMap, type ResolverOptionsWithExtensions, type ResolverOptionsWithParent, type ResolverPayload, type ResolvingOptions, symbols as SYMBOLS, type SchemaToSilk, type SchemaVendorWeaver, SchemaWeaver, type SilkFieldOrOperation, type SilkResolver, type Subscription, type SubscriptionFactory, type SubscriptionOptions, type ValueOf, type WeaverConfig, type WeaverContext, type WrapPropertyType, applyMiddlewares, baseResolver, collectName, collectNames, compose, createFieldFactory, createInputParser, createLoom, createMemoization, createMutationFactory, createQueryFactory, createResolverFactory, createSubscriptionFactory, deepMerge, defaultSubscriptionResolve, ensureInputObjectType, ensureInputType, ensureInterfaceType, field, getCacheType, getFieldOptions, getGraphQLType, getOperationOptions, getStandardValue, getSubscriptionOptions, initWeaverContext, inputToArgs, isOnlyMemoryPayload, isSchemaVendorWeaver, isSilk, listSilk, loom, mapValue, markErrorLocation, markLocation, mutation, nonNullSilk, notNullish, nullableSilk, onlyMemoization, parseInputValue, parseSilk, provideWeaverContext, query, resolver, resolverPayloadStorage, silk, subscription, toObjMap, tryIn, useContext, useMemoizationMap, useResolverPayload, v1, weave, weaverContext };