@soda-gql/core 0.9.1 → 0.10.1

package/dist/{index-_6fYTfcA.d.cts → index-ChwPP6wc.d.cts}

@@ -1,5 +1,5 @@
-import { At as ConstValue, B as UnionMemberName, C as AnyFieldName, D as InferInputKind, 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-zCOsREx0.cjs";
-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
 /**
@@ -1072,6 +1093,22 @@ declare const createVarBuilder: <TSchema extends AnyGraphqlSchema>(inputTypeMeth
  * variables, and colocation helpers.
  */
 type GqlElementComposer<TContext> = <TResult extends AnyFragment | AnyOperation>(composeElement: (context: TContext) => TResult) => TResult;
+/**
+ * GQL element composer with schema access.
+ *
+ * Extends the base composer function with a `$schema` property that provides
+ * runtime access to the schema definition. This is useful for:
+ * - Type generation tools (typegen)
+ * - Runtime schema introspection
+ * - Debugging and tooling
+ */
+type GqlElementComposerWithSchema<TContext, TSchema extends AnyGraphqlSchema> = GqlElementComposer<TContext> & {
+  /**
+   * The GraphQL schema definition used by this composer.
+   * Provides runtime access to schema types, operations, and metadata.
+   */
+  readonly $schema: TSchema;
+};
 /**
  * Extracts the helpers type from an adapter.
  * Uses `any` for non-target type parameters to avoid contravariance issues
@@ -1134,39 +1171,39 @@ 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<{
+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 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>;
+      fields: FieldsBuilder<TSchema, TSchema["operations"]["query"] & keyof TSchema["object"] & string, TVarDefinitions, TFields$1>;
       transformDocument?: OperationDocumentTransformer<TOperationMetadata> | undefined;
-    }) => Operation<"query", TOperationName, (keyof TVarDefinitions & string)[], ConstAssignableInput<TSchema, TVarDefinitions>, TFields, InferFields<TSchema, TFields>>;
+    }) => 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>;
+      fields: FieldsBuilder<TSchema, TSchema["operations"]["mutation"] & keyof TSchema["object"] & string, TVarDefinitions, TFields$1>;
       transformDocument?: OperationDocumentTransformer<TOperationMetadata> | undefined;
-    }) => Operation<"mutation", TOperationName, (keyof TVarDefinitions & string)[], ConstAssignableInput<TSchema, TVarDefinitions>, TFields, InferFields<TSchema, TFields>>;
+    }) => 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>;
+      fields: FieldsBuilder<TSchema, TSchema["operations"]["subscription"] & keyof TSchema["object"] & string, TVarDefinitions, TFields$1>;
       transformDocument?: OperationDocumentTransformer<TOperationMetadata> | undefined;
-    }) => Operation<"subscription", TOperationName, (keyof TVarDefinitions & string)[], ConstAssignableInput<TSchema, TVarDefinitions>, TFields, InferFields<TSchema, TFields>>;
+    }) => Operation<"subscription", TOperationName$1, (keyof TVarDefinitions & string)[], ConstAssignableInput<TSchema, TVarDefinitions>, TFields$1, InferFields<TSchema, TFields$1>>;
   };
   $var: VarBuilder<TSchema>;
   $dir: TDirectiveMethods;
   $colocate: <TEntries extends ColocatedEntries>(entries: TEntries) => ColocatedFields<TEntries>;
-} & ExtractHelpers<TAdapter>>;
+} & ExtractHelpers<TAdapter>, TSchema>;
 //#endregion
 //#region packages/core/src/composer/operation.d.ts
 /**
@@ -1185,13 +1222,274 @@ 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 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>;
+  fields: FieldsBuilder<TSchema, TSchema["operations"][TOperationType$1] & keyof TSchema["object"] & string, TVarDefinitions, TFields$1>;
   transformDocument?: OperationDocumentTransformer<TOperationMetadata>;
-}) => Operation<TOperationType, TOperationName, (keyof TVarDefinitions & string)[], ConstAssignableInput<TSchema, TVarDefinitions>, TFields, InferFields<TSchema, TFields>>;
+}) => 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>;
+//#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);
@@ -1200,5 +1498,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-_6fYTfcA.d.cts.map
+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-ChwPP6wc.d.cts.map