@soda-gql/core 0.0.1

package/dist/index-DiEkx8-6.d.ts

@@ -0,0 +1,1112 @@
+import { ConstValueNode, FormattedExecutionResult, GraphQLFormattedError, NamedTypeNode, OperationTypeNode, TypeNode, TypedQueryDocumentNode, ValueNode } from "graphql";
+
+//#region packages/core/src/types/schema/const-value.d.ts
+type ConstValue = string | number | boolean | null | undefined | {
+  readonly [key: string]: ConstValue;
+} | readonly ConstValue[];
+type ConstValues = {
+  readonly [key: string]: ConstValue;
+};
+//#endregion
+//#region packages/core/src/utils/hidden.d.ts
+declare const hidden: <T>() => (() => T);
+type Hidden<T> = () => T;
+//#endregion
+//#region packages/core/src/types/schema/type-modifier.d.ts
+type AnyTypeModifier = string;
+type TypeModifier = "?" | `!${string}` | `[]${string}`;
+type ListTypeModifierSuffix = "[]" | "[]!";
+type StripTailingListFromTypeModifier<TModifier extends TypeModifier> = TModifier extends `${infer TInner extends TypeModifier}${ListTypeModifierSuffix}` ? TInner : TModifier;
+type ApplyTypeModifier<TModifier extends TypeModifier, TInner> = TModifier extends "!" ? TInner : TModifier extends "?" | "" ? TInner | null | undefined : TModifier extends `![]${infer TNext extends TypeModifier}` ? ApplyTypeModifier<TNext, TInner[]> : TModifier extends `[]${infer TNext extends TypeModifier}` ? ApplyTypeModifier<TNext, (TInner | null | undefined)[]> : never;
+type ApplyTypeModifierToKeys<T extends {
+  [key: string]: {
+    modifier: TypeModifier;
+  };
+}> = { readonly [K in keyof T as T[K]["modifier"] extends `${string}!` ? K : never]-?: T[K] } & { readonly [K in keyof T as T[K]["modifier"] extends `${string}!` ? never : K]+?: T[K] };
+type ModifiedTypeName<TNameCandidate extends string, TName extends TNameCandidate, TModifier extends AnyTypeModifier> = (`${TName}:${TModifier}` & NoInfer<TypeModifierValidation<TModifier>>) | NoInfer<`${TName}:${TypeModifierSuggestion<TModifier>}`>;
+type TypeModifierSuggestion<TModifier extends AnyTypeModifier> = [TModifier, TypeModifier] extends [TypeModifier, TModifier] ? "?" | "!" | "[]" : TModifier extends "?" ? "?" : TModifier extends `${string}!` ? `${TModifier}[]` : TModifier extends `${string}[]` ? `${TModifier}[]` | `${TModifier}!` : never;
+type TypeModifierValidation<TModifier extends AnyTypeModifier> = TModifier extends "?" | "!" ? string : TModifier extends `${"!" | ""}[]${infer TNext extends TypeModifier | ""}` ? TNext extends "" ? string : TypeModifierValidation<TNext> : {
+  _: "If you see this message on type error, modifier format is wrong.";
+};
+declare const parseModifiedTypeName: <TName extends string, TModifier extends AnyTypeModifier>(nameAndModifier: ModifiedTypeName<string, TName, TModifier>) => {
+  name: TName;
+  modifier: TModifier;
+};
+//#endregion
+//#region packages/core/src/types/schema/type-specifier.d.ts
+type AnyDefaultValue = {
+  default: ConstValue;
+};
+type InputTypeKind = "scalar" | "enum" | "input";
+type OutputTypeKind = "scalar" | "enum" | "object" | "union" | "typename";
+type AnyTypeSpecifier = {
+  readonly kind: string;
+  readonly name: string;
+  readonly modifier: TypeModifier;
+  readonly directives: AnyConstDirectiveAttachments;
+  readonly defaultValue?: AnyDefaultValue | null;
+  readonly arguments?: InputTypeSpecifiers;
+};
+type AbstractInputTypeSpecifier<TKind extends InputTypeKind> = {
+  readonly kind: TKind;
+  readonly name: string;
+  readonly modifier: TypeModifier;
+  readonly directives: AnyConstDirectiveAttachments;
+  readonly defaultValue: AnyDefaultValue | null;
+};
+type InputTypeSpecifiers = {
+  [key: string]: InputTypeSpecifier;
+};
+type InputTypeSpecifier = InputScalarSpecifier | InputEnumSpecifier | InputInputObjectSpecifier;
+type InputInferrableTypeSpecifier = InputScalarSpecifier | InputEnumSpecifier;
+type InputScalarSpecifier = AbstractInputTypeSpecifier<"scalar">;
+type InputEnumSpecifier = AbstractInputTypeSpecifier<"enum">;
+type InputInputObjectSpecifier = AbstractInputTypeSpecifier<"input">;
+type AbstractOutputTypeSpecifier<TKind extends OutputTypeKind> = {
+  readonly kind: TKind;
+  readonly name: string;
+  readonly modifier: TypeModifier;
+  readonly directives: AnyConstDirectiveAttachments;
+  readonly arguments: InputTypeSpecifiers;
+};
+type OutputTypeSpecifiers = {
+  [key: string]: OutputTypeSpecifier;
+};
+type OutputTypeSpecifier = OutputScalarSpecifier | OutputEnumSpecifier | OutputObjectSpecifier | OutputUnionSpecifier | OutputTypenameSpecifier;
+type OutputInferrableTypeSpecifier = OutputScalarSpecifier | OutputEnumSpecifier | OutputTypenameSpecifier;
+type OutputScalarSpecifier = AbstractOutputTypeSpecifier<"scalar">;
+type OutputEnumSpecifier = AbstractOutputTypeSpecifier<"enum">;
+type OutputObjectSpecifier = AbstractOutputTypeSpecifier<"object">;
+type OutputUnionSpecifier = AbstractOutputTypeSpecifier<"union">;
+type OutputTypenameSpecifier = AbstractOutputTypeSpecifier<"typename">;
+type StripTailingListFromTypeSpecifier<TTypeSpecifier extends AnyTypeSpecifier> = TTypeSpecifier extends {
+  defaultValue: AnyDefaultValue | null;
+} ? {
+  readonly kind: TTypeSpecifier["kind"];
+  readonly name: TTypeSpecifier["name"];
+  readonly modifier: StripTailingListFromTypeModifier<TTypeSpecifier["modifier"]>;
+  readonly directives: TTypeSpecifier["directives"];
+  readonly defaultValue: TTypeSpecifier["modifier"] extends `${string}${ListTypeModifierSuffix}` ? null : TTypeSpecifier["defaultValue"];
+} : TTypeSpecifier extends {
+  arguments: InputTypeSpecifiers;
+} ? {
+  readonly kind: TTypeSpecifier["kind"];
+  readonly name: TTypeSpecifier["name"];
+  readonly modifier: StripTailingListFromTypeModifier<TTypeSpecifier["modifier"]>;
+  readonly directives: TTypeSpecifier["directives"];
+  readonly arguments: TTypeSpecifier["arguments"];
+} : never;
+//#endregion
+//#region packages/core/src/types/schema/const-assignable-input.d.ts
+type AnyConstAssignableInputValue = ConstValue;
+type AnyConstAssignableInput = {
+  readonly [key: string]: AnyConstAssignableInputValue;
+};
+type ConstAssignableInput<TSchema extends AnyGraphqlSchema, TRefs extends InputTypeSpecifiers> = { readonly [K in keyof ApplyTypeModifierToKeys<TRefs>]: ConstAssignableInputValue<TSchema, TRefs[K]> };
+type ConstAssignableInputValue<TSchema extends AnyGraphqlSchema, TRef extends InputTypeSpecifier> = TRef["modifier"] extends `${string}${ListTypeModifierSuffix}` ? ConstAssignableInputValue<TSchema, StripTailingListFromTypeSpecifier<TRef>>[] : (TRef extends InputInputObjectSpecifier ? ConstAssignableInput<TSchema, InputFieldRecord<TSchema, TRef>> : never) | (TRef extends InputInferrableTypeSpecifier ? InferInputTypeRef<TSchema, TRef> : never);
+//#endregion
+//#region packages/core/src/types/schema/const-directives.d.ts
+type AnyConstDirectiveAttachments = {
+  readonly [key: string]: AnyConstAssignableInputValue;
+};
+//#endregion
+//#region packages/core/src/types/schema/schema.d.ts
+type OperationType = keyof OperationRoots;
+type AnyTypeName = string;
+type AnyFieldName = string;
+type AnyGraphqlSchema = {
+  readonly operations: OperationRoots;
+  readonly scalar: {
+    readonly [name: string]: ScalarDefinition<any>;
+  };
+  readonly enum: {
+    readonly [name: string]: EnumDefinition<any>;
+  };
+  readonly input: {
+    readonly [name: string]: InputDefinition;
+  };
+  readonly object: {
+    readonly [name: string]: ObjectDefinition;
+  };
+  readonly union: {
+    readonly [name: string]: UnionDefinition;
+  };
+};
+type OperationRoots = {
+  readonly query: string | null;
+  readonly mutation: string | null;
+  readonly subscription: string | null;
+};
+type ScalarDefinition<T extends {
+  input: unknown;
+  output: unknown;
+}> = {
+  readonly _type: Hidden<{
+    input: T["input"];
+    output: T["output"];
+  }>;
+  readonly name: string;
+  readonly directives: AnyConstDirectiveAttachments;
+};
+type EnumDefinition<T extends string> = {
+  readonly _type: Hidden<T>;
+  readonly name: string;
+  readonly values: { readonly [_ in T]: true };
+  readonly directives: AnyConstDirectiveAttachments;
+};
+type InputDefinition = {
+  readonly name: string;
+  readonly fields: InputTypeSpecifiers;
+  readonly directives: AnyConstDirectiveAttachments;
+};
+type ObjectDefinition = {
+  readonly name: string;
+  readonly fields: OutputTypeSpecifiers;
+  readonly directives: AnyConstDirectiveAttachments;
+};
+type UnionDefinition = {
+  readonly name: string;
+  readonly types: {
+    [typename: string]: true;
+  };
+  readonly directives: AnyConstDirectiveAttachments;
+};
+type InferInputTypeRef<TSchema extends AnyGraphqlSchema, TSpecifier extends InputInferrableTypeSpecifier> = (TSpecifier extends {
+  defaultValue: null;
+} ? never : undefined) | (TSpecifier extends InputScalarSpecifier ? ApplyTypeModifier<TSpecifier["modifier"], ReturnType<TSchema["scalar"][TSpecifier["name"]]["_type"]>["input"]> : TSpecifier extends InputEnumSpecifier ? ApplyTypeModifier<TSpecifier["modifier"], ReturnType<TSchema["enum"][TSpecifier["name"]]["_type"]>> : never);
+type InferOutputTypeRef<TSchema extends AnyGraphqlSchema, TSpecifier extends OutputInferrableTypeSpecifier> = TSpecifier extends OutputScalarSpecifier ? ApplyTypeModifier<TSpecifier["modifier"], ReturnType<TSchema["scalar"][TSpecifier["name"]]["_type"]>["output"]> : TSpecifier extends OutputEnumSpecifier ? ApplyTypeModifier<TSpecifier["modifier"], ReturnType<TSchema["enum"][TSpecifier["name"]]["_type"]>> : TSpecifier extends OutputTypenameSpecifier ? ApplyTypeModifier<TSpecifier["modifier"], TSpecifier["name"]> : never;
+type PickTypeSpecifierByFieldName<TSchema extends AnyGraphqlSchema, TTypeName extends keyof TSchema["object"], TFieldName extends keyof TSchema["object"][TTypeName]["fields"]> = TSchema["object"][TTypeName]["fields"][TFieldName];
+type InputFieldRecord<TSchema extends AnyGraphqlSchema, TSpecifier extends InputTypeSpecifier> = TSchema["input"][TSpecifier["name"]]["fields"];
+type ObjectFieldRecord<TSchema extends AnyGraphqlSchema, TTypeName extends keyof TSchema["object"]> = { readonly [TFieldName in keyof TSchema["object"][TTypeName]["fields"]]: TSchema["object"][TTypeName]["fields"][TFieldName] };
+type UnionTypeRecord<TSchema extends AnyGraphqlSchema, TSpecifier extends OutputUnionSpecifier> = { readonly [TTypeName in UnionMemberName<TSchema, TSpecifier>]: TSchema["object"][TTypeName] };
+type UnionMemberName<TSchema extends AnyGraphqlSchema, TSpecifier extends OutputUnionSpecifier> = Extract<keyof TSchema["object"], keyof TSchema["union"][TSpecifier["name"]]["types"]> & string;
+//#endregion
+//#region packages/core/src/utils/prettify.d.ts
+type Prettify<T> = { [K in keyof T]: T[K] } & {};
+declare const prettify: <T extends object>(obj: T) => Prettify<T>;
+//#endregion
+//#region packages/core/src/types/fragment/var-ref.d.ts
+/** Nominal reference placeholder used inside `AnyVariableAssignments`. */
+type AnyVarRef = VarRef<any>;
+type AnyVarRefMeta = {
+  readonly kind: string;
+  readonly name: string;
+  readonly modifier: unknown;
+};
+type VarRefBy<TRef extends InputTypeSpecifier> = VarRef<VarRefMetaBy<TRef>>;
+type VarRefMetaBy<TRef extends InputTypeSpecifier> = Prettify<{
+  readonly kind: TRef["kind"];
+  readonly name: TRef["name"];
+  readonly modifier: ApplyTypeModifier<TRef["modifier"], "_"> | (TRef["defaultValue"] extends AnyDefaultValue ? null | undefined : never);
+}>;
+declare const __VAR_REF_BRAND__: unique symbol;
+/** Nominal reference used to defer variable binding while carrying type info. */
+declare class VarRef<TMeta extends AnyVarRefMeta> {
+  readonly name: string;
+  readonly [__VAR_REF_BRAND__]: Hidden<TMeta>;
+  private constructor();
+  static create<TRef extends InputTypeSpecifier>(name: string): VarRefBy<TRef>;
+}
+//#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 AssignableInput<TSchema extends AnyGraphqlSchema, TRefs extends InputTypeSpecifiers> = { readonly [K in keyof ApplyTypeModifierToKeys<TRefs>]: AssignableInputValue<TSchema, TRefs[K]> };
+type AssignableInputValue<TSchema extends AnyGraphqlSchema, TRef extends InputTypeSpecifier> = VarRefBy<TRef> | (TRef["modifier"] extends `${string}${ListTypeModifierSuffix}` ? AssignableInputValue<TSchema, StripTailingListFromTypeSpecifier<TRef>>[] : (TRef extends InputInputObjectSpecifier ? AssignableInput<TSchema, InputFieldRecord<TSchema, TRef>> : never) | (TRef extends InputInferrableTypeSpecifier ? InferInputTypeRef<TSchema, TRef> : never));
+type AssignableInputByFieldName<TSchema extends AnyGraphqlSchema, TTypeName extends keyof TSchema["object"], TFieldName extends keyof TSchema["object"][TTypeName]["fields"]> = AssignableInput<TSchema, TSchema["object"][TTypeName]["fields"][TFieldName]["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 extends AnyTypeName, TFieldName extends AnyFieldName, TRef extends OutputTypeSpecifier, TArgs extends AnyAssignableInput, TDirectives extends AnyDirectiveAttachments, TExtras extends {
+  object: AnyNestedObject;
+} | {
+  union: AnyNestedUnion;
+} | {
+  _?: never;
+}> = {
+  readonly parent: TTypeName;
+  readonly field: TFieldName;
+  readonly type: TRef;
+  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 extends keyof TSchema["object"] & string, TFieldName extends keyof TSchema["object"][TTypeName]["fields"] & string> = PickTypeSpecifierByFieldName<TSchema, TTypeName, TFieldName> extends infer TRef extends OutputTypeSpecifier ? AbstractFieldSelection<TTypeName, TFieldName, TRef, AssignableInputByFieldName<TSchema, TTypeName, TFieldName>, 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> = Prettify<{ readonly [TAliasName in keyof TFields]: InferField<TSchema, TFields[TAliasName]> }>;
+/** 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 TRef extends OutputObjectSpecifier;
+  object: infer TNested extends AnyNestedObject;
+} ? ApplyTypeModifier<TRef["modifier"], InferFields<TSchema, TNested>> : never) | (TSelection extends {
+  type: infer TRef extends OutputUnionSpecifier;
+  union: infer TNested extends AnyNestedUnion;
+} ? ApplyTypeModifier<TRef["modifier"], { [TTypename in keyof TNested]: undefined extends TNested[TTypename] ? never : InferFields<TSchema, NonNullable<TNested[TTypename]>> }[keyof TNested]> : never) | (TSelection extends {
+  type: infer TRef extends OutputInferrableTypeSpecifier;
+} ? InferOutputTypeRef<TSchema, TRef> : never);
+//#endregion
+//#region packages/core/src/types/fragment/field-path.d.ts
+type AnyFieldPath = string;
+/**
+ * Computes strongly typed "$.foo.bar" style selectors for a set of fields so
+ * slice result transforms can reference response paths safely.
+ */
+type AvailableFieldPathOf<TSchema extends AnyGraphqlSchema, TFields extends AnyFields> = AvailableFieldPathsInner<TSchema, TFields, "$">;
+/** Recursive helper used to build path strings for nested selections. */
+type AvailableFieldPathsInner<TSchema extends AnyGraphqlSchema, TFields extends AnyFields, TCurr extends AnyFieldPath> = { readonly [TAliasName in keyof TFields & string]: `${TCurr}.${TAliasName}` | (TFields[TAliasName] extends {
+  object: infer TNested extends AnyNestedObject;
+} ? AvailableFieldPathsInner<TSchema, TNested, `${TCurr}.${TAliasName}`> : never) }[keyof TFields & string];
+/** Resolve the TypeScript type located at a given field path. */
+type InferByFieldPath<TSchema extends AnyGraphqlSchema, TFields extends AnyFields, TPath extends AnyFieldPath> = string extends keyof TFields ? any : TPath extends "$" ? never : InferByFieldPathInner<TSchema, TFields, TPath, "$">;
+/** Internal helper that walks a field tree while matching a path literal. */
+type InferByFieldPathInner<TSchema extends AnyGraphqlSchema, TFields extends AnyFields, TPathTarget extends AnyFieldPath, TPathCurrent extends AnyFieldPath> = { readonly [TAliasName in keyof TFields]: TAliasName extends string ? `${TPathCurrent}.${TAliasName}` extends TPathTarget ? InferField<TSchema, TFields[TAliasName]> : TFields[TAliasName] extends {
+  object: infer TNested extends AnyNestedObject;
+} ? InferByFieldPathInner<TSchema, TNested, TPathTarget, `${TPathCurrent}.${TAliasName}`> : never : never }[keyof TFields];
+//#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;
+}) => TypedQueryDocumentNode<InferFields<TSchema, TFields>, ConstAssignableInput<TSchema, TVarDefinitions>>;
+//#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 = {
+  canonicalId: string;
+};
+type GqlElementDefinitionFactory<T> = (context: GqlElementContext | null) => T;
+declare abstract class GqlElement<TDefinition> {
+  private [GQL_ELEMENT_FACTORY];
+  private [GQL_ELEMENT_CONTEXT];
+  protected constructor(define: GqlElementDefinitionFactory<TDefinition>);
+  static setContext<TElement extends GqlElement<any>>(element: TElement, context: GqlElementContext): void;
+  static evaluate(element: GqlElement<any>): void;
+  static get<TValue>(element: GqlElement<TValue>): TValue;
+}
+//#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 T[K] extends ((...args: any[]) => any) ? never : K]: T[K] };
+type StripSymbols<T extends object> = { [K in keyof T as K extends symbol ? never : K]: T[K] };
+//#endregion
+//#region packages/core/src/types/runtime/runtime-adapter.d.ts
+/**
+ * Defines the runtime surface that the typed layer depends on. Implementations
+ * adapt framework-specific error payloads without leaking those types into the
+ * generated code.
+ */
+type AnyGraphqlRuntimeAdapter = {
+  nonGraphqlErrorType: Hidden<any>;
+};
+//#endregion
+//#region packages/core/src/types/runtime/execution-result.d.ts
+type NormalizedExecutionResult<TRuntimeAdapter extends AnyGraphqlRuntimeAdapter, TData, TExtensions> = EmptyResult | GraphqlExecutionResult<TData, TExtensions> | NonGraphqlErrorResult<TRuntimeAdapter>;
+type EmptyResult = {
+  type: "empty";
+};
+type GraphqlExecutionResult<TData, TExtensions> = {
+  type: "graphql";
+  body: FormattedExecutionResult<TData, TExtensions>;
+};
+type NonGraphqlErrorResult<TRuntimeAdapter extends AnyGraphqlRuntimeAdapter> = {
+  type: "non-graphql-error";
+  error: ReturnType<TRuntimeAdapter["nonGraphqlErrorType"]>;
+};
+type NormalizedError<TRuntimeAdapter extends AnyGraphqlRuntimeAdapter> = {
+  type: "graphql-error";
+  errors: GraphQLFormattedError[];
+} | {
+  type: "non-graphql-error";
+  error: ReturnType<TRuntimeAdapter["nonGraphqlErrorType"]>;
+} | {
+  type: "parse-error";
+  errors: Error[];
+};
+//#endregion
+//#region packages/core/src/types/runtime/sliced-execution-result.d.ts
+type AnySlicedExecutionResult = SlicedExecutionResult<any, AnyGraphqlRuntimeAdapter>;
+/**
+ * Internal discriminated union describing the Result-like wrapper exposed to
+ * slice selection callbacks. The adapter decides how raw errors are
+ * materialized.
+ */
+type AnySlicedExecutionResultRecord = {
+  [path: string]: AnySlicedExecutionResult;
+};
+type SafeUnwrapResult<TTransformed, TError> = {
+  data?: never;
+  error?: never;
+} | {
+  data: TTransformed;
+  error?: never;
+} | {
+  data?: never;
+  error: TError;
+};
+/** Utility signature returned by the safe unwrap helper. */
+type SlicedExecutionResultCommon<TData, TError> = {
+  safeUnwrap<TTransformed>(transform: (data: TData) => TTransformed): SafeUnwrapResult<TTransformed, TError>;
+};
+/** Public union used by selection callbacks to inspect data, empty, or error states. */
+type SlicedExecutionResult<TData, TRuntimeAdapter extends AnyGraphqlRuntimeAdapter> = SlicedExecutionResultEmpty<TData, TRuntimeAdapter> | SlicedExecutionResultSuccess<TData, TRuntimeAdapter> | SlicedExecutionResultError<TData, TRuntimeAdapter>;
+/** Runtime guard interface shared by all slice result variants. */
+declare class SlicedExecutionResultGuards<TData, TRuntimeAdapter extends AnyGraphqlRuntimeAdapter> {
+  private readonly type;
+  isSuccess(): this is SlicedExecutionResultSuccess<TData, TRuntimeAdapter>;
+  isError(): this is SlicedExecutionResultError<TData, TRuntimeAdapter>;
+  isEmpty(): this is SlicedExecutionResultEmpty<TData, TRuntimeAdapter>;
+  constructor(type: "success" | "error" | "empty");
+}
+/** Variant representing an empty payload (no data, no error). */
+declare class SlicedExecutionResultEmpty<TData, TRuntimeAdapter extends AnyGraphqlRuntimeAdapter> extends SlicedExecutionResultGuards<TData, TRuntimeAdapter> implements SlicedExecutionResultCommon<TData, NormalizedError<TRuntimeAdapter>> {
+  constructor();
+  unwrap(): null;
+  safeUnwrap(): {
+    data: undefined;
+    error: undefined;
+  };
+}
+/** Variant representing a successful payload. */
+declare class SlicedExecutionResultSuccess<TData, TRuntimeAdapter extends AnyGraphqlRuntimeAdapter> extends SlicedExecutionResultGuards<TData, TRuntimeAdapter> implements SlicedExecutionResultCommon<TData, NormalizedError<TRuntimeAdapter>> {
+  readonly data: TData;
+  readonly extensions?: unknown | undefined;
+  constructor(data: TData, extensions?: unknown | undefined);
+  unwrap(): TData;
+  safeUnwrap<TTransformed>(transform: (data: TData) => TTransformed): {
+    data: TTransformed;
+    error: undefined;
+  };
+}
+/** Variant representing an error payload created by the adapter. */
+declare class SlicedExecutionResultError<TData, TRuntimeAdapter extends AnyGraphqlRuntimeAdapter> extends SlicedExecutionResultGuards<TData, TRuntimeAdapter> implements SlicedExecutionResultCommon<TData, NormalizedError<TRuntimeAdapter>> {
+  readonly error: NormalizedError<TRuntimeAdapter>;
+  readonly extensions?: unknown | undefined;
+  constructor(error: NormalizedError<TRuntimeAdapter>, extensions?: unknown | undefined);
+  unwrap(): never;
+  safeUnwrap(): {
+    data: undefined;
+    error: NormalizedError<TRuntimeAdapter>;
+  };
+}
+//#endregion
+//#region packages/core/src/types/runtime/projection.d.ts
+/** Shape of a single selection slice projection. */
+type AnyProjection = Projection<any>;
+declare const __PROJECTION_BRAND__: unique symbol;
+/**
+ * Nominal type representing any slice selection regardless of schema specifics.
+ * Encodes how individual slices map a concrete field path to a projection
+ * function. Multiple selections allow slices to expose several derived values.
+ */
+declare class Projection<TProjected> {
+  readonly projector: (result: AnySlicedExecutionResult) => TProjected;
+  readonly [__PROJECTION_BRAND__]: Hidden<never>;
+  constructor(paths: Tuple<string>, projector: (result: AnySlicedExecutionResult) => TProjected);
+  readonly paths: ProjectionPath[];
+}
+type ProjectionPath = {
+  full: string;
+  segments: Tuple<string>;
+};
+type InferExecutionResultProjection<TProjection extends AnyProjection> = ReturnType<TProjection["projector"]>;
+//#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/slice.d.ts
+type AnySlice = AnySliceOf<"query"> | AnySliceOf<"mutation"> | AnySliceOf<"subscription">;
+type AnySliceOf<TOperationType extends OperationType> = Slice<TOperationType, any, AnyFields, AnyProjection>;
+type SliceDefinition<TOperationType extends OperationType, TVariables extends Partial<AnyAssignableInput> | void, TFields extends Partial<AnyFields>, TProjection extends AnyProjection> = {
+  readonly operationType: TOperationType;
+  readonly embed: (variables: TVariables) => SlicePayload<TVariables, TFields, TProjection>;
+};
+declare const __OPERATION_SLICE_BRAND__: unique symbol;
+declare class Slice<TOperationType extends OperationType, TVariables extends Partial<AnyAssignableInput> | void, TFields extends Partial<AnyFields>, TProjection extends AnyProjection> extends GqlElement<SliceDefinition<TOperationType, TVariables, TFields, TProjection>> implements SliceDefinition<TOperationType, TVariables, TFields, TProjection> {
+  readonly [__OPERATION_SLICE_BRAND__]: Hidden<{
+    operationType: TOperationType;
+    output: InferExecutionResultProjection<TProjection>;
+  }>;
+  private constructor();
+  get operationType(): TOperationType;
+  get embed(): (variables: TVariables) => SlicePayload<TVariables, TFields, TProjection>;
+  static create<TSchema extends AnyGraphqlSchema, TOperationType extends OperationType, TVariableDefinitions extends InputTypeSpecifiers, TFields extends AnyFields, TProjection extends AnyProjection>(define: () => {
+    operationType: TOperationType;
+    embed: (variables: SwitchIfEmpty<TVariableDefinitions, void, AssignableInput<TSchema, TVariableDefinitions>>) => SlicePayload<SwitchIfEmpty<TVariableDefinitions, void, AssignableInput<TSchema, TVariableDefinitions>>, TFields, TProjection>;
+  }): Slice<TOperationType, SwitchIfEmpty<TVariableDefinitions, void, AssignableInput<TSchema, TVariableDefinitions>>, TFields & {
+    [key: symbol]: never;
+  }, TProjection>;
+}
+type AnySlicePayloads = {
+  [key: string]: AnySlicePayload;
+};
+type AnySlicePayload = SlicePayload<AnyAssignableInput | void, AnyFields, AnyProjection>;
+type SlicePayload<TVariables extends Partial<AnyAssignableInput> | void, TFields extends Partial<AnyFields>, TProjection extends AnyProjection> = {
+  variables: TVariables;
+  getFields: () => TFields;
+  projection: TProjection;
+};
+type InferOutputOfSlice<TSlice extends AnySliceOf<any>> = ReturnType<TSlice[typeof __OPERATION_SLICE_BRAND__]>["output"];
+//#endregion
+//#region packages/core/src/types/element/composed-operation.d.ts
+type AnyComposedOperation = AnyComposedOperationOf<"query"> | AnyComposedOperationOf<"mutation"> | AnyComposedOperationOf<"subscription">;
+type AnyComposedOperationOf<TOperationType extends OperationType> = ComposedOperation<AnyGraphqlRuntimeAdapter, TOperationType, string, string[], any, any, any>;
+declare const __COMPOSED_OPERATION_BRAND__: unique symbol;
+type ComposedOperationDefinition<TRuntimeAdapter extends AnyGraphqlRuntimeAdapter, TOperationType extends OperationType, TOperationName extends string, TVariableNames extends string[], TVariables extends AnyConstAssignableInput, TRawData extends object, TProjectedData extends object> = {
+  readonly operationType: TOperationType;
+  readonly operationName: TOperationName;
+  readonly variableNames: TVariableNames;
+  readonly projectionPathGraph: ProjectionPathGraphNode;
+  readonly document: TypedQueryDocumentNode<TRawData, TVariables>;
+  readonly parse: (result: NormalizedExecutionResult<TRuntimeAdapter, TRawData, any>) => TProjectedData;
+};
+declare class ComposedOperation<TRuntimeAdapter extends AnyGraphqlRuntimeAdapter, TOperationType extends OperationType, TOperationName extends string, TVariableNames extends string[], TVariables extends AnyConstAssignableInput, TRawData extends object, TProjectedData extends object> extends GqlElement<ComposedOperationDefinition<TRuntimeAdapter, TOperationType, TOperationName, TVariableNames, TVariables, TRawData, TProjectedData>> implements ComposedOperationDefinition<TRuntimeAdapter, TOperationType, TOperationName, TVariableNames, TVariables, TRawData, TProjectedData> {
+  readonly [__COMPOSED_OPERATION_BRAND__]: Hidden<{
+    operationType: TOperationType;
+  }>;
+  private constructor();
+  get operationType(): TOperationType;
+  get operationName(): TOperationName;
+  get variableNames(): TVariableNames;
+  get projectionPathGraph(): ProjectionPathGraphNode;
+  get document(): TypedQueryDocumentNode<TRawData, TVariables>;
+  get parse(): (result: NormalizedExecutionResult<TRuntimeAdapter, TRawData, any>) => TProjectedData;
+  static create<TSchema extends AnyGraphqlSchema, TRuntimeAdapter extends AnyGraphqlRuntimeAdapter, TOperationType extends OperationType, TOperationName extends string, TVariableDefinitions extends InputTypeSpecifiers, TSliceFragments extends AnySlicePayloads>(define: (context: GqlElementContext | null) => {
+    operationType: TOperationType;
+    operationName: TOperationName;
+    variableNames: (keyof TVariableDefinitions & string)[];
+    projectionPathGraph: ProjectionPathGraphNode;
+    document: TypedQueryDocumentNode<InferComposedOperationRawData<TSchema, TSliceFragments>, ConstAssignableInput<TSchema, TVariableDefinitions>>;
+    parse: (result: NormalizedExecutionResult<TRuntimeAdapter, InferComposedOperationRawData<TSchema, TSliceFragments>, any>) => { [K in keyof TSliceFragments]: InferExecutionResultProjection<TSliceFragments[K]["projection"]> };
+  }): ComposedOperation<TRuntimeAdapter, TOperationType, TOperationName, (keyof TVariableDefinitions & string)[], ConstAssignableInput<TSchema, TVariableDefinitions>, ((ConcatSlicePayloads<TSliceFragments> extends infer T_2 extends AnyFields ? { readonly [TAliasName in keyof T_2]: InferField<TSchema_1, T_2[TAliasName]> } : never) extends infer T_1 ? { [K_1 in keyof T_1]: T_1[K_1] } : never) extends infer T ? { [K in keyof T]: T[K] } : never, { [K_2 in keyof TSliceFragments]: InferExecutionResultProjection<TSliceFragments[K_2]["projection"]> }>;
+}
+type ProjectionPathGraphNode = {
+  readonly matches: {
+    label: string;
+    path: string;
+    exact: boolean;
+  }[];
+  readonly children: {
+    readonly [segment: string]: ProjectionPathGraphNode;
+  };
+};
+type ConcatSlicePayloads<TSlicePayloads extends AnySlicePayloads> = Prettify<UnionToIntersection<{ [TLabel in keyof TSlicePayloads & string]: TSlicePayloads[TLabel] extends {
+  getFields: () => infer TFields;
+} ? { [K in keyof TFields & string as `${TLabel}_${K}`]: TFields[K] } : {} }[keyof TSlicePayloads & string]>> & AnyFields;
+type InferComposedOperationRawData<TSchema extends AnyGraphqlSchema, TSlicePayloads extends AnySlicePayloads> = Prettify<InferFields<TSchema, ConcatSlicePayloads<TSlicePayloads>>>;
+type ComposedOperationDefinitionBuilder<TSchema extends AnyGraphqlSchema, TVarDefinitions extends InputTypeSpecifiers, TSliceContents extends AnySlicePayloads> = (tools: {
+  $: NoInfer<AssignableInput<TSchema, TVarDefinitions>>;
+}) => TSliceContents;
+//#endregion
+//#region packages/core/src/types/element/execution-result-projection-builder.d.ts
+type AnyExecutionResultProjectionsBuilder = ExecutionResultProjectionsBuilder<AnyGraphqlSchema, AnyGraphqlRuntimeAdapter, any, any>;
+type ExecutionResultProjectionsBuilder<TSchema extends AnyGraphqlSchema, TRuntimeAdapter extends AnyGraphqlRuntimeAdapter, TFields extends AnyFields, TProjection extends AnyProjection> = (tools: {
+  select: ResultSelector<TSchema, TRuntimeAdapter, TFields>;
+}) => TProjection;
+type ResultSelector<TSchema extends AnyGraphqlSchema, TRuntimeAdapter extends AnyGraphqlRuntimeAdapter, TFields extends AnyFields> = <TPaths extends Tuple<AvailableFieldPathOf<TSchema, TFields>>, TProjected>(paths: TPaths, projector: (result: NoInfer<SlicedExecutionResult<InferByResultSelectorPaths<TSchema, TFields, TPaths>, TRuntimeAdapter>>) => TProjected) => NoInfer<Projection<TProjected>>;
+type InferByResultSelectorPaths<TSchema extends AnyGraphqlSchema, TFields extends AnyFields, TPaths extends Tuple<AvailableFieldPathOf<TSchema, TFields>>> = TPaths extends string[] ? { [K in keyof TPaths]: TPaths[K] extends string ? InferByFieldPath<TSchema, TFields, TPaths[K]> : never } : never;
+//#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 extends keyof TSchema["object"] & string, TVariableDefinitions extends InputTypeSpecifiers, TFields extends AnyFields[]> = (tools: NoInfer<FieldsBuilderTools<TSchema, TTypeName, TVariableDefinitions>>) => TFields;
+type FieldsBuilderTools<TSchema extends AnyGraphqlSchema, TTypeName extends keyof TSchema["object"] & string, TVariableDefinitions extends InputTypeSpecifiers> = {
+  f: FieldSelectionFactories<TSchema, TTypeName>;
+  $: AssignableInput<TSchema, TVariableDefinitions>;
+};
+/** Narrow builder used when a field resolves to an object and we need nested selections. */
+type NestedObjectFieldsBuilder<TSchema extends AnyGraphqlSchema, TTypeName extends keyof TSchema["object"] & string, TFields extends AnyNestedObject[]> = (tools: NoInfer<NestedObjectFieldsBuilderTools<TSchema, TTypeName>>) => TFields;
+type NestedObjectFieldsBuilderTools<TSchema extends AnyGraphqlSchema, TTypeName extends keyof TSchema["object"] & string> = {
+  f: FieldSelectionFactories<TSchema, TTypeName>;
+};
+type NestedUnionFieldsBuilder<TSchema extends AnyGraphqlSchema, TMemberName extends string, TUnionFields extends AnyNestedUnion> = { [TTypename in keyof TUnionFields & TMemberName]?: NestedObjectFieldsBuilder<TSchema, TTypename, NonNullable<TUnionFields[TTypename]>[]> };
+/** Map each field to a factory capable of emitting fully-typed references. */
+type FieldSelectionFactories<TSchema extends AnyGraphqlSchema, TTypeName extends keyof TSchema["object"] & string> = { [TFieldName in keyof ObjectFieldRecord<TSchema, TTypeName>]: TFieldName extends string ? FieldSelectionFactory<TSchema, FieldSelectionTemplateOf<TSchema, TTypeName, 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 extends AnyNestedObject[]>(nest: NestedObjectFieldsBuilder<TSchema, TSelection["type"]["name"], TNested>) => { [_ in TAlias extends null ? TSelection["field"] : TAlias]: AbstractFieldSelection<TSelection["parent"], TSelection["field"], TSelection["type"], TSelection["args"], TSelection["directives"], {
+  object: MergeFields<TNested>;
+}> };
+type FieldSelectionFactoryUnionReturn<TSchema extends AnyGraphqlSchema, TSelection extends AnyFieldSelection & {
+  type: OutputUnionSpecifier;
+}, TAlias extends string | null> = <TNested extends AnyNestedUnion>(nest: NestedUnionFieldsBuilder<TSchema, UnionMemberName<TSchema, TSelection["type"]>, TNested>) => { [_ in TAlias extends null ? TSelection["field"] : TAlias]: AbstractFieldSelection<TSelection["parent"], TSelection["field"], TSelection["type"], TSelection["args"], TSelection["directives"], {
+  union: TNested;
+}> };
+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/inline-operation.d.ts
+type AnyInlineOperation = AnyInlineOperationOf<"query"> | AnyInlineOperationOf<"mutation"> | AnyInlineOperationOf<"subscription">;
+type AnyInlineOperationOf<TOperationType extends OperationType> = InlineOperation<TOperationType, string, string[], any, AnyFields, any>;
+declare const __INLINE_OPERATION_BRAND__: unique symbol;
+type InlineOperationArtifact<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: TypedQueryDocumentNode<TData, TVariables>;
+};
+declare class InlineOperation<TOperationType extends OperationType, TOperationName extends string, TVariableNames extends string[], TVariables extends AnyConstAssignableInput, TFields extends Partial<AnyFields>, TData extends object> extends GqlElement<InlineOperationArtifact<TOperationType, TOperationName, TVariableNames, TVariables, TFields, TData>> implements InlineOperationArtifact<TOperationType, TOperationName, TVariableNames, TVariables, TFields, TData> {
+  readonly [__INLINE_OPERATION_BRAND__]: Hidden<{
+    operationType: TOperationType;
+  }>;
+  private constructor();
+  get operationType(): TOperationType;
+  get operationName(): TOperationName;
+  get variableNames(): TVariableNames;
+  get documentSource(): () => TFields;
+  get document(): TypedQueryDocumentNode<TData, TVariables>;
+  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: TypedQueryDocumentNode<InferFields<TSchema, TFields>, ConstAssignableInput<TSchema, TVariableDefinitions>>;
+  }): InlineOperation<TOperationType, TOperationName, (keyof TVariableDefinitions & string)[], ConstAssignableInput<TSchema, TVariableDefinitions>, TFields, { [K in keyof { readonly [TAliasName in keyof TFields]: InferField<TSchema, TFields[TAliasName]> }]: { readonly [TAliasName in keyof TFields]: InferField<TSchema, TFields[TAliasName]> }[K] }>;
+}
+//#endregion
+//#region packages/core/src/types/element/model.d.ts
+type AnyModel = Model<string, any, AnyFields, any, any>;
+type ModelArtifact<TTypeName extends string, TVariables extends Partial<AnyAssignableInput> | void, TFields extends Partial<AnyFields>, TRaw extends object, TNormalized extends object> = {
+  readonly typename: TTypeName;
+  readonly fragment: (variables: TVariables) => TFields;
+  readonly normalize: (raw: TRaw) => TNormalized;
+};
+declare const __MODEL_BRAND__: unique symbol;
+declare class Model<TTypeName extends string, TVariables extends Partial<AnyAssignableInput> | void, TFields extends Partial<AnyFields>, TRaw extends object, TNormalized extends object> extends GqlElement<ModelArtifact<TTypeName, TVariables, TFields, TRaw, TNormalized>> implements ModelArtifact<TTypeName, TVariables, TFields, TRaw, TNormalized> {
+  readonly [__MODEL_BRAND__]: Hidden<{
+    input: TVariables;
+    output: TNormalized;
+  }>;
+  private constructor();
+  get typename(): TTypeName;
+  get fragment(): (variables: TVariables) => TFields;
+  get normalize(): (raw: TRaw) => TNormalized;
+  static create<TSchema extends AnyGraphqlSchema, TTypeName extends keyof TSchema["object"] & string, TVariableDefinitions extends InputTypeSpecifiers, TFields extends AnyFields, TNormalized extends object>(define: () => {
+    typename: TTypeName;
+    fragment: (variables: SwitchIfEmpty<TVariableDefinitions, void, AssignableInput<TSchema, TVariableDefinitions>>) => TFields;
+    normalize: (raw: NoInfer<InferFields<TSchema, TFields>>) => TNormalized;
+  }): Model<TTypeName, SwitchIfEmpty<TVariableDefinitions, void, AssignableInput<TSchema, TVariableDefinitions>>, TFields & {
+    [key: symbol]: never;
+  }, { [K in keyof { readonly [TAliasName in keyof TFields]: InferField<TSchema, TFields[TAliasName]> }]: { readonly [TAliasName in keyof TFields]: InferField<TSchema, TFields[TAliasName]> }[K] } & {
+    [key: symbol]: never;
+  }, TNormalized>;
+}
+//#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, provided: AnyAssignableInput | void) => AssignableInput<TSchema, TVariableDefinitions>;
+declare const createVarRefs: <TSchema extends AnyGraphqlSchema, TVarDefinitions extends InputTypeSpecifiers>(definitions: TVarDefinitions) => AssignableInput<TSchema, TVarDefinitions>;
+//#endregion
+//#region packages/core/src/composer/composed-operation.d.ts
+declare const createComposedOperationComposerFactory: <TSchema extends AnyGraphqlSchema, TRuntimeAdapter extends AnyGraphqlRuntimeAdapter>() => <TOperationType extends OperationType>(operationType: TOperationType) => <TOperationName extends string, TSliceFragments extends AnySlicePayloads, TVarDefinitions extends InputTypeSpecifiers[] = [{}]>(options: {
+  operationName: TOperationName;
+  variables?: TVarDefinitions;
+}, builder: ComposedOperationDefinitionBuilder<TSchema, MergeVarDefinitions<TVarDefinitions>, TSliceFragments>) => ComposedOperation<TRuntimeAdapter, TOperationType, TOperationName, (keyof MergeVarDefinitions<TVarDefinitions> & string)[], ConstAssignableInput<TSchema, MergeVarDefinitions<TVarDefinitions>>, ((ConcatSlicePayloads<TSliceFragments> extends infer T_2 extends AnyFields ? { readonly [TAliasName in keyof T_2]: InferField<TSchema_1, T_2[TAliasName]> } : never) extends infer T_1 ? { [K_1 in keyof T_1]: T_1[K_1] } : never) extends infer T ? { [K in keyof T]: T[K] } : never, { [K_2 in keyof TSliceFragments]: ReturnType<TSliceFragments[K_2]["projection"]["projector"]> }>;
+//#endregion
+//#region packages/core/src/composer/fields-builder.d.ts
+declare const createFieldFactories: <TSchema extends AnyGraphqlSchema, TTypeName extends keyof TSchema["object"] & string>(schema: TSchema, typeName: TTypeName) => FieldSelectionFactories<TSchema, TTypeName>;
+//#endregion
+//#region packages/core/src/composer/gql-composer.d.ts
+type GqlElementComposer<TComposers, THelper> = <TResult extends AnyModel | AnySlice | AnyComposedOperation | AnyInlineOperation>(composeElement: (composers: TComposers, helper: THelper) => TResult) => TResult;
+declare const createGqlElementComposer: <TSchema extends AnyGraphqlSchema, TRuntimeAdapter extends AnyGraphqlRuntimeAdapter>(schema: NoInfer<TSchema>) => GqlElementComposer<{
+  model: Omit<{ readonly [TTypeName in keyof TSchema["object"]]: TTypeName extends string ? <TFieldEntries extends AnyFields[], TNormalized extends object, TVarDefinitions extends InputTypeSpecifiers[] = [{}]>(options: {
+    variables?: TVarDefinitions | undefined;
+  }, builder: FieldsBuilder<TSchema, TTypeName, MergeVarDefinitions<TVarDefinitions>, TFieldEntries>, normalize: (raw: NoInfer<(MergeFields<TFieldEntries> extends infer T_1 extends AnyFields ? { readonly [TAliasName in keyof T_1]: InferField<TSchema_1, T_1[TAliasName]> } : never) extends infer T ? { [K in keyof T]: T[K] } : never>) => TNormalized) => Model<TTypeName, SwitchIfEmpty<MergeVarDefinitions<TVarDefinitions>, void, AssignableInput<TSchema, MergeVarDefinitions<TVarDefinitions>>>, MergeFields<TFieldEntries> & {
+    [key: symbol]: never;
+  }, ((MergeFields<TFieldEntries> extends infer T_1 extends AnyFields ? { readonly [TAliasName in keyof T_1]: InferField<TSchema_1, T_1[TAliasName]> } : never) extends infer T ? { [K in keyof T]: T[K] } : never) & {
+    [key: symbol]: never;
+  }, TNormalized> : never }, TSchema["operations"][keyof OperationRoots] & keyof TSchema["object"]>;
+  query: {
+    slice: <TFieldEntries extends AnyFields[], TProjection extends AnyProjection, TVarDefinitions_1 extends InputTypeSpecifiers[] = [{}]>(options: {
+      variables?: TVarDefinitions_1 | undefined;
+    }, fieldBuilder: FieldsBuilder<TSchema, TSchema["operations"]["query"] & keyof TSchema["object"] & string, MergeVarDefinitions<TVarDefinitions_1>, TFieldEntries>, projectionBuilder: ExecutionResultProjectionsBuilder<TSchema, TRuntimeAdapter, MergeFields<TFieldEntries>, TProjection>) => Slice<"query", SwitchIfEmpty<MergeVarDefinitions<TVarDefinitions_1>, void, AssignableInput<TSchema, MergeVarDefinitions<TVarDefinitions_1>>>, MergeFields<TFieldEntries> & {
+      [key: symbol]: never;
+    }, TProjection>;
+    composed: <TOperationName extends string, TSliceFragments extends AnySlicePayloads, TVarDefinitions_2 extends InputTypeSpecifiers[] = [{}]>(options: {
+      operationName: TOperationName;
+      variables?: TVarDefinitions_2 | undefined;
+    }, builder: ComposedOperationDefinitionBuilder<TSchema, MergeVarDefinitions<TVarDefinitions_2>, TSliceFragments>) => ComposedOperation<TRuntimeAdapter, "query", TOperationName, (keyof MergeVarDefinitions<TVarDefinitions_2> & string)[], ConstAssignableInput<TSchema, MergeVarDefinitions<TVarDefinitions_2>>, ((ConcatSlicePayloads<TSliceFragments> extends infer T_2 extends AnyFields ? { readonly [TAliasName in keyof T_2]: InferField<TSchema_1, T_2[TAliasName]> } : never) extends infer T_1 ? { [K_1 in keyof T_1]: T_1[K_1] } : never) extends infer T ? { [K in keyof T]: T[K] } : never, { [K_2 in keyof TSliceFragments]: ReturnType<TSliceFragments[K_2]["projection"]["projector"]> }>;
+    inline: <TOperationName extends string, TFields extends AnyFields[], TVarDefinitions_3 extends InputTypeSpecifiers[] = [{}]>(options: {
+      operationName: TOperationName;
+      variables?: TVarDefinitions_3 | undefined;
+    }, fieldBuilder: FieldsBuilder<TSchema, TSchema["operations"]["query"] & keyof TSchema["object"] & string, MergeVarDefinitions<TVarDefinitions_3>, TFields>) => InlineOperation<"query", TOperationName, (keyof MergeVarDefinitions<TVarDefinitions_3> & string)[], ConstAssignableInput<TSchema, MergeVarDefinitions<TVarDefinitions_3>>, MergeFields<TFields>, (MergeFields<TFields> extends infer T_1 extends AnyFields ? { readonly [TAliasName in keyof T_1]: InferField<TSchema_1, T_1[TAliasName]> } : never) extends infer T ? { [K in keyof T]: T[K] } : never>;
+  };
+  mutation: {
+    slice: <TFieldEntries extends AnyFields[], TProjection extends AnyProjection, TVarDefinitions_1 extends InputTypeSpecifiers[] = [{}]>(options: {
+      variables?: TVarDefinitions_1 | undefined;
+    }, fieldBuilder: FieldsBuilder<TSchema, TSchema["operations"]["mutation"] & keyof TSchema["object"] & string, MergeVarDefinitions<TVarDefinitions_1>, TFieldEntries>, projectionBuilder: ExecutionResultProjectionsBuilder<TSchema, TRuntimeAdapter, MergeFields<TFieldEntries>, TProjection>) => Slice<"mutation", SwitchIfEmpty<MergeVarDefinitions<TVarDefinitions_1>, void, AssignableInput<TSchema, MergeVarDefinitions<TVarDefinitions_1>>>, MergeFields<TFieldEntries> & {
+      [key: symbol]: never;
+    }, TProjection>;
+    composed: <TOperationName extends string, TSliceFragments extends AnySlicePayloads, TVarDefinitions_2 extends InputTypeSpecifiers[] = [{}]>(options: {
+      operationName: TOperationName;
+      variables?: TVarDefinitions_2 | undefined;
+    }, builder: ComposedOperationDefinitionBuilder<TSchema, MergeVarDefinitions<TVarDefinitions_2>, TSliceFragments>) => ComposedOperation<TRuntimeAdapter, "mutation", TOperationName, (keyof MergeVarDefinitions<TVarDefinitions_2> & string)[], ConstAssignableInput<TSchema, MergeVarDefinitions<TVarDefinitions_2>>, ((ConcatSlicePayloads<TSliceFragments> extends infer T_2 extends AnyFields ? { readonly [TAliasName in keyof T_2]: InferField<TSchema_1, T_2[TAliasName]> } : never) extends infer T_1 ? { [K_1 in keyof T_1]: T_1[K_1] } : never) extends infer T ? { [K in keyof T]: T[K] } : never, { [K_2 in keyof TSliceFragments]: ReturnType<TSliceFragments[K_2]["projection"]["projector"]> }>;
+    inline: <TOperationName extends string, TFields extends AnyFields[], TVarDefinitions_3 extends InputTypeSpecifiers[] = [{}]>(options: {
+      operationName: TOperationName;
+      variables?: TVarDefinitions_3 | undefined;
+    }, fieldBuilder: FieldsBuilder<TSchema, TSchema["operations"]["mutation"] & keyof TSchema["object"] & string, MergeVarDefinitions<TVarDefinitions_3>, TFields>) => InlineOperation<"mutation", TOperationName, (keyof MergeVarDefinitions<TVarDefinitions_3> & string)[], ConstAssignableInput<TSchema, MergeVarDefinitions<TVarDefinitions_3>>, MergeFields<TFields>, (MergeFields<TFields> extends infer T_1 extends AnyFields ? { readonly [TAliasName in keyof T_1]: InferField<TSchema_1, T_1[TAliasName]> } : never) extends infer T ? { [K in keyof T]: T[K] } : never>;
+  };
+  subscription: {
+    slice: <TFieldEntries extends AnyFields[], TProjection extends AnyProjection, TVarDefinitions_1 extends InputTypeSpecifiers[] = [{}]>(options: {
+      variables?: TVarDefinitions_1 | undefined;
+    }, fieldBuilder: FieldsBuilder<TSchema, TSchema["operations"]["subscription"] & keyof TSchema["object"] & string, MergeVarDefinitions<TVarDefinitions_1>, TFieldEntries>, projectionBuilder: ExecutionResultProjectionsBuilder<TSchema, TRuntimeAdapter, MergeFields<TFieldEntries>, TProjection>) => Slice<"subscription", SwitchIfEmpty<MergeVarDefinitions<TVarDefinitions_1>, void, AssignableInput<TSchema, MergeVarDefinitions<TVarDefinitions_1>>>, MergeFields<TFieldEntries> & {
+      [key: symbol]: never;
+    }, TProjection>;
+    composed: <TOperationName extends string, TSliceFragments extends AnySlicePayloads, TVarDefinitions_2 extends InputTypeSpecifiers[] = [{}]>(options: {
+      operationName: TOperationName;
+      variables?: TVarDefinitions_2 | undefined;
+    }, builder: ComposedOperationDefinitionBuilder<TSchema, MergeVarDefinitions<TVarDefinitions_2>, TSliceFragments>) => ComposedOperation<TRuntimeAdapter, "subscription", TOperationName, (keyof MergeVarDefinitions<TVarDefinitions_2> & string)[], ConstAssignableInput<TSchema, MergeVarDefinitions<TVarDefinitions_2>>, ((ConcatSlicePayloads<TSliceFragments> extends infer T_2 extends AnyFields ? { readonly [TAliasName in keyof T_2]: InferField<TSchema_1, T_2[TAliasName]> } : never) extends infer T_1 ? { [K_1 in keyof T_1]: T_1[K_1] } : never) extends infer T ? { [K in keyof T]: T[K] } : never, { [K_2 in keyof TSliceFragments]: ReturnType<TSliceFragments[K_2]["projection"]["projector"]> }>;
+    inline: <TOperationName extends string, TFields extends AnyFields[], TVarDefinitions_3 extends InputTypeSpecifiers[] = [{}]>(options: {
+      operationName: TOperationName;
+      variables?: TVarDefinitions_3 | undefined;
+    }, fieldBuilder: FieldsBuilder<TSchema, TSchema["operations"]["subscription"] & keyof TSchema["object"] & string, MergeVarDefinitions<TVarDefinitions_3>, TFields>) => InlineOperation<"subscription", TOperationName, (keyof MergeVarDefinitions<TVarDefinitions_3> & string)[], ConstAssignableInput<TSchema, MergeVarDefinitions<TVarDefinitions_3>>, MergeFields<TFields>, (MergeFields<TFields> extends infer T_1 extends AnyFields ? { readonly [TAliasName in keyof T_1]: InferField<TSchema_1, T_1[TAliasName]> } : never) extends infer T ? { [K in keyof T]: T[K] } : never>;
+  };
+}, {
+  $: <TVarName extends string>(varName: TVarName) => {
+    scalar: <const TTypeName_1 extends keyof TSchema["scalar"] & string, const TModifier extends TypeModifier, const TDefaultFn extends (() => ConstAssignableInputValue<TSchema, {
+      kind: "scalar";
+      name: TTypeName_1;
+      modifier: TModifier;
+      directives: {};
+      defaultValue: null;
+    }>) | null = null, const TDirectives extends AnyConstDirectiveAttachments = {}>(type: ModifiedTypeName<string, TTypeName_1, TModifier>, extras?: {
+      default?: (TDefaultFn & (() => ConstAssignableInputValue<TSchema, {
+        kind: "scalar";
+        name: TTypeName_1;
+        modifier: TModifier;
+        directives: {};
+        defaultValue: null;
+      }>)) | (NoInfer<TDefaultFn> extends null ? () => ConstAssignableInputValue<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 (() => ConstAssignableInputValue<TSchema, {
+      kind: "enum";
+      name: TTypeName_1;
+      modifier: TModifier;
+      directives: {};
+      defaultValue: null;
+    }>) | null = null, const TDirectives extends AnyConstDirectiveAttachments = {}>(type: ModifiedTypeName<string, TTypeName_1, TModifier>, extras?: {
+      default?: (TDefaultFn & (() => ConstAssignableInputValue<TSchema, {
+        kind: "enum";
+        name: TTypeName_1;
+        modifier: TModifier;
+        directives: {};
+        defaultValue: null;
+      }>)) | (NoInfer<TDefaultFn> extends null ? () => ConstAssignableInputValue<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 (() => ConstAssignableInputValue<TSchema, {
+      kind: "input";
+      name: TTypeName_1;
+      modifier: TModifier;
+      directives: {};
+      defaultValue: null;
+    }>) | null = null, const TDirectives extends AnyConstDirectiveAttachments = {}>(type: ModifiedTypeName<string, TTypeName_1, TModifier>, extras?: {
+      default?: (TDefaultFn & (() => ConstAssignableInputValue<TSchema, {
+        kind: "input";
+        name: TTypeName_1;
+        modifier: TModifier;
+        directives: {};
+        defaultValue: null;
+      }>)) | (NoInfer<TDefaultFn> extends null ? () => ConstAssignableInputValue<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 extends keyof TSchema["object"][TTypeName_1]["fields"] & string, const TArgName extends keyof TSchema["object"][TTypeName_1]["fields"][TFieldName]["arguments"] & string>(typeName: TTypeName_1, fieldName: TFieldName, argName: TArgName) => TSchema["object"][TTypeName_1]["fields"][TFieldName]["arguments"][TArgName];
+  };
+}>;
+//#endregion
+//#region packages/core/src/composer/model.d.ts
+declare const createGqlModelComposers: <TSchema extends AnyGraphqlSchema>(schema: NoInfer<TSchema>) => Omit<{ readonly [TTypeName in keyof TSchema["object"]]: TTypeName extends string ? <TFieldEntries extends AnyFields[], TNormalized extends object, TVarDefinitions extends InputTypeSpecifiers[] = [{}]>(options: {
+  variables?: TVarDefinitions | undefined;
+}, builder: FieldsBuilder<TSchema, TTypeName, MergeVarDefinitions<TVarDefinitions>, TFieldEntries>, normalize: (raw: NoInfer<(MergeFields<TFieldEntries> extends infer T_1 extends AnyFields ? { readonly [TAliasName in keyof T_1]: InferField<TSchema_1, T_1[TAliasName]> } : never) extends infer T ? { [K in keyof T]: T[K] } : never>) => TNormalized) => Model<TTypeName, SwitchIfEmpty<MergeVarDefinitions<TVarDefinitions>, void, AssignableInput<TSchema, MergeVarDefinitions<TVarDefinitions>>>, MergeFields<TFieldEntries> & {
+  [key: symbol]: never;
+}, ((MergeFields<TFieldEntries> extends infer T_1 extends AnyFields ? { readonly [TAliasName in keyof T_1]: InferField<TSchema_1, T_1[TAliasName]> } : never) extends infer T ? { [K in keyof T]: T[K] } : never) & {
+  [key: symbol]: never;
+}, TNormalized> : never }, TSchema["operations"][keyof OperationRoots] & keyof TSchema["object"]>;
+//#endregion
+//#region packages/core/src/composer/projection-path-graph.d.ts
+declare function createPathGraphFromSliceEntries(fragments: {
+  [key: string]: AnySlicePayload;
+}): ProjectionPathGraphNode;
+//#endregion
+//#region packages/core/src/composer/slice.d.ts
+declare const createSliceComposerFactory: <TSchema extends AnyGraphqlSchema, TRuntimeAdapter extends AnyGraphqlRuntimeAdapter>(schema: NoInfer<TSchema>) => <TOperationType extends OperationType>(operationType: TOperationType) => <TFieldEntries extends AnyFields[], TProjection extends AnyProjection, TVarDefinitions extends InputTypeSpecifiers[] = [{}]>(options: {
+  variables?: TVarDefinitions;
+}, fieldBuilder: FieldsBuilder<TSchema, TSchema["operations"][TOperationType] & keyof TSchema["object"] & string, MergeVarDefinitions<TVarDefinitions>, TFieldEntries>, projectionBuilder: ExecutionResultProjectionsBuilder<TSchema, TRuntimeAdapter, MergeFields<TFieldEntries>, TProjection>) => Slice<TOperationType, SwitchIfEmpty<MergeVarDefinitions<TVarDefinitions>, void, AssignableInput<TSchema, MergeVarDefinitions<TVarDefinitions>>>, MergeFields<TFieldEntries> & {
+  [key: symbol]: never;
+}, TProjection>;
+//#endregion
+//#region packages/core/src/composer/var-builder.d.ts
+declare const createVarBuilder: <TSchema extends AnyGraphqlSchema>(schema: TSchema) => {
+  $: <TVarName extends string>(varName: TVarName) => {
+    scalar: <const TTypeName extends keyof TSchema["scalar"] & string, const TModifier extends TypeModifier, const TDefaultFn extends (() => ConstAssignableInputValue<TSchema, {
+      kind: "scalar";
+      name: TTypeName;
+      modifier: TModifier;
+      directives: {};
+      defaultValue: null;
+    }>) | null = null, const TDirectives extends AnyConstDirectiveAttachments = {}>(type: ModifiedTypeName<string, TTypeName, TModifier>, extras?: {
+      default?: (TDefaultFn & (() => ConstAssignableInputValue<TSchema, {
+        kind: "scalar";
+        name: TTypeName;
+        modifier: TModifier;
+        directives: {};
+        defaultValue: null;
+      }>)) | (NoInfer<TDefaultFn> extends null ? () => ConstAssignableInputValue<TSchema, {
+        kind: "scalar";
+        name: TTypeName;
+        modifier: TModifier;
+        directives: {};
+        defaultValue: null;
+      }> : never) | undefined;
+      directives?: TDirectives | undefined;
+    } | undefined) => { [K in TVarName]: {
+      kind: "scalar";
+      name: TTypeName;
+      modifier: TModifier;
+      defaultValue: TDefaultFn extends null ? null : {
+        default: ReturnType<NonNullable<TDefaultFn>>;
+      };
+      directives: TDirectives;
+    } };
+    enum: <const TTypeName extends keyof TSchema["enum"] & string, const TModifier extends TypeModifier, const TDefaultFn extends (() => ConstAssignableInputValue<TSchema, {
+      kind: "enum";
+      name: TTypeName;
+      modifier: TModifier;
+      directives: {};
+      defaultValue: null;
+    }>) | null = null, const TDirectives extends AnyConstDirectiveAttachments = {}>(type: ModifiedTypeName<string, TTypeName, TModifier>, extras?: {
+      default?: (TDefaultFn & (() => ConstAssignableInputValue<TSchema, {
+        kind: "enum";
+        name: TTypeName;
+        modifier: TModifier;
+        directives: {};
+        defaultValue: null;
+      }>)) | (NoInfer<TDefaultFn> extends null ? () => ConstAssignableInputValue<TSchema, {
+        kind: "enum";
+        name: TTypeName;
+        modifier: TModifier;
+        directives: {};
+        defaultValue: null;
+      }> : never) | undefined;
+      directives?: TDirectives | undefined;
+    } | undefined) => { [K in TVarName]: {
+      kind: "enum";
+      name: TTypeName;
+      modifier: TModifier;
+      defaultValue: TDefaultFn extends null ? null : {
+        default: ReturnType<NonNullable<TDefaultFn>>;
+      };
+      directives: TDirectives;
+    } };
+    input: <const TTypeName extends keyof TSchema["input"] & string, const TModifier extends TypeModifier, const TDefaultFn extends (() => ConstAssignableInputValue<TSchema, {
+      kind: "input";
+      name: TTypeName;
+      modifier: TModifier;
+      directives: {};
+      defaultValue: null;
+    }>) | null = null, const TDirectives extends AnyConstDirectiveAttachments = {}>(type: ModifiedTypeName<string, TTypeName, TModifier>, extras?: {
+      default?: (TDefaultFn & (() => ConstAssignableInputValue<TSchema, {
+        kind: "input";
+        name: TTypeName;
+        modifier: TModifier;
+        directives: {};
+        defaultValue: null;
+      }>)) | (NoInfer<TDefaultFn> extends null ? () => ConstAssignableInputValue<TSchema, {
+        kind: "input";
+        name: TTypeName;
+        modifier: TModifier;
+        directives: {};
+        defaultValue: null;
+      }> : never) | undefined;
+      directives?: TDirectives | undefined;
+    } | undefined) => { [K in TVarName]: {
+      kind: "input";
+      name: TTypeName;
+      modifier: TModifier;
+      defaultValue: TDefaultFn extends null ? null : {
+        default: ReturnType<NonNullable<TDefaultFn>>;
+      };
+      directives: TDirectives;
+    } };
+    byField: <const TTypeName extends keyof TSchema["object"] & string, const TFieldName extends keyof TSchema["object"][TTypeName]["fields"] & string, const TArgName extends keyof TSchema["object"][TTypeName]["fields"][TFieldName]["arguments"] & string>(typeName: TTypeName, fieldName: TFieldName, argName: TArgName) => TSchema["object"][TTypeName]["fields"][TFieldName]["arguments"][TArgName];
+  };
+};
+//#endregion
+//#region packages/core/src/schema/schema-builder.d.ts
+declare const defineScalar: <const TName extends string, TInput, TOutput, TDirectives extends AnyConstDirectiveAttachments>(name: TName, definition: (tool: {
+  type: typeof hidden;
+}) => {
+  input: Hidden<TInput>;
+  output: Hidden<TOutput>;
+  directives: TDirectives;
+}) => { [K in TName]: {
+  _type: Hidden<{
+    input: TInput;
+    output: TOutput;
+  }>;
+  name: TName;
+  directives: TDirectives;
+} };
+declare const define: <const TName extends string>(name: TName) => {
+  enum: <const TValues extends EnumDefinition<string>["values"], TDirectives extends AnyConstDirectiveAttachments>(values: TValues, directives: TDirectives) => {
+    _type: () => keyof TValues & string;
+    name: TName;
+    values: TValues;
+    directives: TDirectives;
+  };
+  input: <TFields extends InputDefinition["fields"], TDirectives_1 extends AnyConstDirectiveAttachments>(fields: TFields, directives: TDirectives_1) => {
+    name: TName;
+    fields: TFields;
+    directives: TDirectives_1;
+  };
+  object: <TFields extends ObjectDefinition["fields"], TDirectives_2 extends AnyConstDirectiveAttachments>(fields: TFields, directives: TDirectives_2) => {
+    name: TName;
+    fields: {
+      __typename: {
+        kind: "typename";
+        name: `${TName}`;
+        modifier: "!";
+        arguments: {};
+        directives: AnyConstDirectiveAttachments;
+      };
+    } & TFields;
+    directives: TDirectives_2;
+  };
+  union: <TTypes extends UnionDefinition["types"], TDirectives_3 extends AnyConstDirectiveAttachments>(types: TTypes, directives: TDirectives_3) => {
+    name: TName;
+    types: TTypes;
+    directives: TDirectives_3;
+  };
+};
+declare const defineOperationRoots: <const TOperationRoots extends OperationRoots>(operationRoots: TOperationRoots) => TOperationRoots;
+//#endregion
+//#region packages/core/src/schema/type-specifier-builder.d.ts
+declare const unsafeInputType: {
+  scalar: <const TName extends string, const TModifier extends TypeModifier, const TDefaultFactory extends (() => ConstValue) | null = null, const TDirectives extends AnyConstDirectiveAttachments = {}>(type: ModifiedTypeName<string, TName, TModifier>, extras: {
+    default?: TDefaultFactory | undefined;
+    directives?: TDirectives | undefined;
+  }) => {
+    kind: "scalar";
+    name: TName;
+    modifier: TModifier;
+    defaultValue: TDefaultFactory extends null ? null : {
+      default: ReturnType<NonNullable<TDefaultFactory>>;
+    };
+    directives: TDirectives;
+  };
+  enum: <const TName extends string, const TModifier extends TypeModifier, const TDefaultFactory extends (() => ConstValue) | null = null, const TDirectives extends AnyConstDirectiveAttachments = {}>(type: ModifiedTypeName<string, TName, TModifier>, extras: {
+    default?: TDefaultFactory | undefined;
+    directives?: TDirectives | undefined;
+  }) => {
+    kind: "enum";
+    name: TName;
+    modifier: TModifier;
+    defaultValue: TDefaultFactory extends null ? null : {
+      default: ReturnType<NonNullable<TDefaultFactory>>;
+    };
+    directives: TDirectives;
+  };
+  input: <const TName extends string, const TModifier extends TypeModifier, const TDefaultFactory extends (() => ConstValue) | null = null, const TDirectives extends AnyConstDirectiveAttachments = {}>(type: ModifiedTypeName<string, TName, TModifier>, extras: {
+    default?: TDefaultFactory | undefined;
+    directives?: TDirectives | undefined;
+  }) => {
+    kind: "input";
+    name: TName;
+    modifier: TModifier;
+    defaultValue: TDefaultFactory extends null ? null : {
+      default: ReturnType<NonNullable<TDefaultFactory>>;
+    };
+    directives: TDirectives;
+  };
+};
+declare const unsafeOutputType: {
+  scalar: <const TName extends string, const TModifier extends TypeModifier, const TArguments extends InputTypeSpecifiers = {}, const TDirectives extends AnyConstDirectiveAttachments = {}>(type: ModifiedTypeName<string, TName, TModifier>, extras: {
+    arguments?: TArguments | undefined;
+    directives?: TDirectives | undefined;
+  }) => {
+    kind: "scalar";
+    name: TName;
+    modifier: TModifier;
+    arguments: InputTypeSpecifiers extends TArguments ? {} : TArguments;
+    directives: TDirectives;
+  };
+  enum: <const TName extends string, const TModifier extends TypeModifier, const TArguments extends InputTypeSpecifiers = {}, const TDirectives extends AnyConstDirectiveAttachments = {}>(type: ModifiedTypeName<string, TName, TModifier>, extras: {
+    arguments?: TArguments | undefined;
+    directives?: TDirectives | undefined;
+  }) => {
+    kind: "enum";
+    name: TName;
+    modifier: TModifier;
+    arguments: InputTypeSpecifiers extends TArguments ? {} : TArguments;
+    directives: TDirectives;
+  };
+  object: <const TName extends string, const TModifier extends TypeModifier, const TArguments extends InputTypeSpecifiers = {}, const TDirectives extends AnyConstDirectiveAttachments = {}>(type: ModifiedTypeName<string, TName, TModifier>, extras: {
+    arguments?: TArguments | undefined;
+    directives?: TDirectives | undefined;
+  }) => {
+    kind: "object";
+    name: TName;
+    modifier: TModifier;
+    arguments: InputTypeSpecifiers extends TArguments ? {} : TArguments;
+    directives: TDirectives;
+  };
+  union: <const TName extends string, const TModifier extends TypeModifier, const TArguments extends InputTypeSpecifiers = {}, const TDirectives extends AnyConstDirectiveAttachments = {}>(type: ModifiedTypeName<string, TName, TModifier>, extras: {
+    arguments?: TArguments | undefined;
+    directives?: TDirectives | undefined;
+  }) => {
+    kind: "union";
+    name: TName;
+    modifier: TModifier;
+    arguments: InputTypeSpecifiers extends TArguments ? {} : TArguments;
+    directives: TDirectives;
+  };
+  typename: <const TName extends string, const TModifier extends TypeModifier, const TArguments extends InputTypeSpecifiers = {}, const TDirectives extends AnyConstDirectiveAttachments = {}>(type: ModifiedTypeName<string, TName, TModifier>, extras: {
+    arguments?: TArguments | undefined;
+    directives?: TDirectives | undefined;
+  }) => {
+    kind: "typename";
+    name: TName;
+    modifier: TModifier;
+    arguments: InputTypeSpecifiers extends TArguments ? {} : TArguments;
+    directives: TDirectives;
+  };
+};
+//#endregion
+//#region packages/core/src/utils/wrap-by-key.d.ts
+declare const wrapByKey: <TName extends string, TValue>(name: TName, value: TValue) => { [K in TName]: TValue };
+//#endregion
+export { AbstractFieldSelection, AnyAssignableInput, AnyAssignableInputValue, AnyComposedOperation, AnyComposedOperationOf, AnyConstAssignableInput, AnyConstAssignableInputValue, AnyConstDirectiveAttachments, AnyDefaultValue, AnyDirectiveAttachments, AnyExecutionResultProjectionsBuilder, AnyFieldName, AnyFieldPath, AnyFieldSelection, AnyFieldSelectionFactory, AnyFieldSelectionFactoryReturn, AnyFields, AnyGraphqlRuntimeAdapter, AnyGraphqlSchema, AnyInlineOperation, AnyInlineOperationOf, AnyModel, AnyNestedObject, AnyNestedUnion, AnyProjection, AnySlice, AnySliceOf, AnySlicePayload, AnySlicePayloads, AnySlicedExecutionResult, AnySlicedExecutionResultRecord, AnyTypeModifier, AnyTypeName, AnyTypeSpecifier, AnyVarRef, ApplyTypeModifier, ApplyTypeModifierToKeys, AssignableInput, AssignableInputByFieldName, AssignableInputValue, AvailableFieldPathOf, ComposedOperation, ComposedOperationDefinitionBuilder, ConcatSlicePayloads, ConstAssignableInput, ConstAssignableInputValue, ConstValue, ConstValues, EmptyObject, EmptyResult, EnumDefinition, ExecutionResultProjectionsBuilder, FieldSelectionFactories, FieldSelectionFactory, FieldSelectionFactoryFieldArguments, FieldSelectionFactoryObjectReturn, FieldSelectionFactoryPrimitiveReturn, FieldSelectionFactoryReturn, FieldSelectionFactoryUnionReturn, FieldSelectionTemplateOf, FieldsBuilder, FieldsBuilderTools, GqlElement, GqlElementComposer, GqlElementContext, GqlElementDefinitionFactory, GraphqlExecutionResult, Hidden, IfEmpty, InferByFieldPath, InferComposedOperationRawData, InferExecutionResultProjection, InferField, InferFields, InferInputTypeRef, InferOutputOfSlice, InferOutputTypeRef, InlineOperation, InputDefinition, InputEnumSpecifier, InputFieldRecord, InputInferrableTypeSpecifier, InputInputObjectSpecifier, InputScalarSpecifier, InputTypeKind, InputTypeSpecifier, InputTypeSpecifiers, ListTypeModifierSuffix, MergeFields, MergeVarDefinitions, Model, ModifiedTypeName, NestedObjectFieldsBuilder, NestedObjectFieldsBuilderTools, NestedUnionFieldsBuilder, NonGraphqlErrorResult, NormalizedError, NormalizedExecutionResult, ObjectDefinition, ObjectFieldRecord, OperationRoots, OperationType, OutputEnumSpecifier, OutputInferrableTypeSpecifier, OutputObjectSpecifier, OutputScalarSpecifier, OutputTypeKind, OutputTypeSpecifier, OutputTypeSpecifiers, OutputTypenameSpecifier, OutputUnionSpecifier, PickTypeSpecifierByFieldName, Prettify, Projection, ProjectionPath, ProjectionPathGraphNode, SafeUnwrapResult, ScalarDefinition, Slice, SlicePayload, SlicedExecutionResult, SlicedExecutionResultEmpty, SlicedExecutionResultError, SlicedExecutionResultSuccess, StripFunctions, StripSymbols, StripTailingListFromTypeModifier, StripTailingListFromTypeSpecifier, SwitchIfEmpty, Tuple, TypeModifier, UnionDefinition, UnionMemberName, UnionToIntersection, UnionTypeRecord, VarRef, VarRefBy, buildArgumentValue, buildConstValueNode, buildDocument, buildOperationTypeNode, buildWithTypeModifier, createComposedOperationComposerFactory, createFieldFactories, createGqlElementComposer, createGqlModelComposers, createPathGraphFromSliceEntries, createSliceComposerFactory, createVarAssignments, createVarBuilder, createVarRefs, define, defineOperationRoots, defineScalar, empty, hidden, mergeFields, mergeVarDefinitions, parseModifiedTypeName, prettify, unsafeInputType, unsafeOutputType, wrapByKey };
+//# sourceMappingURL=index-DiEkx8-6.d.ts.map