@soda-gql/core 0.9.0 → 0.10.0

package/dist/{index-wkJ6KSwK.d.ts → index-CHshzPrG.d.cts}

@@ -1,5 +1,5 @@
-import { C as ObjectTypeProfile, Ct as GetSignature, Et as ConstValue, F as AnyMetadataAdapter, G as FragmentMetadataBuilder, I as DefaultAdapter, L as DefaultMetadataAdapter, N as Adapter, Ot as FieldPath, P as AnyAdapter, R as ExtractAdapterTypes, S as GetModifiedType, St as ApplyTypeModifier, T as TypeProfile, X as AnyVarRef, Z as AnyVarRefBrand, bt as OutputTypenameSpecifier, c as InferOutputProfile, dt as InputTypeSpecifier, et as VarRef, f as ObjectFieldRecord, ft as InputTypeSpecifiers, g as ResolveInputProfileFromMeta, gt as OutputScalarSpecifier, h as PickTypeSpecifierByFieldName, ht as OutputObjectSpecifier, i as AnyTypeName, it as AnyDefaultValue, m as OperationType, mt as OutputInferrableTypeSpecifier, n as AnyFieldName, o as InferInputKind, pt as OutputEnumSpecifier, q as MetadataBuilder, r as AnyGraphqlSchema, s as InferInputProfile, t as AllInputTypeNames, ut as InputTypeKind, vt as OutputTypeSpecifier, w as PrimitiveTypeProfile, wt as TypeModifier, x as GetConstAssignableType, xt as OutputUnionSpecifier, y as UnionMemberName } from "./schema-2qqtKss4.js";
-import { ConstValueNode, NamedTypeNode, OperationTypeNode, TypeNode, ValueNode } from "graphql";
+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-DnLzk2bC.cjs";
+import { ConstValueNode, NamedTypeNode, OperationTypeNode, TypeNode, ValueNode, VariableDefinitionNode } from "graphql";
 import { TypedDocumentNode } from "@graphql-typed-document-node/core";
 
 //#region packages/core/src/types/type-foundation/directive-ref.d.ts
@@ -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 extends AnyFields> = { [_ in TSchema["label"]]: { [TAliasName in keyof TFields]: InferField<TSchema, TFields[TAliasName]> } & {} }[TSchema["label"]];
+type InferFields<TSchema extends AnyGraphqlSchema, TFields$1 extends AnyFields> = { [_ in TSchema["label"]]: { [TAliasName in keyof TFields$1]: InferField<TSchema, TFields$1[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;
@@ -279,12 +279,12 @@ declare const buildOperationTypeNode: (operation: OperationType) => OperationTyp
  * @param options - Operation configuration (name, type, variables, fields)
  * @returns TypedDocumentNode with inferred input/output types
  */
-declare const buildDocument: <TSchema extends AnyGraphqlSchema, TFields extends AnyFields, TVarDefinitions extends InputTypeSpecifiers>(options: {
+declare const buildDocument: <TSchema extends AnyGraphqlSchema, TFields$1 extends AnyFields, TVarDefinitions extends InputTypeSpecifiers>(options: {
   operationName: string;
   operationType: OperationType;
   variables: TVarDefinitions;
-  fields: TFields;
-}) => TypedDocumentNode<InferFields<TSchema, TFields>, ConstAssignableInput<TSchema, TVarDefinitions>>;
+  fields: TFields$1;
+}) => TypedDocumentNode<InferFields<TSchema, TFields$1>, 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 +479,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 extends AnyFields> = (tools: NoInfer<FieldsBuilderTools<TSchema, TTypeName$1, TVariableDefinitions>>) => TFields;
+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;
 /**
  * Tools provided to field builder callbacks.
  * - `f`: Field selection factories for the current type
@@ -493,7 +493,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 extends AnyNestedObject> = (tools: NoInfer<NestedObjectFieldsBuilderTools<TSchema, TTypeName$1>>) => TFields;
+type NestedObjectFieldsBuilder<TSchema extends AnyGraphqlSchema, TTypeName$1 extends keyof TSchema["object"] & string, TFields$1 extends AnyNestedObject> = (tools: NoInfer<NestedObjectFieldsBuilderTools<TSchema, TTypeName$1>>) => TFields$1;
 /**
  * Tools for nested object builders (no variable access).
  * @internal
@@ -651,7 +651,7 @@ declare abstract class GqlElement<TDefinition extends object, TInfer extends obj
 /**
  * Type alias for any Fragment instance.
  */
-type AnyFragment = Fragment<string, any, AnyFields, any>;
+type AnyFragment = Fragment<string, any, AnyFields, any, string | undefined>;
 /**
  * Type inference metadata for fragments.
  * Access via `typeof fragment.$infer`.
@@ -664,9 +664,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 extends Partial<AnyFields>> {
+interface FragmentArtifact<TTypeName$1 extends string, TVariables extends Partial<AnyAssignableInput> | void, TFields$1 extends Partial<AnyFields>, TKey$1 extends string | undefined = undefined> {
   readonly typename: TTypeName$1;
-  readonly spread: (variables: TVariables) => TFields;
+  readonly key: TKey$1;
+  readonly schemaLabel: string;
+  readonly variableDefinitions: InputTypeSpecifiers;
+  readonly spread: (variables: TVariables) => TFields$1;
 }
 declare const __FRAGMENT_BRAND__: unique symbol;
 /**
@@ -679,30 +682,40 @@ 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 extends Partial<AnyFields>, TOutput extends object> extends GqlElement<FragmentArtifact<TTypeName$1, TVariables, TFields>, FragmentInferMeta<TVariables, TOutput>> implements FragmentArtifact<TTypeName$1, TVariables, TFields> {
+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> {
   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;
+  /** The schema label this fragment belongs to. */
+  get schemaLabel(): string;
+  /** Variable definitions for this fragment. */
+  get variableDefinitions(): InputTypeSpecifiers;
   /**
    * Spreads this fragment's fields into a parent selection.
    * Pass variables if the fragment defines any.
    */
-  get spread(): (variables: TVariables) => TFields;
+  get spread(): (variables: TVariables) => TFields$1;
   /**
    * 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 extends AnyFields>(define: () => {
+  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: () => {
     typename: TTypeName$1;
-    spread: (variables: OptionalArg<AssignableInput<TSchema, TVariableDefinitions>>) => TFields;
-  }): Fragment<TTypeName$1, OptionalArg<AssignableInput<TSchema, TVariableDefinitions>>, TFields & {
+    key: TKey$1;
+    schemaLabel: TSchema["label"];
+    variableDefinitions: TVariableDefinitions;
+    spread: (variables: OptionalArg<AssignableInput<TSchema, TVariableDefinitions>>) => TFields$1;
+  }): Fragment<TTypeName$1, OptionalArg<AssignableInput<TSchema, TVariableDefinitions>>, TFields$1 & {
     [key: symbol]: never;
-  }, InferFields<TSchema, TFields> & {
+  }, InferFields<TSchema, TFields$1> & {
     [key: symbol]: never;
-  }>;
+  }, TKey$1>;
 }
 //#endregion
 //#region packages/core/src/types/element/operation.d.ts
@@ -713,7 +726,7 @@ type AnyOperation = AnyOperationOf<"query"> | AnyOperationOf<"mutation"> | AnyOp
 /**
  * Type alias for an Operation of a specific type.
  */
-type AnyOperationOf<TOperationType extends OperationType> = Operation<TOperationType, string, string[], any, AnyFields, any>;
+type AnyOperationOf<TOperationType$1 extends OperationType> = Operation<TOperationType$1, string, string[], any, AnyFields, any>;
 /**
  * Type inference metadata for operations.
  * Access via `typeof operation.$infer`.
@@ -727,11 +740,12 @@ declare const __OPERATION_BRAND__: unique symbol;
  * Internal artifact shape produced by operation evaluation.
  * @internal
  */
-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 variableNames: TVariableNames;
-  readonly documentSource: () => TFields;
+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;
+  readonly schemaLabel: string;
+  readonly variableNames: TVariableNames$1;
+  readonly documentSource: () => TFields$1;
   readonly document: TypedDocumentNode<TData, TVariables>;
   readonly metadata?: unknown;
 };
@@ -748,20 +762,22 @@ type OperationArtifact<TOperationType extends OperationType, TOperationName exte
  * @template TFields - Selected fields structure
  * @template TData - Inferred response data type
  */
-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> {
+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> {
   private readonly [__OPERATION_BRAND__];
   private constructor();
   /** The operation type: 'query', 'mutation', or 'subscription'. */
-  get operationType(): TOperationType;
+  get operationType(): TOperationType$1;
   /** The unique name of this operation. */
-  get operationName(): TOperationName;
+  get operationName(): TOperationName$1;
+  /** The schema label this operation belongs to. */
+  get schemaLabel(): string;
   /** List of variable names defined for this operation. */
-  get variableNames(): TVariableNames;
+  get variableNames(): TVariableNames$1;
   /**
    * Returns the field selections. Used for document reconstruction.
    * @internal
    */
-  get documentSource(): () => TFields;
+  get documentSource(): () => TFields$1;
   /** The TypedDocumentNode for use with GraphQL clients. */
   get document(): TypedDocumentNode<TData, TVariables>;
   /** Custom metadata attached to this operation, if any. */
@@ -771,21 +787,23 @@ declare class Operation<TOperationType extends OperationType, TOperationName ext
    * Prefer using the `gql(({ query }) => ...)` API instead.
    * @internal
    */
-  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;
+  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;
+    schemaLabel: TSchema["label"];
     variableNames: (keyof TVariableDefinitions & string)[];
-    documentSource: () => TFields;
-    document: TypedDocumentNode<InferFields<TSchema, TFields>, ConstAssignableInput<TSchema, TVariableDefinitions>>;
+    documentSource: () => TFields$1;
+    document: TypedDocumentNode<InferFields<TSchema, TFields$1>, ConstAssignableInput<TSchema, TVariableDefinitions>>;
     metadata?: unknown;
   } | Promise<{
-    operationType: TOperationType;
-    operationName: TOperationName;
+    operationType: TOperationType$1;
+    operationName: TOperationName$1;
+    schemaLabel: TSchema["label"];
     variableNames: (keyof TVariableDefinitions & string)[];
-    documentSource: () => TFields;
-    document: TypedDocumentNode<InferFields<TSchema, TFields>, ConstAssignableInput<TSchema, TVariableDefinitions>>;
+    documentSource: () => TFields$1;
+    document: TypedDocumentNode<InferFields<TSchema, TFields$1>, ConstAssignableInput<TSchema, TVariableDefinitions>>;
     metadata?: unknown;
-  }>): Operation<TOperationType, TOperationName, (keyof TVariableDefinitions & string)[], ConstAssignableInput<TSchema, TVariableDefinitions>, TFields, InferFields<TSchema, TFields>>;
+  }>): Operation<TOperationType$1, TOperationName$1, (keyof TVariableDefinitions & string)[], ConstAssignableInput<TSchema, TVariableDefinitions>, TFields$1, InferFields<TSchema, TFields$1>>;
 }
 //#endregion
 //#region packages/core/src/composer/fields-builder.d.ts
@@ -833,11 +851,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 extends AnyFields, TVarDefinitions extends InputTypeSpecifiers = {}>(options: {
+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: {
+  /** Optional unique key for prebuilt type lookup. */
+  key?: TKey$1;
   variables?: TVarDefinitions;
   metadata?: FragmentMetadataBuilder<ReturnType<typeof createVarRefs<TSchema, TVarDefinitions>>, ExtractAdapterTypes<TAdapter>["fragmentMetadata"]>;
-  fields: FieldsBuilder<TSchema, TTypeName$1, TVarDefinitions, TFields>;
-}) => ReturnType<typeof Fragment.create<TSchema, TTypeName$1, TVarDefinitions, TFields>>;
+  fields: FieldsBuilder<TSchema, TTypeName$1, TVarDefinitions, TFields$1>;
+}) => ReturnType<typeof Fragment.create<TSchema, TTypeName$1, TVarDefinitions, TFields$1, TKey$1>>;
 /**
  * Creates fragment builder functions for all object types in the schema.
  *
@@ -850,15 +870,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 extends AnyFields, TVarDefinitions extends InputTypeSpecifiers = {}>(options: {
+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;
   variables?: TVarDefinitions | undefined;
   metadata?: FragmentMetadataBuilder<DeclaredVariables<TSchema, TVarDefinitions>, ExtractAdapterTypes<TAdapter>["fragmentMetadata"]> | undefined;
-  fields: FieldsBuilder<TSchema, TTypeName, TVarDefinitions, TFields>;
-}) => Fragment<TTypeName, OptionalArg<AssignableInput<TSchema, TVarDefinitions>>, TFields & {
+  fields: FieldsBuilder<TSchema, TTypeName, TVarDefinitions, TFields$1>;
+}) => Fragment<TTypeName, OptionalArg<AssignableInput<TSchema, TVarDefinitions>>, TFields$1 & {
   [key: symbol]: never;
-}, InferFields<TSchema, TFields> & {
+}, InferFields<TSchema, TFields$1> & {
   [key: symbol]: never;
-}> : never };
+}, TKey$1> : never };
 //#endregion
 //#region packages/core/src/composer/fragment-usage-context.d.ts
 /**
@@ -1074,8 +1095,10 @@ declare const createVarBuilder: <TSchema extends AnyGraphqlSchema>(inputTypeMeth
 type GqlElementComposer<TContext> = <TResult extends AnyFragment | AnyOperation>(composeElement: (context: TContext) => TResult) => TResult;
 /**
  * Extracts the helpers type from an adapter.
+ * Uses `any` for non-target type parameters to avoid contravariance issues
+ * with the `aggregateFragmentMetadata` function parameter type.
  */
-type ExtractHelpers<TAdapter extends AnyAdapter> = TAdapter extends Adapter<infer THelpers, unknown, unknown, unknown> ? THelpers : object;
+type ExtractHelpers<TAdapter extends AnyAdapter> = TAdapter extends Adapter<infer THelpers, any, any, any> ? THelpers : object;
 /**
  * Extracts the metadata adapter type from an adapter.
  * Handles optional metadata property correctly.
@@ -1135,28 +1158,31 @@ 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>>) => GqlElementComposer<{
   fragment: TFragmentBuilders;
   query: {
-    operation: <TOperationName extends string, TFields extends AnyFields, TVarDefinitions extends InputTypeSpecifiers = {}, TOperationMetadata = unknown>(options: {
-      name: TOperationName;
+    operation: <TOperationName$1 extends string, TFields$1 extends AnyFields, TVarDefinitions extends InputTypeSpecifiers = {}, TOperationMetadata = unknown>(options: {
+      name: TOperationName$1;
       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>;
-    }) => Operation<"query", TOperationName, (keyof TVarDefinitions & string)[], ConstAssignableInput<TSchema, TVarDefinitions>, TFields, InferFields<TSchema, TFields>>;
+      fields: FieldsBuilder<TSchema, TSchema["operations"]["query"] & keyof TSchema["object"] & string, TVarDefinitions, TFields$1>;
+      transformDocument?: OperationDocumentTransformer<TOperationMetadata> | undefined;
+    }) => Operation<"query", TOperationName$1, (keyof TVarDefinitions & string)[], ConstAssignableInput<TSchema, TVarDefinitions>, TFields$1, InferFields<TSchema, TFields$1>>;
   };
   mutation: {
-    operation: <TOperationName extends string, TFields extends AnyFields, TVarDefinitions extends InputTypeSpecifiers = {}, TOperationMetadata = unknown>(options: {
-      name: TOperationName;
+    operation: <TOperationName$1 extends string, TFields$1 extends AnyFields, TVarDefinitions extends InputTypeSpecifiers = {}, TOperationMetadata = unknown>(options: {
+      name: TOperationName$1;
       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>;
-    }) => Operation<"mutation", TOperationName, (keyof TVarDefinitions & string)[], ConstAssignableInput<TSchema, TVarDefinitions>, TFields, InferFields<TSchema, TFields>>;
+      fields: FieldsBuilder<TSchema, TSchema["operations"]["mutation"] & keyof TSchema["object"] & string, TVarDefinitions, TFields$1>;
+      transformDocument?: OperationDocumentTransformer<TOperationMetadata> | undefined;
+    }) => Operation<"mutation", TOperationName$1, (keyof TVarDefinitions & string)[], ConstAssignableInput<TSchema, TVarDefinitions>, TFields$1, InferFields<TSchema, TFields$1>>;
   };
   subscription: {
-    operation: <TOperationName extends string, TFields extends AnyFields, TVarDefinitions extends InputTypeSpecifiers = {}, TOperationMetadata = unknown>(options: {
-      name: TOperationName;
+    operation: <TOperationName$1 extends string, TFields$1 extends AnyFields, TVarDefinitions extends InputTypeSpecifiers = {}, TOperationMetadata = unknown>(options: {
+      name: TOperationName$1;
       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>;
-    }) => Operation<"subscription", TOperationName, (keyof TVarDefinitions & string)[], ConstAssignableInput<TSchema, TVarDefinitions>, TFields, InferFields<TSchema, TFields>>;
+      fields: FieldsBuilder<TSchema, TSchema["operations"]["subscription"] & keyof TSchema["object"] & string, TVarDefinitions, TFields$1>;
+      transformDocument?: OperationDocumentTransformer<TOperationMetadata> | undefined;
+    }) => Operation<"subscription", TOperationName$1, (keyof TVarDefinitions & string)[], ConstAssignableInput<TSchema, TVarDefinitions>, TFields$1, InferFields<TSchema, TFields$1>>;
   };
   $var: VarBuilder<TSchema>;
   $dir: TDirectiveMethods;
@@ -1175,16 +1201,267 @@ declare const createGqlElementComposer: <TSchema extends AnyGraphqlSchema, TFrag
  *
  * @param schema - The GraphQL schema definition
  * @param adapter - Optional metadata adapter for custom metadata handling
+ * @param transformDocument - Optional document transformer called after building
  * @returns Operation type selector function
  *
  * @internal Used by `createGqlElementComposer`
  */
-declare const createOperationComposerFactory: <TSchema extends AnyGraphqlSchema, TAdapter extends AnyMetadataAdapter = DefaultMetadataAdapter>(schema: NoInfer<TSchema>, adapter?: TAdapter) => <TOperationType extends OperationType>(operationType: TOperationType) => <TOperationName extends string, TFields extends AnyFields, TVarDefinitions extends InputTypeSpecifiers = {}, TOperationMetadata = unknown>(options: {
-  name: TOperationName;
+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;
   variables?: TVarDefinitions;
   metadata?: MetadataBuilder<ReturnType<typeof createVarRefs<TSchema, TVarDefinitions>>, TOperationMetadata, ExtractAdapterTypes<TAdapter>["aggregatedFragmentMetadata"], ExtractAdapterTypes<TAdapter>["schemaLevel"]>;
-  fields: FieldsBuilder<TSchema, TSchema["operations"][TOperationType] & keyof TSchema["object"] & string, TVarDefinitions, TFields>;
-}) => Operation<TOperationType, TOperationName, (keyof TVarDefinitions & string)[], ConstAssignableInput<TSchema, TVarDefinitions>, TFields, InferFields<TSchema, TFields>>;
+  fields: FieldsBuilder<TSchema, TSchema["operations"][TOperationType$1] & keyof TSchema["object"] & string, TVarDefinitions, TFields$1>;
+  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>;
+/**
+ * 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>>) => PrebuiltGqlElementComposer<TContext, TPrebuilt>;
+//#endregion
+//#region packages/core/src/prebuilt/type-calculator.d.ts
+/**
+ * Formatters for customizing type name output.
+ *
+ * Used by type generation functions to format scalar and input object type names
+ * with custom prefixes or patterns (e.g., schema-specific prefixes).
+ */
+type TypeFormatters = {
+  /**
+   * Format a scalar input type name.
+   * Default: `ScalarInput<"Name">`
+   */
+  readonly scalarInput?: (name: string) => string;
+  /**
+   * Format a scalar output type name.
+   * Default: `ScalarOutput<"Name">`
+   */
+  readonly scalarOutput?: (name: string) => string;
+  /**
+   * Format an input object type name.
+   * Default: returns the name unchanged
+   */
+  readonly inputObject?: (name: string) => string;
+};
+/**
+ * Apply a type modifier to a base type string.
+ *
+ * Modifier format:
+ * - "!" = required (T)
+ * - "?" = optional (T | null | undefined)
+ * - "![]!" = required array of required items (T[])
+ * - "![]?" = optional array of required items (T[] | null | undefined)
+ * - "?[]!" = required array of optional items ((T | null | undefined)[])
+ * - "?[]?" = optional array of optional items ((T | null | undefined)[] | null | undefined)
+ * - Deeper nesting follows the same pattern
+ */
+declare const applyTypeModifier: (baseType: string, modifier: TypeModifier) => string;
+/**
+ * Get the TypeScript type string for a scalar output type from the schema.
+ *
+ * Returns a `ScalarOutput<"Name">` reference for all scalars in the schema.
+ * The actual type is resolved at compile time from the inject file's scalar definitions.
+ * This allows users to customize even built-in scalars (ID, String, etc.).
+ */
+declare const getScalarOutputType: (schema: AnyGraphqlSchema, scalarName: string) => string;
+/**
+ * Get the TypeScript type string for a scalar input type from the schema.
+ *
+ * Returns a `ScalarInput<"Name">` reference for all scalars in the schema.
+ * Used for input/variable types in operations.
+ */
+declare const getScalarInputType: (schema: AnyGraphqlSchema, scalarName: string) => string;
+/**
+ * Get the TypeScript type string for an enum type from the schema.
+ */
+declare const getEnumType: (schema: AnyGraphqlSchema, enumName: string) => string;
+/**
+ * Options for generating input object types.
+ */
+type GenerateInputObjectTypeOptions = {
+  /**
+   * Default depth limit for recursive types.
+   * @default 3
+   */
+  readonly defaultDepth?: number;
+  /**
+   * Per-type depth overrides.
+   */
+  readonly depthOverrides?: InputDepthOverrides;
+  /**
+   * Custom formatters for type names.
+   */
+  readonly formatters?: TypeFormatters;
+};
+/**
+ * Generate a TypeScript type string for an input object type.
+ *
+ * Recursively expands fields using ScalarInput for scalars.
+ * Returns `unknown` if depth is exhausted or circular reference is detected.
+ *
+ * @param schema - The GraphQL schema
+ * @param inputName - The input object type name
+ * @param options - Generation options including depth limits
+ * @param seen - Set of already visited input names (for circular reference detection)
+ * @param currentDepth - Current recursion depth
+ */
+declare const generateInputObjectType: (schema: AnyGraphqlSchema, inputName: string, options?: GenerateInputObjectTypeOptions, seen?: Set<string>, currentDepth?: number) => string;
+/**
+ * Calculate the TypeScript type string for a single field selection.
+ *
+ * @param schema - The GraphQL schema
+ * @param selection - The field selection to calculate type for
+ * @param formatters - Optional formatters for customizing type names
+ */
+declare const calculateFieldType: (schema: AnyGraphqlSchema, selection: AnyFieldSelection, formatters?: TypeFormatters) => string;
+/**
+ * Calculate the TypeScript type string for a set of field selections.
+ * This is the main entry point for type calculation.
+ *
+ * @param schema - The GraphQL schema
+ * @param fields - The field selections to calculate types for
+ * @param formatters - Optional formatters for customizing type names
+ */
+declare const calculateFieldsType: (schema: AnyGraphqlSchema, fields: AnyFields | AnyNestedObject, formatters?: TypeFormatters) => string;
+/**
+ * Convert a GraphQL TypeNode to a TypeScript type string for input types.
+ *
+ * Handles NonNullType, ListType, and NamedType recursively.
+ * Uses ScalarInput for scalar types since this is used for input/variable types.
+ *
+ * @param schema - The GraphQL schema
+ * @param typeNode - The GraphQL type node to convert
+ * @param formatters - Optional formatters for customizing type names
+ */
+declare const graphqlTypeToTypeScript: (schema: AnyGraphqlSchema, typeNode: TypeNode, formatters?: TypeFormatters) => string;
+/**
+ * Generate a TypeScript type string for operation input variables.
+ *
+ * Extracts variable types from GraphQL VariableDefinitionNode AST.
+ *
+ * @param schema - The GraphQL schema
+ * @param variableDefinitions - Variable definition nodes from the operation
+ * @param formatters - Optional formatters for customizing type names
+ */
+declare const generateInputType: (schema: AnyGraphqlSchema, variableDefinitions: readonly VariableDefinitionNode[], formatters?: TypeFormatters) => string;
+/**
+ * Generate a TypeScript type string for input variables from InputTypeSpecifiers.
+ *
+ * Unlike generateInputType which works with GraphQL AST VariableDefinitionNode[],
+ * this function works with soda-gql's internal InputTypeSpecifiers format.
+ * Used for generating Fragment input types in prebuilt mode.
+ *
+ * @param schema - The GraphQL schema
+ * @param specifiers - Input type specifiers (variable definitions)
+ * @param options - Generation options including depth limits
+ */
+declare const generateInputTypeFromSpecifiers: (schema: AnyGraphqlSchema, specifiers: InputTypeSpecifiers, options?: GenerateInputObjectTypeOptions) => string;
 //#endregion
 //#region packages/core/src/utils/hidden.d.ts
 declare const hidden: <T>() => (() => T);
@@ -1193,5 +1470,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 { NestedUnionFieldsBuilder as $, AnyDirectiveRefBrand as $t, AnyOperationOf as A, AbstractFieldSelection as At, AnyFieldSelectionFactory as B, AnyAssignableInputValue as Bt, withFragmentUsageCollection as C, Tuple as Ct, createVarRefs as D, buildDocument as Dt, createVarAssignments as E, buildConstValueNode as Et, FragmentInferMeta as F, FieldSelectionTemplateOf as Ft, FieldSelectionFactoryObjectReturn as G, FieldArgumentValue as Gt, FieldSelectionFactories as H, AssignableInput as Ht, GqlElement as I, InferField as It, FieldSelectionFactoryUnionReturn as J, AnyConstAssignableInputValue as Jt, FieldSelectionFactoryPrimitiveReturn as K, AnyConstDirectiveAttachments as Kt, GqlElementAttachment as L, InferFields as Lt, OperationInferMeta as M, AnyFields as Mt, AnyFragment as N, AnyNestedObject as Nt, createFieldFactories as O, buildOperationTypeNode as Ot, Fragment as P, AnyNestedUnion as Pt, NestedObjectFieldsBuilderTools as Q, AnyDirectiveRef as Qt, GqlElementContext as R, AnyDirectiveAttachments as Rt, recordFragmentUsage as S, StripSymbols as St, createGqlFragmentComposers as T, buildArgumentValue as Tt, FieldSelectionFactory as U, AssignableInputByFieldName as Ut, AnyFieldSelectionFactoryReturn as V, AnyAssigningInput as Vt, FieldSelectionFactoryFieldArguments as W, DeclaredVariables as Wt, FieldsBuilderTools as X, ConstAssignableInputValue as Xt, FieldsBuilder as Y, ConstAssignableInput as Yt, NestedObjectFieldsBuilder as Z, GetAssignableType as Zt, VarSpecifier as _, ColocateHelper as _t, ExtractMetadataAdapter as a, AttachmentShape as at, createVarMethodFactory as b, createColocateHelper as bt, GqlElementComposerOptions as c, AnyDirectiveMethod as ct, InputTypeMethods as d, DirectiveMethod as dt, DirectiveLocation as en, EmptyObject as et, ResolveTypeFromMeta as f, StandardDirectives as ft, VarBuilderMethods as g, isDirectiveRef as gt, VarBuilder as h, createStandardDirectives as ht, createOperationComposerFactory as i, empty as it, Operation as j, AnyFieldSelection as jt, AnyOperation as k, buildWithTypeModifier as kt, createGqlElementComposer as l, DirectiveArgValue as lt, SchemaAwareGetValueAt as m, createDirectiveMethod as mt, Hidden as n, DirectiveRefInner as nn, OptionalArg as nt, FragmentBuildersAll as o, AttachmentToProperty as ot, SchemaAwareGetNameAt as p, createDirectiveBuilder as pt, FieldSelectionFactoryReturn as q, AnyConstAssignableInput as qt, hidden as r, SwitchIfOmittable as rt, GqlElementComposer as s, AttachmentsTupleToIntersection as st, wrapByKey as t, DirectiveRef as tn, IfOmittable as tt, InputTypeMethod as u, DirectiveBuilder as ut, createVarBuilder as v, ColocatedEntries as vt, FragmentBuilderFor as w, UnionToIntersection as wt, FragmentUsageRecord as x, StripFunctions as xt, createVarMethod as y, ColocatedFields as yt, GqlElementDefinitionFactory as z, AnyAssignableInput as zt };
-//# sourceMappingURL=index-wkJ6KSwK.d.ts.map
+export { AnyOperationOf as $, AbstractFieldSelection as $t, GqlElementComposer as A, AttachmentsTupleToIntersection as At, VarSpecifier as B, ColocateHelper as Bt, PrebuiltFragmentOutput as C, DirectiveLocation as Cn, EmptyObject as Ct, createOperationComposerFactory as D, empty as Dt, PrebuiltTypeRegistry as E, SwitchIfOmittable as Et, ResolveTypeFromMeta as F, StandardDirectives as Ft, recordFragmentUsage as G, StripSymbols as Gt, createVarMethod as H, ColocatedFields as Ht, SchemaAwareGetNameAt as I, createDirectiveBuilder as It, createGqlFragmentComposers as J, buildArgumentValue as Jt, withFragmentUsageCollection as K, Tuple as Kt, SchemaAwareGetValueAt as L, createDirectiveMethod as Lt, createGqlElementComposer as M, DirectiveArgValue as Mt, InputTypeMethod as N, DirectiveBuilder as Nt, ExtractMetadataAdapter as O, AttachmentShape as Ot, InputTypeMethods as P, DirectiveMethod as Pt, AnyOperation as Q, buildWithTypeModifier as Qt, VarBuilder as R, createStandardDirectives as Rt, PrebuiltFragmentInput as S, AnyDirectiveRefBrand as Sn, NestedUnionFieldsBuilder as St, PrebuiltOperationOutput as T, DirectiveRefInner as Tn, OptionalArg as Tt, createVarMethodFactory as U, createColocateHelper as Ut, createVarBuilder as V, ColocatedEntries as Vt, FragmentUsageRecord as W, StripFunctions as Wt, createVarRefs as X, buildDocument as Xt, createVarAssignments as Y, buildConstValueNode as Yt, createFieldFactories as Z, buildOperationTypeNode as Zt, ResolvePrebuiltElement as _, AnyConstAssignableInputValue as _n, FieldSelectionFactoryUnionReturn as _t, TypeFormatters as a, InferField as an, GqlElement as at, HasPrebuiltFragment as b, GetAssignableType as bn, NestedObjectFieldsBuilder as bt, calculateFieldsType as c, AnyAssignableInput as cn, GqlElementDefinitionFactory as ct, generateInputTypeFromSpecifiers as d, AssignableInput as dn, FieldSelectionFactories as dt, AnyFieldSelection as en, Operation as et, getEnumType as f, AssignableInputByFieldName as fn, FieldSelectionFactory as ft, PrebuiltGqlElementComposer as g, AnyConstAssignableInput as gn, FieldSelectionFactoryReturn as gt, graphqlTypeToTypeScript as h, AnyConstDirectiveAttachments as hn, FieldSelectionFactoryPrimitiveReturn as ht, GenerateInputObjectTypeOptions as i, FieldSelectionTemplateOf as in, FragmentInferMeta as it, GqlElementComposerOptions as j, AnyDirectiveMethod as jt, FragmentBuildersAll as k, AttachmentToProperty as kt, generateInputObjectType as l, AnyAssignableInputValue as ln, AnyFieldSelectionFactory as lt, getScalarOutputType as m, FieldArgumentValue as mn, FieldSelectionFactoryObjectReturn as mt, Hidden as n, AnyNestedObject as nn, AnyFragment as nt, applyTypeModifier as o, InferFields as on, GqlElementAttachment as ot, getScalarInputType as p, DeclaredVariables as pn, FieldSelectionFactoryFieldArguments as pt, FragmentBuilderFor as q, UnionToIntersection as qt, hidden as r, AnyNestedUnion as rn, Fragment as rt, calculateFieldType as s, AnyDirectiveAttachments as sn, GqlElementContext as st, wrapByKey as t, AnyFields as tn, OperationInferMeta as tt, generateInputType as u, AnyAssigningInput as un, AnyFieldSelectionFactoryReturn as ut, createPrebuiltGqlElementComposer as v, ConstAssignableInput as vn, FieldsBuilder as vt, PrebuiltOperationInput as w, DirectiveRef as wn, IfOmittable as wt, HasPrebuiltOperation as x, AnyDirectiveRef as xn, NestedObjectFieldsBuilderTools as xt, EmptyPrebuiltTypeRegistry as y, ConstAssignableInputValue as yn, FieldsBuilderTools as yt, VarBuilderMethods as z, isDirectiveRef as zt };
+//# sourceMappingURL=index-CHshzPrG.d.cts.map