@soda-gql/core 0.2.0 → 0.4.0

package/dist/{index-B-erotAZ.d.cts → index-eFR-ZKOA.d.cts}

@@ -1,16 +1,7 @@
-import { $ as AnyVarRef, A as OutputScalarSpecifier, B as DefaultMetadataAdapter, D as OutputEnumSpecifier, E as InputTypeSpecifiers, F as OutputUnionSpecifier, I as Adapter, J as FragmentMetadataBuilder, L as AnyAdapter, M as OutputTypeSpecifier, O as OutputInferrableTypeSpecifier, P as OutputTypenameSpecifier, R as AnyMetadataAdapter, T as InputTypeSpecifier, V as ExtractAdapterTypes, X as MetadataBuilder, _t as ConstValue, a as InferInputProfile, dt as GetModifiedType, f as OperationType, g as UnionMemberName, gt as ValidTypeModifier, ht as TypeModifier, k as OutputObjectSpecifier, lt as GetAssigningType, mt as ApplyTypeModifier, n as AnyGraphqlSchema, nt as VarRefInner, o as InferOutputProfile, p as PickTypeSpecifierByFieldName, pt as TypeProfile, r as AnyTypeName, t as AnyFieldName, tt as VarRef, u as ObjectFieldRecord, ut as GetConstAssignableType, v as AnyDefaultValue, yt as FieldPath, z as DefaultAdapter } from "./schema-DRkKucYe.cjs";
+import { A as OutputInferrableTypeSpecifier, B as AnyMetadataAdapter, Ct as ApplyTypeModifier, D as InputTypeSpecifier, E as InputTypeKind, Et as ConstValue, H as DefaultMetadataAdapter, I as OutputTypenameSpecifier, L as OutputUnionSpecifier, M as OutputScalarSpecifier, O as InputTypeSpecifiers, Ot as FieldPath, P as OutputTypeSpecifier, Q as MetadataBuilder, R as Adapter, St as TypeProfile, U as ExtractAdapterTypes, V as DefaultAdapter, X as FragmentMetadataBuilder, b as AnyDefaultValue, bt as GetModifiedType, c as InferOutputProfile, dt as getNameAt, f as ObjectFieldRecord, ft as getValueAt, h as PickTypeSpecifierByFieldName, ht as getVarRefValue, i as AnyTypeName, j as OutputObjectSpecifier, k as OutputEnumSpecifier, m as OperationType, mt as getVarRefName, n as AnyFieldName, o as InferInputKind, pt as getVarRefInner, r as AnyGraphqlSchema, s as InferInputProfile, st as VarRef, t as AllInputTypeNames, tt as AnyVarRef, v as UnionMemberName, vt as GetAssigningType, wt as TypeModifier, yt as GetConstAssignableType, z as AnyAdapter } from "./schema-5Vfg289u.cjs";
 import { ConstValueNode, NamedTypeNode, OperationTypeNode, TypeNode, ValueNode } from "graphql";
 import { TypedDocumentNode } from "@graphql-typed-document-node/core";
 
-//#region packages/core/src/types/type-foundation/modified-type-name.d.ts
-type ModifiedTypeName<TNameCandidate extends [string], TName extends TNameCandidate[0], TModifier extends TypeModifier> = [string] extends TNameCandidate ? `${TName}:${TModifier}` : TNameCandidate extends [TName] ?
-// First, user inputs TName based on TNameCandidate
-NoInfer<`${TNameCandidate[0]}`> | (TName & NoInfer<TypeModifier extends TModifier ? never : string>) : `${TName}:${TModifier & ValidTypeModifier}`;
-declare function parseModifiedTypeName<TNameCandidate extends [string], TName extends string, TModifier extends TypeModifier>(nameAndModifier: ModifiedTypeName<TNameCandidate, TName, TModifier>): {
-  name: TName;
-  modifier: TModifier;
-};
-//#endregion
 //#region packages/core/src/types/type-foundation/type-modifier-extension.generated.d.ts
 interface Op<T> {
   readonly 0: T[];
@@ -189,12 +180,13 @@ type ColocatedFields<TEntries extends ColocatedEntries> = UnionToIntersection<{
  * @example
  * ```typescript
  * // In operation definition
- * query.operation({ name: "GetData" }, ({ f, $ }) => [
- *   $colocate({
- *     userCard: userCardFragment.embed({ userId: $.userId }),
- *     posts: postsFragment.embed({ userId: $.userId }),
+ * query.operation({
+ *   name: "GetData",
+ *   fields: ({ $ }) => $colocate({
+ *     userCard: userCardFragment.spread({ userId: $.userId }),
+ *     posts: postsFragment.spread({ userId: $.userId }),
  *   }),
- * ]);
+ * });
  *
  * // In parser definition (same labels)
  * createExecutionResultParser({
@@ -217,24 +209,22 @@ type SwitchIfEmpty<TTarget, TTrue, TFalse> = IsEmptyObject<TTarget> extends true
 declare const empty: () => EmptyObject;
 //#endregion
 //#region packages/core/src/types/element/fields-builder.d.ts
-declare const mergeFields: <TFieldEntries extends AnyFields[]>(fields: TFieldEntries) => MergeFields<TFieldEntries>;
-type MergeFields<TFieldEntries extends AnyFields[]> = UnionToIntersection<TFieldEntries[number]> extends infer TFieldsIntersection ? { [TFieldName in keyof TFieldsIntersection]: TFieldsIntersection[TFieldName] extends AnyFieldSelection ? TFieldsIntersection[TFieldName] : never } & {} : never;
 /**
  * Builder signature exposed to userland `model` and `slice` helpers. The
  * 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 extends AnyFields> = (tools: NoInfer<FieldsBuilderTools<TSchema, TTypeName$1, TVariableDefinitions>>) => TFields;
 type FieldsBuilderTools<TSchema extends AnyGraphqlSchema, TTypeName$1 extends keyof TSchema["object"] & string, TVariableDefinitions extends InputTypeSpecifiers> = {
   f: FieldSelectionFactories<TSchema, TTypeName$1>;
   $: AssigningInput<TSchema, TVariableDefinitions>;
 };
 /** Narrow builder used when a field resolves to an object and we need nested 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 extends AnyNestedObject> = (tools: NoInfer<NestedObjectFieldsBuilderTools<TSchema, TTypeName$1>>) => TFields;
 type NestedObjectFieldsBuilderTools<TSchema extends AnyGraphqlSchema, TTypeName$1 extends keyof TSchema["object"] & string> = {
   f: FieldSelectionFactories<TSchema, TTypeName$1>;
 };
-type NestedUnionFieldsBuilder<TSchema extends AnyGraphqlSchema, TMemberName extends string, TUnionFields extends AnyNestedUnion> = { [TTypename in keyof TUnionFields & TMemberName]?: NestedObjectFieldsBuilder<TSchema, TTypename, NonNullable<TUnionFields[TTypename]>[]> };
+type NestedUnionFieldsBuilder<TSchema extends AnyGraphqlSchema, TMemberName extends string, TUnionFields extends AnyNestedUnion> = { [TTypename in keyof TUnionFields & TMemberName]?: NestedObjectFieldsBuilder<TSchema, TTypename, NonNullable<TUnionFields[TTypename]>> };
 /** Map each field to a factory capable of emitting fully-typed references. */
 type FieldSelectionFactories<TSchema extends AnyGraphqlSchema, TTypeName$1 extends keyof TSchema["object"] & string> = { [TFieldName in keyof ObjectFieldRecord<TSchema, TTypeName$1>]: TFieldName extends string ? FieldSelectionFactory<TSchema, FieldSelectionTemplateOf<TSchema, TTypeName$1, TFieldName>> : never };
 type AnyFieldSelectionFactory = <TAlias extends string | null = null>(fieldArgs: AnyAssignableInput | void, extras?: {
@@ -261,8 +251,8 @@ type FieldSelectionFactoryReturn<TSchema extends AnyGraphqlSchema, TSelection ex
 } ? FieldSelectionFactoryPrimitiveReturn<TSelection, TAlias> : never;
 type FieldSelectionFactoryObjectReturn<TSchema extends AnyGraphqlSchema, TSelection extends AnyFieldSelection & {
   type: OutputObjectSpecifier;
-}, TAlias extends string | null> = <TNested$1 extends AnyNestedObject[]>(nest: NestedObjectFieldsBuilder<TSchema, TSelection["type"]["name"], TNested$1>) => { [_ in TAlias extends null ? TSelection["field"] : TAlias]: AbstractFieldSelection<TSelection["parent"], TSelection["field"], TSelection["type"], TSelection["args"], TSelection["directives"], {
-  object: MergeFields<TNested$1>;
+}, TAlias extends string | null> = <TNested$1 extends AnyNestedObject>(nest: NestedObjectFieldsBuilder<TSchema, TSelection["type"]["name"], TNested$1>) => { [_ in TAlias extends null ? TSelection["field"] : TAlias]: AbstractFieldSelection<TSelection["parent"], TSelection["field"], TSelection["type"], TSelection["args"], TSelection["directives"], {
+  object: TNested$1;
 }> };
 type FieldSelectionFactoryUnionReturn<TSchema extends AnyGraphqlSchema, TSelection extends AnyFieldSelection & {
   type: OutputUnionSpecifier;
@@ -287,8 +277,8 @@ declare const GQL_ELEMENT_FACTORY: unique symbol;
 declare const GQL_ELEMENT_CONTEXT: unique symbol;
 type GqlElementContext = LazyEvaluatorContext;
 type GqlElementDefinitionFactory<T> = (context: GqlElementContext | null) => T | Promise<T>;
-type GqlElementAttachment<TElement extends object, TName extends string, TValue extends object> = {
-  name: TName;
+type GqlElementAttachment<TElement extends object, TName$1 extends string, TValue extends object> = {
+  name: TName$1;
   createValue: (element: TElement) => TValue;
 };
 declare abstract class GqlElement<TDefinition extends object, TInfer extends object> {
@@ -296,7 +286,7 @@ declare abstract class GqlElement<TDefinition extends object, TInfer extends obj
   private [GQL_ELEMENT_FACTORY];
   private [GQL_ELEMENT_CONTEXT];
   protected constructor(define: GqlElementDefinitionFactory<TDefinition>, getDeps?: () => GqlElement<any, any>[]);
-  attach<TName extends string, TValue extends object>(attachment: GqlElementAttachment<this, TName, TValue>): this & { [_ in TName]: TValue };
+  attach<TName$1 extends string, TValue extends object>(attachment: GqlElementAttachment<this, TName$1, TValue>): this & { [_ in TName$1]: TValue };
   static setContext<TElement extends GqlElement<any, any>>(element: TElement, context: GqlElementContext): void;
   static createEvaluationGenerator(element: GqlElement<any, any>): Generator<Promise<void>, void, void>;
   private static evaluateInstantly;
@@ -312,17 +302,17 @@ type FragmentInferMeta<TVariables, TOutput extends object> = {
 };
 interface FragmentArtifact<TTypeName$1 extends string, TVariables extends Partial<AnyAssignableInput> | void, TFields extends Partial<AnyFields>> {
   readonly typename: TTypeName$1;
-  readonly embed: (variables: TVariables) => TFields;
+  readonly spread: (variables: TVariables) => TFields;
 }
 declare const __FRAGMENT_BRAND__: unique symbol;
 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();
   get typename(): TTypeName$1;
-  get embed(): (variables: TVariables) => TFields;
+  get spread(): (variables: TVariables) => TFields;
   static create<TSchema extends AnyGraphqlSchema, TTypeName$1 extends keyof TSchema["object"] & string, TVariableDefinitions extends InputTypeSpecifiers, TFields extends AnyFields>(define: () => {
     typename: TTypeName$1;
-    embed: (variables: SwitchIfEmpty<TVariableDefinitions, void, AssignableInput<TSchema, TVariableDefinitions>>) => TFields;
+    spread: (variables: SwitchIfEmpty<TVariableDefinitions, void, AssignableInput<TSchema, TVariableDefinitions>>) => TFields;
   }): Fragment<TTypeName$1, SwitchIfEmpty<TVariableDefinitions, void, AssignableInput<TSchema, TVariableDefinitions>>, TFields & {
     [key: symbol]: never;
   }, InferFields<TSchema, TFields> & {
@@ -375,25 +365,20 @@ declare class Operation<TOperationType extends OperationType, TOperationName ext
 //#region packages/core/src/composer/fields-builder.d.ts
 declare const createFieldFactories: <TSchema extends AnyGraphqlSchema, TTypeName$1 extends keyof TSchema["object"] & string>(schema: TSchema, typeName: TTypeName$1) => FieldSelectionFactories<TSchema, TTypeName$1>;
 //#endregion
-//#region packages/core/src/composer/input.d.ts
-declare const mergeVarDefinitions: <TVarDefinitions extends InputTypeSpecifiers[]>(definitions: TVarDefinitions) => MergeVarDefinitions<TVarDefinitions>;
-type MergeVarDefinitions<TVarDefinitions extends InputTypeSpecifiers[]> = UnionToIntersection<TVarDefinitions[number]> extends infer TDefinitions ? { readonly [K in keyof TDefinitions]: TDefinitions[K] } : never;
-declare const createVarAssignments: <TSchema extends AnyGraphqlSchema, TVariableDefinitions extends InputTypeSpecifiers>(definitions: TVariableDefinitions, providedValues: AnyAssignableInput | void) => AssigningInput<TSchema, TVariableDefinitions>;
-declare const createVarRefs: <TSchema extends AnyGraphqlSchema, TVarDefinitions extends InputTypeSpecifiers>(definitions: TVarDefinitions) => AssigningInput<TSchema, TVarDefinitions>;
-//#endregion
 //#region packages/core/src/composer/fragment.d.ts
-declare const createGqlFragmentComposers: <TSchema extends AnyGraphqlSchema, TAdapter extends AnyMetadataAdapter = DefaultMetadataAdapter>(schema: NoInfer<TSchema>, _adapter?: TAdapter) => { readonly [TTypeName in keyof TSchema["object"]]: TTypeName extends string ? <TFieldEntries 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 extends AnyFields, TVarDefinitions extends InputTypeSpecifiers = {}>(options: {
   variables?: TVarDefinitions | undefined;
-  metadata?: FragmentMetadataBuilder<AssigningInput<TSchema, MergeVarDefinitions<TVarDefinitions>>, ExtractAdapterTypes<TAdapter>["fragmentMetadata"]> | undefined;
-}, builder: FieldsBuilder<TSchema, TTypeName, MergeVarDefinitions<TVarDefinitions>, TFieldEntries>) => Fragment<TTypeName, SwitchIfEmpty<MergeVarDefinitions<TVarDefinitions>, void, AssignableInput<TSchema, MergeVarDefinitions<TVarDefinitions>>>, MergeFields<TFieldEntries> & {
+  metadata?: FragmentMetadataBuilder<AssigningInput<TSchema, TVarDefinitions>, ExtractAdapterTypes<TAdapter>["fragmentMetadata"]> | undefined;
+  fields: FieldsBuilder<TSchema, TTypeName, TVarDefinitions, TFields>;
+}) => Fragment<TTypeName, SwitchIfEmpty<TVarDefinitions, void, AssignableInput<TSchema, TVarDefinitions>>, TFields & {
   [key: symbol]: never;
-}, InferFields<TSchema, MergeFields<TFieldEntries>> & {
+}, InferFields<TSchema, TFields> & {
   [key: symbol]: never;
 }> : never };
 //#endregion
 //#region packages/core/src/composer/fragment-usage-context.d.ts
 /**
- * Record of a fragment being embedded in an operation.
+ * Record of a fragment being spread in an operation.
  * Stores metadata builder (not fragment reference) since fragment cannot reference itself.
  *
  * @template TFragmentMetadata - The type of metadata produced by the fragment's metadata builder
@@ -401,7 +386,7 @@ declare const createGqlFragmentComposers: <TSchema extends AnyGraphqlSchema, TAd
 type FragmentUsageRecord<TFragmentMetadata = unknown> = {
   /** Metadata builder factory from the fragment, if defined */
   readonly metadataBuilder: (() => TFragmentMetadata | Promise<TFragmentMetadata>) | null;
-  /** Field path where the fragment was embedded */
+  /** Field path where the fragment was spread */
   readonly path: FieldPath | null;
 };
 /**
@@ -415,15 +400,116 @@ declare const withFragmentUsageCollection: <T>(fn: () => T) => {
   usages: FragmentUsageRecord[];
 };
 /**
- * Record a fragment usage. Called when fragment.embed() is invoked.
+ * Record a fragment usage. Called when fragment.spread() is invoked.
  * No-op if not in a collection context.
  *
  * @internal
  */
 declare const recordFragmentUsage: (record: FragmentUsageRecord) => void;
 //#endregion
+//#region packages/core/src/composer/var-builder.d.ts
+/**
+ * Type for the default value function for a variable.
+ */
+type AssignableDefaultValue<TSchema extends AnyGraphqlSchema, TKind extends InputTypeKind, TName$1 extends string, TModifier extends TypeModifier> = ConstAssignableInputValue<TSchema, {
+  scalar: {
+    kind: "scalar";
+    name: TName$1;
+    modifier: TModifier;
+    directives: {};
+    defaultValue: null;
+  };
+  enum: {
+    kind: "enum";
+    name: TName$1;
+    modifier: TModifier;
+    directives: {};
+    defaultValue: null;
+  };
+  input: {
+    kind: "input";
+    name: TName$1;
+    modifier: TModifier;
+    directives: {};
+    defaultValue: null;
+  };
+}[TKind]>;
+/**
+ * Variable specifier type.
+ */
+type VarSpecifier<TKind extends InputTypeKind, TTypeName$1 extends string, TModifier extends TypeModifier, TDefaultFn extends (() => unknown) | null, TDirectives extends AnyConstDirectiveAttachments> = {
+  kind: TKind;
+  name: TTypeName$1;
+  modifier: TModifier;
+  defaultValue: TDefaultFn extends null ? null : {
+    default: ReturnType<NonNullable<TDefaultFn>>;
+  };
+  directives: TDirectives;
+};
+/**
+ * Creates a variable method for a specific input type.
+ * This is used by codegen to generate type-specific variable methods.
+ *
+ * @deprecated Use createVarMethodFactory instead for proper type inference with nested input objects.
+ */
+declare const createVarMethod: <TKind extends InputTypeKind, TTypeName$1 extends string>(kind: TKind, typeName: TTypeName$1) => <TSchema extends AnyGraphqlSchema, const TModifier extends TypeModifier, const TDefaultFn extends (() => AssignableDefaultValue<TSchema, TKind, TTypeName$1, TModifier>) | null = null, const TDirectives extends AnyConstDirectiveAttachments = {}>(modifier: TModifier, extras?: {
+  default?: TDefaultFn & (() => AssignableDefaultValue<TSchema, TKind, TTypeName$1, TModifier>);
+  directives?: TDirectives;
+}) => VarSpecifier<TKind, TTypeName$1, TModifier, TDefaultFn, TDirectives>;
+/**
+ * Creates a factory function for generating schema-scoped variable methods.
+ * This ensures proper type inference for nested input objects by binding the schema type upfront.
+ *
+ * @example
+ * ```typescript
+ * const createMethod = createVarMethodFactory<typeof schema>();
+ * const inputTypeMethods = {
+ *   Boolean: createMethod("scalar", "Boolean"),
+ *   user_bool_exp: createMethod("input", "user_bool_exp"),
+ * } satisfies InputTypeMethods<typeof schema>;
+ * ```
+ */
+declare const createVarMethodFactory: <TSchema extends AnyGraphqlSchema>() => <TKind extends InputTypeKind, TTypeName$1 extends AllInputTypeNames<TSchema>>(kind: TKind, typeName: TTypeName$1) => InputTypeMethod<TSchema, TKind, TTypeName$1>;
+/**
+ * Type for a single input type method.
+ */
+type InputTypeMethod<TSchema extends AnyGraphqlSchema, TKind extends InputTypeKind, TTypeName$1 extends string> = <const TModifier extends TypeModifier, const TDefaultFn extends (() => AssignableDefaultValue<TSchema, TKind, TTypeName$1, TModifier>) | null = null, const TDirectives extends AnyConstDirectiveAttachments = {}>(modifier: TModifier, extras?: {
+  default?: TDefaultFn & (() => AssignableDefaultValue<TSchema, TKind, TTypeName$1, TModifier>);
+  directives?: TDirectives;
+}) => VarSpecifier<TKind, TTypeName$1, TModifier, TDefaultFn, TDirectives>;
+/**
+ * Type for all input type methods in a schema.
+ */
+type InputTypeMethods<TSchema extends AnyGraphqlSchema> = { [TName in AllInputTypeNames<TSchema>]: InputTypeMethod<TSchema, InferInputKind<TSchema, TName>, TName> };
+/**
+ * Type for a wrapped variable method that includes the variable name in the result.
+ */
+type WrappedVarMethod<TVarName extends string, TSchema extends AnyGraphqlSchema, TKind extends InputTypeKind, TTypeName$1 extends string> = <const TModifier extends TypeModifier, const TDefaultFn extends (() => AssignableDefaultValue<TSchema, TKind, TTypeName$1, TModifier>) | null = null, const TDirectives extends AnyConstDirectiveAttachments = {}>(modifier: TModifier, extras?: {
+  default?: TDefaultFn & (() => AssignableDefaultValue<TSchema, TKind, TTypeName$1, TModifier>);
+  directives?: TDirectives;
+}) => { [K in TVarName]: VarSpecifier<TKind, TTypeName$1, TModifier, TDefaultFn, TDirectives> };
+/**
+ * Type for the variable builder methods for a specific variable name.
+ */
+type VarBuilderMethods<TVarName extends string, TSchema extends AnyGraphqlSchema> = { [TName in AllInputTypeNames<TSchema>]: WrappedVarMethod<TVarName, TSchema, InferInputKind<TSchema, TName>, TName> };
+/**
+ * Type for the variable builder function.
+ */
+type VarBuilder<TSchema extends AnyGraphqlSchema> = {
+  <TVarName extends string>(varName: TVarName): VarBuilderMethods<TVarName, TSchema>;
+  getName: typeof getVarRefName;
+  getValue: typeof getVarRefValue;
+  getInner: typeof getVarRefInner;
+  getNameAt: typeof getNameAt;
+  getValueAt: typeof getValueAt;
+};
+/**
+ * Creates a variable builder that uses injected input type methods.
+ */
+declare const createVarBuilder: <TSchema extends AnyGraphqlSchema>(inputTypeMethods: InputTypeMethods<TSchema>) => VarBuilder<TSchema>;
+//#endregion
 //#region packages/core/src/composer/gql-composer.d.ts
-type GqlElementComposer<TComposers, THelper> = <TResult extends AnyFragment | AnyOperation>(composeElement: (composers: TComposers, helper: THelper) => TResult) => TResult;
+type GqlElementComposer<TContext> = <TResult extends AnyFragment | AnyOperation>(composeElement: (context: TContext) => TResult) => TResult;
 /**
  * Extracts the helpers type from an adapter.
  */
@@ -435,223 +521,66 @@ type ExtractHelpers<TAdapter extends AnyAdapter> = TAdapter extends Adapter<infe
 type ExtractMetadataAdapter<TAdapter extends AnyAdapter> = TAdapter extends {
   metadata?: infer M;
 } ? NonNullable<M> extends AnyMetadataAdapter ? NonNullable<M> : DefaultMetadataAdapter : DefaultMetadataAdapter;
-type GqlElementComposerOptions<TAdapter extends AnyAdapter = DefaultAdapter> = {
+type GqlElementComposerOptions<TSchema extends AnyGraphqlSchema, TAdapter extends AnyAdapter = DefaultAdapter> = {
   adapter?: TAdapter;
+  inputTypeMethods: InputTypeMethods<TSchema>;
 };
-declare const createGqlElementComposer: <TSchema extends AnyGraphqlSchema, TAdapter extends AnyAdapter = DefaultAdapter>(schema: NoInfer<TSchema>, options?: GqlElementComposerOptions<NoInfer<TAdapter>>) => GqlElementComposer<{
-  fragment: { readonly [TTypeName in keyof TSchema["object"]]: TTypeName extends string ? <TFieldEntries extends AnyFields[], TVarDefinitions extends InputTypeSpecifiers[] = [{}]>(options: {
+declare const createGqlElementComposer: <TSchema extends AnyGraphqlSchema, TAdapter extends AnyAdapter = DefaultAdapter>(schema: NoInfer<TSchema>, options: GqlElementComposerOptions<NoInfer<TSchema>, NoInfer<TAdapter>>) => GqlElementComposer<{
+  fragment: { readonly [TTypeName in keyof TSchema["object"]]: TTypeName extends string ? <TFields extends AnyFields, TVarDefinitions extends InputTypeSpecifiers = {}>(options: {
     variables?: TVarDefinitions | undefined;
-    metadata?: FragmentMetadataBuilder<AssigningInput<TSchema, MergeVarDefinitions<TVarDefinitions>>, ExtractAdapterTypes<ExtractMetadataAdapter<TAdapter>>["fragmentMetadata"]> | undefined;
-  }, builder: FieldsBuilder<TSchema, TTypeName, MergeVarDefinitions<TVarDefinitions>, TFieldEntries>) => Fragment<TTypeName, SwitchIfEmpty<MergeVarDefinitions<TVarDefinitions>, void, AssignableInput<TSchema, MergeVarDefinitions<TVarDefinitions>>>, MergeFields<TFieldEntries> & {
+    metadata?: FragmentMetadataBuilder<AssigningInput<TSchema, TVarDefinitions>, ExtractAdapterTypes<ExtractMetadataAdapter<TAdapter>>["fragmentMetadata"]> | undefined;
+    fields: FieldsBuilder<TSchema, TTypeName, TVarDefinitions, TFields>;
+  }) => Fragment<TTypeName, SwitchIfEmpty<TVarDefinitions, void, AssignableInput<TSchema, TVarDefinitions>>, TFields & {
     [key: symbol]: never;
-  }, InferFields<TSchema, MergeFields<TFieldEntries>> & {
+  }, InferFields<TSchema, TFields> & {
     [key: symbol]: never;
   }> : never };
   query: {
-    operation: <TOperationName extends string, TFields extends AnyFields[], TVarDefinitions_1 extends InputTypeSpecifiers[] = [{}], TOperationMetadata = unknown>(options: {
+    operation: <TOperationName extends string, TFields extends AnyFields, TVarDefinitions_1 extends InputTypeSpecifiers = {}, TOperationMetadata = unknown>(options: {
       name: TOperationName;
       variables?: TVarDefinitions_1 | undefined;
-      metadata?: MetadataBuilder<AssigningInput<TSchema, MergeVarDefinitions<TVarDefinitions_1>>, TOperationMetadata, ExtractAdapterTypes<ExtractMetadataAdapter<TAdapter>>["aggregatedFragmentMetadata"], ExtractAdapterTypes<ExtractMetadataAdapter<TAdapter>>["schemaLevel"]> | undefined;
-    }, fieldBuilder: FieldsBuilder<TSchema, TSchema["operations"]["query"] & keyof TSchema["object"] & string, MergeVarDefinitions<TVarDefinitions_1>, TFields>) => Operation<"query", TOperationName, (keyof MergeVarDefinitions<TVarDefinitions_1> & string)[], ConstAssignableInput<TSchema, MergeVarDefinitions<TVarDefinitions_1>>, MergeFields<TFields>, InferFields<TSchema, MergeFields<TFields>>>;
+      metadata?: MetadataBuilder<AssigningInput<TSchema, TVarDefinitions_1>, TOperationMetadata, ExtractAdapterTypes<ExtractMetadataAdapter<TAdapter>>["aggregatedFragmentMetadata"], ExtractAdapterTypes<ExtractMetadataAdapter<TAdapter>>["schemaLevel"]> | undefined;
+      fields: FieldsBuilder<TSchema, TSchema["operations"]["query"] & keyof TSchema["object"] & string, TVarDefinitions_1, TFields>;
+    }) => Operation<"query", TOperationName, (keyof TVarDefinitions_1 & string)[], ConstAssignableInput<TSchema, TVarDefinitions_1>, TFields, InferFields<TSchema, TFields>>;
   };
   mutation: {
-    operation: <TOperationName extends string, TFields extends AnyFields[], TVarDefinitions_1 extends InputTypeSpecifiers[] = [{}], TOperationMetadata = unknown>(options: {
+    operation: <TOperationName extends string, TFields extends AnyFields, TVarDefinitions_1 extends InputTypeSpecifiers = {}, TOperationMetadata = unknown>(options: {
       name: TOperationName;
       variables?: TVarDefinitions_1 | undefined;
-      metadata?: MetadataBuilder<AssigningInput<TSchema, MergeVarDefinitions<TVarDefinitions_1>>, TOperationMetadata, ExtractAdapterTypes<ExtractMetadataAdapter<TAdapter>>["aggregatedFragmentMetadata"], ExtractAdapterTypes<ExtractMetadataAdapter<TAdapter>>["schemaLevel"]> | undefined;
-    }, fieldBuilder: FieldsBuilder<TSchema, TSchema["operations"]["mutation"] & keyof TSchema["object"] & string, MergeVarDefinitions<TVarDefinitions_1>, TFields>) => Operation<"mutation", TOperationName, (keyof MergeVarDefinitions<TVarDefinitions_1> & string)[], ConstAssignableInput<TSchema, MergeVarDefinitions<TVarDefinitions_1>>, MergeFields<TFields>, InferFields<TSchema, MergeFields<TFields>>>;
+      metadata?: MetadataBuilder<AssigningInput<TSchema, TVarDefinitions_1>, TOperationMetadata, ExtractAdapterTypes<ExtractMetadataAdapter<TAdapter>>["aggregatedFragmentMetadata"], ExtractAdapterTypes<ExtractMetadataAdapter<TAdapter>>["schemaLevel"]> | undefined;
+      fields: FieldsBuilder<TSchema, TSchema["operations"]["mutation"] & keyof TSchema["object"] & string, TVarDefinitions_1, TFields>;
+    }) => Operation<"mutation", TOperationName, (keyof TVarDefinitions_1 & string)[], ConstAssignableInput<TSchema, TVarDefinitions_1>, TFields, InferFields<TSchema, TFields>>;
   };
   subscription: {
-    operation: <TOperationName extends string, TFields extends AnyFields[], TVarDefinitions_1 extends InputTypeSpecifiers[] = [{}], TOperationMetadata = unknown>(options: {
+    operation: <TOperationName extends string, TFields extends AnyFields, TVarDefinitions_1 extends InputTypeSpecifiers = {}, TOperationMetadata = unknown>(options: {
       name: TOperationName;
       variables?: TVarDefinitions_1 | undefined;
-      metadata?: MetadataBuilder<AssigningInput<TSchema, MergeVarDefinitions<TVarDefinitions_1>>, TOperationMetadata, ExtractAdapterTypes<ExtractMetadataAdapter<TAdapter>>["aggregatedFragmentMetadata"], ExtractAdapterTypes<ExtractMetadataAdapter<TAdapter>>["schemaLevel"]> | undefined;
-    }, fieldBuilder: FieldsBuilder<TSchema, TSchema["operations"]["subscription"] & keyof TSchema["object"] & string, MergeVarDefinitions<TVarDefinitions_1>, TFields>) => Operation<"subscription", TOperationName, (keyof MergeVarDefinitions<TVarDefinitions_1> & string)[], ConstAssignableInput<TSchema, MergeVarDefinitions<TVarDefinitions_1>>, MergeFields<TFields>, InferFields<TSchema, MergeFields<TFields>>>;
-  };
-}, {
-  $var: {
-    <TVarName extends string>(varName: TVarName): {
-      scalar: <const TTypeName_1 extends keyof TSchema["scalar"] & string, const TModifier extends TypeModifier, const TDefaultFn extends (() => GetConstAssignableType<InferInputProfile<TSchema, {
-        kind: "scalar";
-        name: TTypeName_1;
-        modifier: TModifier;
-        directives: {};
-        defaultValue: null;
-      }>> & {}) | null = null, const TDirectives extends AnyConstDirectiveAttachments = {}>(type: ModifiedTypeName<[keyof TSchema["scalar"] & string], TTypeName_1, TModifier>, extras?: {
-        default?: (TDefaultFn & (() => GetConstAssignableType<InferInputProfile<TSchema, {
-          kind: "scalar";
-          name: TTypeName_1;
-          modifier: TModifier;
-          directives: {};
-          defaultValue: null;
-        }>> & {})) | (NoInfer<TDefaultFn> extends null ? () => GetConstAssignableType<InferInputProfile<TSchema, {
-          kind: "scalar";
-          name: TTypeName_1;
-          modifier: TModifier;
-          directives: {};
-          defaultValue: null;
-        }>> & {} : never) | undefined;
-        directives?: TDirectives | undefined;
-      } | undefined) => { [K in TVarName]: {
-        kind: "scalar";
-        name: TTypeName_1;
-        modifier: TModifier;
-        defaultValue: TDefaultFn extends null ? null : {
-          default: ReturnType<NonNullable<TDefaultFn>>;
-        };
-        directives: TDirectives;
-      } };
-      enum: <const TTypeName_1 extends keyof TSchema["enum"] & string, const TModifier extends TypeModifier, const TDefaultFn extends (() => GetConstAssignableType<InferInputProfile<TSchema, {
-        kind: "enum";
-        name: TTypeName_1;
-        modifier: TModifier;
-        directives: {};
-        defaultValue: null;
-      }>> & {}) | null = null, const TDirectives extends AnyConstDirectiveAttachments = {}>(type: ModifiedTypeName<[keyof TSchema["enum"] & string], TTypeName_1, TModifier>, extras?: {
-        default?: (TDefaultFn & (() => GetConstAssignableType<InferInputProfile<TSchema, {
-          kind: "enum";
-          name: TTypeName_1;
-          modifier: TModifier;
-          directives: {};
-          defaultValue: null;
-        }>> & {})) | (NoInfer<TDefaultFn> extends null ? () => GetConstAssignableType<InferInputProfile<TSchema, {
-          kind: "enum";
-          name: TTypeName_1;
-          modifier: TModifier;
-          directives: {};
-          defaultValue: null;
-        }>> & {} : never) | undefined;
-        directives?: TDirectives | undefined;
-      } | undefined) => { [K in TVarName]: {
-        kind: "enum";
-        name: TTypeName_1;
-        modifier: TModifier;
-        defaultValue: TDefaultFn extends null ? null : {
-          default: ReturnType<NonNullable<TDefaultFn>>;
-        };
-        directives: TDirectives;
-      } };
-      input: <const TTypeName_1 extends keyof TSchema["input"] & string, const TModifier extends TypeModifier, const TDefaultFn extends (() => GetConstAssignableType<InferInputProfile<TSchema, {
-        kind: "input";
-        name: TTypeName_1;
-        modifier: TModifier;
-        directives: {};
-        defaultValue: null;
-      }>> & {}) | null = null, const TDirectives extends AnyConstDirectiveAttachments = {}>(type: ModifiedTypeName<[keyof TSchema["input"] & string], TTypeName_1, TModifier>, extras?: {
-        default?: (TDefaultFn & (() => GetConstAssignableType<InferInputProfile<TSchema, {
-          kind: "input";
-          name: TTypeName_1;
-          modifier: TModifier;
-          directives: {};
-          defaultValue: null;
-        }>> & {})) | (NoInfer<TDefaultFn> extends null ? () => GetConstAssignableType<InferInputProfile<TSchema, {
-          kind: "input";
-          name: TTypeName_1;
-          modifier: TModifier;
-          directives: {};
-          defaultValue: null;
-        }>> & {} : never) | undefined;
-        directives?: TDirectives | undefined;
-      } | undefined) => { [K in TVarName]: {
-        kind: "input";
-        name: TTypeName_1;
-        modifier: TModifier;
-        defaultValue: TDefaultFn extends null ? null : {
-          default: ReturnType<NonNullable<TDefaultFn>>;
-        };
-        directives: TDirectives;
-      } };
-      byField: <const TTypeName_1 extends keyof TSchema["object"] & string, const TFieldName$1 extends keyof TSchema["object"][TTypeName_1]["fields"] & string, const TArgName extends keyof TSchema["object"][TTypeName_1]["fields"][TFieldName$1]["arguments"] & string>(typeName: TTypeName_1, fieldName: TFieldName$1, argName: TArgName) => TSchema["object"][TTypeName_1]["fields"][TFieldName$1]["arguments"][TArgName];
-    };
-    getName: (varRef: AnyVarRef) => string;
-    getValue: (varRef: AnyVarRef) => ConstValue;
-    getInner: (varRef: AnyVarRef) => VarRefInner;
+      metadata?: MetadataBuilder<AssigningInput<TSchema, TVarDefinitions_1>, TOperationMetadata, ExtractAdapterTypes<ExtractMetadataAdapter<TAdapter>>["aggregatedFragmentMetadata"], ExtractAdapterTypes<ExtractMetadataAdapter<TAdapter>>["schemaLevel"]> | undefined;
+      fields: FieldsBuilder<TSchema, TSchema["operations"]["subscription"] & keyof TSchema["object"] & string, TVarDefinitions_1, TFields>;
+    }) => Operation<"subscription", TOperationName, (keyof TVarDefinitions_1 & string)[], ConstAssignableInput<TSchema, TVarDefinitions_1>, TFields, InferFields<TSchema, TFields>>;
   };
+  $var: VarBuilder<TSchema>;
   $colocate: <TEntries extends ColocatedEntries>(entries: TEntries) => ColocatedFields<TEntries>;
 } & ExtractHelpers<TAdapter>>;
 //#endregion
+//#region packages/core/src/composer/input.d.ts
+declare const createVarAssignments: <TSchema extends AnyGraphqlSchema, TVariableDefinitions extends InputTypeSpecifiers>(definitions: TVariableDefinitions, providedValues: AnyAssignableInput | void) => AssigningInput<TSchema, TVariableDefinitions>;
+declare const createVarRefs: <TSchema extends AnyGraphqlSchema, TVarDefinitions extends InputTypeSpecifiers>(definitions: TVarDefinitions) => AssigningInput<TSchema, TVarDefinitions>;
+//#endregion
 //#region packages/core/src/composer/operation.d.ts
-declare const createOperationComposerFactory: <TSchema extends AnyGraphqlSchema, TAdapter extends AnyMetadataAdapter = DefaultMetadataAdapter>(schema: NoInfer<TSchema>, adapter?: TAdapter) => <TOperationType extends OperationType>(operationType: TOperationType) => <TOperationName extends string, TFields extends AnyFields[], TVarDefinitions extends InputTypeSpecifiers[] = [{}], TOperationMetadata = unknown>(options: {
+declare const createOperationComposerFactory: <TSchema extends AnyGraphqlSchema, TAdapter extends AnyMetadataAdapter = DefaultMetadataAdapter>(schema: NoInfer<TSchema>, adapter?: TAdapter) => <TOperationType extends OperationType>(operationType: TOperationType) => <TOperationName extends string, TFields extends AnyFields, TVarDefinitions extends InputTypeSpecifiers = {}, TOperationMetadata = unknown>(options: {
   name: TOperationName;
   variables?: TVarDefinitions;
-  metadata?: MetadataBuilder<ReturnType<typeof createVarRefs<TSchema, MergeVarDefinitions<TVarDefinitions>>>, TOperationMetadata, ExtractAdapterTypes<TAdapter>["aggregatedFragmentMetadata"], ExtractAdapterTypes<TAdapter>["schemaLevel"]>;
-}, fieldBuilder: FieldsBuilder<TSchema, TSchema["operations"][TOperationType] & keyof TSchema["object"] & string, MergeVarDefinitions<TVarDefinitions>, TFields>) => Operation<TOperationType, TOperationName, (keyof MergeVarDefinitions<TVarDefinitions> & string)[], ConstAssignableInput<TSchema, MergeVarDefinitions<TVarDefinitions>>, MergeFields<TFields>, InferFields<TSchema, MergeFields<TFields>>>;
-//#endregion
-//#region packages/core/src/composer/var-builder.d.ts
-type AssignableDefaultValue<TSchema extends AnyGraphqlSchema, TKind extends "scalar" | "enum" | "input", TName extends keyof TSchema[TKind] & string, TModifier extends TypeModifier> = ConstAssignableInputValue<TSchema, {
-  scalar: {
-    kind: "scalar";
-    name: TName;
-    modifier: TModifier;
-    directives: {};
-    defaultValue: null;
-  };
-  enum: {
-    kind: "enum";
-    name: TName;
-    modifier: TModifier;
-    directives: {};
-    defaultValue: null;
-  };
-  input: {
-    kind: "input";
-    name: TName;
-    modifier: TModifier;
-    directives: {};
-    defaultValue: null;
-  };
-}[TKind]>;
-declare const createVarBuilder: <TSchema extends AnyGraphqlSchema>(schema: TSchema) => {
-  <TVarName extends string>(varName: TVarName): {
-    scalar: <const TTypeName$1 extends keyof TSchema["scalar"] & string, const TModifier extends TypeModifier, const TDefaultFn extends (() => AssignableDefaultValue<TSchema, "scalar", TTypeName$1, TModifier>) | null = null, const TDirectives extends AnyConstDirectiveAttachments = {}>(type: ModifiedTypeName<[keyof TSchema["scalar"] & string], TTypeName$1, TModifier>, extras?: {
-      default?: (TDefaultFn & (() => AssignableDefaultValue<TSchema, "scalar", TTypeName$1, TModifier>)) | (NoInfer<TDefaultFn> extends null ? () => AssignableDefaultValue<TSchema, "scalar", TTypeName$1, TModifier> : never) | undefined;
-      directives?: TDirectives | undefined;
-    } | undefined) => { [K in TVarName]: {
-      kind: "scalar";
-      name: TTypeName$1;
-      modifier: TModifier;
-      defaultValue: TDefaultFn extends null ? null : {
-        default: ReturnType<NonNullable<TDefaultFn>>;
-      };
-      directives: TDirectives;
-    } };
-    enum: <const TTypeName$1 extends keyof TSchema["enum"] & string, const TModifier extends TypeModifier, const TDefaultFn extends (() => AssignableDefaultValue<TSchema, "enum", TTypeName$1, TModifier>) | null = null, const TDirectives extends AnyConstDirectiveAttachments = {}>(type: ModifiedTypeName<[keyof TSchema["enum"] & string], TTypeName$1, TModifier>, extras?: {
-      default?: (TDefaultFn & (() => AssignableDefaultValue<TSchema, "enum", TTypeName$1, TModifier>)) | (NoInfer<TDefaultFn> extends null ? () => AssignableDefaultValue<TSchema, "enum", TTypeName$1, TModifier> : never) | undefined;
-      directives?: TDirectives | undefined;
-    } | undefined) => { [K in TVarName]: {
-      kind: "enum";
-      name: TTypeName$1;
-      modifier: TModifier;
-      defaultValue: TDefaultFn extends null ? null : {
-        default: ReturnType<NonNullable<TDefaultFn>>;
-      };
-      directives: TDirectives;
-    } };
-    input: <const TTypeName$1 extends keyof TSchema["input"] & string, const TModifier extends TypeModifier, const TDefaultFn extends (() => AssignableDefaultValue<TSchema, "input", TTypeName$1, TModifier>) | null = null, const TDirectives extends AnyConstDirectiveAttachments = {}>(type: ModifiedTypeName<[keyof TSchema["input"] & string], TTypeName$1, TModifier>, extras?: {
-      default?: (TDefaultFn & (() => AssignableDefaultValue<TSchema, "input", TTypeName$1, TModifier>)) | (NoInfer<TDefaultFn> extends null ? () => AssignableDefaultValue<TSchema, "input", TTypeName$1, TModifier> : never) | undefined;
-      directives?: TDirectives | undefined;
-    } | undefined) => { [K in TVarName]: {
-      kind: "input";
-      name: TTypeName$1;
-      modifier: TModifier;
-      defaultValue: TDefaultFn extends null ? null : {
-        default: ReturnType<NonNullable<TDefaultFn>>;
-      };
-      directives: TDirectives;
-    } };
-    byField: <const TTypeName$1 extends keyof TSchema["object"] & string, const TFieldName$1 extends keyof TSchema["object"][TTypeName$1]["fields"] & string, const TArgName extends keyof TSchema["object"][TTypeName$1]["fields"][TFieldName$1]["arguments"] & string>(typeName: TTypeName$1, fieldName: TFieldName$1, argName: TArgName) => TSchema["object"][TTypeName$1]["fields"][TFieldName$1]["arguments"][TArgName];
-  };
-  getName: (varRef: AnyVarRef) => string;
-  getValue: (varRef: AnyVarRef) => ConstValue;
-  getInner: (varRef: AnyVarRef) => VarRefInner;
-};
+  metadata?: MetadataBuilder<ReturnType<typeof createVarRefs<TSchema, TVarDefinitions>>, TOperationMetadata, ExtractAdapterTypes<TAdapter>["aggregatedFragmentMetadata"], ExtractAdapterTypes<TAdapter>["schemaLevel"]>;
+  fields: FieldsBuilder<TSchema, TSchema["operations"][TOperationType] & keyof TSchema["object"] & string, TVarDefinitions, TFields>;
+}) => Operation<TOperationType, TOperationName, (keyof TVarDefinitions & string)[], ConstAssignableInput<TSchema, TVarDefinitions>, TFields, InferFields<TSchema, TFields>>;
 //#endregion
 //#region packages/core/src/utils/hidden.d.ts
 declare const hidden: <T>() => (() => T);
 type Hidden<T> = () => T;
 //#endregion
 //#region packages/core/src/utils/wrap-by-key.d.ts
-declare function wrapByKey<TName extends string, TValue>(name: TName, value: TValue): { [K in TName]: TValue };
+declare function wrapByKey<TName$1 extends string, TValue>(name: TName$1, value: TValue): { [K in TName$1]: TValue };
 //#endregion
-export { StripFunctions as $, AnyFieldSelectionFactoryReturn as A, ModifiedTypeName as At, MergeFields as B, Fragment as C, AssigningInput as Ct, GqlElementContext as D, ConstAssignableInput as Dt, GqlElementAttachment as E, AnyConstAssignableInputValue as Et, FieldSelectionFactoryPrimitiveReturn as F, EmptyObject as G, NestedObjectFieldsBuilderTools as H, FieldSelectionFactoryReturn as I, empty as J, IfEmpty as K, FieldSelectionFactoryUnionReturn as L, FieldSelectionFactory as M, FieldSelectionFactoryFieldArguments as N, GqlElementDefinitionFactory as O, ConstAssignableInputValue as Ot, FieldSelectionFactoryObjectReturn as P, createColocateHelper as Q, FieldsBuilder as R, AnyFragment as S, AssignableInputValue as St, GqlElement as T, AnyConstAssignableInput as Tt, NestedUnionFieldsBuilder as U, NestedObjectFieldsBuilder as V, mergeFields as W, ColocatedEntries as X, ColocateHelper as Y, ColocatedFields as Z, createFieldFactories as _, AnyAssignableInput as _t, createOperationComposerFactory as a, buildDocument as at, Operation as b, AssignableInput as bt, createGqlElementComposer as c, AbstractFieldSelection as ct, withFragmentUsageCollection as d, AnyNestedObject as dt, StripSymbols as et, createGqlFragmentComposers as f, AnyNestedUnion as ft, mergeVarDefinitions as g, AnyDirectiveAttachments as gt, createVarRefs as h, InferFields as ht, createVarBuilder as i, buildConstValueNode as it, FieldSelectionFactories as j, parseModifiedTypeName as jt, AnyFieldSelectionFactory as k, GetAssignableType as kt, FragmentUsageRecord as l, AnyFieldSelection as lt, createVarAssignments as m, InferField as mt, Hidden as n, UnionToIntersection as nt, GqlElementComposer as o, buildOperationTypeNode as ot, MergeVarDefinitions as p, FieldSelectionTemplateOf as pt, SwitchIfEmpty as q, hidden as r, buildArgumentValue as rt, GqlElementComposerOptions as s, buildWithTypeModifier as st, wrapByKey as t, Tuple as tt, recordFragmentUsage as u, AnyFields as ut, AnyOperation as v, AnyAssignableInputValue as vt, FragmentInferMeta as w, AnyConstDirectiveAttachments as wt, OperationInferMeta as x, AssignableInputByFieldName as xt, AnyOperationOf as y, AnyAssigningInput as yt, FieldsBuilderTools as z };
-//# sourceMappingURL=index-B-erotAZ.d.cts.map
+export { ColocatedEntries as $, GqlElement as A, ConstAssignableInput as At, FieldSelectionFactoryPrimitiveReturn as B, AnyOperation as C, AssignableInput as Ct, AnyFragment as D, AnyConstDirectiveAttachments as Dt, OperationInferMeta as E, AssigningInput as Et, AnyFieldSelectionFactoryReturn as F, NestedObjectFieldsBuilder as G, FieldSelectionFactoryUnionReturn as H, FieldSelectionFactories as I, EmptyObject as J, NestedObjectFieldsBuilderTools as K, FieldSelectionFactory as L, GqlElementContext as M, GetAssignableType as Mt, GqlElementDefinitionFactory as N, Fragment as O, AnyConstAssignableInput as Ot, AnyFieldSelectionFactory as P, ColocateHelper as Q, FieldSelectionFactoryFieldArguments as R, createFieldFactories as S, AnyAssigningInput as St, Operation as T, AssignableInputValue as Tt, FieldsBuilder as U, FieldSelectionFactoryReturn as V, FieldsBuilderTools as W, SwitchIfEmpty as X, IfEmpty as Y, empty as Z, createVarMethodFactory as _, InferField as _t, createVarAssignments as a, UnionToIntersection as at, withFragmentUsageCollection as b, AnyAssignableInput as bt, GqlElementComposerOptions as c, buildDocument as ct, InputTypeMethods as d, AbstractFieldSelection as dt, ColocatedFields as et, VarBuilder as f, AnyFieldSelection as ft, createVarMethod as g, FieldSelectionTemplateOf as gt, createVarBuilder as h, AnyNestedUnion as ht, createOperationComposerFactory as i, Tuple as it, GqlElementAttachment as j, ConstAssignableInputValue as jt, FragmentInferMeta as k, AnyConstAssignableInputValue as kt, createGqlElementComposer as l, buildOperationTypeNode as lt, VarSpecifier as m, AnyNestedObject as mt, Hidden as n, StripFunctions as nt, createVarRefs as o, buildArgumentValue as ot, VarBuilderMethods as p, AnyFields as pt, NestedUnionFieldsBuilder as q, hidden as r, StripSymbols as rt, GqlElementComposer as s, buildConstValueNode as st, wrapByKey as t, createColocateHelper as tt, InputTypeMethod as u, buildWithTypeModifier as ut, FragmentUsageRecord as v, InferFields as vt, AnyOperationOf as w, AssignableInputByFieldName as wt, createGqlFragmentComposers as x, AnyAssignableInputValue as xt, recordFragmentUsage as y, AnyDirectiveAttachments as yt, FieldSelectionFactoryObjectReturn as z };
+//# sourceMappingURL=index-eFR-ZKOA.d.cts.map