@soda-gql/core 0.11.10 → 0.11.12

package/dist/{index-DPtgl2f4.d.ts → index-CULnRHFI.d.ts}

@@ -152,8 +152,8 @@ 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>> & {};
+type ConstAssignableInput<TSchema$1 extends AnyGraphqlSchema, TSpecifiers extends InputTypeSpecifiers> = { readonly [K in keyof TSpecifiers as IsOptional$1<TSpecifiers[K]> extends true ? K : never]+?: ConstAssignableInputValue<TSchema$1, TSpecifiers[K]> } & { readonly [K in keyof TSpecifiers as IsOptional$1<TSpecifiers[K]> extends false ? K : never]-?: ConstAssignableInputValue<TSchema$1, TSpecifiers[K]> };
+type ConstAssignableInputValue<TSchema$1 extends AnyGraphqlSchema, TSpecifier$1 extends InputTypeSpecifier> = GetConstAssignableType<InferInputProfile<TSchema$1, TSpecifier$1>> & {};
 //#endregion
 //#region packages/core/src/types/schema/const-directives.d.ts
 type AnyConstDirectiveAttachments = {
@@ -171,20 +171,20 @@ 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]+?: FieldArgumentValue<TSchema, TSpecifiers[K]> } & { readonly [K in keyof TSpecifiers as IsOptional<TSpecifiers[K]> extends false ? K : never]-?: FieldArgumentValue<TSchema, TSpecifiers[K]> };
+type AssignableInput<TSchema$1 extends AnyGraphqlSchema, TSpecifiers extends InputTypeSpecifiers> = { readonly [K in keyof TSpecifiers as IsOptional<TSpecifiers[K]> extends true ? K : never]+?: FieldArgumentValue<TSchema$1, TSpecifiers[K]> } & { readonly [K in keyof TSpecifiers as IsOptional<TSpecifiers[K]> extends false ? K : never]-?: FieldArgumentValue<TSchema$1, TSpecifiers[K]> };
 /**
  * Field argument value type using typeName + kind for VarRef comparison.
  * Uses GetAssignableType which derives typeName + kind from the profile.
  * This name appears in TypeScript error messages when argument types don't match.
  */
-type FieldArgumentValue<TSchema extends AnyGraphqlSchema, TSpecifier$1 extends InputTypeSpecifier> = GetAssignableType<InferInputProfile<TSchema, TSpecifier$1>>;
+type FieldArgumentValue<TSchema$1 extends AnyGraphqlSchema, TSpecifier$1 extends InputTypeSpecifier> = GetAssignableType<InferInputProfile<TSchema$1, TSpecifier$1>>;
 /**
  * Declared variables record for an operation or fragment.
  * Maps variable names to their VarRef types with proper branding.
  * This name appears in TypeScript error messages when variable access fails.
  */
-type DeclaredVariables<TSchema extends AnyGraphqlSchema, TSpecifiers extends InputTypeSpecifiers> = { readonly [K in keyof TSpecifiers]-?: VarRef<TypeProfile.DeclaredVariableType<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"]>;
+type DeclaredVariables<TSchema$1 extends AnyGraphqlSchema, TSpecifiers extends InputTypeSpecifiers> = { readonly [K in keyof TSpecifiers]-?: VarRef<TypeProfile.DeclaredVariableType<InferInputProfile<TSchema$1, TSpecifiers[K]>>> };
+type AssignableInputByFieldName<TSchema$1 extends AnyGraphqlSchema, TTypeName$1 extends keyof TSchema$1["object"], TFieldName$1 extends keyof TSchema$1["object"][TTypeName$1]["fields"]> = AssignableInput<TSchema$1, TSchema$1["object"][TTypeName$1]["fields"][TFieldName$1]["arguments"]>;
 //#endregion
 //#region packages/core/src/types/fragment/directives.d.ts
 /**
@@ -241,23 +241,23 @@ type AbstractFieldSelection<TTypeName$1 extends AnyTypeName, TFieldName$1 extend
   } ? 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 ? {
+type FieldSelectionTemplateOf<TSchema$1 extends AnyGraphqlSchema, TTypeName$1 extends keyof TSchema$1["object"] & string, TFieldName$1 extends keyof TSchema$1["object"][TTypeName$1]["fields"] & string> = PickTypeSpecifierByFieldName<TSchema$1, TTypeName$1, TFieldName$1> extends infer TRef extends OutputTypeSpecifier ? AbstractFieldSelection<TTypeName$1, TFieldName$1, TRef, AssignableInputByFieldName<TSchema$1, 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"]];
+type InferFields<TSchema$1 extends AnyGraphqlSchema, TFields$1 extends AnyFields> = { [_ in TSchema$1["label"]]: { [TAliasName in keyof TFields$1]: InferField<TSchema$1, TFields$1[TAliasName]> } & {} }[TSchema$1["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 InferField<TSchema$1 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 {
+} ? ApplyTypeModifier<InferFields<TSchema$1, 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 {
+} ? ApplyTypeModifier<{ [TTypename in keyof TNested]: undefined extends TNested[TTypename] ? never : InferFields<TSchema$1, NonNullable<TNested[TTypename]>> }[keyof TNested], TSpecifier["modifier"]> : never) | (TSelection extends {
   type: infer TSpecifier extends OutputInferrableTypeSpecifier;
-} ? GetModifiedType<InferOutputProfile<TSchema, TSpecifier>, TSpecifier["modifier"]> : never);
+} ? GetModifiedType<InferOutputProfile<TSchema$1, TSpecifier>, TSpecifier["modifier"]> : never);
 //#endregion
 //#region packages/core/src/composer/build-document.d.ts
 /**
@@ -318,13 +318,13 @@ declare const buildOperationTypeNode: (operation: OperationType) => OperationTyp
  * @param options - Operation configuration (name, type, variables, fields, schema)
  * @returns TypedDocumentNode with inferred input/output types
  */
-declare const buildDocument: <TSchema extends AnyGraphqlSchema, TFields extends AnyFields, TVarDefinitions extends InputTypeSpecifiers>(options: {
+declare const buildDocument: <TSchema$1 extends AnyGraphqlSchema, TFields$1 extends AnyFields, TVarDefinitions$1 extends InputTypeSpecifiers>(options: {
   operationName: string;
   operationType: OperationType;
-  variables: TVarDefinitions;
-  fields: TFields;
-  schema: TSchema;
-}) => TypedDocumentNode<InferFields<TSchema, TFields>, ConstAssignableInput<TSchema, TVarDefinitions>>;
+  variables: TVarDefinitions$1;
+  fields: TFields$1;
+  schema: TSchema$1;
+}) => TypedDocumentNode<InferFields<TSchema$1, TFields$1>, ConstAssignableInput<TSchema$1, TVarDefinitions$1>>;
 //#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;
@@ -371,131 +371,6 @@ type ColocatedFields<TEntries extends ColocatedEntries> = UnionToIntersection<{
 declare const createColocateHelper: () => <TEntries extends ColocatedEntries>(entries: TEntries) => ColocatedFields<TEntries>;
 type ColocateHelper = ReturnType<typeof createColocateHelper>;
 //#endregion
-//#region packages/core/src/composer/directive-builder.d.ts
-/**
- * A method that creates a DirectiveRef with specific type information.
- * The TArgs type defines the expected argument shape for the directive.
- */
-type DirectiveMethod<TDirectiveName extends string, TLocations extends readonly DirectiveLocation[], TArgs> = (args: TArgs) => DirectiveRef<{
-  directiveName: TDirectiveName;
-  locations: TLocations;
-}>;
-/**
- * Type for directive arguments that can include VarRef values.
- * This allows using variables in directive arguments like `{ if: $.shouldSkip }`.
- */
-type DirectiveArgValue = boolean | string | number | null | AnyVarRef;
-/**
- * Standard GraphQL directives that are always available.
- */
-type StandardDirectives = {
-  /**
-   * @skip directive - conditionally skip a field.
-   * @example
-   * ```typescript
-   * f.email({}, { directives: [$dir.skip({ if: $.hideEmail })] })
-   * ```
-   */
-  skip: DirectiveMethod<"skip", readonly ["FIELD", "FRAGMENT_SPREAD", "INLINE_FRAGMENT"], {
-    if: DirectiveArgValue;
-  }>;
-  /**
-   * @include directive - conditionally include a field.
-   * @example
-   * ```typescript
-   * f.email({}, { directives: [$dir.include({ if: $.showEmail })] })
-   * ```
-   */
-  include: DirectiveMethod<"include", readonly ["FIELD", "FRAGMENT_SPREAD", "INLINE_FRAGMENT"], {
-    if: DirectiveArgValue;
-  }>;
-};
-/**
- * Creates a directive method factory for a specific directive.
- *
- * @param name - The directive name (without @)
- * @param locations - Valid locations where the directive can be applied
- * @returns A function that creates DirectiveRef instances
- *
- * @example
- * ```typescript
- * const skipMethod = createDirectiveMethod("skip", ["FIELD", "FRAGMENT_SPREAD", "INLINE_FRAGMENT"] as const);
- * const skipDirective = skipMethod({ if: true });
- * ```
- */
-declare const createDirectiveMethod: <TDirectiveName extends string, const TLocations extends readonly DirectiveLocation[]>(name: TDirectiveName, locations: TLocations) => (<TArgs extends Record<string, unknown>>(args: TArgs) => DirectiveRef<{
-  directiveName: TDirectiveName;
-  locations: TLocations;
-}>);
-/**
- * Type for directive argument specifiers.
- * Maps argument names to their type information.
- */
-type DirectiveArgumentSpecifiers = {
-  readonly [argName: string]: DirectiveArgumentSpecifier;
-};
-/**
- * Creates a typed directive method with argument type specifiers.
- * Enables enum value output in directive arguments.
- *
- * @param name - The directive name (without @)
- * @param locations - Valid locations where the directive can be applied
- * @param argSpecs - Type specifiers for directive arguments
- * @returns A function that creates DirectiveRef instances with argument type info
- *
- * @example
- * ```typescript
- * const authMethod = createTypedDirectiveMethod(
- *   "auth",
- *   ["FIELD"] as const,
- *   { role: { kind: "enum", name: "Role", modifier: "!" } }
- * );
- * const authDirective = authMethod({ role: "ADMIN" });
- * ```
- */
-declare const createTypedDirectiveMethod: <TDirectiveName extends string, const TLocations extends readonly DirectiveLocation[], const TArgSpecs extends DirectiveArgumentSpecifiers>(name: TDirectiveName, locations: TLocations, argSpecs: TArgSpecs) => (<TArgs extends Record<string, unknown>>(args: TArgs) => DirectiveRef<{
-  directiveName: TDirectiveName;
-  locations: TLocations;
-}>);
-/**
- * Creates the standard GraphQL directives (@skip, @include).
- * These are always available regardless of schema definition.
- *
- * @returns Object containing skip and include directive methods
- *
- * @example
- * ```typescript
- * const $dir = createStandardDirectives();
- * const skipDirective = $dir.skip({ if: true });
- * ```
- */
-declare const createStandardDirectives: () => StandardDirectives;
-/**
- * Type for any directive method (type-erased).
- */
-type AnyDirectiveMethod = (args: any) => AnyDirectiveRef;
-/**
- * Type for the directive builder that includes standard directives
- * and can be extended with schema-specific directives.
- */
-type DirectiveBuilder<TCustomDirectives extends Record<string, AnyDirectiveMethod> = {}> = StandardDirectives & TCustomDirectives;
-/**
- * Creates a directive builder with standard directives and optional custom directives.
- *
- * @param customDirectives - Additional directive methods from schema (generated by codegen)
- * @returns Combined directive builder with all available directives
- *
- * @internal Used by codegen to create schema-specific directive builders
- */
-declare const createDirectiveBuilder: <TCustomDirectives extends Record<string, AnyDirectiveMethod> = {}>(customDirectives?: TCustomDirectives) => DirectiveBuilder<TCustomDirectives>;
-/**
- * Type guard to check if a value is a DirectiveRef.
- *
- * @param value - Value to check
- * @returns True if value is a DirectiveRef instance
- */
-declare const isDirectiveRef: (value: unknown) => value is AnyDirectiveRef;
-//#endregion
 //#region packages/core/src/types/element/attachment-types.d.ts
 /**
  * Shape constraint for attachment objects used in type utilities.
@@ -549,34 +424,34 @@ declare const empty: () => EmptyObject;
  * tooling `f`/`fields`/`_` aliases provide ergonomic access to GraphQL fields
  * while preserving the original schema information for inference.
  */
-type FieldsBuilder<TSchema extends AnyGraphqlSchema, TTypeName$1 extends keyof TSchema["object"] & string, TVariableDefinitions extends InputTypeSpecifiers, TFields extends AnyFields> = (tools: NoInfer<FieldsBuilderTools<TSchema, TTypeName$1, TVariableDefinitions>>) => TFields;
+type FieldsBuilder<TSchema$1 extends AnyGraphqlSchema, TTypeName$1 extends keyof TSchema$1["object"] & string, TVariableDefinitions extends InputTypeSpecifiers, TFields$1 extends AnyFields> = (tools: NoInfer<FieldsBuilderTools<TSchema$1, TTypeName$1, TVariableDefinitions>>) => TFields$1;
 /**
  * Tools provided to field builder callbacks.
  * - `f`: Field selection factories for the current type
  * - `$`: Variable references for the current scope
  */
-type FieldsBuilderTools<TSchema extends AnyGraphqlSchema, TTypeName$1 extends keyof TSchema["object"] & string, TVariableDefinitions extends InputTypeSpecifiers> = {
-  f: FieldSelectionFactories<TSchema, TTypeName$1>;
-  $: DeclaredVariables<TSchema, TVariableDefinitions>;
+type FieldsBuilderTools<TSchema$1 extends AnyGraphqlSchema, TTypeName$1 extends keyof TSchema$1["object"] & string, TVariableDefinitions extends InputTypeSpecifiers> = {
+  f: FieldSelectionFactories<TSchema$1, TTypeName$1>;
+  $: DeclaredVariables<TSchema$1, TVariableDefinitions>;
 };
 /**
  * Builder for nested object field selections.
  * Used when a field returns an object type requiring sub-selections.
  */
-type NestedObjectFieldsBuilder<TSchema extends AnyGraphqlSchema, TTypeName$1 extends keyof TSchema["object"] & string, TFields extends AnyNestedObject> = (tools: NoInfer<NestedObjectFieldsBuilderTools<TSchema, TTypeName$1>>) => TFields;
+type NestedObjectFieldsBuilder<TSchema$1 extends AnyGraphqlSchema, TTypeName$1 extends keyof TSchema$1["object"] & string, TFields$1 extends AnyNestedObject> = (tools: NoInfer<NestedObjectFieldsBuilderTools<TSchema$1, TTypeName$1>>) => TFields$1;
 /**
  * Tools for nested object builders (no variable access).
  * @internal
  */
-type NestedObjectFieldsBuilderTools<TSchema extends AnyGraphqlSchema, TTypeName$1 extends keyof TSchema["object"] & string> = {
-  f: FieldSelectionFactories<TSchema, TTypeName$1>;
+type NestedObjectFieldsBuilderTools<TSchema$1 extends AnyGraphqlSchema, TTypeName$1 extends keyof TSchema$1["object"] & string> = {
+  f: FieldSelectionFactories<TSchema$1, TTypeName$1>;
 };
 /**
  * Builder for union type selections with per-member field definitions.
  */
-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$1 extends AnyGraphqlSchema, TMemberName extends string, TUnionFields extends AnyNestedUnion> = { [TTypename in keyof TUnionFields & TMemberName]?: NestedObjectFieldsBuilder<TSchema$1, 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 FieldSelectionFactories<TSchema$1 extends AnyGraphqlSchema, TTypeName$1 extends keyof TSchema$1["object"] & string> = { [TFieldName in keyof ObjectFieldRecord<TSchema$1, TTypeName$1>]: TFieldName extends string ? FieldSelectionFactory<TSchema$1, FieldSelectionTemplateOf<TSchema$1, TTypeName$1, TFieldName>> : never };
 /**
  * Type-erased field selection factory.
  * @internal
@@ -589,10 +464,10 @@ type AnyFieldSelectionFactory = <TAlias extends string | null = null>(fieldArgs:
  * Factory function for creating a typed field selection.
  * Accepts field arguments and optional alias/directives.
  */
-type FieldSelectionFactory<TSchema extends AnyGraphqlSchema, TSelection extends AnyFieldSelection> = <TAlias extends string | null = null>(fieldArgs: TSelection["args"] | IfOmittable<TSelection["args"], void | null>, extras?: {
+type FieldSelectionFactory<TSchema$1 extends AnyGraphqlSchema, TSelection extends AnyFieldSelection> = <TAlias extends string | null = null>(fieldArgs: TSelection["args"] | IfOmittable<TSelection["args"], void | null>, extras?: {
   alias?: TAlias;
   directives?: AnyDirectiveRef[];
-}) => FieldSelectionFactoryReturn<TSchema, TSelection, TAlias>;
+}) => FieldSelectionFactoryReturn<TSchema$1, TSelection, TAlias>;
 type AnyFieldSelectionFactoryReturn<TAlias extends string | null> = FieldSelectionFactoryReturn<AnyGraphqlSchema, AnyFieldSelection & {
   type: OutputObjectSpecifier;
 }, TAlias> | FieldSelectionFactoryReturn<AnyGraphqlSchema, AnyFieldSelection & {
@@ -600,21 +475,21 @@ type AnyFieldSelectionFactoryReturn<TAlias extends string | null> = FieldSelecti
 }, TAlias> | FieldSelectionFactoryReturn<AnyGraphqlSchema, AnyFieldSelection & {
   type: OutputTypenameSpecifier | OutputScalarSpecifier | OutputEnumSpecifier;
 }, TAlias>;
-type FieldSelectionFactoryReturn<TSchema extends AnyGraphqlSchema, TSelection extends AnyFieldSelection, TAlias extends string | null> = TSelection extends {
+type FieldSelectionFactoryReturn<TSchema$1 extends AnyGraphqlSchema, TSelection extends AnyFieldSelection, TAlias extends string | null> = TSelection extends {
   type: OutputObjectSpecifier;
-} ? FieldSelectionFactoryObjectReturn<TSchema, TSelection, TAlias> : TSelection extends {
+} ? FieldSelectionFactoryObjectReturn<TSchema$1, TSelection, TAlias> : TSelection extends {
   type: OutputUnionSpecifier;
-} ? FieldSelectionFactoryUnionReturn<TSchema, TSelection, TAlias> : TSelection extends {
+} ? FieldSelectionFactoryUnionReturn<TSchema$1, TSelection, TAlias> : TSelection extends {
   type: OutputTypenameSpecifier | OutputScalarSpecifier | OutputEnumSpecifier;
 } ? FieldSelectionFactoryPrimitiveReturn<TSelection, TAlias> : never;
-type FieldSelectionFactoryObjectReturn<TSchema extends AnyGraphqlSchema, TSelection extends AnyFieldSelection & {
+type FieldSelectionFactoryObjectReturn<TSchema$1 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"], {
+}, TAlias extends string | null> = <TNested$1 extends AnyNestedObject>(nest: NestedObjectFieldsBuilder<TSchema$1, 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 FieldSelectionFactoryUnionReturn<TSchema$1 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"], {
+}, TAlias extends string | null> = <TNested$1 extends AnyNestedUnion>(nest: NestedUnionFieldsBuilder<TSchema$1, UnionMemberName<TSchema$1, 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 & {
@@ -622,6 +497,55 @@ type FieldSelectionFactoryPrimitiveReturn<TSelection extends AnyFieldSelection &
 }, 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"] | IfOmittable<TFieldSelectionTemplate["args"], void | null>;
 //#endregion
+//#region packages/core/src/types/element/compat-spec.d.ts
+/**
+ * Specification for a compat operation, storing unevaluated fieldsBuilder.
+ * Created by `query.compat()`, `mutation.compat()`, `subscription.compat()`.
+ *
+ * The fieldsBuilder is stored unevaluated and will be evaluated when
+ * `extend()` is called to create the final Operation.
+ *
+ * @template TSchema - The GraphQL schema type
+ * @template TOperationType - The operation type ('query' | 'mutation' | 'subscription')
+ * @template TOperationName - The operation name literal type
+ * @template TVarDefinitions - The variable definitions type
+ * @template TFields - The fields type returned by the fieldsBuilder
+ *
+ * @example
+ * ```typescript
+ * // This is created internally by query.compat()
+ * const spec: CompatSpec<Schema, 'query', 'GetUser', { userId: VarSpec }, Fields> = {
+ *   schema,
+ *   operationType: 'query',
+ *   operationName: 'GetUser',
+ *   variables: { userId: varSpec },
+ *   fieldsBuilder: ({ f, $ }) => ({ ...f.user({ id: $.userId })(...) }),
+ * };
+ * ```
+ */
+type CompatSpec<TSchema$1 extends AnyGraphqlSchema, TOperationType$1 extends OperationType, TOperationName$1 extends string, TVarDefinitions$1 extends InputTypeSpecifiers, TFields$1 extends AnyFields> = {
+  readonly schema: TSchema$1;
+  readonly operationType: TOperationType$1;
+  readonly operationName: TOperationName$1;
+  readonly variables: TVarDefinitions$1;
+  readonly fieldsBuilder: FieldsBuilder<TSchema$1, TSchema$1["operations"][TOperationType$1] & keyof TSchema$1["object"] & string, TVarDefinitions$1, TFields$1>;
+};
+/**
+ * Type alias for any CompatSpec instance.
+ */
+type AnyCompatSpec = CompatSpec<AnyGraphqlSchema, OperationType, string, InputTypeSpecifiers, AnyFields>;
+/**
+ * Extracts type information from a CompatSpec.
+ * Used by extend() to infer types from the compat operation.
+ */
+type ExtractCompatSpec<T> = T extends CompatSpec<infer TSchema, infer TOperationType, infer TOperationName, infer TVarDefinitions, infer TFields> ? {
+  schema: TSchema;
+  operationType: TOperationType;
+  operationName: TOperationName;
+  variables: TVarDefinitions;
+  fields: TFields;
+} : never;
+//#endregion
 //#region packages/core/src/types/element/lazy-evaluator.d.ts
 /**
  * Context passed to the definition factory during evaluation.
@@ -717,6 +641,79 @@ declare abstract class GqlElement<TDefinition extends object, TInfer extends obj
   static get<TValue$1 extends object>(element: GqlElement<TValue$1, any>): TValue$1;
 }
 //#endregion
+//#region packages/core/src/types/element/define.d.ts
+/**
+ * Type alias for any GqlDefine instance.
+ */
+type AnyGqlDefine = GqlDefine<unknown>;
+/**
+ * Type inference metadata for define elements.
+ * Access via `typeof defineElement.$infer`.
+ */
+type DefineInferMeta<TValue$1> = {
+  readonly value: TValue$1;
+};
+declare const __DEFINE_BRAND__: unique symbol;
+/**
+ * Internal artifact shape produced by define evaluation.
+ * @internal
+ */
+type DefineArtifact<TValue$1> = {
+  readonly factoryResult: TValue$1;
+};
+/**
+ * Represents a factory-based value definition.
+ *
+ * Define elements are created via `gql(({ define }) => define(() => value))`.
+ * The factory is evaluated lazily and the result is cached.
+ *
+ * @template TValue - The type of value produced by the factory
+ *
+ * @example
+ * ```typescript
+ * // Store a primitive value
+ * const myNumber = gql.default(({ define }) => define(() => 42));
+ * console.log(myNumber.value); // 42
+ *
+ * // Store a plain object
+ * const myConfig = gql.default(({ define }) => define(() => ({
+ *   apiUrl: "https://api.example.com",
+ *   timeout: 5000,
+ * })));
+ * console.log(myConfig.value.apiUrl); // "https://api.example.com"
+ * ```
+ */
+declare class GqlDefine<TValue$1> extends GqlElement<DefineArtifact<TValue$1>, DefineInferMeta<TValue$1>> {
+  private readonly [__DEFINE_BRAND__];
+  private constructor();
+  /**
+   * The evaluated value from the factory.
+   * Triggers lazy evaluation on first access.
+   */
+  get value(): TValue$1;
+  /**
+   * Creates a new GqlDefine instance.
+   *
+   * Prefer using the `gql(({ define }) => define(() => value))` API instead.
+   *
+   * @param factory - Function that produces the value. Can be sync or async.
+   * @returns A new GqlDefine instance wrapping the factory result.
+   *
+   * @example
+   * ```typescript
+   * // Sync factory
+   * const syncDefine = GqlDefine.create(() => 42);
+   *
+   * // Async factory
+   * const asyncDefine = GqlDefine.create(async () => {
+   *   const data = await fetch('/api/config');
+   *   return data.json();
+   * });
+   * ```
+   */
+  static create<TValue$1>(factory: () => TValue$1 | Promise<TValue$1>): GqlDefine<TValue$1>;
+}
+//#endregion
 //#region packages/core/src/types/element/fragment.d.ts
 /**
  * Type alias for any Fragment instance.
@@ -734,12 +731,12 @@ type FragmentInferMeta<TVariables, TOutput extends object> = {
  * Internal artifact shape produced by fragment evaluation.
  * @internal
  */
-interface FragmentArtifact<TTypeName$1 extends string, TVariables extends Partial<AnyAssignableInput> | void, TFields extends Partial<AnyFields>> {
+interface FragmentArtifact<TTypeName$1 extends string, TVariables extends Partial<AnyAssignableInput> | void, TFields$1 extends Partial<AnyFields>> {
   readonly typename: TTypeName$1;
   readonly key: string | undefined;
   readonly schemaLabel: string;
   readonly variableDefinitions: InputTypeSpecifiers;
-  readonly spread: (variables: TVariables) => TFields;
+  readonly spread: (variables: TVariables) => TFields$1;
 }
 declare const __FRAGMENT_BRAND__: unique symbol;
 /**
@@ -753,7 +750,7 @@ declare const __FRAGMENT_BRAND__: unique symbol;
  * @template TFields - The selected fields structure
  * @template TOutput - Inferred output type from selected fields
  */
-declare class Fragment<TTypeName$1 extends string, TVariables extends Partial<AnyAssignableInput> | void, TFields extends Partial<AnyFields>, TOutput extends object> extends GqlElement<FragmentArtifact<TTypeName$1, TVariables, TFields>, FragmentInferMeta<TVariables, TOutput>> implements FragmentArtifact<TTypeName$1, TVariables, TFields> {
+declare class Fragment<TTypeName$1 extends string, TVariables extends Partial<AnyAssignableInput> | void, TFields$1 extends Partial<AnyFields>, TOutput extends object> extends GqlElement<FragmentArtifact<TTypeName$1, TVariables, TFields$1>, FragmentInferMeta<TVariables, TOutput>> implements FragmentArtifact<TTypeName$1, TVariables, TFields$1> {
   private readonly [__FRAGMENT_BRAND__];
   private constructor();
   /** The GraphQL type name this fragment selects from. */
@@ -768,21 +765,21 @@ declare class Fragment<TTypeName$1 extends string, TVariables extends Partial<An
    * Spreads this fragment's fields into a parent selection.
    * Pass variables if the fragment defines any.
    */
-  get spread(): (variables: TVariables) => TFields;
+  get spread(): (variables: TVariables) => TFields$1;
   /**
    * Creates a new Fragment instance.
    * Prefer using the `gql(({ fragment }) => ...)` API instead.
    * @internal
    */
-  static create<TSchema extends AnyGraphqlSchema, TTypeName$1 extends keyof TSchema["object"] & string, TVariableDefinitions extends InputTypeSpecifiers, TFields extends AnyFields>(define: () => {
+  static create<TSchema$1 extends AnyGraphqlSchema, TTypeName$1 extends keyof TSchema$1["object"] & string, TVariableDefinitions extends InputTypeSpecifiers, TFields$1 extends AnyFields>(define: () => {
     typename: TTypeName$1;
     key: string | undefined;
-    schemaLabel: TSchema["label"];
+    schemaLabel: TSchema$1["label"];
     variableDefinitions: TVariableDefinitions;
-    spread: (variables: OptionalArg<AssignableInput<TSchema, TVariableDefinitions>>) => TFields;
-  }): Fragment<TTypeName$1, OptionalArg<AssignableInput<TSchema, TVariableDefinitions>>, TFields & {
+    spread: (variables: OptionalArg<AssignableInput<TSchema$1, TVariableDefinitions>>) => TFields$1;
+  }): Fragment<TTypeName$1, OptionalArg<AssignableInput<TSchema$1, TVariableDefinitions>>, TFields$1 & {
     [key: symbol]: never;
-  }, InferFields<TSchema, TFields> & {
+  }, InferFields<TSchema$1, TFields$1> & {
     [key: symbol]: never;
   }>;
 }
@@ -795,7 +792,7 @@ type AnyOperation = AnyOperationOf<"query"> | AnyOperationOf<"mutation"> | AnyOp
 /**
  * Type alias for an Operation of a specific type.
  */
-type AnyOperationOf<TOperationType extends OperationType> = Operation<TOperationType, string, string[], any, AnyFields, any>;
+type AnyOperationOf<TOperationType$1 extends OperationType> = Operation<TOperationType$1, string, string[], any, AnyFields, any>;
 /**
  * Type inference metadata for operations.
  * Access via `typeof operation.$infer`.
@@ -809,12 +806,12 @@ declare const __OPERATION_BRAND__: unique symbol;
  * Internal artifact shape produced by operation evaluation.
  * @internal
  */
-type OperationArtifact<TOperationType extends OperationType, TOperationName extends string, TVariableNames extends string[], TVariables extends AnyConstAssignableInput, TFields extends Partial<AnyFields>, TData extends object> = {
-  readonly operationType: TOperationType;
-  readonly operationName: TOperationName;
+type OperationArtifact<TOperationType$1 extends OperationType, TOperationName$1 extends string, TVariableNames extends string[], TVariables extends AnyConstAssignableInput, TFields$1 extends Partial<AnyFields>, TData extends object> = {
+  readonly operationType: TOperationType$1;
+  readonly operationName: TOperationName$1;
   readonly schemaLabel: string;
   readonly variableNames: TVariableNames;
-  readonly documentSource: () => TFields;
+  readonly documentSource: () => TFields$1;
   readonly document: TypedDocumentNode<TData, TVariables>;
   readonly metadata?: unknown;
 };
@@ -831,13 +828,13 @@ type OperationArtifact<TOperationType extends OperationType, TOperationName exte
  * @template TFields - Selected fields structure
  * @template TData - Inferred response data type
  */
-declare class Operation<TOperationType extends OperationType, TOperationName extends string, TVariableNames extends string[], TVariables extends AnyConstAssignableInput, TFields extends Partial<AnyFields>, TData extends object> extends GqlElement<OperationArtifact<TOperationType, TOperationName, TVariableNames, TVariables, TFields, TData>, OperationInferMeta<TVariables, TData>> implements OperationArtifact<TOperationType, TOperationName, TVariableNames, TVariables, TFields, TData> {
+declare class Operation<TOperationType$1 extends OperationType, TOperationName$1 extends string, TVariableNames extends string[], TVariables extends AnyConstAssignableInput, TFields$1 extends Partial<AnyFields>, TData extends object> extends GqlElement<OperationArtifact<TOperationType$1, TOperationName$1, TVariableNames, TVariables, TFields$1, TData>, OperationInferMeta<TVariables, TData>> implements OperationArtifact<TOperationType$1, TOperationName$1, TVariableNames, TVariables, TFields$1, TData> {
   private readonly [__OPERATION_BRAND__];
   private constructor();
   /** The operation type: 'query', 'mutation', or 'subscription'. */
-  get operationType(): TOperationType;
+  get operationType(): TOperationType$1;
   /** The unique name of this operation. */
-  get operationName(): TOperationName;
+  get operationName(): TOperationName$1;
   /** The schema label this operation belongs to. */
   get schemaLabel(): string;
   /** List of variable names defined for this operation. */
@@ -846,7 +843,7 @@ declare class Operation<TOperationType extends OperationType, TOperationName ext
    * Returns the field selections. Used for document reconstruction.
    * @internal
    */
-  get documentSource(): () => TFields;
+  get documentSource(): () => TFields$1;
   /** The TypedDocumentNode for use with GraphQL clients. */
   get document(): TypedDocumentNode<TData, TVariables>;
   /** Custom metadata attached to this operation, if any. */
@@ -856,25 +853,201 @@ declare class Operation<TOperationType extends OperationType, TOperationName ext
    * Prefer using the `gql(({ query }) => ...)` API instead.
    * @internal
    */
-  static create<TSchema extends AnyGraphqlSchema, TOperationType extends OperationType, TOperationName extends string, TVariableDefinitions extends InputTypeSpecifiers, TFields extends AnyFields>(define: (context: GqlElementContext | null) => {
-    operationType: TOperationType;
-    operationName: TOperationName;
-    schemaLabel: TSchema["label"];
+  static create<TSchema$1 extends AnyGraphqlSchema, TOperationType$1 extends OperationType, TOperationName$1 extends string, TVariableDefinitions extends InputTypeSpecifiers, TFields$1 extends AnyFields>(define: (context: GqlElementContext | null) => {
+    operationType: TOperationType$1;
+    operationName: TOperationName$1;
+    schemaLabel: TSchema$1["label"];
     variableNames: (keyof TVariableDefinitions & string)[];
-    documentSource: () => TFields;
-    document: TypedDocumentNode<InferFields<TSchema, TFields>, ConstAssignableInput<TSchema, TVariableDefinitions>>;
+    documentSource: () => TFields$1;
+    document: TypedDocumentNode<InferFields<TSchema$1, TFields$1>, ConstAssignableInput<TSchema$1, TVariableDefinitions>>;
     metadata?: unknown;
   } | Promise<{
-    operationType: TOperationType;
-    operationName: TOperationName;
-    schemaLabel: TSchema["label"];
+    operationType: TOperationType$1;
+    operationName: TOperationName$1;
+    schemaLabel: TSchema$1["label"];
     variableNames: (keyof TVariableDefinitions & string)[];
-    documentSource: () => TFields;
-    document: TypedDocumentNode<InferFields<TSchema, TFields>, ConstAssignableInput<TSchema, TVariableDefinitions>>;
+    documentSource: () => TFields$1;
+    document: TypedDocumentNode<InferFields<TSchema$1, TFields$1>, ConstAssignableInput<TSchema$1, TVariableDefinitions>>;
     metadata?: unknown;
-  }>): Operation<TOperationType, TOperationName, (keyof TVariableDefinitions & string)[], ConstAssignableInput<TSchema, TVariableDefinitions>, TFields, InferFields<TSchema, TFields>>;
+  }>): Operation<TOperationType$1, TOperationName$1, (keyof TVariableDefinitions & string)[], ConstAssignableInput<TSchema$1, TVariableDefinitions>, TFields$1, InferFields<TSchema$1, TFields$1>>;
 }
 //#endregion
+//#region packages/core/src/composer/compat.d.ts
+/**
+ * Options for creating a compat operation specification.
+ */
+type CompatOptions<TSchema$1 extends AnyGraphqlSchema, TTypeName$1 extends keyof TSchema$1["object"] & string, TOperationName$1 extends string, TVarDefinitions$1 extends InputTypeSpecifiers, TFields$1 extends AnyFields> = {
+  /** The operation name */
+  name: TOperationName$1;
+  /** Optional variable definitions */
+  variables?: TVarDefinitions$1;
+  /** Field selection builder */
+  fields: FieldsBuilder<TSchema$1, TTypeName$1, TVarDefinitions$1, TFields$1>;
+};
+/**
+ * Creates a factory for composing compat operation specifications.
+ *
+ * Returns a function that creates a `GqlDefine<CompatSpec<...>>` storing
+ * the operation specification with unevaluated fieldsBuilder.
+ *
+ * @param schema - The GraphQL schema definition
+ * @param operationType - The operation type ('query' | 'mutation' | 'subscription')
+ * @returns Compat operation composer function
+ *
+ * @internal Used by `createGqlElementComposer`
+ */
+declare const createCompatComposer: <TSchema$1 extends AnyGraphqlSchema, TOperationType$1 extends OperationType>(schema: NoInfer<TSchema$1>, operationType: TOperationType$1) => <TOperationName$1 extends string, TFields$1 extends AnyFields, TVarDefinitions$1 extends InputTypeSpecifiers = {}>(options: CompatOptions<TSchema$1, TSchema$1["operations"][TOperationType$1] & keyof TSchema$1["object"] & string, TOperationName$1, TVarDefinitions$1, TFields$1>) => GqlDefine<CompatSpec<TSchema$1, TOperationType$1, TOperationName$1, TVarDefinitions$1, TFields$1>>;
+//#endregion
+//#region packages/core/src/composer/directive-builder.d.ts
+/**
+ * A method that creates a DirectiveRef with specific type information.
+ * The TArgs type defines the expected argument shape for the directive.
+ */
+type DirectiveMethod<TDirectiveName extends string, TLocations extends readonly DirectiveLocation[], TArgs> = (args: TArgs) => DirectiveRef<{
+  directiveName: TDirectiveName;
+  locations: TLocations;
+}>;
+/**
+ * Type for directive arguments that can include VarRef values.
+ * This allows using variables in directive arguments like `{ if: $.shouldSkip }`.
+ */
+type DirectiveArgValue = boolean | string | number | null | AnyVarRef;
+/**
+ * Standard GraphQL directives that are always available.
+ */
+type StandardDirectives = {
+  /**
+   * @skip directive - conditionally skip a field.
+   * @example
+   * ```typescript
+   * f.email({}, { directives: [$dir.skip({ if: $.hideEmail })] })
+   * ```
+   */
+  skip: DirectiveMethod<"skip", readonly ["FIELD", "FRAGMENT_SPREAD", "INLINE_FRAGMENT"], {
+    if: DirectiveArgValue;
+  }>;
+  /**
+   * @include directive - conditionally include a field.
+   * @example
+   * ```typescript
+   * f.email({}, { directives: [$dir.include({ if: $.showEmail })] })
+   * ```
+   */
+  include: DirectiveMethod<"include", readonly ["FIELD", "FRAGMENT_SPREAD", "INLINE_FRAGMENT"], {
+    if: DirectiveArgValue;
+  }>;
+};
+/**
+ * Creates a directive method factory for a specific directive.
+ *
+ * @param name - The directive name (without @)
+ * @param locations - Valid locations where the directive can be applied
+ * @returns A function that creates DirectiveRef instances
+ *
+ * @example
+ * ```typescript
+ * const skipMethod = createDirectiveMethod("skip", ["FIELD", "FRAGMENT_SPREAD", "INLINE_FRAGMENT"] as const);
+ * const skipDirective = skipMethod({ if: true });
+ * ```
+ */
+declare const createDirectiveMethod: <TDirectiveName extends string, const TLocations extends readonly DirectiveLocation[]>(name: TDirectiveName, locations: TLocations) => (<TArgs extends Record<string, unknown>>(args: TArgs) => DirectiveRef<{
+  directiveName: TDirectiveName;
+  locations: TLocations;
+}>);
+/**
+ * Type for directive argument specifiers.
+ * Maps argument names to their type information.
+ */
+type DirectiveArgumentSpecifiers = {
+  readonly [argName: string]: DirectiveArgumentSpecifier;
+};
+/**
+ * Creates a typed directive method with argument type specifiers.
+ * Enables enum value output in directive arguments.
+ *
+ * @param name - The directive name (without @)
+ * @param locations - Valid locations where the directive can be applied
+ * @param argSpecs - Type specifiers for directive arguments
+ * @returns A function that creates DirectiveRef instances with argument type info
+ *
+ * @example
+ * ```typescript
+ * const authMethod = createTypedDirectiveMethod(
+ *   "auth",
+ *   ["FIELD"] as const,
+ *   { role: { kind: "enum", name: "Role", modifier: "!" } }
+ * );
+ * const authDirective = authMethod({ role: "ADMIN" });
+ * ```
+ */
+declare const createTypedDirectiveMethod: <TDirectiveName extends string, const TLocations extends readonly DirectiveLocation[], const TArgSpecs extends DirectiveArgumentSpecifiers>(name: TDirectiveName, locations: TLocations, argSpecs: TArgSpecs) => (<TArgs extends Record<string, unknown>>(args: TArgs) => DirectiveRef<{
+  directiveName: TDirectiveName;
+  locations: TLocations;
+}>);
+/**
+ * Creates the standard GraphQL directives (@skip, @include).
+ * These are always available regardless of schema definition.
+ *
+ * @returns Object containing skip and include directive methods
+ *
+ * @example
+ * ```typescript
+ * const $dir = createStandardDirectives();
+ * const skipDirective = $dir.skip({ if: true });
+ * ```
+ */
+declare const createStandardDirectives: () => StandardDirectives;
+/**
+ * Type for any directive method (type-erased).
+ */
+type AnyDirectiveMethod = (args: any) => AnyDirectiveRef;
+/**
+ * Type for the directive builder that includes standard directives
+ * and can be extended with schema-specific directives.
+ */
+type DirectiveBuilder<TCustomDirectives extends Record<string, AnyDirectiveMethod> = {}> = StandardDirectives & TCustomDirectives;
+/**
+ * Creates a directive builder with standard directives and optional custom directives.
+ *
+ * @param customDirectives - Additional directive methods from schema (generated by codegen)
+ * @returns Combined directive builder with all available directives
+ *
+ * @internal Used by codegen to create schema-specific directive builders
+ */
+declare const createDirectiveBuilder: <TCustomDirectives extends Record<string, AnyDirectiveMethod> = {}>(customDirectives?: TCustomDirectives) => DirectiveBuilder<TCustomDirectives>;
+/**
+ * Type guard to check if a value is a DirectiveRef.
+ *
+ * @param value - Value to check
+ * @returns True if value is a DirectiveRef instance
+ */
+declare const isDirectiveRef: (value: unknown) => value is AnyDirectiveRef;
+//#endregion
+//#region packages/core/src/composer/extend.d.ts
+/**
+ * Options for extending a compat spec into a full operation.
+ */
+type ExtendOptions<TSchema$1 extends AnyGraphqlSchema, TVarDefinitions$1 extends InputTypeSpecifiers, TOperationMetadata, TAggregatedFragmentMetadata, TSchemaLevel> = {
+  /** Optional metadata builder */
+  metadata?: MetadataBuilder<DeclaredVariables<TSchema$1, TVarDefinitions$1>, TOperationMetadata, TAggregatedFragmentMetadata, TSchemaLevel>;
+  /** Optional document transformer */
+  transformDocument?: OperationDocumentTransformer<TOperationMetadata>;
+};
+/**
+ * Creates a factory for extending compat specs into full operations.
+ *
+ * The extend function takes a compat spec (created by `query.compat()`) and
+ * optional metadata/transformDocument options, then creates a full Operation.
+ *
+ * @param schema - The GraphQL schema definition
+ * @param adapter - Optional metadata adapter for custom metadata handling
+ * @param transformDocument - Optional document transformer
+ * @returns Extend composer function
+ *
+ * @internal Used by `createGqlElementComposer`
+ */
+declare const createExtendComposer: <TSchema$1 extends AnyGraphqlSchema, TAdapter extends AnyMetadataAdapter = DefaultMetadataAdapter>(schema: NoInfer<TSchema$1>, adapter?: TAdapter, transformDocument?: DocumentTransformer<ExtractAdapterTypes<TAdapter>["schemaLevel"], ExtractAdapterTypes<TAdapter>["aggregatedFragmentMetadata"]>) => <TOperationType$1 extends OperationType, TOperationName$1 extends string, TVarDefinitions$1 extends InputTypeSpecifiers, TFields$1 extends AnyFields, TOperationMetadata = unknown>(compat: GqlDefine<CompatSpec<TSchema$1, TOperationType$1, TOperationName$1, TVarDefinitions$1, TFields$1>>, options?: ExtendOptions<TSchema$1, TVarDefinitions$1, TOperationMetadata, ExtractAdapterTypes<TAdapter>["aggregatedFragmentMetadata"], ExtractAdapterTypes<TAdapter>["schemaLevel"]>) => Operation<TOperationType$1, TOperationName$1, (keyof TVarDefinitions$1 & string)[], ConstAssignableInput<TSchema$1, TVarDefinitions$1>, TFields$1, InferFields<TSchema$1, TFields$1>>;
+//#endregion
 //#region packages/core/src/composer/fields-builder.d.ts
 /**
  * Creates field selection factories for a given object type.
@@ -888,7 +1061,7 @@ declare class Operation<TOperationType extends OperationType, TOperationName ext
  *
  * @internal Used by operation and fragment composers
  */
-declare const createFieldFactories: <TSchema extends AnyGraphqlSchema, TTypeName$1 extends keyof TSchema["object"] & string>(schema: TSchema, typeName: TTypeName$1) => FieldSelectionFactories<TSchema, TTypeName$1>;
+declare const createFieldFactories: <TSchema$1 extends AnyGraphqlSchema, TTypeName$1 extends keyof TSchema$1["object"] & string>(schema: TSchema$1, typeName: TTypeName$1) => FieldSelectionFactories<TSchema$1, TTypeName$1>;
 //#endregion
 //#region packages/core/src/composer/input.d.ts
 /**
@@ -902,7 +1075,7 @@ declare const createFieldFactories: <TSchema extends AnyGraphqlSchema, TTypeName
  *
  * @internal
  */
-declare const createVarAssignments: <TSchema extends AnyGraphqlSchema, TVariableDefinitions extends InputTypeSpecifiers>(definitions: TVariableDefinitions, providedValues: AnyAssignableInput | void) => DeclaredVariables<TSchema, TVariableDefinitions>;
+declare const createVarAssignments: <TSchema$1 extends AnyGraphqlSchema, TVariableDefinitions extends InputTypeSpecifiers>(definitions: TVariableDefinitions, providedValues: AnyAssignableInput | void) => DeclaredVariables<TSchema$1, TVariableDefinitions>;
 /**
  * Creates variable references from variable definitions.
  *
@@ -911,7 +1084,7 @@ declare const createVarAssignments: <TSchema extends AnyGraphqlSchema, TVariable
  *
  * @internal
  */
-declare const createVarRefs: <TSchema extends AnyGraphqlSchema, TVarDefinitions extends InputTypeSpecifiers>(definitions: TVarDefinitions) => DeclaredVariables<TSchema, TVarDefinitions>;
+declare const createVarRefs: <TSchema$1 extends AnyGraphqlSchema, TVarDefinitions$1 extends InputTypeSpecifiers>(definitions: TVarDefinitions$1) => DeclaredVariables<TSchema$1, TVarDefinitions$1>;
 //#endregion
 //#region packages/core/src/composer/fragment.d.ts
 /**
@@ -920,13 +1093,13 @@ declare const createVarRefs: <TSchema extends AnyGraphqlSchema, TVarDefinitions
  * Used by codegen to generate explicit fragment builder types instead of
  * expensive mapped types. This improves IDE performance for large schemas.
  */
-type FragmentBuilderFor<TSchema extends AnyGraphqlSchema, TTypeName$1 extends keyof TSchema["object"] & string, TAdapter extends AnyMetadataAdapter = DefaultMetadataAdapter> = <TFields extends AnyFields, TVarDefinitions extends InputTypeSpecifiers = {}>(options: {
+type FragmentBuilderFor<TSchema$1 extends AnyGraphqlSchema, TTypeName$1 extends keyof TSchema$1["object"] & string, TAdapter extends AnyMetadataAdapter = DefaultMetadataAdapter> = <TFields$1 extends AnyFields, TVarDefinitions$1 extends InputTypeSpecifiers = {}>(options: {
   /** Optional unique key for prebuilt type lookup. */
   key?: string;
-  variables?: TVarDefinitions;
-  metadata?: FragmentMetadataBuilder<ReturnType<typeof createVarRefs<TSchema, TVarDefinitions>>, ExtractAdapterTypes<TAdapter>["fragmentMetadata"]>;
-  fields: FieldsBuilder<TSchema, TTypeName$1, TVarDefinitions, TFields>;
-}) => ReturnType<typeof Fragment.create<TSchema, TTypeName$1, TVarDefinitions, TFields>>;
+  variables?: TVarDefinitions$1;
+  metadata?: FragmentMetadataBuilder<ReturnType<typeof createVarRefs<TSchema$1, TVarDefinitions$1>>, ExtractAdapterTypes<TAdapter>["fragmentMetadata"]>;
+  fields: FieldsBuilder<TSchema$1, TTypeName$1, TVarDefinitions$1, TFields$1>;
+}) => ReturnType<typeof Fragment.create<TSchema$1, TTypeName$1, TVarDefinitions$1, TFields$1>>;
 /**
  * Creates fragment builder functions for all object types in the schema.
  *
@@ -939,14 +1112,14 @@ type FragmentBuilderFor<TSchema extends AnyGraphqlSchema, TTypeName$1 extends ke
  *
  * @internal Used by `createGqlElementComposer`
  */
-declare const createGqlFragmentComposers: <TSchema extends AnyGraphqlSchema, TAdapter extends AnyMetadataAdapter = DefaultMetadataAdapter>(schema: NoInfer<TSchema>, _adapter?: TAdapter) => { readonly [TTypeName in keyof TSchema["object"]]: TTypeName extends string ? <TFields extends AnyFields, TVarDefinitions extends InputTypeSpecifiers = {}>(options: {
+declare const createGqlFragmentComposers: <TSchema$1 extends AnyGraphqlSchema, TAdapter extends AnyMetadataAdapter = DefaultMetadataAdapter>(schema: NoInfer<TSchema$1>, _adapter?: TAdapter) => { readonly [TTypeName in keyof TSchema$1["object"]]: TTypeName extends string ? <TFields$1 extends AnyFields, TVarDefinitions$1 extends InputTypeSpecifiers = {}>(options: {
   key?: string;
-  variables?: TVarDefinitions | undefined;
-  metadata?: FragmentMetadataBuilder<DeclaredVariables<TSchema, TVarDefinitions>, ExtractAdapterTypes<TAdapter>["fragmentMetadata"]> | undefined;
-  fields: FieldsBuilder<TSchema, TTypeName, TVarDefinitions, TFields>;
-}) => Fragment<TTypeName, OptionalArg<AssignableInput<TSchema, TVarDefinitions>>, TFields & {
+  variables?: TVarDefinitions$1 | undefined;
+  metadata?: FragmentMetadataBuilder<DeclaredVariables<TSchema$1, TVarDefinitions$1>, ExtractAdapterTypes<TAdapter>["fragmentMetadata"]> | undefined;
+  fields: FieldsBuilder<TSchema$1, TTypeName, TVarDefinitions$1, TFields$1>;
+}) => Fragment<TTypeName, OptionalArg<AssignableInput<TSchema$1, TVarDefinitions$1>>, TFields$1 & {
   [key: symbol]: never;
-}, InferFields<TSchema, TFields> & {
+}, InferFields<TSchema$1, TFields$1> & {
   [key: symbol]: never;
 }> : never };
 //#endregion
@@ -1019,7 +1192,7 @@ declare const getVariablePath: <T, U>(varRef: VarRef<AnyVarRefBrand>, selector:
 /**
  * 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, {
+type AssignableDefaultValue<TSchema$1 extends AnyGraphqlSchema, TKind extends InputTypeKind, TName$1 extends string, TModifier extends TypeModifier> = ConstAssignableInputValue<TSchema$1, {
   scalar: {
     kind: "scalar";
     name: TName$1;
@@ -1062,8 +1235,8 @@ type VarSpecifier<TKind extends InputTypeKind, TTypeName$1 extends string, TModi
  *
  * @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>);
+declare const createVarMethod: <TKind extends InputTypeKind, TTypeName$1 extends string>(kind: TKind, typeName: TTypeName$1) => <TSchema$1 extends AnyGraphqlSchema, const TModifier extends TypeModifier, const TDefaultFn extends (() => AssignableDefaultValue<TSchema$1, TKind, TTypeName$1, TModifier>) | null = null, const TDirectives extends AnyConstDirectiveAttachments = {}>(modifier: TModifier, extras?: {
+  default?: TDefaultFn & (() => AssignableDefaultValue<TSchema$1, TKind, TTypeName$1, TModifier>);
   directives?: TDirectives;
 }) => VarSpecifier<TKind, TTypeName$1, TModifier, TDefaultFn, TDirectives>;
 /**
@@ -1079,29 +1252,29 @@ declare const createVarMethod: <TKind extends InputTypeKind, TTypeName$1 extends
  * } 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>;
+declare const createVarMethodFactory: <TSchema$1 extends AnyGraphqlSchema>() => <TKind extends InputTypeKind, TTypeName$1 extends AllInputTypeNames<TSchema$1>>(kind: TKind, typeName: TTypeName$1) => InputTypeMethod<TSchema$1, 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>);
+type InputTypeMethod<TSchema$1 extends AnyGraphqlSchema, TKind extends InputTypeKind, TTypeName$1 extends string> = <const TModifier extends TypeModifier, const TDefaultFn extends (() => AssignableDefaultValue<TSchema$1, TKind, TTypeName$1, TModifier>) | null = null, const TDirectives extends AnyConstDirectiveAttachments = {}>(modifier: TModifier, extras?: {
+  default?: TDefaultFn & (() => AssignableDefaultValue<TSchema$1, 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 InputTypeMethods<TSchema$1 extends AnyGraphqlSchema> = { [TName in AllInputTypeNames<TSchema$1>]: InputTypeMethod<TSchema$1, InferInputKind<TSchema$1, 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>);
+type WrappedVarMethod<TVarName extends string, TSchema$1 extends AnyGraphqlSchema, TKind extends InputTypeKind, TTypeName$1 extends string> = <const TModifier extends TypeModifier, const TDefaultFn extends (() => AssignableDefaultValue<TSchema$1, TKind, TTypeName$1, TModifier>) | null = null, const TDirectives extends AnyConstDirectiveAttachments = {}>(modifier: TModifier, extras?: {
+  default?: TDefaultFn & (() => AssignableDefaultValue<TSchema$1, 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 VarBuilderMethods<TVarName extends string, TSchema$1 extends AnyGraphqlSchema> = { [TName in AllInputTypeNames<TSchema$1>]: WrappedVarMethod<TVarName, TSchema$1, InferInputKind<TSchema$1, TName>, TName> };
 /**
  * Variable builder function type.
  *
@@ -1117,29 +1290,29 @@ type VarBuilderMethods<TVarName extends string, TSchema extends AnyGraphqlSchema
  * $var.getValueAt($.userId, p => p)
  * ```
  */
-type VarBuilder<TSchema extends AnyGraphqlSchema> = {
-  <TVarName extends string>(varName: TVarName): VarBuilderMethods<TVarName, TSchema>;
+type VarBuilder<TSchema$1 extends AnyGraphqlSchema> = {
+  <TVarName extends string>(varName: TVarName): VarBuilderMethods<TVarName, TSchema$1>;
   getName: typeof getVarRefName;
   getValue: typeof getVarRefValue;
-  getNameAt: SchemaAwareGetNameAt<TSchema>;
-  getValueAt: SchemaAwareGetValueAt<TSchema>;
+  getNameAt: SchemaAwareGetNameAt<TSchema$1>;
+  getValueAt: SchemaAwareGetValueAt<TSchema$1>;
   getVariablePath: typeof getVariablePath;
 };
 /**
  * Resolves the TypeScript type from VarRef meta using schema.
  * This is used for getValueAt/getNameAt with type structure resolution.
  */
-type ResolveTypeFromMeta<TSchema extends AnyGraphqlSchema, TMeta extends AnyVarRefBrand> = TypeProfile.Type<ResolveInputProfileFromMeta<TSchema, TMeta["typeName"], TMeta["kind"], "!">>;
+type ResolveTypeFromMeta<TSchema$1 extends AnyGraphqlSchema, TMeta extends AnyVarRefBrand> = TypeProfile.Type<ResolveInputProfileFromMeta<TSchema$1, TMeta["typeName"], TMeta["kind"], "!">>;
 /**
  * Schema-aware getValueAt type.
  * Resolves type structure from schema using typeName + kind.
  */
-type SchemaAwareGetValueAt<TSchema extends AnyGraphqlSchema> = <T extends AnyVarRefBrand, U>(varRef: VarRef<T>, selector: (proxy: SelectableProxy<ResolveTypeFromMeta<TSchema, T>>) => U) => U;
+type SchemaAwareGetValueAt<TSchema$1 extends AnyGraphqlSchema> = <T extends AnyVarRefBrand, U>(varRef: VarRef<T>, selector: (proxy: SelectableProxy<ResolveTypeFromMeta<TSchema$1, T>>) => U) => U;
 /**
  * Schema-aware getNameAt type.
  * Resolves type structure from schema using typeName + kind.
  */
-type SchemaAwareGetNameAt<TSchema extends AnyGraphqlSchema> = <T extends AnyVarRefBrand, U>(varRef: VarRef<T>, selector: (proxy: ResolveTypeFromMeta<TSchema, T>) => U) => string;
+type SchemaAwareGetNameAt<TSchema$1 extends AnyGraphqlSchema> = <T extends AnyVarRefBrand, U>(varRef: VarRef<T>, selector: (proxy: ResolveTypeFromMeta<TSchema$1, T>) => U) => string;
 /**
  * Creates a variable builder using injected input type methods.
  *
@@ -1152,7 +1325,7 @@ type SchemaAwareGetNameAt<TSchema extends AnyGraphqlSchema> = <T extends AnyVarR
  *
  * @internal Used by `createGqlElementComposer`
  */
-declare const createVarBuilder: <TSchema extends AnyGraphqlSchema>(inputTypeMethods: InputTypeMethods<TSchema>) => VarBuilder<TSchema>;
+declare const createVarBuilder: <TSchema$1 extends AnyGraphqlSchema>(inputTypeMethods: InputTypeMethods<TSchema$1>) => VarBuilder<TSchema$1>;
 //#endregion
 //#region packages/core/src/composer/gql-composer.d.ts
 /**
@@ -1161,7 +1334,7 @@ declare const createVarBuilder: <TSchema extends AnyGraphqlSchema>(inputTypeMeth
  * The composer provides a context with builders for fragments, operations,
  * variables, and colocation helpers.
  */
-type GqlElementComposer<TContext> = <TResult extends AnyFragment | AnyOperation>(composeElement: (context: TContext) => TResult) => TResult;
+type GqlElementComposer<TContext> = <TResult extends AnyFragment | AnyOperation | AnyGqlDefine>(composeElement: (context: TContext) => TResult) => TResult;
 /**
  * GQL element composer with schema access.
  *
@@ -1171,12 +1344,12 @@ type GqlElementComposer<TContext> = <TResult extends AnyFragment | AnyOperation>
  * - Runtime schema introspection
  * - Debugging and tooling
  */
-type GqlElementComposerWithSchema<TContext, TSchema extends AnyGraphqlSchema> = GqlElementComposer<TContext> & {
+type GqlElementComposerWithSchema<TContext, TSchema$1 extends AnyGraphqlSchema> = GqlElementComposer<TContext> & {
   /**
    * The GraphQL schema definition used by this composer.
    * Provides runtime access to schema types, operations, and metadata.
    */
-  readonly $schema: TSchema;
+  readonly $schema: TSchema$1;
 };
 /**
  * Extracts the helpers type from an adapter.
@@ -1195,15 +1368,15 @@ type ExtractMetadataAdapter<TAdapter extends AnyAdapter> = TAdapter extends {
  * Default fragment builders type computed from schema.
  * This is the mapped type that's expensive to compute for large schemas.
  */
-type FragmentBuildersAll<TSchema extends AnyGraphqlSchema, TAdapter extends AnyMetadataAdapter = DefaultMetadataAdapter> = { readonly [TTypeName in keyof TSchema["object"]]: TTypeName extends string ? FragmentBuilderFor<TSchema, TTypeName, TAdapter> : never };
+type FragmentBuildersAll<TSchema$1 extends AnyGraphqlSchema, TAdapter extends AnyMetadataAdapter = DefaultMetadataAdapter> = { readonly [TTypeName in keyof TSchema$1["object"]]: TTypeName extends string ? FragmentBuilderFor<TSchema$1, TTypeName, TAdapter> : never };
 /**
  * Configuration options for `createGqlElementComposer`.
  */
-type GqlElementComposerOptions<TSchema extends AnyGraphqlSchema, TDirectiveMethods extends StandardDirectives, TAdapter extends AnyAdapter = DefaultAdapter> = {
+type GqlElementComposerOptions<TSchema$1 extends AnyGraphqlSchema, TDirectiveMethods extends StandardDirectives, TAdapter extends AnyAdapter = DefaultAdapter> = {
   /** Optional adapter for custom helpers and metadata handling. */
   adapter?: TAdapter;
   /** Methods for building variable type specifiers. */
-  inputTypeMethods: InputTypeMethods<TSchema>;
+  inputTypeMethods: InputTypeMethods<TSchema$1>;
   /** Optional custom directive methods (including schema-defined directives). */
   directiveMethods?: TDirectiveMethods;
 };
@@ -1240,39 +1413,44 @@ type GqlElementComposerOptions<TSchema extends AnyGraphqlSchema, TDirectiveMetho
  * );
  * ```
  */
-declare const createGqlElementComposer: <TSchema extends AnyGraphqlSchema, TFragmentBuilders, TDirectiveMethods extends StandardDirectives, TAdapter extends AnyAdapter = DefaultAdapter>(schema: NoInfer<TSchema>, options: GqlElementComposerOptions<NoInfer<TSchema>, NoInfer<TDirectiveMethods>, NoInfer<TAdapter>>) => GqlElementComposerWithSchema<{
+declare const createGqlElementComposer: <TSchema$1 extends AnyGraphqlSchema, TFragmentBuilders, TDirectiveMethods extends StandardDirectives, TAdapter extends AnyAdapter = DefaultAdapter>(schema: NoInfer<TSchema$1>, options: GqlElementComposerOptions<NoInfer<TSchema$1>, NoInfer<TDirectiveMethods>, NoInfer<TAdapter>>) => GqlElementComposerWithSchema<{
   fragment: TFragmentBuilders;
   query: {
-    operation: <TOperationName extends string, TFields extends AnyFields, TVarDefinitions extends InputTypeSpecifiers = {}, TOperationMetadata = unknown>(options: {
-      name: TOperationName;
-      variables?: TVarDefinitions | undefined;
-      metadata?: MetadataBuilder<DeclaredVariables<TSchema, TVarDefinitions>, TOperationMetadata, ExtractAdapterTypes<ExtractMetadataAdapter<TAdapter>>["aggregatedFragmentMetadata"], ExtractAdapterTypes<ExtractMetadataAdapter<TAdapter>>["schemaLevel"]> | undefined;
-      fields: FieldsBuilder<TSchema, TSchema["operations"]["query"] & keyof TSchema["object"] & string, TVarDefinitions, TFields>;
+    operation: <TOperationName$1 extends string, TFields$1 extends AnyFields, TVarDefinitions$1 extends InputTypeSpecifiers = {}, TOperationMetadata = unknown>(options: {
+      name: TOperationName$1;
+      variables?: TVarDefinitions$1 | undefined;
+      metadata?: MetadataBuilder<DeclaredVariables<TSchema$1, TVarDefinitions$1>, TOperationMetadata, ExtractAdapterTypes<ExtractMetadataAdapter<TAdapter>>["aggregatedFragmentMetadata"], ExtractAdapterTypes<ExtractMetadataAdapter<TAdapter>>["schemaLevel"]> | undefined;
+      fields: FieldsBuilder<TSchema$1, TSchema$1["operations"]["query"] & keyof TSchema$1["object"] & string, TVarDefinitions$1, TFields$1>;
       transformDocument?: OperationDocumentTransformer<TOperationMetadata> | undefined;
-    }) => Operation<"query", TOperationName, (keyof TVarDefinitions & string)[], ConstAssignableInput<TSchema, TVarDefinitions>, TFields, InferFields<TSchema, TFields>>;
+    }) => Operation<"query", TOperationName$1, (keyof TVarDefinitions$1 & string)[], ConstAssignableInput<TSchema$1, TVarDefinitions$1>, TFields$1, InferFields<TSchema$1, TFields$1>>;
+    compat: <TOperationName$1 extends string, TFields_1 extends AnyFields, TVarDefinitions_1 extends InputTypeSpecifiers = {}>(options: CompatOptions<TSchema$1, TSchema$1["operations"]["query"] & keyof TSchema$1["object"] & string, TOperationName$1, TVarDefinitions_1, TFields_1>) => GqlDefine<CompatSpec<TSchema$1, "query", TOperationName$1, TVarDefinitions_1, TFields_1>>;
   };
   mutation: {
-    operation: <TOperationName extends string, TFields extends AnyFields, TVarDefinitions extends InputTypeSpecifiers = {}, TOperationMetadata = unknown>(options: {
-      name: TOperationName;
-      variables?: TVarDefinitions | undefined;
-      metadata?: MetadataBuilder<DeclaredVariables<TSchema, TVarDefinitions>, TOperationMetadata, ExtractAdapterTypes<ExtractMetadataAdapter<TAdapter>>["aggregatedFragmentMetadata"], ExtractAdapterTypes<ExtractMetadataAdapter<TAdapter>>["schemaLevel"]> | undefined;
-      fields: FieldsBuilder<TSchema, TSchema["operations"]["mutation"] & keyof TSchema["object"] & string, TVarDefinitions, TFields>;
+    operation: <TOperationName$1 extends string, TFields$1 extends AnyFields, TVarDefinitions$1 extends InputTypeSpecifiers = {}, TOperationMetadata = unknown>(options: {
+      name: TOperationName$1;
+      variables?: TVarDefinitions$1 | undefined;
+      metadata?: MetadataBuilder<DeclaredVariables<TSchema$1, TVarDefinitions$1>, TOperationMetadata, ExtractAdapterTypes<ExtractMetadataAdapter<TAdapter>>["aggregatedFragmentMetadata"], ExtractAdapterTypes<ExtractMetadataAdapter<TAdapter>>["schemaLevel"]> | undefined;
+      fields: FieldsBuilder<TSchema$1, TSchema$1["operations"]["mutation"] & keyof TSchema$1["object"] & string, TVarDefinitions$1, TFields$1>;
       transformDocument?: OperationDocumentTransformer<TOperationMetadata> | undefined;
-    }) => Operation<"mutation", TOperationName, (keyof TVarDefinitions & string)[], ConstAssignableInput<TSchema, TVarDefinitions>, TFields, InferFields<TSchema, TFields>>;
+    }) => Operation<"mutation", TOperationName$1, (keyof TVarDefinitions$1 & string)[], ConstAssignableInput<TSchema$1, TVarDefinitions$1>, TFields$1, InferFields<TSchema$1, TFields$1>>;
+    compat: <TOperationName$1 extends string, TFields_1 extends AnyFields, TVarDefinitions_1 extends InputTypeSpecifiers = {}>(options: CompatOptions<TSchema$1, TSchema$1["operations"]["mutation"] & keyof TSchema$1["object"] & string, TOperationName$1, TVarDefinitions_1, TFields_1>) => GqlDefine<CompatSpec<TSchema$1, "mutation", TOperationName$1, TVarDefinitions_1, TFields_1>>;
   };
   subscription: {
-    operation: <TOperationName extends string, TFields extends AnyFields, TVarDefinitions extends InputTypeSpecifiers = {}, TOperationMetadata = unknown>(options: {
-      name: TOperationName;
-      variables?: TVarDefinitions | undefined;
-      metadata?: MetadataBuilder<DeclaredVariables<TSchema, TVarDefinitions>, TOperationMetadata, ExtractAdapterTypes<ExtractMetadataAdapter<TAdapter>>["aggregatedFragmentMetadata"], ExtractAdapterTypes<ExtractMetadataAdapter<TAdapter>>["schemaLevel"]> | undefined;
-      fields: FieldsBuilder<TSchema, TSchema["operations"]["subscription"] & keyof TSchema["object"] & string, TVarDefinitions, TFields>;
+    operation: <TOperationName$1 extends string, TFields$1 extends AnyFields, TVarDefinitions$1 extends InputTypeSpecifiers = {}, TOperationMetadata = unknown>(options: {
+      name: TOperationName$1;
+      variables?: TVarDefinitions$1 | undefined;
+      metadata?: MetadataBuilder<DeclaredVariables<TSchema$1, TVarDefinitions$1>, TOperationMetadata, ExtractAdapterTypes<ExtractMetadataAdapter<TAdapter>>["aggregatedFragmentMetadata"], ExtractAdapterTypes<ExtractMetadataAdapter<TAdapter>>["schemaLevel"]> | undefined;
+      fields: FieldsBuilder<TSchema$1, TSchema$1["operations"]["subscription"] & keyof TSchema$1["object"] & string, TVarDefinitions$1, TFields$1>;
       transformDocument?: OperationDocumentTransformer<TOperationMetadata> | undefined;
-    }) => Operation<"subscription", TOperationName, (keyof TVarDefinitions & string)[], ConstAssignableInput<TSchema, TVarDefinitions>, TFields, InferFields<TSchema, TFields>>;
+    }) => Operation<"subscription", TOperationName$1, (keyof TVarDefinitions$1 & string)[], ConstAssignableInput<TSchema$1, TVarDefinitions$1>, TFields$1, InferFields<TSchema$1, TFields$1>>;
+    compat: <TOperationName$1 extends string, TFields_1 extends AnyFields, TVarDefinitions_1 extends InputTypeSpecifiers = {}>(options: CompatOptions<TSchema$1, TSchema$1["operations"]["subscription"] & keyof TSchema$1["object"] & string, TOperationName$1, TVarDefinitions_1, TFields_1>) => GqlDefine<CompatSpec<TSchema$1, "subscription", TOperationName$1, TVarDefinitions_1, TFields_1>>;
   };
-  $var: VarBuilder<TSchema>;
+  define: <TValue$1>(factory: () => TValue$1 | Promise<TValue$1>) => GqlDefine<TValue$1>;
+  extend: <TOperationType$1 extends OperationType, TOperationName$1 extends string, TVarDefinitions_2 extends InputTypeSpecifiers, TFields_2 extends AnyFields, TOperationMetadata_1 = unknown>(compat: GqlDefine<CompatSpec<TSchema$1, TOperationType$1, TOperationName$1, TVarDefinitions_2, TFields_2>>, options?: ExtendOptions<TSchema$1, TVarDefinitions_2, TOperationMetadata_1, ExtractAdapterTypes<ExtractMetadataAdapter<TAdapter>>["aggregatedFragmentMetadata"], ExtractAdapterTypes<ExtractMetadataAdapter<TAdapter>>["schemaLevel"]> | undefined) => Operation<TOperationType$1, TOperationName$1, (keyof TVarDefinitions_2 & string)[], ConstAssignableInput<TSchema$1, TVarDefinitions_2>, TFields_2, InferFields<TSchema$1, TFields_2>>;
+  $var: VarBuilder<TSchema$1>;
   $dir: TDirectiveMethods;
   $colocate: <TEntries extends ColocatedEntries>(entries: TEntries) => ColocatedFields<TEntries>;
-} & ExtractHelpers<TAdapter>, TSchema>;
+} & ExtractHelpers<TAdapter>, TSchema$1>;
 /**
  * Abstract Context type for prebuilt composers.
  *
@@ -1286,13 +1464,18 @@ type AnyGqlContext = {
   readonly fragment: Record<string, unknown>;
   readonly query: {
     operation: (...args: unknown[]) => AnyOperation;
+    compat: (...args: unknown[]) => AnyGqlDefine;
   };
   readonly mutation: {
     operation: (...args: unknown[]) => AnyOperation;
+    compat: (...args: unknown[]) => AnyGqlDefine;
   };
   readonly subscription: {
     operation: (...args: unknown[]) => AnyOperation;
+    compat: (...args: unknown[]) => AnyGqlDefine;
   };
+  readonly define: <TValue$1>(factory: () => TValue$1 | Promise<TValue$1>) => GqlDefine<TValue$1>;
+  readonly extend: (...args: unknown[]) => AnyOperation;
   readonly $var: unknown;
   readonly $dir: StandardDirectives;
   readonly $colocate: unknown;
@@ -1316,13 +1499,60 @@ type AnyGqlContext = {
  *
  * @internal Used by `createGqlElementComposer`
  */
-declare const createOperationComposerFactory: <TSchema extends AnyGraphqlSchema, TAdapter extends AnyMetadataAdapter = DefaultMetadataAdapter>(schema: NoInfer<TSchema>, adapter?: TAdapter, transformDocument?: DocumentTransformer<ExtractAdapterTypes<TAdapter>["schemaLevel"], ExtractAdapterTypes<TAdapter>["aggregatedFragmentMetadata"]>) => <TOperationType extends OperationType>(operationType: TOperationType) => <TOperationName extends string, TFields extends AnyFields, TVarDefinitions extends InputTypeSpecifiers = {}, TOperationMetadata = unknown>(options: {
-  name: TOperationName;
-  variables?: TVarDefinitions;
-  metadata?: MetadataBuilder<ReturnType<typeof createVarRefs<TSchema, TVarDefinitions>>, TOperationMetadata, ExtractAdapterTypes<TAdapter>["aggregatedFragmentMetadata"], ExtractAdapterTypes<TAdapter>["schemaLevel"]>;
-  fields: FieldsBuilder<TSchema, TSchema["operations"][TOperationType] & keyof TSchema["object"] & string, TVarDefinitions, TFields>;
+declare const createOperationComposerFactory: <TSchema$1 extends AnyGraphqlSchema, TAdapter extends AnyMetadataAdapter = DefaultMetadataAdapter>(schema: NoInfer<TSchema$1>, adapter?: TAdapter, transformDocument?: DocumentTransformer<ExtractAdapterTypes<TAdapter>["schemaLevel"], ExtractAdapterTypes<TAdapter>["aggregatedFragmentMetadata"]>) => <TOperationType$1 extends OperationType>(operationType: TOperationType$1) => <TOperationName$1 extends string, TFields$1 extends AnyFields, TVarDefinitions$1 extends InputTypeSpecifiers = {}, TOperationMetadata = unknown>(options: {
+  name: TOperationName$1;
+  variables?: TVarDefinitions$1;
+  metadata?: MetadataBuilder<ReturnType<typeof createVarRefs<TSchema$1, TVarDefinitions$1>>, TOperationMetadata, ExtractAdapterTypes<TAdapter>["aggregatedFragmentMetadata"], ExtractAdapterTypes<TAdapter>["schemaLevel"]>;
+  fields: FieldsBuilder<TSchema$1, TSchema$1["operations"][TOperationType$1] & keyof TSchema$1["object"] & string, TVarDefinitions$1, TFields$1>;
   transformDocument?: OperationDocumentTransformer<TOperationMetadata>;
-}) => Operation<TOperationType, TOperationName, (keyof TVarDefinitions & string)[], ConstAssignableInput<TSchema, TVarDefinitions>, TFields, InferFields<TSchema, TFields>>;
+}) => Operation<TOperationType$1, TOperationName$1, (keyof TVarDefinitions$1 & string)[], ConstAssignableInput<TSchema$1, TVarDefinitions$1>, TFields$1, InferFields<TSchema$1, TFields$1>>;
+//#endregion
+//#region packages/core/src/composer/operation-core.d.ts
+/**
+ * Parameters for building an operation artifact.
+ * Used by both operation and extend composers.
+ */
+type OperationCoreParams<TSchema$1 extends AnyGraphqlSchema, TOperationType$1 extends OperationType, TOperationName$1 extends string, TVarDefinitions$1 extends InputTypeSpecifiers, TFields$1 extends AnyFields, TOperationMetadata, TAdapter extends AnyMetadataAdapter> = {
+  readonly schema: TSchema$1;
+  readonly operationType: TOperationType$1;
+  readonly operationTypeName: TSchema$1["operations"][TOperationType$1] & keyof TSchema$1["object"] & string;
+  readonly operationName: TOperationName$1;
+  readonly variables: TVarDefinitions$1;
+  readonly fieldsFactory: FieldsBuilder<TSchema$1, TSchema$1["operations"][TOperationType$1] & keyof TSchema$1["object"] & string, TVarDefinitions$1, TFields$1>;
+  readonly adapter: TAdapter;
+  readonly metadata?: MetadataBuilder<DeclaredVariables<TSchema$1, TVarDefinitions$1>, TOperationMetadata, ExtractAdapterTypes<TAdapter>["aggregatedFragmentMetadata"], ExtractAdapterTypes<TAdapter>["schemaLevel"]>;
+  readonly transformDocument?: OperationDocumentTransformer<TOperationMetadata>;
+  readonly adapterTransformDocument?: DocumentTransformer<ExtractAdapterTypes<TAdapter>["schemaLevel"], ExtractAdapterTypes<TAdapter>["aggregatedFragmentMetadata"]>;
+};
+/**
+ * Result type from buildOperationArtifact.
+ * Matches the artifact shape expected by Operation.create().
+ */
+type OperationArtifactResult<TOperationType$1 extends OperationType, TOperationName$1 extends string, TVarDefinitions$1 extends InputTypeSpecifiers, TFields$1 extends AnyFields, TOperationMetadata> = {
+  readonly operationType: TOperationType$1;
+  readonly operationName: TOperationName$1;
+  readonly schemaLabel: string;
+  readonly variableNames: (keyof TVarDefinitions$1 & string)[];
+  readonly documentSource: () => TFields$1;
+  readonly document: ReturnType<typeof buildDocument>;
+  readonly metadata: TOperationMetadata | undefined;
+};
+/**
+ * Builds an operation artifact from the provided parameters.
+ *
+ * This function contains the core logic for:
+ * - Creating variable refs and field factories
+ * - Evaluating fields with fragment usage tracking
+ * - Building the document
+ * - Handling metadata (sync and async)
+ * - Applying document transformations
+ *
+ * @param params - Operation building parameters
+ * @returns Operation artifact or Promise of artifact (if async metadata)
+ *
+ * @internal Used by operation.ts and extend.ts
+ */
+declare const buildOperationArtifact: <TSchema$1 extends AnyGraphqlSchema, TOperationType$1 extends OperationType, TOperationName$1 extends string, TVarDefinitions$1 extends InputTypeSpecifiers, TFields$1 extends AnyFields, TOperationMetadata, TAdapter extends AnyMetadataAdapter>(params: OperationCoreParams<TSchema$1, TOperationType$1, TOperationName$1, TVarDefinitions$1, TFields$1, TOperationMetadata, TAdapter>) => OperationArtifactResult<TOperationType$1, TOperationName$1, TVarDefinitions$1, TFields$1, TOperationMetadata> | Promise<OperationArtifactResult<TOperationType$1, TOperationName$1, TVarDefinitions$1, TFields$1, TOperationMetadata>>;
 //#endregion
 //#region packages/core/src/prebuilt/type-calculator.d.ts
 /**
@@ -1555,5 +1785,5 @@ type Hidden<T> = () => T;
 //#region packages/core/src/utils/wrap-by-key.d.ts
 declare function wrapByKey<TName$1 extends string, TValue$1>(name: TName$1, value: TValue$1): { [K in TName$1]: TValue$1 };
 //#endregion
-export { AnyOperation as $, buildConstValueNode as $t, GqlElementComposer as A, DirectiveRefInner as An, AttachmentToProperty as At, VarBuilderMethods as B, createStandardDirectives as Bt, getScalarInputType as C, ConstAssignableInputValue as Cn, NestedUnionFieldsBuilder as Ct, AnyGqlContext as D, DirectiveArgumentSpecifier as Dn, SwitchIfOmittable as Dt, createOperationComposerFactory as E, AnyDirectiveRefBrand as En, OptionalArg as Et, InputTypeMethods as F, DirectiveBuilder as Ft, FragmentUsageRecord as G, ColocatedFields as Gt, createVarBuilder as H, isDirectiveRef as Ht, ResolveTypeFromMeta as I, DirectiveMethod as It, FragmentBuilderFor as J, StripSymbols as Jt, recordFragmentUsage as K, createColocateHelper as Kt, SchemaAwareGetNameAt as L, StandardDirectives as Lt, GqlElementComposerWithSchema as M, TypeSystemDirectiveLocation as Mn, AnyDirectiveMethod as Mt, createGqlElementComposer as N, DirectiveArgValue as Nt, ExtractMetadataAdapter as O, DirectiveLocation as On, empty as Ot, InputTypeMethod as P, DirectiveArgumentSpecifiers as Pt, createFieldFactories as Q, buildArgumentValue as Qt, SchemaAwareGetValueAt as R, createDirectiveBuilder as Rt, getEnumType as S, ConstAssignableInput as Sn, NestedObjectFieldsBuilderTools as St, graphqlTypeToTypeScript as T, AnyDirectiveRef as Tn, IfOmittable as Tt, createVarMethod as U, ColocateHelper as Ut, VarSpecifier as V, createTypedDirectiveMethod as Vt, createVarMethodFactory as W, ColocatedEntries as Wt, createVarAssignments as X, UnionToIntersection as Xt, createGqlFragmentComposers as Y, Tuple as Yt, createVarRefs as Z, EnumLookup as Zt, calculateFieldType as _, DeclaredVariables as _n, FieldSelectionFactoryReturn as _t, HasPrebuiltFragment as a, AnyFields as an, FragmentInferMeta as at, generateInputType as b, AnyConstAssignableInput as bn, FieldsBuilderTools as bt, PrebuiltFragmentInput as c, FieldSelectionTemplateOf as cn, GqlElementContext as ct, PrebuiltOperationOutput as d, AnyDirectiveAttachments as dn, AnyFieldSelectionFactoryReturn as dt, buildDocument as en, AnyOperationOf as et, PrebuiltTypeRegistry as f, AnyAssignableInput as fn, FieldSelectionFactories as ft, applyTypeModifier as g, AssignableInputByFieldName as gn, FieldSelectionFactoryPrimitiveReturn as gt, TypeFormatters as h, AssignableInput as hn, FieldSelectionFactoryObjectReturn as ht, EmptyPrebuiltTypeRegistry as i, AnyFieldSelection as in, Fragment as it, GqlElementComposerOptions as j, ExecutableDirectiveLocation as jn, AttachmentsTupleToIntersection as jt, FragmentBuildersAll as k, DirectiveRef as kn, AttachmentShape as kt, PrebuiltFragmentOutput as l, InferField as ln, GqlElementDefinitionFactory as lt, GenerateInputObjectTypeOptions as m, AnyAssigningInput as mn, FieldSelectionFactoryFieldArguments as mt, Hidden as n, buildWithTypeModifier as nn, OperationInferMeta as nt, HasPrebuiltOperation as o, AnyNestedObject as on, GqlElement as ot, PrebuiltUnknownElement as p, AnyAssignableInputValue as pn, FieldSelectionFactory as pt, withFragmentUsageCollection as q, StripFunctions as qt, hidden as r, AbstractFieldSelection as rn, AnyFragment as rt, PrebuiltEntryNotFound as s, AnyNestedUnion as sn, GqlElementAttachment as st, wrapByKey as t, buildOperationTypeNode as tn, Operation as tt, PrebuiltOperationInput as u, InferFields as un, AnyFieldSelectionFactory as ut, calculateFieldsType as v, FieldArgumentValue as vn, FieldSelectionFactoryUnionReturn as vt, getScalarOutputType as w, GetAssignableType as wn, EmptyObject as wt, generateInputTypeFromSpecifiers as x, AnyConstAssignableInputValue as xn, NestedObjectFieldsBuilder as xt, generateInputObjectType as y, AnyConstDirectiveAttachments as yn, FieldsBuilder as yt, VarBuilder as z, createDirectiveMethod as zt };
-//# sourceMappingURL=index-DPtgl2f4.d.ts.map
+export { createVarAssignments as $, AttachmentShape as $t, AnyGqlContext as A, DeclaredVariables as An, GqlElementDefinitionFactory as At, SchemaAwareGetNameAt as B, DirectiveArgumentSpecifier as Bn, FieldSelectionFactoryPrimitiveReturn as Bt, getScalarInputType as C, InferFields as Cn, FragmentInferMeta as Ct, OperationCoreParams as D, AnyAssigningInput as Dn, GqlElement as Dt, OperationArtifactResult as E, AnyAssignableInputValue as En, GqlDefine as Et, GqlElementComposerWithSchema as F, ConstAssignableInput as Fn, AnyFieldSelectionFactoryReturn as Ft, createVarBuilder as G, TypeSystemDirectiveLocation as Gn, NestedObjectFieldsBuilder as Gt, VarBuilder as H, DirectiveRef as Hn, FieldSelectionFactoryUnionReturn as Ht, createGqlElementComposer as I, ConstAssignableInputValue as In, FieldSelectionFactories as It, FragmentUsageRecord as J, EmptyObject as Jt, createVarMethod as K, NestedObjectFieldsBuilderTools as Kt, InputTypeMethod as L, GetAssignableType as Ln, FieldSelectionFactory as Lt, FragmentBuildersAll as M, AnyConstDirectiveAttachments as Mn, CompatSpec as Mt, GqlElementComposer as N, AnyConstAssignableInput as Nn, ExtractCompatSpec as Nt, buildOperationArtifact as O, AssignableInput as On, GqlElementAttachment as Ot, GqlElementComposerOptions as P, AnyConstAssignableInputValue as Pn, AnyFieldSelectionFactory as Pt, createGqlFragmentComposers as Q, empty as Qt, InputTypeMethods as R, AnyDirectiveRef as Rn, FieldSelectionFactoryFieldArguments as Rt, getEnumType as S, InferField as Sn, Fragment as St, graphqlTypeToTypeScript as T, AnyAssignableInput as Tn, DefineInferMeta as Tt, VarBuilderMethods as U, DirectiveRefInner as Un, FieldsBuilder as Ut, SchemaAwareGetValueAt as V, DirectiveLocation as Vn, FieldSelectionFactoryReturn as Vt, VarSpecifier as W, ExecutableDirectiveLocation as Wn, FieldsBuilderTools as Wt, withFragmentUsageCollection as X, OptionalArg as Xt, recordFragmentUsage as Y, IfOmittable as Yt, FragmentBuilderFor as Z, SwitchIfOmittable as Zt, calculateFieldType as _, AnyFieldSelection as _n, AnyOperation as _t, HasPrebuiltFragment as a, createColocateHelper as an, DirectiveArgValue as at, generateInputType as b, AnyNestedUnion as bn, OperationInferMeta as bt, PrebuiltFragmentInput as c, Tuple as cn, DirectiveMethod as ct, PrebuiltOperationOutput as d, buildArgumentValue as dn, createDirectiveMethod as dt, AttachmentToProperty as en, createVarRefs as et, PrebuiltTypeRegistry as f, buildConstValueNode as fn, createStandardDirectives as ft, applyTypeModifier as g, AbstractFieldSelection as gn, createCompatComposer as gt, TypeFormatters as h, buildWithTypeModifier as hn, CompatOptions as ht, EmptyPrebuiltTypeRegistry as i, ColocatedFields as in, AnyDirectiveMethod as it, ExtractMetadataAdapter as j, FieldArgumentValue as jn, AnyCompatSpec as jt, createOperationComposerFactory as k, AssignableInputByFieldName as kn, GqlElementContext as kt, PrebuiltFragmentOutput as l, UnionToIntersection as ln, StandardDirectives as lt, GenerateInputObjectTypeOptions as m, buildOperationTypeNode as mn, isDirectiveRef as mt, Hidden as n, ColocateHelper as nn, ExtendOptions as nt, HasPrebuiltOperation as o, StripFunctions as on, DirectiveArgumentSpecifiers as ot, PrebuiltUnknownElement as p, buildDocument as pn, createTypedDirectiveMethod as pt, createVarMethodFactory as q, NestedUnionFieldsBuilder as qt, hidden as r, ColocatedEntries as rn, createExtendComposer as rt, PrebuiltEntryNotFound as s, StripSymbols as sn, DirectiveBuilder as st, wrapByKey as t, AttachmentsTupleToIntersection as tn, createFieldFactories as tt, PrebuiltOperationInput as u, EnumLookup as un, createDirectiveBuilder as ut, calculateFieldsType as v, AnyFields as vn, AnyOperationOf as vt, getScalarOutputType as w, AnyDirectiveAttachments as wn, AnyGqlDefine as wt, generateInputTypeFromSpecifiers as x, FieldSelectionTemplateOf as xn, AnyFragment as xt, generateInputObjectType as y, AnyNestedObject as yn, Operation as yt, ResolveTypeFromMeta as z, AnyDirectiveRefBrand as zn, FieldSelectionFactoryObjectReturn as zt };
+//# sourceMappingURL=index-CULnRHFI.d.ts.map