@soda-gql/core 0.10.2 → 0.11.0

package/dist/{index-gHe-Lwi7.d.cts → index-CatAewXz.d.cts}

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