@soda-gql/core 0.10.1 → 0.11.0

package/dist/{index-DaREzuQm.d.ts → index-BcA2XPEk.d.ts}

@@ -1,4 +1,4 @@
-import { At as ConstValue, B as UnionMemberName, C as AnyFieldName, D as InferInputKind, Dt as InputDepthOverrides, F as OperationType, H as AnyVarRef, I as PickTypeSpecifierByFieldName, K as VarRef, L as ResolveInputProfileFromMeta, Mt as FieldPath, N as ObjectFieldRecord, O as InferInputProfile, S as AllInputTypeNames, T as AnyTypeName, U as AnyVarRefBrand, X as AnyDefaultValue, _ as FragmentMetadataBuilder, _t as PrimitiveTypeProfile, a as DefaultMetadataAdapter, at as OutputEnumSpecifier, bt as GetSignature, c as ExtractAdapterTypes, ct as OutputScalarSpecifier, ft as OutputTypenameSpecifier, gt as ObjectTypeProfile, ht as GetModifiedType, i as DefaultAdapter, it as InputTypeSpecifiers, k as InferOutputProfile, mt as GetConstAssignableType, n as AnyAdapter, nt as InputTypeKind, ot as OutputInferrableTypeSpecifier, p as OperationDocumentTransformer, pt as OutputUnionSpecifier, r as AnyMetadataAdapter, rt as InputTypeSpecifier, s as DocumentTransformer, st as OutputObjectSpecifier, t as Adapter, ut as OutputTypeSpecifier, vt as TypeProfile, w as AnyGraphqlSchema, xt as TypeModifier, y as MetadataBuilder, yt as ApplyTypeModifier } from "./index-CnQ5XVCf.js";
+import { At as ConstValue, B as UnionMemberName, C as AnyFieldName, D as InferInputKind, Dt as InputDepthOverrides, F as OperationType, H as AnyVarRef, I as PickTypeSpecifierByFieldName, K as VarRef, L as ResolveInputProfileFromMeta, Mt as FieldPath, N as ObjectFieldRecord, O as InferInputProfile, S as AllInputTypeNames, T as AnyTypeName, U as AnyVarRefBrand, X as AnyDefaultValue, _ as FragmentMetadataBuilder, _t as PrimitiveTypeProfile, a as DefaultMetadataAdapter, at as OutputEnumSpecifier, bt as GetSignature, c as ExtractAdapterTypes, ct as OutputScalarSpecifier, ft as OutputTypenameSpecifier, gt as ObjectTypeProfile, ht as GetModifiedType, i as DefaultAdapter, it as InputTypeSpecifiers, k as InferOutputProfile, mt as GetConstAssignableType, n as AnyAdapter, nt as InputTypeKind, ot as OutputInferrableTypeSpecifier, p as OperationDocumentTransformer, pt as OutputUnionSpecifier, r as AnyMetadataAdapter, rt as InputTypeSpecifier, s as DocumentTransformer, st as OutputObjectSpecifier, t as Adapter, ut as OutputTypeSpecifier, vt as TypeProfile, w as AnyGraphqlSchema, xt as TypeModifier, y as MetadataBuilder, yt as ApplyTypeModifier } from "./index-DbANHktR.js";
 import { ConstValueNode, NamedTypeNode, OperationTypeNode, TypeNode, ValueNode, VariableDefinitionNode } from "graphql";
 import { TypedDocumentNode } from "@graphql-typed-document-node/core";
 
@@ -225,7 +225,7 @@ type FieldSelectionTemplateOf<TSchema extends AnyGraphqlSchema, TTypeName$1 exte
   union: AnyNestedUnion;
 } : never)> : never;
 /** Resolve the data shape produced by a set of field selections. */
-type InferFields<TSchema extends AnyGraphqlSchema, TFields$1 extends AnyFields> = { [_ in TSchema["label"]]: { [TAliasName in keyof TFields$1]: InferField<TSchema, TFields$1[TAliasName]> } & {} }[TSchema["label"]];
+type InferFields<TSchema extends AnyGraphqlSchema, TFields extends AnyFields> = { [_ in TSchema["label"]]: { [TAliasName in keyof TFields]: InferField<TSchema, TFields[TAliasName]> } & {} }[TSchema["label"]];
 /** Resolve the data shape for a single field reference, including nested objects/unions. */
 type InferField<TSchema extends AnyGraphqlSchema, TSelection extends AnyFieldSelection> = (TSelection extends {
   type: infer TSpecifier extends OutputObjectSpecifier;
@@ -238,20 +238,37 @@ type InferField<TSchema extends AnyGraphqlSchema, TSelection extends AnyFieldSel
 } ? GetModifiedType<InferOutputProfile<TSchema, TSpecifier>, TSpecifier["modifier"]> : never);
 //#endregion
 //#region packages/core/src/composer/build-document.d.ts
+/**
+ * Context for determining if a value should be output as an enum.
+ * Contains the schema for looking up nested input types and the current type specifier.
+ */
+type EnumLookup = {
+  schema: AnyGraphqlSchema;
+  /** Type specifier for the current value. null means enum detection is skipped. */
+  typeSpecifier: InputTypeSpecifier | null;
+};
 /**
  * Converts an assignable input value to a GraphQL AST ValueNode.
  *
  * Handles primitives, arrays, objects, and variable references.
  * Returns null for undefined values (field is omitted).
+ *
+ * @param value - The value to convert
+ * @param enumLookup - Context for enum detection. String values will be output
+ *                     as Kind.ENUM if typeSpecifier indicates an enum type.
  */
-declare const buildArgumentValue: (value: AnyAssignableInputValue) => ValueNode | null;
+declare const buildArgumentValue: (value: AnyAssignableInputValue, enumLookup: EnumLookup) => ValueNode | null;
 /**
  * Converts a constant value to a GraphQL AST ConstValueNode.
  *
  * Unlike `buildArgumentValue`, this only handles literal values
  * (no variable references). Used for default values.
+ *
+ * @param value - The constant value to convert
+ * @param enumLookup - Context for enum detection. String values will be output
+ *                     as Kind.ENUM if typeSpecifier indicates an enum type.
  */
-declare const buildConstValueNode: (value: ConstValue) => ConstValueNode | null;
+declare const buildConstValueNode: (value: ConstValue, enumLookup: EnumLookup) => ConstValueNode | null;
 /**
  * Wraps a named type with modifiers (non-null, list).
  *
@@ -276,15 +293,16 @@ declare const buildOperationTypeNode: (operation: OperationType) => OperationTyp
  * a GraphQL document AST. The result can be used with any GraphQL
  * client that supports TypedDocumentNode.
  *
- * @param options - Operation configuration (name, type, variables, fields)
+ * @param options - Operation configuration (name, type, variables, fields, schema)
  * @returns TypedDocumentNode with inferred input/output types
  */
-declare const buildDocument: <TSchema extends AnyGraphqlSchema, TFields$1 extends AnyFields, TVarDefinitions extends InputTypeSpecifiers>(options: {
+declare const buildDocument: <TSchema extends AnyGraphqlSchema, TFields extends AnyFields, TVarDefinitions extends InputTypeSpecifiers>(options: {
   operationName: string;
   operationType: OperationType;
   variables: TVarDefinitions;
-  fields: TFields$1;
-}) => TypedDocumentNode<InferFields<TSchema, TFields$1>, ConstAssignableInput<TSchema, TVarDefinitions>>;
+  fields: TFields;
+  schema: TSchema;
+}) => TypedDocumentNode<InferFields<TSchema, TFields>, ConstAssignableInput<TSchema, TVarDefinitions>>;
 //#endregion
 //#region packages/core/src/utils/type-utils.d.ts
 type UnionToIntersection<U> = (U extends any ? (x: U) => void : never) extends ((x: infer I) => void) ? I : never;
@@ -479,7 +497,7 @@ declare const empty: () => EmptyObject;
  * tooling `f`/`fields`/`_` aliases provide ergonomic access to GraphQL fields
  * while preserving the original schema information for inference.
  */
-type FieldsBuilder<TSchema extends AnyGraphqlSchema, TTypeName$1 extends keyof TSchema["object"] & string, TVariableDefinitions extends InputTypeSpecifiers, TFields$1 extends AnyFields> = (tools: NoInfer<FieldsBuilderTools<TSchema, TTypeName$1, TVariableDefinitions>>) => TFields$1;
+type FieldsBuilder<TSchema extends AnyGraphqlSchema, TTypeName$1 extends keyof TSchema["object"] & string, TVariableDefinitions extends InputTypeSpecifiers, TFields extends AnyFields> = (tools: NoInfer<FieldsBuilderTools<TSchema, TTypeName$1, TVariableDefinitions>>) => TFields;
 /**
  * Tools provided to field builder callbacks.
  * - `f`: Field selection factories for the current type
@@ -493,7 +511,7 @@ type FieldsBuilderTools<TSchema extends AnyGraphqlSchema, TTypeName$1 extends ke
  * Builder for nested object field selections.
  * Used when a field returns an object type requiring sub-selections.
  */
-type NestedObjectFieldsBuilder<TSchema extends AnyGraphqlSchema, TTypeName$1 extends keyof TSchema["object"] & string, TFields$1 extends AnyNestedObject> = (tools: NoInfer<NestedObjectFieldsBuilderTools<TSchema, TTypeName$1>>) => TFields$1;
+type NestedObjectFieldsBuilder<TSchema extends AnyGraphqlSchema, TTypeName$1 extends keyof TSchema["object"] & string, TFields extends AnyNestedObject> = (tools: NoInfer<NestedObjectFieldsBuilderTools<TSchema, TTypeName$1>>) => TFields;
 /**
  * Tools for nested object builders (no variable access).
  * @internal
@@ -651,7 +669,7 @@ declare abstract class GqlElement<TDefinition extends object, TInfer extends obj
 /**
  * Type alias for any Fragment instance.
  */
-type AnyFragment = Fragment<string, any, AnyFields, any, string | undefined>;
+type AnyFragment = Fragment<string, any, AnyFields, any>;
 /**
  * Type inference metadata for fragments.
  * Access via `typeof fragment.$infer`.
@@ -664,12 +682,12 @@ type FragmentInferMeta<TVariables, TOutput extends object> = {
  * Internal artifact shape produced by fragment evaluation.
  * @internal
  */
-interface FragmentArtifact<TTypeName$1 extends string, TVariables extends Partial<AnyAssignableInput> | void, TFields$1 extends Partial<AnyFields>, TKey$1 extends string | undefined = undefined> {
+interface FragmentArtifact<TTypeName$1 extends string, TVariables extends Partial<AnyAssignableInput> | void, TFields extends Partial<AnyFields>> {
   readonly typename: TTypeName$1;
-  readonly key: TKey$1;
+  readonly key: string | undefined;
   readonly schemaLabel: string;
   readonly variableDefinitions: InputTypeSpecifiers;
-  readonly spread: (variables: TVariables) => TFields$1;
+  readonly spread: (variables: TVariables) => TFields;
 }
 declare const __FRAGMENT_BRAND__: unique symbol;
 /**
@@ -682,15 +700,14 @@ declare const __FRAGMENT_BRAND__: unique symbol;
  * @template TVariables - Variables required when spreading
  * @template TFields - The selected fields structure
  * @template TOutput - Inferred output type from selected fields
- * @template TKey - Optional unique key for prebuilt type lookup
  */
-declare class Fragment<TTypeName$1 extends string, TVariables extends Partial<AnyAssignableInput> | void, TFields$1 extends Partial<AnyFields>, TOutput extends object, TKey$1 extends string | undefined = undefined> extends GqlElement<FragmentArtifact<TTypeName$1, TVariables, TFields$1, TKey$1>, FragmentInferMeta<TVariables, TOutput>> implements FragmentArtifact<TTypeName$1, TVariables, TFields$1, TKey$1> {
+declare class Fragment<TTypeName$1 extends string, TVariables extends Partial<AnyAssignableInput> | void, TFields extends Partial<AnyFields>, TOutput extends object> extends GqlElement<FragmentArtifact<TTypeName$1, TVariables, TFields>, FragmentInferMeta<TVariables, TOutput>> implements FragmentArtifact<TTypeName$1, TVariables, TFields> {
   private readonly [__FRAGMENT_BRAND__];
   private constructor();
   /** The GraphQL type name this fragment selects from. */
   get typename(): TTypeName$1;
   /** Optional unique key for prebuilt type lookup. */
-  get key(): TKey$1;
+  get key(): string | undefined;
   /** The schema label this fragment belongs to. */
   get schemaLabel(): string;
   /** Variable definitions for this fragment. */
@@ -699,23 +716,23 @@ declare class Fragment<TTypeName$1 extends string, TVariables extends Partial<An
    * Spreads this fragment's fields into a parent selection.
    * Pass variables if the fragment defines any.
    */
-  get spread(): (variables: TVariables) => TFields$1;
+  get spread(): (variables: TVariables) => TFields;
   /**
    * Creates a new Fragment instance.
    * Prefer using the `gql(({ fragment }) => ...)` API instead.
    * @internal
    */
-  static create<TSchema extends AnyGraphqlSchema, TTypeName$1 extends keyof TSchema["object"] & string, TVariableDefinitions extends InputTypeSpecifiers, TFields$1 extends AnyFields, TKey$1 extends string | undefined = undefined>(define: () => {
+  static create<TSchema extends AnyGraphqlSchema, TTypeName$1 extends keyof TSchema["object"] & string, TVariableDefinitions extends InputTypeSpecifiers, TFields extends AnyFields>(define: () => {
     typename: TTypeName$1;
-    key: TKey$1;
+    key: string | undefined;
     schemaLabel: TSchema["label"];
     variableDefinitions: TVariableDefinitions;
-    spread: (variables: OptionalArg<AssignableInput<TSchema, TVariableDefinitions>>) => TFields$1;
-  }): Fragment<TTypeName$1, OptionalArg<AssignableInput<TSchema, TVariableDefinitions>>, TFields$1 & {
+    spread: (variables: OptionalArg<AssignableInput<TSchema, TVariableDefinitions>>) => TFields;
+  }): Fragment<TTypeName$1, OptionalArg<AssignableInput<TSchema, TVariableDefinitions>>, TFields & {
     [key: symbol]: never;
-  }, InferFields<TSchema, TFields$1> & {
+  }, InferFields<TSchema, TFields> & {
     [key: symbol]: never;
-  }, TKey$1>;
+  }>;
 }
 //#endregion
 //#region packages/core/src/types/element/operation.d.ts
@@ -726,7 +743,7 @@ type AnyOperation = AnyOperationOf<"query"> | AnyOperationOf<"mutation"> | AnyOp
 /**
  * Type alias for an Operation of a specific type.
  */
-type AnyOperationOf<TOperationType$1 extends OperationType> = Operation<TOperationType$1, string, string[], any, AnyFields, any>;
+type AnyOperationOf<TOperationType extends OperationType> = Operation<TOperationType, string, string[], any, AnyFields, any>;
 /**
  * Type inference metadata for operations.
  * Access via `typeof operation.$infer`.
@@ -740,12 +757,12 @@ declare const __OPERATION_BRAND__: unique symbol;
  * Internal artifact shape produced by operation evaluation.
  * @internal
  */
-type OperationArtifact<TOperationType$1 extends OperationType, TOperationName$1 extends string, TVariableNames$1 extends string[], TVariables extends AnyConstAssignableInput, TFields$1 extends Partial<AnyFields>, TData extends object> = {
-  readonly operationType: TOperationType$1;
-  readonly operationName: TOperationName$1;
+type OperationArtifact<TOperationType extends OperationType, TOperationName extends string, TVariableNames extends string[], TVariables extends AnyConstAssignableInput, TFields extends Partial<AnyFields>, TData extends object> = {
+  readonly operationType: TOperationType;
+  readonly operationName: TOperationName;
   readonly schemaLabel: string;
-  readonly variableNames: TVariableNames$1;
-  readonly documentSource: () => TFields$1;
+  readonly variableNames: TVariableNames;
+  readonly documentSource: () => TFields;
   readonly document: TypedDocumentNode<TData, TVariables>;
   readonly metadata?: unknown;
 };
@@ -762,22 +779,22 @@ type OperationArtifact<TOperationType$1 extends OperationType, TOperationName$1
  * @template TFields - Selected fields structure
  * @template TData - Inferred response data type
  */
-declare class Operation<TOperationType$1 extends OperationType, TOperationName$1 extends string, TVariableNames$1 extends string[], TVariables extends AnyConstAssignableInput, TFields$1 extends Partial<AnyFields>, TData extends object> extends GqlElement<OperationArtifact<TOperationType$1, TOperationName$1, TVariableNames$1, TVariables, TFields$1, TData>, OperationInferMeta<TVariables, TData>> implements OperationArtifact<TOperationType$1, TOperationName$1, TVariableNames$1, TVariables, TFields$1, TData> {
+declare class Operation<TOperationType extends OperationType, TOperationName extends string, TVariableNames extends string[], TVariables extends AnyConstAssignableInput, TFields extends Partial<AnyFields>, TData extends object> extends GqlElement<OperationArtifact<TOperationType, TOperationName, TVariableNames, TVariables, TFields, TData>, OperationInferMeta<TVariables, TData>> implements OperationArtifact<TOperationType, TOperationName, TVariableNames, TVariables, TFields, TData> {
   private readonly [__OPERATION_BRAND__];
   private constructor();
   /** The operation type: 'query', 'mutation', or 'subscription'. */
-  get operationType(): TOperationType$1;
+  get operationType(): TOperationType;
   /** The unique name of this operation. */
-  get operationName(): TOperationName$1;
+  get operationName(): TOperationName;
   /** The schema label this operation belongs to. */
   get schemaLabel(): string;
   /** List of variable names defined for this operation. */
-  get variableNames(): TVariableNames$1;
+  get variableNames(): TVariableNames;
   /**
    * Returns the field selections. Used for document reconstruction.
    * @internal
    */
-  get documentSource(): () => TFields$1;
+  get documentSource(): () => TFields;
   /** The TypedDocumentNode for use with GraphQL clients. */
   get document(): TypedDocumentNode<TData, TVariables>;
   /** Custom metadata attached to this operation, if any. */
@@ -787,23 +804,23 @@ declare class Operation<TOperationType$1 extends OperationType, TOperationName$1
    * Prefer using the `gql(({ query }) => ...)` API instead.
    * @internal
    */
-  static create<TSchema extends AnyGraphqlSchema, TOperationType$1 extends OperationType, TOperationName$1 extends string, TVariableDefinitions extends InputTypeSpecifiers, TFields$1 extends AnyFields>(define: (context: GqlElementContext | null) => {
-    operationType: TOperationType$1;
-    operationName: TOperationName$1;
+  static create<TSchema extends AnyGraphqlSchema, TOperationType extends OperationType, TOperationName extends string, TVariableDefinitions extends InputTypeSpecifiers, TFields extends AnyFields>(define: (context: GqlElementContext | null) => {
+    operationType: TOperationType;
+    operationName: TOperationName;
     schemaLabel: TSchema["label"];
     variableNames: (keyof TVariableDefinitions & string)[];
-    documentSource: () => TFields$1;
-    document: TypedDocumentNode<InferFields<TSchema, TFields$1>, ConstAssignableInput<TSchema, TVariableDefinitions>>;
+    documentSource: () => TFields;
+    document: TypedDocumentNode<InferFields<TSchema, TFields>, ConstAssignableInput<TSchema, TVariableDefinitions>>;
     metadata?: unknown;
   } | Promise<{
-    operationType: TOperationType$1;
-    operationName: TOperationName$1;
+    operationType: TOperationType;
+    operationName: TOperationName;
     schemaLabel: TSchema["label"];
     variableNames: (keyof TVariableDefinitions & string)[];
-    documentSource: () => TFields$1;
-    document: TypedDocumentNode<InferFields<TSchema, TFields$1>, ConstAssignableInput<TSchema, TVariableDefinitions>>;
+    documentSource: () => TFields;
+    document: TypedDocumentNode<InferFields<TSchema, TFields>, ConstAssignableInput<TSchema, TVariableDefinitions>>;
     metadata?: unknown;
-  }>): Operation<TOperationType$1, TOperationName$1, (keyof TVariableDefinitions & string)[], ConstAssignableInput<TSchema, TVariableDefinitions>, TFields$1, InferFields<TSchema, TFields$1>>;
+  }>): Operation<TOperationType, TOperationName, (keyof TVariableDefinitions & string)[], ConstAssignableInput<TSchema, TVariableDefinitions>, TFields, InferFields<TSchema, TFields>>;
 }
 //#endregion
 //#region packages/core/src/composer/fields-builder.d.ts
@@ -851,13 +868,13 @@ declare const createVarRefs: <TSchema extends AnyGraphqlSchema, TVarDefinitions
  * Used by codegen to generate explicit fragment builder types instead of
  * expensive mapped types. This improves IDE performance for large schemas.
  */
-type FragmentBuilderFor<TSchema extends AnyGraphqlSchema, TTypeName$1 extends keyof TSchema["object"] & string, TAdapter extends AnyMetadataAdapter = DefaultMetadataAdapter> = <TFields$1 extends AnyFields, TVarDefinitions extends InputTypeSpecifiers = {}, TKey$1 extends string | undefined = undefined>(options: {
+type FragmentBuilderFor<TSchema extends AnyGraphqlSchema, TTypeName$1 extends keyof TSchema["object"] & string, TAdapter extends AnyMetadataAdapter = DefaultMetadataAdapter> = <TFields extends AnyFields, TVarDefinitions extends InputTypeSpecifiers = {}>(options: {
   /** Optional unique key for prebuilt type lookup. */
-  key?: TKey$1;
+  key?: string;
   variables?: TVarDefinitions;
   metadata?: FragmentMetadataBuilder<ReturnType<typeof createVarRefs<TSchema, TVarDefinitions>>, ExtractAdapterTypes<TAdapter>["fragmentMetadata"]>;
-  fields: FieldsBuilder<TSchema, TTypeName$1, TVarDefinitions, TFields$1>;
-}) => ReturnType<typeof Fragment.create<TSchema, TTypeName$1, TVarDefinitions, TFields$1, TKey$1>>;
+  fields: FieldsBuilder<TSchema, TTypeName$1, TVarDefinitions, TFields>;
+}) => ReturnType<typeof Fragment.create<TSchema, TTypeName$1, TVarDefinitions, TFields>>;
 /**
  * Creates fragment builder functions for all object types in the schema.
  *
@@ -870,16 +887,16 @@ type FragmentBuilderFor<TSchema extends AnyGraphqlSchema, TTypeName$1 extends ke
  *
  * @internal Used by `createGqlElementComposer`
  */
-declare const createGqlFragmentComposers: <TSchema extends AnyGraphqlSchema, TAdapter extends AnyMetadataAdapter = DefaultMetadataAdapter>(schema: NoInfer<TSchema>, _adapter?: TAdapter) => { readonly [TTypeName in keyof TSchema["object"]]: TTypeName extends string ? <TFields$1 extends AnyFields, TVarDefinitions extends InputTypeSpecifiers = {}, TKey$1 extends string | undefined = undefined>(options: {
-  key?: TKey$1 | undefined;
+declare const createGqlFragmentComposers: <TSchema extends AnyGraphqlSchema, TAdapter extends AnyMetadataAdapter = DefaultMetadataAdapter>(schema: NoInfer<TSchema>, _adapter?: TAdapter) => { readonly [TTypeName in keyof TSchema["object"]]: TTypeName extends string ? <TFields extends AnyFields, TVarDefinitions extends InputTypeSpecifiers = {}>(options: {
+  key?: string;
   variables?: TVarDefinitions | undefined;
   metadata?: FragmentMetadataBuilder<DeclaredVariables<TSchema, TVarDefinitions>, ExtractAdapterTypes<TAdapter>["fragmentMetadata"]> | undefined;
-  fields: FieldsBuilder<TSchema, TTypeName, TVarDefinitions, TFields$1>;
-}) => Fragment<TTypeName, OptionalArg<AssignableInput<TSchema, TVarDefinitions>>, TFields$1 & {
+  fields: FieldsBuilder<TSchema, TTypeName, TVarDefinitions, TFields>;
+}) => Fragment<TTypeName, OptionalArg<AssignableInput<TSchema, TVarDefinitions>>, TFields & {
   [key: symbol]: never;
-}, InferFields<TSchema, TFields$1> & {
+}, InferFields<TSchema, TFields> & {
   [key: symbol]: never;
-}, TKey$1> : never };
+}> : never };
 //#endregion
 //#region packages/core/src/composer/fragment-usage-context.d.ts
 /**
@@ -1174,36 +1191,61 @@ type GqlElementComposerOptions<TSchema extends AnyGraphqlSchema, TDirectiveMetho
 declare const createGqlElementComposer: <TSchema extends AnyGraphqlSchema, TFragmentBuilders, TDirectiveMethods extends StandardDirectives, TAdapter extends AnyAdapter = DefaultAdapter>(schema: NoInfer<TSchema>, options: GqlElementComposerOptions<NoInfer<TSchema>, NoInfer<TDirectiveMethods>, NoInfer<TAdapter>>) => GqlElementComposerWithSchema<{
   fragment: TFragmentBuilders;
   query: {
-    operation: <TOperationName$1 extends string, TFields$1 extends AnyFields, TVarDefinitions extends InputTypeSpecifiers = {}, TOperationMetadata = unknown>(options: {
-      name: TOperationName$1;
+    operation: <TOperationName extends string, TFields extends AnyFields, TVarDefinitions extends InputTypeSpecifiers = {}, TOperationMetadata = unknown>(options: {
+      name: TOperationName;
       variables?: TVarDefinitions | undefined;
       metadata?: MetadataBuilder<DeclaredVariables<TSchema, TVarDefinitions>, TOperationMetadata, ExtractAdapterTypes<ExtractMetadataAdapter<TAdapter>>["aggregatedFragmentMetadata"], ExtractAdapterTypes<ExtractMetadataAdapter<TAdapter>>["schemaLevel"]> | undefined;
-      fields: FieldsBuilder<TSchema, TSchema["operations"]["query"] & keyof TSchema["object"] & string, TVarDefinitions, TFields$1>;
+      fields: FieldsBuilder<TSchema, TSchema["operations"]["query"] & keyof TSchema["object"] & string, TVarDefinitions, TFields>;
       transformDocument?: OperationDocumentTransformer<TOperationMetadata> | undefined;
-    }) => Operation<"query", TOperationName$1, (keyof TVarDefinitions & string)[], ConstAssignableInput<TSchema, TVarDefinitions>, TFields$1, InferFields<TSchema, TFields$1>>;
+    }) => Operation<"query", TOperationName, (keyof TVarDefinitions & string)[], ConstAssignableInput<TSchema, TVarDefinitions>, TFields, InferFields<TSchema, TFields>>;
   };
   mutation: {
-    operation: <TOperationName$1 extends string, TFields$1 extends AnyFields, TVarDefinitions extends InputTypeSpecifiers = {}, TOperationMetadata = unknown>(options: {
-      name: TOperationName$1;
+    operation: <TOperationName extends string, TFields extends AnyFields, TVarDefinitions extends InputTypeSpecifiers = {}, TOperationMetadata = unknown>(options: {
+      name: TOperationName;
       variables?: TVarDefinitions | undefined;
       metadata?: MetadataBuilder<DeclaredVariables<TSchema, TVarDefinitions>, TOperationMetadata, ExtractAdapterTypes<ExtractMetadataAdapter<TAdapter>>["aggregatedFragmentMetadata"], ExtractAdapterTypes<ExtractMetadataAdapter<TAdapter>>["schemaLevel"]> | undefined;
-      fields: FieldsBuilder<TSchema, TSchema["operations"]["mutation"] & keyof TSchema["object"] & string, TVarDefinitions, TFields$1>;
+      fields: FieldsBuilder<TSchema, TSchema["operations"]["mutation"] & keyof TSchema["object"] & string, TVarDefinitions, TFields>;
       transformDocument?: OperationDocumentTransformer<TOperationMetadata> | undefined;
-    }) => Operation<"mutation", TOperationName$1, (keyof TVarDefinitions & string)[], ConstAssignableInput<TSchema, TVarDefinitions>, TFields$1, InferFields<TSchema, TFields$1>>;
+    }) => Operation<"mutation", TOperationName, (keyof TVarDefinitions & string)[], ConstAssignableInput<TSchema, TVarDefinitions>, TFields, InferFields<TSchema, TFields>>;
   };
   subscription: {
-    operation: <TOperationName$1 extends string, TFields$1 extends AnyFields, TVarDefinitions extends InputTypeSpecifiers = {}, TOperationMetadata = unknown>(options: {
-      name: TOperationName$1;
+    operation: <TOperationName extends string, TFields extends AnyFields, TVarDefinitions extends InputTypeSpecifiers = {}, TOperationMetadata = unknown>(options: {
+      name: TOperationName;
       variables?: TVarDefinitions | undefined;
       metadata?: MetadataBuilder<DeclaredVariables<TSchema, TVarDefinitions>, TOperationMetadata, ExtractAdapterTypes<ExtractMetadataAdapter<TAdapter>>["aggregatedFragmentMetadata"], ExtractAdapterTypes<ExtractMetadataAdapter<TAdapter>>["schemaLevel"]> | undefined;
-      fields: FieldsBuilder<TSchema, TSchema["operations"]["subscription"] & keyof TSchema["object"] & string, TVarDefinitions, TFields$1>;
+      fields: FieldsBuilder<TSchema, TSchema["operations"]["subscription"] & keyof TSchema["object"] & string, TVarDefinitions, TFields>;
       transformDocument?: OperationDocumentTransformer<TOperationMetadata> | undefined;
-    }) => Operation<"subscription", TOperationName$1, (keyof TVarDefinitions & string)[], ConstAssignableInput<TSchema, TVarDefinitions>, TFields$1, InferFields<TSchema, TFields$1>>;
+    }) => Operation<"subscription", TOperationName, (keyof TVarDefinitions & string)[], ConstAssignableInput<TSchema, TVarDefinitions>, TFields, InferFields<TSchema, TFields>>;
   };
   $var: VarBuilder<TSchema>;
   $dir: TDirectiveMethods;
   $colocate: <TEntries extends ColocatedEntries>(entries: TEntries) => ColocatedFields<TEntries>;
 } & ExtractHelpers<TAdapter>, TSchema>;
+/**
+ * Abstract Context type for prebuilt composers.
+ *
+ * Provides minimal structure while allowing PrebuiltTypeRegistry to resolve
+ * actual types. Used by prebuilt module to avoid heavy schema type inference.
+ *
+ * Type safety in prebuilt comes from `ResolvePrebuiltElement`, not from
+ * the Context type.
+ */
+type AnyGqlContext = {
+  readonly fragment: Record<string, unknown>;
+  readonly query: {
+    operation: (...args: unknown[]) => AnyOperation;
+  };
+  readonly mutation: {
+    operation: (...args: unknown[]) => AnyOperation;
+  };
+  readonly subscription: {
+    operation: (...args: unknown[]) => AnyOperation;
+  };
+  readonly $var: unknown;
+  readonly $dir: StandardDirectives;
+  readonly $colocate: unknown;
+  readonly [key: string]: unknown;
+};
 //#endregion
 //#region packages/core/src/composer/operation.d.ts
 /**
@@ -1222,136 +1264,13 @@ declare const createGqlElementComposer: <TSchema extends AnyGraphqlSchema, TFrag
  *
  * @internal Used by `createGqlElementComposer`
  */
-declare const createOperationComposerFactory: <TSchema extends AnyGraphqlSchema, TAdapter extends AnyMetadataAdapter = DefaultMetadataAdapter>(schema: NoInfer<TSchema>, adapter?: TAdapter, transformDocument?: DocumentTransformer<ExtractAdapterTypes<TAdapter>["schemaLevel"], ExtractAdapterTypes<TAdapter>["aggregatedFragmentMetadata"]>) => <TOperationType$1 extends OperationType>(operationType: TOperationType$1) => <TOperationName$1 extends string, TFields$1 extends AnyFields, TVarDefinitions extends InputTypeSpecifiers = {}, TOperationMetadata = unknown>(options: {
-  name: TOperationName$1;
+declare const createOperationComposerFactory: <TSchema extends AnyGraphqlSchema, TAdapter extends AnyMetadataAdapter = DefaultMetadataAdapter>(schema: NoInfer<TSchema>, adapter?: TAdapter, transformDocument?: DocumentTransformer<ExtractAdapterTypes<TAdapter>["schemaLevel"], ExtractAdapterTypes<TAdapter>["aggregatedFragmentMetadata"]>) => <TOperationType extends OperationType>(operationType: TOperationType) => <TOperationName extends string, TFields extends AnyFields, TVarDefinitions extends InputTypeSpecifiers = {}, TOperationMetadata = unknown>(options: {
+  name: TOperationName;
   variables?: TVarDefinitions;
   metadata?: MetadataBuilder<ReturnType<typeof createVarRefs<TSchema, TVarDefinitions>>, TOperationMetadata, ExtractAdapterTypes<TAdapter>["aggregatedFragmentMetadata"], ExtractAdapterTypes<TAdapter>["schemaLevel"]>;
-  fields: FieldsBuilder<TSchema, TSchema["operations"][TOperationType$1] & keyof TSchema["object"] & string, TVarDefinitions, TFields$1>;
+  fields: FieldsBuilder<TSchema, TSchema["operations"][TOperationType] & keyof TSchema["object"] & string, TVarDefinitions, TFields>;
   transformDocument?: OperationDocumentTransformer<TOperationMetadata>;
-}) => Operation<TOperationType$1, TOperationName$1, (keyof TVarDefinitions & string)[], ConstAssignableInput<TSchema, TVarDefinitions>, TFields$1, InferFields<TSchema, TFields$1>>;
-//#endregion
-//#region packages/core/src/prebuilt/types.d.ts
-/**
- * Type definitions for prebuilt type system.
- *
- * These types enable looking up pre-computed types from a registry
- * instead of relying on complex type inference that may be lost
- * when bundling with tools like tsdown.
- *
- * @module
- */
-/**
- * Registry mapping fragment/operation keys to their inferred types.
- * Generated by the builder and used by prebuilt composers.
- */
-type PrebuiltTypeRegistry = {
-  readonly fragments: {
-    readonly [key: string]: {
-      readonly input: unknown;
-      readonly output: object;
-    };
-  };
-  readonly operations: {
-    readonly [key: string]: {
-      readonly input: object;
-      readonly output: object;
-    };
-  };
-};
-/**
- * Empty registry type for when no prebuilt types are available.
- */
-type EmptyPrebuiltTypeRegistry = {
-  readonly fragments: Record<string, never>;
-  readonly operations: Record<string, never>;
-};
-/**
- * Extract the input type for a fragment from the registry.
- */
-type PrebuiltFragmentInput<TRegistry extends PrebuiltTypeRegistry, TKey$1 extends keyof TRegistry["fragments"] & string> = TRegistry["fragments"][TKey$1]["input"];
-/**
- * Extract the output type for a fragment from the registry.
- */
-type PrebuiltFragmentOutput<TRegistry extends PrebuiltTypeRegistry, TKey$1 extends keyof TRegistry["fragments"] & string> = TRegistry["fragments"][TKey$1]["output"];
-/**
- * Extract the input type for an operation from the registry.
- */
-type PrebuiltOperationInput<TRegistry extends PrebuiltTypeRegistry, TKey$1 extends keyof TRegistry["operations"] & string> = TRegistry["operations"][TKey$1]["input"];
-/**
- * Extract the output type for an operation from the registry.
- */
-type PrebuiltOperationOutput<TRegistry extends PrebuiltTypeRegistry, TKey$1 extends keyof TRegistry["operations"] & string> = TRegistry["operations"][TKey$1]["output"];
-/**
- * Check if a key exists in the fragment registry.
- */
-type HasPrebuiltFragment<TRegistry extends PrebuiltTypeRegistry, TKey$1 extends string> = TKey$1 extends keyof TRegistry["fragments"] ? true : false;
-/**
- * Check if a key exists in the operation registry.
- */
-type HasPrebuiltOperation<TRegistry extends PrebuiltTypeRegistry, TKey$1 extends string> = TKey$1 extends keyof TRegistry["operations"] ? true : false;
-//#endregion
-//#region packages/core/src/composer/prebuilt-composer.d.ts
-/**
- * Resolves the output type for a prebuilt element.
- *
- * For Operations: Looks up by operation name in the registry
- * For Fragments: Looks up by fragment key in the registry
- * Falls back to the element's original type if not found in registry
- */
-type ResolvePrebuiltElement<TElement, TPrebuilt extends PrebuiltTypeRegistry> = TElement extends Operation<infer TOperationType extends OperationType, infer TOperationName extends string, infer TVariableNames extends string[], any, infer TFields extends Partial<AnyFields>, any> ? TOperationName extends keyof TPrebuilt["operations"] ? Operation<TOperationType, TOperationName, TVariableNames, TPrebuilt["operations"][TOperationName]["input"] & AnyConstAssignableInput, TFields, TPrebuilt["operations"][TOperationName]["output"] & object> : TElement : TElement extends Fragment<infer TTypeName extends string, any, infer TFields extends Partial<AnyFields>, any, infer TKey extends string | undefined> ? TKey extends keyof TPrebuilt["fragments"] ? Fragment<TTypeName, TPrebuilt["fragments"][TKey]["input"] extends infer TInput ? TInput extends AnyAssignableInput ? Partial<TInput> : void : void, TFields, TPrebuilt["fragments"][TKey]["output"] & object, TKey> : TElement : TElement;
-/**
- * Prebuilt element composer that resolves types from a registry.
- */
-type PrebuiltGqlElementComposer<TContext, TPrebuilt extends PrebuiltTypeRegistry> = <TResult extends AnyFragment | Operation<OperationType, string, string[], AnyConstAssignableInput, AnyFields, object>>(composeElement: (context: TContext) => TResult) => ResolvePrebuiltElement<TResult, TPrebuilt>;
-/**
- * Prebuilt element composer with schema access.
- *
- * Extends the prebuilt composer function with a `$schema` property that provides
- * runtime access to the schema definition.
- */
-type PrebuiltGqlElementComposerWithSchema<TContext, TPrebuilt extends PrebuiltTypeRegistry, TSchema extends AnyGraphqlSchema> = PrebuiltGqlElementComposer<TContext, TPrebuilt> & {
-  /**
-   * The GraphQL schema definition used by this composer.
-   */
-  readonly $schema: TSchema;
-};
-/**
- * Creates a prebuilt GQL element composer for a given schema.
- *
- * This composer has the same runtime behavior as `createGqlElementComposer`,
- * but the returned elements have their types resolved from the PrebuiltTypeRegistry
- * instead of using complex type inference.
- *
- * Use this when bundling with tools like tsdown that may lose type information.
- *
- * @param schema - The GraphQL schema definition
- * @param options - Configuration including input type methods and optional adapter
- * @returns Prebuilt element composer function
- *
- * @example
- * ```typescript
- * // Generated by codegen in prebuilt/index.ts
- * import type { PrebuiltTypes } from "./types";
- *
- * const gql = createPrebuiltGqlElementComposer<
- *   Schema,
- *   PrebuiltTypes,
- *   FragmentBuilders,
- *   DirectiveMethods,
- *   Context
- * >(schema, { inputTypeMethods });
- *
- * // Types are resolved from PrebuiltTypes registry
- * const GetUser = gql(({ query }) =>
- *   query.operation({
- *     name: "GetUser",
- *     fields: ({ f }) => ({ ...f.user({ id: "1" })(({ f }) => ({ ...f.id() })) }),
- *   })
- * );
- * // GetUser.$infer.output is PrebuiltTypes["operations"]["GetUser"]["output"]
- * ```
- */
-declare const createPrebuiltGqlElementComposer: <TSchema extends AnyGraphqlSchema, TPrebuilt extends PrebuiltTypeRegistry, TFragmentBuilders, TDirectiveMethods extends StandardDirectives, TContext, TAdapter extends AnyAdapter = DefaultAdapter>(schema: NoInfer<TSchema>, options: GqlElementComposerOptions<NoInfer<TSchema>, NoInfer<TDirectiveMethods>, NoInfer<TAdapter>>) => PrebuiltGqlElementComposerWithSchema<TContext, TPrebuilt, TSchema>;
+}) => Operation<TOperationType, TOperationName, (keyof TVarDefinitions & string)[], ConstAssignableInput<TSchema, TVarDefinitions>, TFields, InferFields<TSchema, TFields>>;
 //#endregion
 //#region packages/core/src/prebuilt/type-calculator.d.ts
 /**
@@ -1491,6 +1410,92 @@ declare const generateInputType: (schema: AnyGraphqlSchema, variableDefinitions:
  */
 declare const generateInputTypeFromSpecifiers: (schema: AnyGraphqlSchema, specifiers: InputTypeSpecifiers, options?: GenerateInputObjectTypeOptions) => string;
 //#endregion
+//#region packages/core/src/prebuilt/types.d.ts
+/**
+ * Type definitions for prebuilt type system.
+ *
+ * These types enable looking up pre-computed types from a registry
+ * instead of relying on complex type inference that may be lost
+ * when bundling with tools like tsdown.
+ *
+ * @module
+ */
+/**
+ * Registry mapping fragment/operation keys to their inferred types.
+ * Generated by the builder and used by prebuilt composers.
+ */
+type PrebuiltTypeRegistry = {
+  readonly fragments: {
+    readonly [key: string]: {
+      readonly input: unknown;
+      readonly output: object;
+    };
+  };
+  readonly operations: {
+    readonly [key: string]: {
+      readonly input: object;
+      readonly output: object;
+    };
+  };
+};
+/**
+ * Empty registry type for when no prebuilt types are available.
+ */
+type EmptyPrebuiltTypeRegistry = {
+  readonly fragments: Record<string, never>;
+  readonly operations: Record<string, never>;
+};
+/**
+ * Extract the input type for a fragment from the registry.
+ */
+type PrebuiltFragmentInput<TRegistry extends PrebuiltTypeRegistry, TKey extends keyof TRegistry["fragments"] & string> = TRegistry["fragments"][TKey]["input"];
+/**
+ * Extract the output type for a fragment from the registry.
+ */
+type PrebuiltFragmentOutput<TRegistry extends PrebuiltTypeRegistry, TKey extends keyof TRegistry["fragments"] & string> = TRegistry["fragments"][TKey]["output"];
+/**
+ * Extract the input type for an operation from the registry.
+ */
+type PrebuiltOperationInput<TRegistry extends PrebuiltTypeRegistry, TKey extends keyof TRegistry["operations"] & string> = TRegistry["operations"][TKey]["input"];
+/**
+ * Extract the output type for an operation from the registry.
+ */
+type PrebuiltOperationOutput<TRegistry extends PrebuiltTypeRegistry, TKey extends keyof TRegistry["operations"] & string> = TRegistry["operations"][TKey]["output"];
+/**
+ * Check if a key exists in the fragment registry.
+ */
+type HasPrebuiltFragment<TRegistry extends PrebuiltTypeRegistry, TKey extends string> = TKey extends keyof TRegistry["fragments"] ? true : false;
+/**
+ * Check if a key exists in the operation registry.
+ */
+type HasPrebuiltOperation<TRegistry extends PrebuiltTypeRegistry, TKey extends string> = TKey extends keyof TRegistry["operations"] ? true : false;
+/**
+ * Branded error type for missing prebuilt registry entries.
+ *
+ * This type intentionally produces a clear error message at compile time
+ * when an operation or fragment is not found in the PrebuiltTypeRegistry.
+ * Instead of silently falling back to inferred types, this forces users
+ * to ensure all elements are properly registered via typegen.
+ */
+type PrebuiltEntryNotFound<TKey extends string, TKind extends "fragment" | "operation"> = {
+  readonly __error: "PREBUILT_ENTRY_NOT_FOUND";
+  readonly __message: `${TKind} "${TKey}" not found in PrebuiltTypeRegistry. Run 'soda-gql typegen' to generate prebuilt types.`;
+  readonly __key: TKey;
+  readonly __kind: TKind;
+};
+/**
+ * Branded error type for unrecognized element types in prebuilt resolution.
+ *
+ * This type is returned when ResolvePrebuiltElement receives a type that
+ * is neither Operation nor Fragment. This should not happen in normal usage,
+ * but provides a clear error message for debugging if it does.
+ */
+type PrebuiltUnknownElement<TElement> = {
+  readonly __error: "PREBUILT_UNKNOWN_ELEMENT";
+  readonly __message: "Element type not recognized. Expected Operation or Fragment.";
+  readonly __element: TElement;
+};
+//#endregion
 //#region packages/core/src/utils/hidden.d.ts
 declare const hidden: <T>() => (() => T);
 type Hidden<T> = () => T;
@@ -1498,5 +1503,5 @@ type Hidden<T> = () => T;
 //#region packages/core/src/utils/wrap-by-key.d.ts
 declare function wrapByKey<TName$1 extends string, TValue$1>(name: TName$1, value: TValue$1): { [K in TName$1]: TValue$1 };
 //#endregion
-export { createFieldFactories as $, buildOperationTypeNode as $t, FragmentBuildersAll as A, AttachmentShape as At, VarBuilder as B, createStandardDirectives as Bt, PrebuiltFragmentInput as C, AnyDirectiveRef as Cn, NestedObjectFieldsBuilderTools as Ct, PrebuiltTypeRegistry as D, DirectiveRefInner as Dn, OptionalArg as Dt, PrebuiltOperationOutput as E, DirectiveRef as En, IfOmittable as Et, InputTypeMethod as F, DirectiveBuilder as Ft, createVarMethodFactory as G, createColocateHelper as Gt, VarSpecifier as H, ColocateHelper as Ht, InputTypeMethods as I, DirectiveMethod as It, withFragmentUsageCollection as J, Tuple as Jt, FragmentUsageRecord as K, StripFunctions as Kt, ResolveTypeFromMeta as L, StandardDirectives as Lt, GqlElementComposerOptions as M, AttachmentsTupleToIntersection as Mt, GqlElementComposerWithSchema as N, AnyDirectiveMethod as Nt, createOperationComposerFactory as O, SwitchIfOmittable as Ot, createGqlElementComposer as P, DirectiveArgValue as Pt, createVarRefs as Q, buildDocument as Qt, SchemaAwareGetNameAt as R, createDirectiveBuilder as Rt, HasPrebuiltOperation as S, GetAssignableType as Sn, NestedObjectFieldsBuilder as St, PrebuiltOperationInput as T, DirectiveLocation as Tn, EmptyObject as Tt, createVarBuilder as U, ColocatedEntries as Ut, VarBuilderMethods as V, isDirectiveRef as Vt, createVarMethod as W, ColocatedFields as Wt, createGqlFragmentComposers as X, buildArgumentValue as Xt, FragmentBuilderFor as Y, UnionToIntersection as Yt, createVarAssignments as Z, buildConstValueNode as Zt, PrebuiltGqlElementComposerWithSchema as _, AnyConstDirectiveAttachments as _n, FieldSelectionFactoryPrimitiveReturn as _t, TypeFormatters as a, AnyNestedUnion as an, Fragment as at, EmptyPrebuiltTypeRegistry as b, ConstAssignableInput as bn, FieldsBuilder as bt, calculateFieldsType as c, InferFields as cn, GqlElementAttachment as ct, generateInputTypeFromSpecifiers as d, AnyAssignableInputValue as dn, AnyFieldSelectionFactory as dt, buildWithTypeModifier as en, AnyOperation as et, getEnumType as f, AnyAssigningInput as fn, AnyFieldSelectionFactoryReturn as ft, PrebuiltGqlElementComposer as g, FieldArgumentValue as gn, FieldSelectionFactoryObjectReturn as gt, graphqlTypeToTypeScript as h, DeclaredVariables as hn, FieldSelectionFactoryFieldArguments as ht, GenerateInputObjectTypeOptions as i, AnyNestedObject as in, AnyFragment as it, GqlElementComposer as j, AttachmentToProperty as jt, ExtractMetadataAdapter as k, empty as kt, generateInputObjectType as l, AnyDirectiveAttachments as ln, GqlElementContext as lt, getScalarOutputType as m, AssignableInputByFieldName as mn, FieldSelectionFactory as mt, Hidden as n, AnyFieldSelection as nn, Operation as nt, applyTypeModifier as o, FieldSelectionTemplateOf as on, FragmentInferMeta as ot, getScalarInputType as p, AssignableInput as pn, FieldSelectionFactories as pt, recordFragmentUsage as q, StripSymbols as qt, hidden as r, AnyFields as rn, OperationInferMeta as rt, calculateFieldType as s, InferField as sn, GqlElement as st, wrapByKey as t, AbstractFieldSelection as tn, AnyOperationOf as tt, generateInputType as u, AnyAssignableInput as un, GqlElementDefinitionFactory as ut, ResolvePrebuiltElement as v, AnyConstAssignableInput as vn, FieldSelectionFactoryReturn as vt, PrebuiltFragmentOutput as w, AnyDirectiveRefBrand as wn, NestedUnionFieldsBuilder as wt, HasPrebuiltFragment as x, ConstAssignableInputValue as xn, FieldsBuilderTools as xt, createPrebuiltGqlElementComposer as y, AnyConstAssignableInputValue as yn, FieldSelectionFactoryUnionReturn as yt, SchemaAwareGetValueAt as z, createDirectiveMethod as zt };
-//# sourceMappingURL=index-DaREzuQm.d.ts.map
+export { AnyOperation as $, buildOperationTypeNode as $t, GqlElementComposer as A, AttachmentToProperty as At, VarBuilderMethods as B, isDirectiveRef as Bt, getScalarInputType as C, AnyDirectiveRef as Cn, NestedUnionFieldsBuilder as Ct, AnyGqlContext as D, DirectiveRefInner as Dn, SwitchIfOmittable as Dt, createOperationComposerFactory as E, DirectiveRef as En, OptionalArg as Et, InputTypeMethods as F, DirectiveMethod as Ft, FragmentUsageRecord as G, StripFunctions as Gt, createVarBuilder as H, ColocatedEntries as Ht, ResolveTypeFromMeta as I, StandardDirectives as It, FragmentBuilderFor as J, UnionToIntersection as Jt, recordFragmentUsage as K, StripSymbols as Kt, SchemaAwareGetNameAt as L, createDirectiveBuilder as Lt, GqlElementComposerWithSchema as M, AnyDirectiveMethod as Mt, createGqlElementComposer as N, DirectiveArgValue as Nt, ExtractMetadataAdapter as O, empty as Ot, InputTypeMethod as P, DirectiveBuilder as Pt, createFieldFactories as Q, buildDocument as Qt, SchemaAwareGetValueAt as R, createDirectiveMethod as Rt, getEnumType as S, GetAssignableType as Sn, NestedObjectFieldsBuilderTools as St, graphqlTypeToTypeScript as T, DirectiveLocation as Tn, IfOmittable as Tt, createVarMethod as U, ColocatedFields as Ut, VarSpecifier as V, ColocateHelper as Vt, createVarMethodFactory as W, createColocateHelper as Wt, createVarAssignments as X, buildArgumentValue as Xt, createGqlFragmentComposers as Y, EnumLookup as Yt, createVarRefs as Z, buildConstValueNode as Zt, calculateFieldType as _, AnyConstDirectiveAttachments as _n, FieldSelectionFactoryReturn as _t, HasPrebuiltFragment as a, AnyNestedUnion as an, FragmentInferMeta as at, generateInputType as b, ConstAssignableInput as bn, FieldsBuilderTools as bt, PrebuiltFragmentInput as c, InferFields as cn, GqlElementContext as ct, PrebuiltOperationOutput as d, AnyAssignableInputValue as dn, AnyFieldSelectionFactoryReturn as dt, buildWithTypeModifier as en, AnyOperationOf as et, PrebuiltTypeRegistry as f, AnyAssigningInput as fn, FieldSelectionFactories as ft, applyTypeModifier as g, FieldArgumentValue as gn, FieldSelectionFactoryPrimitiveReturn as gt, TypeFormatters as h, DeclaredVariables as hn, FieldSelectionFactoryObjectReturn as ht, EmptyPrebuiltTypeRegistry as i, AnyNestedObject as in, Fragment as it, GqlElementComposerOptions as j, AttachmentsTupleToIntersection as jt, FragmentBuildersAll as k, AttachmentShape as kt, PrebuiltFragmentOutput as l, AnyDirectiveAttachments as ln, GqlElementDefinitionFactory as lt, GenerateInputObjectTypeOptions as m, AssignableInputByFieldName as mn, FieldSelectionFactoryFieldArguments as mt, Hidden as n, AnyFieldSelection as nn, OperationInferMeta as nt, HasPrebuiltOperation as o, FieldSelectionTemplateOf as on, GqlElement as ot, PrebuiltUnknownElement as p, AssignableInput as pn, FieldSelectionFactory as pt, withFragmentUsageCollection as q, Tuple as qt, hidden as r, AnyFields as rn, AnyFragment as rt, PrebuiltEntryNotFound as s, InferField as sn, GqlElementAttachment as st, wrapByKey as t, AbstractFieldSelection as tn, Operation as tt, PrebuiltOperationInput as u, AnyAssignableInput as un, AnyFieldSelectionFactory as ut, calculateFieldsType as v, AnyConstAssignableInput as vn, FieldSelectionFactoryUnionReturn as vt, getScalarOutputType as w, AnyDirectiveRefBrand as wn, EmptyObject as wt, generateInputTypeFromSpecifiers as x, ConstAssignableInputValue as xn, NestedObjectFieldsBuilder as xt, generateInputObjectType as y, AnyConstAssignableInputValue as yn, FieldsBuilder as yt, VarBuilder as z, createStandardDirectives as zt };
+//# sourceMappingURL=index-BcA2XPEk.d.ts.map