@soda-gql/runtime 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,601 @@
+import { FormattedExecutionResult, GraphQLFormattedError, TypedQueryDocumentNode } from "graphql";
+
+//#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/types/schema/const-value.d.ts
+type ConstValue = string | number | boolean | null | undefined | {
+  readonly [key: string]: ConstValue;
+} | readonly ConstValue[];
+//#endregion
+//#region packages/core/src/utils/hidden.d.ts
+type Hidden<T> = () => T;
+//#endregion
+//#region packages/core/src/types/schema/type-modifier.d.ts
+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] };
+//#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 InputFieldRecord<TSchema extends AnyGraphqlSchema, TSpecifier extends InputTypeSpecifier> = TSchema["input"][TSpecifier["name"]]["fields"];
+//#endregion
+//#region packages/core/src/utils/prettify.d.ts
+type Prettify<T> = { [K in keyof T]: T[K] } & {};
+//#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));
+//#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;
+};
+/** 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/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] };
+//#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>;
+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 SwitchIfEmpty<TTarget, TTrue, TFalse> = IsEmptyObject<TTarget> extends true ? TTrue : TFalse;
+//#endregion
+//#region packages/core/src/types/element/slice.d.ts
+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;
+};
+//#endregion
+//#region packages/core/src/types/element/composed-operation.d.ts
+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>>>;
+//#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/inline-operation.d.ts
+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/runtime/model.d.ts
+type RuntimeModelInput = {
+  prebuild: StripFunctions<AnyModel>;
+  runtime: {
+    normalize: (raw: any) => object;
+  };
+};
+//#endregion
+//#region packages/core/src/runtime/composed-operation.d.ts
+type RuntimeComposedOperationInput = {
+  prebuild: StripFunctions<AnyComposedOperationOf<OperationType>>;
+  runtime: {
+    getSlices: (tools: {
+      $: AnyAssignableInput;
+    }) => {
+      [key: string]: AnySlicePayload;
+    };
+  };
+};
+//#endregion
+//#region packages/core/src/runtime/inline-operation.d.ts
+type RuntimeInlineOperationInput = {
+  prebuild: StripFunctions<AnyInlineOperationOf<OperationType>>;
+  runtime: {};
+};
+//#endregion
+//#region packages/core/src/runtime/slice.d.ts
+type RuntimeSliceInput = {
+  prebuild: StripFunctions<AnySliceOf<OperationType>>;
+  runtime: {
+    buildProjection: AnyExecutionResultProjectionsBuilder;
+  };
+};
+//#endregion
+//#region packages/core/src/runtime/runtime-adapter.d.ts
+type RuntimeAdapterFactory<TRuntimeAdapter extends AnyGraphqlRuntimeAdapter> = (tools: {
+  type: <T>() => Hidden<T>;
+}) => TRuntimeAdapter;
+declare const createRuntimeAdapter: <TRuntimeAdapter extends AnyGraphqlRuntimeAdapter>(factory: RuntimeAdapterFactory<TRuntimeAdapter>) => TRuntimeAdapter;
+//#endregion
+//#region packages/core/src/runtime/index.d.ts
+declare const gqlRuntime: {
+  model: (input: RuntimeModelInput) => AnyModel;
+  composedOperation: (input: RuntimeComposedOperationInput) => AnyComposedOperationOf<OperationType>;
+  inlineOperation: (input: RuntimeInlineOperationInput) => AnyInlineOperationOf<OperationType>;
+  slice: (input: RuntimeSliceInput) => AnySliceOf<OperationType>;
+  getComposedOperation: (name: string) => AnyComposedOperationOf<keyof OperationRoots>;
+  getInlineOperation: (name: string) => AnyInlineOperationOf<keyof OperationRoots>;
+};
+//#endregion
+export { createRuntimeAdapter, gqlRuntime };
+//# sourceMappingURL=index.d.ts.map