@soda-gql/core 0.1.0 → 0.2.0

package/dist/index-Djr9A4KL.d.ts

@@ -0,0 +1,657 @@
+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-BygZwEX8.js";
+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[];
+  readonly 1: T[] | null | undefined;
+}
+type Ref<TProfile extends TypeProfile.WithMeta> = VarRef<TypeProfile.AssignableVarRefMeta<TProfile>>;
+type Assignable_0<T extends TypeProfile.WithMeta> = TypeProfile.AssignableType<[T[0], "!", T[2]]>;
+type Assignable_1<T extends TypeProfile.WithMeta> = TypeProfile.AssignableType<[T[0], "?", T[2]]>;
+type Assignable_00<T extends TypeProfile.WithMeta> = Ref<[T[0], "![]!", T[2]]> | Op<Assignable_0<[T[0], "!"]>>[0];
+type Assignable_01<T extends TypeProfile.WithMeta> = Ref<[T[0], "![]?", T[2]]> | Op<Assignable_0<[T[0], "!"]>>[1];
+type Assignable_10<T extends TypeProfile.WithMeta> = Ref<[T[0], "?[]!", T[2]]> | Op<Assignable_1<[T[0], "?"]>>[0];
+type Assignable_11<T extends TypeProfile.WithMeta> = Ref<[T[0], "?[]?", T[2]]> | Op<Assignable_1<[T[0], "?"]>>[1];
+type Assignable_000<T extends TypeProfile.WithMeta> = Ref<[T[0], "![]![]!", T[2]]> | Op<Assignable_00<[T[0], "!"]>>[0];
+type Assignable_001<T extends TypeProfile.WithMeta> = Ref<[T[0], "![]![]?", T[2]]> | Op<Assignable_00<[T[0], "!"]>>[1];
+type Assignable_010<T extends TypeProfile.WithMeta> = Ref<[T[0], "![]?[]!", T[2]]> | Op<Assignable_01<[T[0], "!"]>>[0];
+type Assignable_011<T extends TypeProfile.WithMeta> = Ref<[T[0], "![]?[]?", T[2]]> | Op<Assignable_01<[T[0], "!"]>>[1];
+type Assignable_100<T extends TypeProfile.WithMeta> = Ref<[T[0], "?[]![]!", T[2]]> | Op<Assignable_10<[T[0], "?"]>>[0];
+type Assignable_101<T extends TypeProfile.WithMeta> = Ref<[T[0], "?[]![]?", T[2]]> | Op<Assignable_10<[T[0], "?"]>>[1];
+type Assignable_110<T extends TypeProfile.WithMeta> = Ref<[T[0], "?[]?[]!", T[2]]> | Op<Assignable_11<[T[0], "?"]>>[0];
+type Assignable_111<T extends TypeProfile.WithMeta> = Ref<[T[0], "?[]?[]?", T[2]]> | Op<Assignable_11<[T[0], "?"]>>[1];
+type Assignable_0000<T extends TypeProfile.WithMeta> = Ref<[T[0], "![]![]![]!", T[2]]> | Op<Assignable_000<[T[0], "!"]>>[0];
+type Assignable_0001<T extends TypeProfile.WithMeta> = Ref<[T[0], "![]![]![]?", T[2]]> | Op<Assignable_000<[T[0], "!"]>>[1];
+type Assignable_0010<T extends TypeProfile.WithMeta> = Ref<[T[0], "![]![]?[]!", T[2]]> | Op<Assignable_001<[T[0], "!"]>>[0];
+type Assignable_0011<T extends TypeProfile.WithMeta> = Ref<[T[0], "![]![]?[]?", T[2]]> | Op<Assignable_001<[T[0], "!"]>>[1];
+type Assignable_0100<T extends TypeProfile.WithMeta> = Ref<[T[0], "![]?[]![]!", T[2]]> | Op<Assignable_010<[T[0], "!"]>>[0];
+type Assignable_0101<T extends TypeProfile.WithMeta> = Ref<[T[0], "![]?[]![]?", T[2]]> | Op<Assignable_010<[T[0], "!"]>>[1];
+type Assignable_0110<T extends TypeProfile.WithMeta> = Ref<[T[0], "![]?[]?[]!", T[2]]> | Op<Assignable_011<[T[0], "!"]>>[0];
+type Assignable_0111<T extends TypeProfile.WithMeta> = Ref<[T[0], "![]?[]?[]?", T[2]]> | Op<Assignable_011<[T[0], "!"]>>[1];
+type Assignable_1000<T extends TypeProfile.WithMeta> = Ref<[T[0], "?[]![]![]!", T[2]]> | Op<Assignable_100<[T[0], "?"]>>[0];
+type Assignable_1001<T extends TypeProfile.WithMeta> = Ref<[T[0], "?[]![]![]?", T[2]]> | Op<Assignable_100<[T[0], "?"]>>[1];
+type Assignable_1010<T extends TypeProfile.WithMeta> = Ref<[T[0], "?[]![]?[]!", T[2]]> | Op<Assignable_101<[T[0], "?"]>>[0];
+type Assignable_1011<T extends TypeProfile.WithMeta> = Ref<[T[0], "?[]![]?[]?", T[2]]> | Op<Assignable_101<[T[0], "?"]>>[1];
+type Assignable_1100<T extends TypeProfile.WithMeta> = Ref<[T[0], "?[]?[]![]!", T[2]]> | Op<Assignable_110<[T[0], "?"]>>[0];
+type Assignable_1101<T extends TypeProfile.WithMeta> = Ref<[T[0], "?[]?[]![]?", T[2]]> | Op<Assignable_110<[T[0], "?"]>>[1];
+type Assignable_1110<T extends TypeProfile.WithMeta> = Ref<[T[0], "?[]?[]?[]!", T[2]]> | Op<Assignable_111<[T[0], "?"]>>[0];
+type Assignable_1111<T extends TypeProfile.WithMeta> = Ref<[T[0], "?[]?[]?[]?", T[2]]> | Op<Assignable_111<[T[0], "?"]>>[1];
+type GetAssignableType<T extends TypeProfile.WithMeta> = T[1] extends "!" ? Assignable_0<T> : T[1] extends "?" ? Assignable_1<T> : T[1] extends "![]!" ? Assignable_00<T> : T[1] extends "![]?" ? Assignable_01<T> : T[1] extends "?[]!" ? Assignable_10<T> : T[1] extends "?[]?" ? Assignable_11<T> : T[1] extends "![]![]!" ? Assignable_000<T> : T[1] extends "![]![]?" ? Assignable_001<T> : T[1] extends "![]?[]!" ? Assignable_010<T> : T[1] extends "![]?[]?" ? Assignable_011<T> : T[1] extends "?[]![]!" ? Assignable_100<T> : T[1] extends "?[]![]?" ? Assignable_101<T> : T[1] extends "?[]?[]!" ? Assignable_110<T> : T[1] extends "?[]?[]?" ? Assignable_111<T> : T[1] extends "![]![]![]!" ? Assignable_0000<T> : T[1] extends "![]![]![]?" ? Assignable_0001<T> : T[1] extends "![]![]?[]!" ? Assignable_0010<T> : T[1] extends "![]![]?[]?" ? Assignable_0011<T> : T[1] extends "![]?[]![]!" ? Assignable_0100<T> : T[1] extends "![]?[]![]?" ? Assignable_0101<T> : T[1] extends "![]?[]?[]!" ? Assignable_0110<T> : T[1] extends "![]?[]?[]?" ? Assignable_0111<T> : T[1] extends "?[]![]![]!" ? Assignable_1000<T> : T[1] extends "?[]![]![]?" ? Assignable_1001<T> : T[1] extends "?[]![]?[]!" ? Assignable_1010<T> : T[1] extends "?[]![]?[]?" ? Assignable_1011<T> : T[1] extends "?[]?[]![]!" ? Assignable_1100<T> : T[1] extends "?[]?[]![]?" ? Assignable_1101<T> : T[1] extends "?[]?[]?[]!" ? Assignable_1110<T> : T[1] extends "?[]?[]?[]?" ? Assignable_1111<T> : never;
+//#endregion
+//#region packages/core/src/types/schema/const-assignable-input.d.ts
+type AnyConstAssignableInputValue = ConstValue;
+type AnyConstAssignableInput = {
+  readonly [key: string]: AnyConstAssignableInputValue;
+};
+type IsOptional$1<TSpecifier$1 extends InputTypeSpecifier> = TSpecifier$1["modifier"] extends `${string}?` ? true : TSpecifier$1["defaultValue"] extends AnyDefaultValue ? true : false;
+type ConstAssignableInput<TSchema extends AnyGraphqlSchema, TSpecifiers extends InputTypeSpecifiers> = { readonly [K in keyof TSpecifiers as IsOptional$1<TSpecifiers[K]> extends true ? K : never]+?: ConstAssignableInputValue<TSchema, TSpecifiers[K]> } & { readonly [K in keyof TSpecifiers as IsOptional$1<TSpecifiers[K]> extends false ? K : never]-?: ConstAssignableInputValue<TSchema, TSpecifiers[K]> };
+type ConstAssignableInputValue<TSchema extends AnyGraphqlSchema, TSpecifier$1 extends InputTypeSpecifier> = GetConstAssignableType<InferInputProfile<TSchema, TSpecifier$1>> & {};
+//#endregion
+//#region packages/core/src/types/schema/const-directives.d.ts
+type AnyConstDirectiveAttachments = {
+  readonly [key: string]: AnyConstAssignableInputValue;
+};
+//#endregion
+//#region packages/core/src/types/fragment/assignable-input.d.ts
+type AnyAssignableInputValue = ConstValue | AnyVarRef | {
+  [key: string]: AnyAssignableInputValue;
+} | AnyAssignableInputValue[] | undefined | null;
+type AnyAssignableInput = {
+  readonly [key: string]: AnyAssignableInputValue;
+};
+type AnyAssigningInput = {
+  readonly [key: string]: AnyVarRef;
+};
+type IsOptional<TSpecifier$1 extends InputTypeSpecifier> = TSpecifier$1["modifier"] extends `${string}?` ? true : TSpecifier$1["defaultValue"] extends AnyDefaultValue ? true : false;
+type AssignableInput<TSchema extends AnyGraphqlSchema, TSpecifiers extends InputTypeSpecifiers> = { readonly [K in keyof TSpecifiers as IsOptional<TSpecifiers[K]> extends true ? K : never]+?: AssignableInputValue<TSchema, TSpecifiers[K]> } & { readonly [K in keyof TSpecifiers as IsOptional<TSpecifiers[K]> extends false ? K : never]-?: AssignableInputValue<TSchema, TSpecifiers[K]> };
+type AssignableInputValue<TSchema extends AnyGraphqlSchema, TSpecifier$1 extends InputTypeSpecifier> = GetAssignableType<InferInputProfile<TSchema, TSpecifier$1>>;
+type AssigningInput<TSchema extends AnyGraphqlSchema, TSpecifiers extends InputTypeSpecifiers> = { readonly [K in keyof TSpecifiers]-?: GetAssigningType<InferInputProfile<TSchema, TSpecifiers[K]>> };
+type AssignableInputByFieldName<TSchema extends AnyGraphqlSchema, TTypeName$1 extends keyof TSchema["object"], TFieldName$1 extends keyof TSchema["object"][TTypeName$1]["fields"]> = AssignableInput<TSchema, TSchema["object"][TTypeName$1]["fields"][TFieldName$1]["arguments"]>;
+//#endregion
+//#region packages/core/src/types/fragment/directives.d.ts
+type AnyDirectiveAttachments = {
+  readonly [key: string]: AnyAssignableInput;
+};
+//#endregion
+//#region packages/core/src/types/fragment/field-selection.d.ts
+/**
+ * Canonical representation of the field selections we collect during model and
+ * slice definition. Each alias maps to a typed field reference that still
+ * remembers its parent type, arguments, directives, and nested selections.
+ */
+type AnyFieldSelection = {
+  readonly parent: AnyTypeName;
+  readonly field: AnyFieldName;
+  readonly type: OutputTypeSpecifier;
+  readonly args: AnyAssignableInput;
+  readonly directives: AnyDirectiveAttachments;
+  readonly object: AnyNestedObject | null;
+  readonly union: AnyNestedUnion | null;
+};
+/** Nested selection produced when resolving an object field. */
+type AnyNestedObject = {
+  readonly [alias: string]: AnyFieldSelection;
+};
+/** Nested selection produced when resolving a union field. */
+type AnyNestedUnion = {
+  readonly [typeName: string]: AnyNestedObject | undefined;
+};
+/** Map of alias → field reference used by builders and inference. */
+type AnyFields = {
+  readonly [alias: string]: AnyFieldSelection;
+};
+/** Strongly typed field reference produced for concrete schema members. */
+type AbstractFieldSelection<TTypeName$1 extends AnyTypeName, TFieldName$1 extends AnyFieldName, TSpecifier$1 extends OutputTypeSpecifier, TArgs extends AnyAssignableInput, TDirectives extends AnyDirectiveAttachments, TExtras extends {
+  object: AnyNestedObject;
+} | {
+  union: AnyNestedUnion;
+} | {
+  _?: never;
+}> = {
+  readonly parent: TTypeName$1;
+  readonly field: TFieldName$1;
+  readonly type: TSpecifier$1;
+  readonly args: TArgs;
+  readonly directives: TDirectives;
+  readonly object: TExtras extends {
+    object: infer TObject;
+  } ? TObject : null;
+  readonly union: TExtras extends {
+    union: infer TUnion;
+  } ? TUnion : null;
+};
+/** Convenience alias to obtain a typed field reference from the schema. */
+type FieldSelectionTemplateOf<TSchema extends AnyGraphqlSchema, TTypeName$1 extends keyof TSchema["object"] & string, TFieldName$1 extends keyof TSchema["object"][TTypeName$1]["fields"] & string> = PickTypeSpecifierByFieldName<TSchema, TTypeName$1, TFieldName$1> extends infer TRef extends OutputTypeSpecifier ? AbstractFieldSelection<TTypeName$1, TFieldName$1, TRef, AssignableInputByFieldName<TSchema, TTypeName$1, TFieldName$1>, AnyDirectiveAttachments, (TRef extends OutputObjectSpecifier ? {
+  object: AnyNestedObject;
+} : never) | (TRef extends OutputUnionSpecifier ? {
+  union: AnyNestedUnion;
+} : never)> : never;
+/** Resolve the data shape produced by a set of field selections. */
+type InferFields<TSchema extends AnyGraphqlSchema, TFields extends AnyFields> = { [_ in TSchema["label"]]: { [TAliasName in keyof TFields]: InferField<TSchema, TFields[TAliasName]> } & {} }[TSchema["label"]];
+/** 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;
+  object: infer TNested extends AnyNestedObject;
+} ? ApplyTypeModifier<InferFields<TSchema, TNested>, TSpecifier["modifier"]> : never) | (TSelection extends {
+  type: infer TSpecifier extends OutputUnionSpecifier;
+  union: infer TNested extends AnyNestedUnion;
+} ? ApplyTypeModifier<{ [TTypename in keyof TNested]: undefined extends TNested[TTypename] ? never : InferFields<TSchema, NonNullable<TNested[TTypename]>> }[keyof TNested], TSpecifier["modifier"]> : never) | (TSelection extends {
+  type: infer TSpecifier extends OutputInferrableTypeSpecifier;
+} ? GetModifiedType<InferOutputProfile<TSchema, TSpecifier>, TSpecifier["modifier"]> : never);
+//#endregion
+//#region packages/core/src/composer/build-document.d.ts
+declare const buildArgumentValue: (value: AnyAssignableInputValue) => ValueNode | null;
+declare const buildConstValueNode: (value: ConstValue) => ConstValueNode | null;
+declare const buildWithTypeModifier: (modifier: TypeModifier, buildType: () => NamedTypeNode) => TypeNode;
+declare const buildOperationTypeNode: (operation: OperationType) => OperationTypeNode;
+declare const buildDocument: <TSchema extends AnyGraphqlSchema, TFields extends AnyFields, TVarDefinitions extends InputTypeSpecifiers>(options: {
+  operationName: string;
+  operationType: OperationType;
+  variables: TVarDefinitions;
+  fields: TFields;
+}) => 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;
+type Tuple<T> = [T, ...T[]];
+type StripFunctions<T extends object> = { [K in keyof T as K extends "$infer" ? never : T[K] extends ((...args: any[]) => any) ? never : K]: T[K] };
+type StripSymbols<T extends object> = { [K in keyof T as K extends symbol | "$infer" ? never : K]: T[K] };
+//#endregion
+//#region packages/core/src/composer/colocate.d.ts
+/**
+ * Type for colocated field entries.
+ * Maps labels to their corresponding field selections.
+ */
+type ColocatedEntries = Record<string, AnyFields>;
+/**
+ * Result type for colocated fields.
+ * Merges all prefixed entries into a single object.
+ */
+type ColocatedFields<TEntries extends ColocatedEntries> = UnionToIntersection<{ [KPrefix in keyof TEntries]: KPrefix extends string ? { [KField in keyof TEntries[KPrefix] as KField extends string ? `${KPrefix}_${KField}` : never]: TEntries[KPrefix][KField] } : never }[keyof TEntries]>;
+/**
+ * Creates a $colocate helper function for fragment colocation.
+ *
+ * $colocate takes an object of { label: fields } and applies prefix-based
+ * aliasing to each entry. This mirrors the structure of createExecutionResultParser
+ * from @soda-gql/colocation-tools.
+ *
+ * @example
+ * ```typescript
+ * // In operation definition
+ * query.operation({ name: "GetData" }, ({ f, $ }) => [
+ *   $colocate({
+ *     userCard: userCardFragment.embed({ userId: $.userId }),
+ *     posts: postsFragment.embed({ userId: $.userId }),
+ *   }),
+ * ]);
+ *
+ * // In parser definition (same labels)
+ * createExecutionResultParser({
+ *   userCard: userCardProjection,
+ *   posts: postsProjection,
+ * });
+ * ```
+ */
+declare const createColocateHelper: () => <TEntries extends ColocatedEntries>(entries: TEntries) => ColocatedFields<TEntries>;
+type ColocateHelper = ReturnType<typeof createColocateHelper>;
+//#endregion
+//#region packages/core/src/utils/empty-object.d.ts
+declare const __EMPTY_SYMBOL__: unique symbol;
+type EmptyObject = {
+  readonly [__EMPTY_SYMBOL__]: never;
+};
+type IsEmptyObject<T> = keyof (T & EmptyObject) extends keyof EmptyObject ? true : false;
+type IfEmpty<TTarget, TType> = IsEmptyObject<TTarget> extends true ? TType : never;
+type SwitchIfEmpty<TTarget, TTrue, TFalse> = IsEmptyObject<TTarget> extends true ? TTrue : TFalse;
+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 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 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]>[]> };
+/** 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?: {
+  alias?: TAlias;
+  directives?: AnyDirectiveAttachments;
+}) => AnyFieldSelectionFactoryReturn<TAlias>;
+type FieldSelectionFactory<TSchema extends AnyGraphqlSchema, TSelection extends AnyFieldSelection> = <TAlias extends string | null = null>(fieldArgs: TSelection["args"] | IfEmpty<TSelection["args"], void | null>, extras?: {
+  alias?: TAlias;
+  directives?: TSelection["directives"];
+}) => FieldSelectionFactoryReturn<TSchema, TSelection, TAlias>;
+type AnyFieldSelectionFactoryReturn<TAlias extends string | null> = FieldSelectionFactoryReturn<AnyGraphqlSchema, AnyFieldSelection & {
+  type: OutputObjectSpecifier;
+}, TAlias> | FieldSelectionFactoryReturn<AnyGraphqlSchema, AnyFieldSelection & {
+  type: OutputUnionSpecifier;
+}, TAlias> | FieldSelectionFactoryReturn<AnyGraphqlSchema, AnyFieldSelection & {
+  type: OutputTypenameSpecifier | OutputScalarSpecifier | OutputEnumSpecifier;
+}, TAlias>;
+type FieldSelectionFactoryReturn<TSchema extends AnyGraphqlSchema, TSelection extends AnyFieldSelection, TAlias extends string | null> = TSelection extends {
+  type: OutputObjectSpecifier;
+} ? FieldSelectionFactoryObjectReturn<TSchema, TSelection, TAlias> : TSelection extends {
+  type: OutputUnionSpecifier;
+} ? FieldSelectionFactoryUnionReturn<TSchema, TSelection, TAlias> : TSelection extends {
+  type: OutputTypenameSpecifier | OutputScalarSpecifier | OutputEnumSpecifier;
+} ? 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>;
+}> };
+type FieldSelectionFactoryUnionReturn<TSchema extends AnyGraphqlSchema, TSelection extends AnyFieldSelection & {
+  type: OutputUnionSpecifier;
+}, TAlias extends string | null> = <TNested$1 extends AnyNestedUnion>(nest: NestedUnionFieldsBuilder<TSchema, UnionMemberName<TSchema, TSelection["type"]>, TNested$1>) => { [_ in TAlias extends null ? TSelection["field"] : TAlias]: AbstractFieldSelection<TSelection["parent"], TSelection["field"], TSelection["type"], TSelection["args"], TSelection["directives"], {
+  union: TNested$1;
+}> };
+type FieldSelectionFactoryPrimitiveReturn<TSelection extends AnyFieldSelection & {
+  type: OutputTypenameSpecifier | OutputScalarSpecifier | OutputEnumSpecifier;
+}, TAlias extends string | null> = { [_ in TAlias extends null ? TSelection["field"] : TAlias]: AbstractFieldSelection<TSelection["parent"], TSelection["field"], TSelection["type"], TSelection["args"], TSelection["directives"], {}> };
+type FieldSelectionFactoryFieldArguments<TFieldSelectionTemplate extends AnyFieldSelection> = TFieldSelectionTemplate["args"] | IfEmpty<TFieldSelectionTemplate["args"], void | null>;
+//#endregion
+//#region packages/core/src/types/element/lazy-evaluator.d.ts
+/**
+ * Context passed to the definition factory during evaluation.
+ */
+type LazyEvaluatorContext = {
+  canonicalId: string;
+};
+//#endregion
+//#region packages/core/src/types/element/gql-element.d.ts
+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;
+  createValue: (element: TElement) => TValue;
+};
+declare abstract class GqlElement<TDefinition extends object, TInfer extends object> {
+  readonly $infer: TInfer;
+  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 };
+  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;
+  static evaluateSync(element: GqlElement<any, any>): void;
+  static get<TValue extends object>(element: GqlElement<TValue, any>): TValue;
+}
+//#endregion
+//#region packages/core/src/types/element/fragment.d.ts
+type AnyFragment = Fragment<string, any, AnyFields, any>;
+type FragmentInferMeta<TVariables, TOutput extends object> = {
+  readonly input: TVariables;
+  readonly output: TOutput;
+};
+interface FragmentArtifact<TTypeName$1 extends string, TVariables extends Partial<AnyAssignableInput> | void, TFields extends Partial<AnyFields>> {
+  readonly typename: TTypeName$1;
+  readonly embed: (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;
+  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;
+  }): Fragment<TTypeName$1, SwitchIfEmpty<TVariableDefinitions, void, AssignableInput<TSchema, TVariableDefinitions>>, TFields & {
+    [key: symbol]: never;
+  }, InferFields<TSchema, TFields> & {
+    [key: symbol]: never;
+  }>;
+}
+//#endregion
+//#region packages/core/src/types/element/operation.d.ts
+type AnyOperation = AnyOperationOf<"query"> | AnyOperationOf<"mutation"> | AnyOperationOf<"subscription">;
+type AnyOperationOf<TOperationType extends OperationType> = Operation<TOperationType, string, string[], any, AnyFields, any>;
+type OperationInferMeta<TVariables, TData extends object> = {
+  readonly input: TVariables;
+  readonly output: TData;
+};
+declare const __OPERATION_BRAND__: unique symbol;
+type OperationArtifact<TOperationType extends OperationType, TOperationName extends string, TVariableNames extends string[], TVariables extends AnyConstAssignableInput, TFields extends Partial<AnyFields>, TData extends object> = {
+  readonly operationType: TOperationType;
+  readonly operationName: TOperationName;
+  readonly variableNames: TVariableNames;
+  readonly documentSource: () => TFields;
+  readonly document: TypedDocumentNode<TData, TVariables>;
+  readonly metadata?: unknown;
+};
+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();
+  get operationType(): TOperationType;
+  get operationName(): TOperationName;
+  get variableNames(): TVariableNames;
+  get documentSource(): () => TFields;
+  get document(): TypedDocumentNode<TData, TVariables>;
+  get metadata(): unknown;
+  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;
+    variableNames: (keyof TVariableDefinitions & string)[];
+    documentSource: () => TFields;
+    document: TypedDocumentNode<InferFields<TSchema, TFields>, ConstAssignableInput<TSchema, TVariableDefinitions>>;
+    metadata?: unknown;
+  } | Promise<{
+    operationType: TOperationType;
+    operationName: TOperationName;
+    variableNames: (keyof TVariableDefinitions & string)[];
+    documentSource: () => TFields;
+    document: TypedDocumentNode<InferFields<TSchema, TFields>, ConstAssignableInput<TSchema, TVariableDefinitions>>;
+    metadata?: unknown;
+  }>): Operation<TOperationType, TOperationName, (keyof TVariableDefinitions & string)[], ConstAssignableInput<TSchema, TVariableDefinitions>, TFields, InferFields<TSchema, TFields>>;
+}
+//#endregion
+//#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: {
+  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> & {
+  [key: symbol]: never;
+}, InferFields<TSchema, MergeFields<TFieldEntries>> & {
+  [key: symbol]: never;
+}> : never };
+//#endregion
+//#region packages/core/src/composer/fragment-usage-context.d.ts
+/**
+ * Record of a fragment being embedded 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
+ */
+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 */
+  readonly path: FieldPath | null;
+};
+/**
+ * Run a function with fragment usage collection enabled.
+ * Returns both the function result and collected fragment usages.
+ *
+ * @internal
+ */
+declare const withFragmentUsageCollection: <T>(fn: () => T) => {
+  result: T;
+  usages: FragmentUsageRecord[];
+};
+/**
+ * Record a fragment usage. Called when fragment.embed() is invoked.
+ * No-op if not in a collection context.
+ *
+ * @internal
+ */
+declare const recordFragmentUsage: (record: FragmentUsageRecord) => void;
+//#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;
+/**
+ * Extracts the helpers type from an adapter.
+ */
+type ExtractHelpers<TAdapter extends AnyAdapter> = TAdapter extends Adapter<infer THelpers, unknown, unknown, unknown> ? THelpers : object;
+/**
+ * Extracts the metadata adapter type from an adapter.
+ * Handles optional metadata property correctly.
+ */
+type ExtractMetadataAdapter<TAdapter extends AnyAdapter> = TAdapter extends {
+  metadata?: infer M;
+} ? NonNullable<M> extends AnyMetadataAdapter ? NonNullable<M> : DefaultMetadataAdapter : DefaultMetadataAdapter;
+type GqlElementComposerOptions<TAdapter extends AnyAdapter = DefaultAdapter> = {
+  adapter?: TAdapter;
+};
+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: {
+    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> & {
+    [key: symbol]: never;
+  }, InferFields<TSchema, MergeFields<TFieldEntries>> & {
+    [key: symbol]: never;
+  }> : never };
+  query: {
+    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>>>;
+  };
+  mutation: {
+    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>>>;
+  };
+  subscription: {
+    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;
+  };
+  $colocate: <TEntries extends ColocatedEntries>(entries: TEntries) => ColocatedFields<TEntries>;
+} & ExtractHelpers<TAdapter>>;
+//#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: {
+  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;
+};
+//#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 };
+//#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-Djr9A4KL.d.ts.map