@mearie/core 0.0.0-next-20260228035926

package/dist/index.d.cts

@@ -0,0 +1,348 @@
+import { k as Source } from "./make-BhxZYW3l.cjs";
+import { Artifact, Artifact as Artifact$1, ArtifactKind, ArtifactKind as ArtifactKind$1, DataOf, DataOf as DataOf$1, FragmentRefs, FragmentRefs as FragmentRefs$1, SchemaMeta, SchemaMeta as SchemaMeta$1, VariablesOf, VariablesOf as VariablesOf$1 } from "@mearie/shared";
+
+//#region src/errors.d.ts
+/**
+ *
+ */
+declare class GraphQLError extends Error {
+  readonly path?: readonly (string | number)[];
+  readonly locations?: readonly {
+    line: number;
+    column: number;
+  }[];
+  readonly extensions?: Record<string, unknown>;
+  constructor(message: string, options?: {
+    path?: readonly (string | number)[];
+    locations?: readonly {
+      line: number;
+      column: number;
+    }[];
+    extensions?: Record<string, unknown>;
+    cause?: unknown;
+  });
+  toJSON(): Record<string, unknown>;
+}
+interface ExchangeErrorExtensionsMap {}
+type OperationError = GraphQLError | ExchangeError<string>;
+/**
+ *
+ */
+declare class ExchangeError<const TName extends keyof ExchangeErrorExtensionsMap | (string & {}) = string> extends Error {
+  readonly exchangeName: TName;
+  readonly extensions: TName extends keyof ExchangeErrorExtensionsMap ? ExchangeErrorExtensionsMap[TName] : Record<string, unknown> | undefined;
+  constructor(message: string, options: {
+    exchangeName: TName;
+    cause?: unknown;
+  } & (TName extends keyof ExchangeErrorExtensionsMap ? undefined extends ExchangeErrorExtensionsMap[TName] ? {
+    extensions?: Exclude<ExchangeErrorExtensionsMap[TName], undefined>;
+  } : {
+    extensions: ExchangeErrorExtensionsMap[TName];
+  } : {
+    extensions?: Record<string, unknown>;
+  }));
+  toJSON(): Record<string, unknown>;
+}
+/**
+ *
+ */
+declare class AggregatedError extends AggregateError {
+  readonly errors: OperationError[];
+  constructor(errors: readonly OperationError[], message?: string);
+  toJSON(): Record<string, unknown>;
+}
+declare const isGraphQLError: (error: unknown) => error is GraphQLError;
+declare function isExchangeError(error: unknown): error is ExchangeError<string>;
+declare function isExchangeError<const TName extends keyof ExchangeErrorExtensionsMap | (string & {})>(error: unknown, exchangeName: TName): error is ExchangeError<TName>;
+declare const isAggregatedError: (error: unknown) => error is AggregatedError;
+//#endregion
+//#region src/scalars.d.ts
+type ScalarTransformer<TExternal = unknown, TInternal = unknown> = {
+  parse: (value: TInternal) => TExternal;
+  serialize: (value: TExternal) => TInternal;
+};
+type ScalarsConfig<TMeta extends SchemaMeta$1 = SchemaMeta$1> = { [K in keyof TMeta['scalars']]: ScalarTransformer<TMeta['scalars'][K], unknown> };
+//#endregion
+//#region src/client.d.ts
+type QueryOptions<T extends Artifact$1<'query'> = Artifact$1<'query'>> = {
+  initialData?: DataOf$1<T>;
+  metadata?: OperationMetadata;
+};
+type MutationOptions = {
+  metadata?: OperationMetadata;
+};
+type SubscriptionOptions = {
+  metadata?: OperationMetadata;
+};
+type FragmentOptions = {
+  metadata?: OperationMetadata;
+};
+type ClientOptions<T extends SchemaMeta$1> = {
+  schema: T;
+  exchanges: Exchange[];
+} & (T['scalars'] extends Record<string, never> ? {
+  scalars?: undefined;
+} : {
+  scalars: ScalarsConfig<T>;
+});
+declare class Client<TMeta extends SchemaMeta$1 = SchemaMeta$1> {
+  #private;
+  private operations$;
+  private results$;
+  constructor(config: ClientOptions<TMeta>);
+  get schema(): TMeta;
+  get scalars(): ScalarsConfig<TMeta> | undefined;
+  private createOperationKey;
+  createOperation(artifact: Artifact$1, variables?: unknown, metadata?: OperationMetadata): Operation;
+  executeOperation(operation: Operation): Source<OperationResult>;
+  executeQuery<T extends Artifact$1<'query'>>(artifact: T, ...[variables, options]: VariablesOf$1<T> extends undefined ? [undefined?, QueryOptions<T>?] : [VariablesOf$1<T>, QueryOptions<T>?]): Source<OperationResult>;
+  executeMutation<T extends Artifact$1<'mutation'>>(artifact: T, ...[variables, options]: VariablesOf$1<T> extends undefined ? [undefined?, MutationOptions?] : [VariablesOf$1<T>, MutationOptions?]): Source<OperationResult>;
+  executeSubscription<T extends Artifact$1<'subscription'>>(artifact: T, ...[variables, options]: VariablesOf$1<T> extends undefined ? [undefined?, SubscriptionOptions?] : [VariablesOf$1<T>, SubscriptionOptions?]): Source<OperationResult>;
+  executeFragment<T extends Artifact$1<'fragment'>>(artifact: T, fragmentRef: FragmentRefs$1<T['name']> | FragmentRefs$1<T['name']>[], options?: FragmentOptions): Source<OperationResult>;
+  query<T extends Artifact$1<'query'>>(artifact: T, ...[variables, options]: VariablesOf$1<T> extends undefined ? [undefined?, QueryOptions<T>?] : [VariablesOf$1<T>, QueryOptions<T>?]): Promise<DataOf$1<T>>;
+  mutation<T extends Artifact$1<'mutation'>>(artifact: T, ...[variables, options]: VariablesOf$1<T> extends undefined ? [undefined?, MutationOptions?] : [VariablesOf$1<T>, MutationOptions?]): Promise<DataOf$1<T>>;
+  /**
+   * Returns the extension registered by a named exchange.
+   * @param name - The exchange name.
+   * @returns The extension object provided by the exchange.
+   */
+  extension<TName extends keyof ExchangeExtensionMap>(name: TName): ExchangeExtensionMap[TName];
+  extension(name: string): unknown;
+  maybeExtension<TName extends keyof ExchangeExtensionMap>(name: TName): ExchangeExtensionMap[TName] | undefined;
+  maybeExtension(name: string): unknown;
+  dispose(): void;
+}
+declare const createClient: <T extends SchemaMeta$1>(config: ClientOptions<T>) => Client<T>;
+//#endregion
+//#region src/exchange.d.ts
+interface OperationMetadataMap {}
+type OperationMetadata = { [K in keyof OperationMetadataMap]?: OperationMetadataMap[K] } & Record<string, unknown>;
+type BaseOperation = {
+  key: string;
+  metadata: OperationMetadataMap & Record<string, unknown>;
+};
+type RequestOperation<K extends ArtifactKind$1 = ArtifactKind$1> = BaseOperation & {
+  variant: 'request';
+  artifact: Artifact$1<K>;
+  variables: VariablesOf$1<Artifact$1<K>>;
+};
+type TeardownOperation = BaseOperation & {
+  variant: 'teardown';
+};
+type Operation<K extends ArtifactKind$1 = ArtifactKind$1> = RequestOperation<K> | TeardownOperation;
+type OperationResult = {
+  operation: Operation;
+  data?: unknown;
+  errors?: readonly OperationError[];
+  extensions?: Record<string, unknown>;
+  stale?: boolean;
+};
+type ExchangeInput<TMeta extends SchemaMeta$1 = SchemaMeta$1> = {
+  forward: ExchangeIO;
+  client: Client<TMeta>;
+};
+type ExchangeIO = (operations: Source<Operation>) => Source<OperationResult>;
+interface ExchangeExtensionMap {}
+type ExchangeResult<TName extends keyof ExchangeExtensionMap | (string & {}) = string> = {
+  name: TName;
+  io: ExchangeIO;
+} & (TName extends keyof ExchangeExtensionMap ? {
+  extension: ExchangeExtensionMap[TName];
+} : {});
+type Exchange<TName extends keyof ExchangeExtensionMap | (string & {}) = string> = <TMeta extends SchemaMeta$1 = SchemaMeta$1>(input: ExchangeInput<TMeta>) => ExchangeResult<TName>;
+//#endregion
+//#region src/exchanges/http.d.ts
+declare module '@mearie/core' {
+  interface ExchangeErrorExtensionsMap {
+    http?: {
+      statusCode?: number;
+    };
+  }
+}
+type HttpOptions = {
+  url: string;
+  headers?: HeadersInit;
+  mode?: RequestMode;
+  credentials?: RequestCredentials;
+  fetch?: typeof globalThis.fetch;
+};
+declare const httpExchange: (options: HttpOptions) => Exchange;
+//#endregion
+//#region src/exchanges/dedup.d.ts
+declare module '@mearie/core' {
+  interface OperationMetadataMap {
+    dedup?: {
+      skip?: boolean;
+    };
+  }
+}
+/**
+ * Prevents duplicate in-flight operations by deduplicating requests with identical artifact names and variables.
+ *
+ * Operations are considered identical if they have the same artifact name and serialized variables.
+ * Mutations are never deduplicated. An operation is "in-flight" from when it's first seen until all subscribers tear down.
+ *
+ * Caveats:
+ *
+ * 1. Upstream metadata is lost when operations are deduplicated. The result will contain the metadata
+ * from the operation that actually went through the pipeline, not from deduplicated operations.
+ * This preserves downstream metadata (retry attempts, cache status) but means custom upstream metadata
+ * from deduplicated operations will not appear in results.
+ * @internal
+ * @returns An exchange that deduplicates in-flight operations.
+ */
+declare const dedupExchange: () => Exchange;
+//#endregion
+//#region src/cache/types.d.ts
+/**
+ * Identifier for a single entity, supporting simple or composite keys.
+ */
+type EntityId = string | number | Record<string, string | number>;
+/**
+ * Target specification for cache invalidation operations.
+ */
+type InvalidateTarget = {
+  __typename: string;
+  id: EntityId;
+} | {
+  __typename: string;
+  id: EntityId;
+  field: string;
+  args?: Record<string, unknown>;
+} | {
+  __typename: 'Query';
+} | {
+  __typename: 'Query';
+  field: string;
+  args?: Record<string, unknown>;
+} | {
+  __typename: string;
+} | {
+  __typename: string;
+  field: string;
+  args?: Record<string, unknown>;
+};
+/**
+ * Opaque type representing a serializable cache snapshot.
+ */
+type CacheSnapshot = {
+  readonly __brand: unique symbol;
+};
+/**
+ * Operations available for programmatic cache manipulation.
+ */
+type CacheOperations = {
+  extract(): CacheSnapshot;
+  hydrate(data: CacheSnapshot): void;
+  invalidate(...targets: InvalidateTarget[]): void;
+  clear(): void;
+};
+//#endregion
+//#region src/exchanges/cache.d.ts
+declare module '@mearie/core' {
+  interface ExchangeExtensionMap {
+    cache: CacheOperations;
+  }
+}
+type CacheOptions = {
+  fetchPolicy?: 'cache-first' | 'cache-and-network' | 'network-only' | 'cache-only';
+};
+declare const cacheExchange: (options?: CacheOptions) => Exchange<"cache">;
+//#endregion
+//#region src/exchanges/retry.d.ts
+declare module '@mearie/core' {
+  interface OperationMetadataMap {
+    retry?: {
+      attempt: number;
+      delay: number;
+    };
+  }
+}
+type RetryOptions = {
+  maxAttempts?: number;
+  backoff?: (attempt: number) => number;
+  shouldRetry?: (error: OperationError) => boolean;
+};
+declare const retryExchange: (options?: RetryOptions) => Exchange;
+//#endregion
+//#region src/exchanges/fragment.d.ts
+declare module '@mearie/core' {
+  interface OperationMetadataMap {
+    fragmentRef?: unknown;
+  }
+}
+declare const fragmentExchange: () => Exchange;
+//#endregion
+//#region src/exchanges/required.d.ts
+declare const requiredExchange: () => Exchange;
+//#endregion
+//#region src/exchanges/subscription.d.ts
+interface SubscriptionClient {
+  subscribe(payload: {
+    operationName?: string;
+    query: string;
+    variables?: Record<string, unknown>;
+  }, sink: {
+    next: (result: unknown) => void;
+    error: (error: unknown) => void;
+    complete: () => void;
+  }): () => void;
+}
+type SubscriptionExchangeOptions = {
+  client: SubscriptionClient;
+};
+declare module '@mearie/core' {
+  interface OperationMetadataMap {
+    subscription?: {
+      transport?: boolean;
+    };
+  }
+}
+/**
+ * Creates an exchange for handling GraphQL subscriptions using a subscription client.
+ *
+ * This exchange accepts subscription clients from graphql-ws, graphql-sse, or any client
+ * implementing the Observer pattern.
+ * @internal
+ * @param options - Configuration options for the subscription exchange.
+ * @returns An exchange that handles subscription operations.
+ * @example
+ * // With graphql-ws
+ * import { createClient } from 'graphql-ws';
+ *
+ * const wsClient = createClient({
+ *   url: 'ws://localhost:4000/graphql',
+ * });
+ *
+ * subscriptionExchange({ client: wsClient })
+ * @example
+ * // With graphql-sse
+ * import { createClient } from 'graphql-sse';
+ *
+ * const sseClient = createClient({
+ *   url: 'http://localhost:4000/graphql/stream',
+ * });
+ *
+ * subscriptionExchange({ client: sseClient })
+ */
+declare const subscriptionExchange: (options: SubscriptionExchangeOptions) => Exchange;
+//#endregion
+//#region src/required.d.ts
+type RequiredAction = 'THROW' | 'CASCADE';
+declare class RequiredFieldError extends Error {
+  fieldPath: string[];
+  fieldName: string;
+  constructor(fieldPath: string[], fieldName: string);
+}
+//#endregion
+//#region src/utils.d.ts
+/**
+ * Stable JSON serialization with sorted keys.
+ * Used for both variables and field arguments.
+ * @internal
+ * @param value - The value to stringify.
+ * @returns The stable JSON string.
+ */
+declare const stringify: (value: unknown) => string;
+//#endregion
+export { AggregatedError, type Artifact, type ArtifactKind, type CacheOptions, type CacheSnapshot, Client, type ClientOptions, type DataOf, type Exchange, ExchangeError, type ExchangeErrorExtensionsMap, type ExchangeExtensionMap, type ExchangeIO, type ExchangeResult, type FragmentOptions, type FragmentRefs, GraphQLError, type HttpOptions, type MutationOptions, type Operation, type OperationError, type OperationMetadata, type OperationMetadataMap, type OperationResult, type QueryOptions, type RequiredAction, RequiredFieldError, type RetryOptions, type SchemaMeta, type SubscriptionClient, type SubscriptionExchangeOptions, type SubscriptionOptions, type VariablesOf, cacheExchange, createClient, dedupExchange, fragmentExchange, httpExchange, isAggregatedError, isExchangeError, isGraphQLError, requiredExchange, retryExchange, stringify, subscriptionExchange };

package/dist/index.d.mts

@@ -0,0 +1,348 @@
+import { k as Source } from "./make-Ve8TkMHJ.mjs";
+import { Artifact, Artifact as Artifact$1, ArtifactKind, ArtifactKind as ArtifactKind$1, DataOf, DataOf as DataOf$1, FragmentRefs, FragmentRefs as FragmentRefs$1, SchemaMeta, SchemaMeta as SchemaMeta$1, VariablesOf, VariablesOf as VariablesOf$1 } from "@mearie/shared";
+
+//#region src/errors.d.ts
+/**
+ *
+ */
+declare class GraphQLError extends Error {
+  readonly path?: readonly (string | number)[];
+  readonly locations?: readonly {
+    line: number;
+    column: number;
+  }[];
+  readonly extensions?: Record<string, unknown>;
+  constructor(message: string, options?: {
+    path?: readonly (string | number)[];
+    locations?: readonly {
+      line: number;
+      column: number;
+    }[];
+    extensions?: Record<string, unknown>;
+    cause?: unknown;
+  });
+  toJSON(): Record<string, unknown>;
+}
+interface ExchangeErrorExtensionsMap {}
+type OperationError = GraphQLError | ExchangeError<string>;
+/**
+ *
+ */
+declare class ExchangeError<const TName extends keyof ExchangeErrorExtensionsMap | (string & {}) = string> extends Error {
+  readonly exchangeName: TName;
+  readonly extensions: TName extends keyof ExchangeErrorExtensionsMap ? ExchangeErrorExtensionsMap[TName] : Record<string, unknown> | undefined;
+  constructor(message: string, options: {
+    exchangeName: TName;
+    cause?: unknown;
+  } & (TName extends keyof ExchangeErrorExtensionsMap ? undefined extends ExchangeErrorExtensionsMap[TName] ? {
+    extensions?: Exclude<ExchangeErrorExtensionsMap[TName], undefined>;
+  } : {
+    extensions: ExchangeErrorExtensionsMap[TName];
+  } : {
+    extensions?: Record<string, unknown>;
+  }));
+  toJSON(): Record<string, unknown>;
+}
+/**
+ *
+ */
+declare class AggregatedError extends AggregateError {
+  readonly errors: OperationError[];
+  constructor(errors: readonly OperationError[], message?: string);
+  toJSON(): Record<string, unknown>;
+}
+declare const isGraphQLError: (error: unknown) => error is GraphQLError;
+declare function isExchangeError(error: unknown): error is ExchangeError<string>;
+declare function isExchangeError<const TName extends keyof ExchangeErrorExtensionsMap | (string & {})>(error: unknown, exchangeName: TName): error is ExchangeError<TName>;
+declare const isAggregatedError: (error: unknown) => error is AggregatedError;
+//#endregion
+//#region src/scalars.d.ts
+type ScalarTransformer<TExternal = unknown, TInternal = unknown> = {
+  parse: (value: TInternal) => TExternal;
+  serialize: (value: TExternal) => TInternal;
+};
+type ScalarsConfig<TMeta extends SchemaMeta$1 = SchemaMeta$1> = { [K in keyof TMeta['scalars']]: ScalarTransformer<TMeta['scalars'][K], unknown> };
+//#endregion
+//#region src/client.d.ts
+type QueryOptions<T extends Artifact$1<'query'> = Artifact$1<'query'>> = {
+  initialData?: DataOf$1<T>;
+  metadata?: OperationMetadata;
+};
+type MutationOptions = {
+  metadata?: OperationMetadata;
+};
+type SubscriptionOptions = {
+  metadata?: OperationMetadata;
+};
+type FragmentOptions = {
+  metadata?: OperationMetadata;
+};
+type ClientOptions<T extends SchemaMeta$1> = {
+  schema: T;
+  exchanges: Exchange[];
+} & (T['scalars'] extends Record<string, never> ? {
+  scalars?: undefined;
+} : {
+  scalars: ScalarsConfig<T>;
+});
+declare class Client<TMeta extends SchemaMeta$1 = SchemaMeta$1> {
+  #private;
+  private operations$;
+  private results$;
+  constructor(config: ClientOptions<TMeta>);
+  get schema(): TMeta;
+  get scalars(): ScalarsConfig<TMeta> | undefined;
+  private createOperationKey;
+  createOperation(artifact: Artifact$1, variables?: unknown, metadata?: OperationMetadata): Operation;
+  executeOperation(operation: Operation): Source<OperationResult>;
+  executeQuery<T extends Artifact$1<'query'>>(artifact: T, ...[variables, options]: VariablesOf$1<T> extends undefined ? [undefined?, QueryOptions<T>?] : [VariablesOf$1<T>, QueryOptions<T>?]): Source<OperationResult>;
+  executeMutation<T extends Artifact$1<'mutation'>>(artifact: T, ...[variables, options]: VariablesOf$1<T> extends undefined ? [undefined?, MutationOptions?] : [VariablesOf$1<T>, MutationOptions?]): Source<OperationResult>;
+  executeSubscription<T extends Artifact$1<'subscription'>>(artifact: T, ...[variables, options]: VariablesOf$1<T> extends undefined ? [undefined?, SubscriptionOptions?] : [VariablesOf$1<T>, SubscriptionOptions?]): Source<OperationResult>;
+  executeFragment<T extends Artifact$1<'fragment'>>(artifact: T, fragmentRef: FragmentRefs$1<T['name']> | FragmentRefs$1<T['name']>[], options?: FragmentOptions): Source<OperationResult>;
+  query<T extends Artifact$1<'query'>>(artifact: T, ...[variables, options]: VariablesOf$1<T> extends undefined ? [undefined?, QueryOptions<T>?] : [VariablesOf$1<T>, QueryOptions<T>?]): Promise<DataOf$1<T>>;
+  mutation<T extends Artifact$1<'mutation'>>(artifact: T, ...[variables, options]: VariablesOf$1<T> extends undefined ? [undefined?, MutationOptions?] : [VariablesOf$1<T>, MutationOptions?]): Promise<DataOf$1<T>>;
+  /**
+   * Returns the extension registered by a named exchange.
+   * @param name - The exchange name.
+   * @returns The extension object provided by the exchange.
+   */
+  extension<TName extends keyof ExchangeExtensionMap>(name: TName): ExchangeExtensionMap[TName];
+  extension(name: string): unknown;
+  maybeExtension<TName extends keyof ExchangeExtensionMap>(name: TName): ExchangeExtensionMap[TName] | undefined;
+  maybeExtension(name: string): unknown;
+  dispose(): void;
+}
+declare const createClient: <T extends SchemaMeta$1>(config: ClientOptions<T>) => Client<T>;
+//#endregion
+//#region src/exchange.d.ts
+interface OperationMetadataMap {}
+type OperationMetadata = { [K in keyof OperationMetadataMap]?: OperationMetadataMap[K] } & Record<string, unknown>;
+type BaseOperation = {
+  key: string;
+  metadata: OperationMetadataMap & Record<string, unknown>;
+};
+type RequestOperation<K extends ArtifactKind$1 = ArtifactKind$1> = BaseOperation & {
+  variant: 'request';
+  artifact: Artifact$1<K>;
+  variables: VariablesOf$1<Artifact$1<K>>;
+};
+type TeardownOperation = BaseOperation & {
+  variant: 'teardown';
+};
+type Operation<K extends ArtifactKind$1 = ArtifactKind$1> = RequestOperation<K> | TeardownOperation;
+type OperationResult = {
+  operation: Operation;
+  data?: unknown;
+  errors?: readonly OperationError[];
+  extensions?: Record<string, unknown>;
+  stale?: boolean;
+};
+type ExchangeInput<TMeta extends SchemaMeta$1 = SchemaMeta$1> = {
+  forward: ExchangeIO;
+  client: Client<TMeta>;
+};
+type ExchangeIO = (operations: Source<Operation>) => Source<OperationResult>;
+interface ExchangeExtensionMap {}
+type ExchangeResult<TName extends keyof ExchangeExtensionMap | (string & {}) = string> = {
+  name: TName;
+  io: ExchangeIO;
+} & (TName extends keyof ExchangeExtensionMap ? {
+  extension: ExchangeExtensionMap[TName];
+} : {});
+type Exchange<TName extends keyof ExchangeExtensionMap | (string & {}) = string> = <TMeta extends SchemaMeta$1 = SchemaMeta$1>(input: ExchangeInput<TMeta>) => ExchangeResult<TName>;
+//#endregion
+//#region src/exchanges/http.d.ts
+declare module '@mearie/core' {
+  interface ExchangeErrorExtensionsMap {
+    http?: {
+      statusCode?: number;
+    };
+  }
+}
+type HttpOptions = {
+  url: string;
+  headers?: HeadersInit;
+  mode?: RequestMode;
+  credentials?: RequestCredentials;
+  fetch?: typeof globalThis.fetch;
+};
+declare const httpExchange: (options: HttpOptions) => Exchange;
+//#endregion
+//#region src/exchanges/dedup.d.ts
+declare module '@mearie/core' {
+  interface OperationMetadataMap {
+    dedup?: {
+      skip?: boolean;
+    };
+  }
+}
+/**
+ * Prevents duplicate in-flight operations by deduplicating requests with identical artifact names and variables.
+ *
+ * Operations are considered identical if they have the same artifact name and serialized variables.
+ * Mutations are never deduplicated. An operation is "in-flight" from when it's first seen until all subscribers tear down.
+ *
+ * Caveats:
+ *
+ * 1. Upstream metadata is lost when operations are deduplicated. The result will contain the metadata
+ * from the operation that actually went through the pipeline, not from deduplicated operations.
+ * This preserves downstream metadata (retry attempts, cache status) but means custom upstream metadata
+ * from deduplicated operations will not appear in results.
+ * @internal
+ * @returns An exchange that deduplicates in-flight operations.
+ */
+declare const dedupExchange: () => Exchange;
+//#endregion
+//#region src/cache/types.d.ts
+/**
+ * Identifier for a single entity, supporting simple or composite keys.
+ */
+type EntityId = string | number | Record<string, string | number>;
+/**
+ * Target specification for cache invalidation operations.
+ */
+type InvalidateTarget = {
+  __typename: string;
+  id: EntityId;
+} | {
+  __typename: string;
+  id: EntityId;
+  field: string;
+  args?: Record<string, unknown>;
+} | {
+  __typename: 'Query';
+} | {
+  __typename: 'Query';
+  field: string;
+  args?: Record<string, unknown>;
+} | {
+  __typename: string;
+} | {
+  __typename: string;
+  field: string;
+  args?: Record<string, unknown>;
+};
+/**
+ * Opaque type representing a serializable cache snapshot.
+ */
+type CacheSnapshot = {
+  readonly __brand: unique symbol;
+};
+/**
+ * Operations available for programmatic cache manipulation.
+ */
+type CacheOperations = {
+  extract(): CacheSnapshot;
+  hydrate(data: CacheSnapshot): void;
+  invalidate(...targets: InvalidateTarget[]): void;
+  clear(): void;
+};
+//#endregion
+//#region src/exchanges/cache.d.ts
+declare module '@mearie/core' {
+  interface ExchangeExtensionMap {
+    cache: CacheOperations;
+  }
+}
+type CacheOptions = {
+  fetchPolicy?: 'cache-first' | 'cache-and-network' | 'network-only' | 'cache-only';
+};
+declare const cacheExchange: (options?: CacheOptions) => Exchange<"cache">;
+//#endregion
+//#region src/exchanges/retry.d.ts
+declare module '@mearie/core' {
+  interface OperationMetadataMap {
+    retry?: {
+      attempt: number;
+      delay: number;
+    };
+  }
+}
+type RetryOptions = {
+  maxAttempts?: number;
+  backoff?: (attempt: number) => number;
+  shouldRetry?: (error: OperationError) => boolean;
+};
+declare const retryExchange: (options?: RetryOptions) => Exchange;
+//#endregion
+//#region src/exchanges/fragment.d.ts
+declare module '@mearie/core' {
+  interface OperationMetadataMap {
+    fragmentRef?: unknown;
+  }
+}
+declare const fragmentExchange: () => Exchange;
+//#endregion
+//#region src/exchanges/required.d.ts
+declare const requiredExchange: () => Exchange;
+//#endregion
+//#region src/exchanges/subscription.d.ts
+interface SubscriptionClient {
+  subscribe(payload: {
+    operationName?: string;
+    query: string;
+    variables?: Record<string, unknown>;
+  }, sink: {
+    next: (result: unknown) => void;
+    error: (error: unknown) => void;
+    complete: () => void;
+  }): () => void;
+}
+type SubscriptionExchangeOptions = {
+  client: SubscriptionClient;
+};
+declare module '@mearie/core' {
+  interface OperationMetadataMap {
+    subscription?: {
+      transport?: boolean;
+    };
+  }
+}
+/**
+ * Creates an exchange for handling GraphQL subscriptions using a subscription client.
+ *
+ * This exchange accepts subscription clients from graphql-ws, graphql-sse, or any client
+ * implementing the Observer pattern.
+ * @internal
+ * @param options - Configuration options for the subscription exchange.
+ * @returns An exchange that handles subscription operations.
+ * @example
+ * // With graphql-ws
+ * import { createClient } from 'graphql-ws';
+ *
+ * const wsClient = createClient({
+ *   url: 'ws://localhost:4000/graphql',
+ * });
+ *
+ * subscriptionExchange({ client: wsClient })
+ * @example
+ * // With graphql-sse
+ * import { createClient } from 'graphql-sse';
+ *
+ * const sseClient = createClient({
+ *   url: 'http://localhost:4000/graphql/stream',
+ * });
+ *
+ * subscriptionExchange({ client: sseClient })
+ */
+declare const subscriptionExchange: (options: SubscriptionExchangeOptions) => Exchange;
+//#endregion
+//#region src/required.d.ts
+type RequiredAction = 'THROW' | 'CASCADE';
+declare class RequiredFieldError extends Error {
+  fieldPath: string[];
+  fieldName: string;
+  constructor(fieldPath: string[], fieldName: string);
+}
+//#endregion
+//#region src/utils.d.ts
+/**
+ * Stable JSON serialization with sorted keys.
+ * Used for both variables and field arguments.
+ * @internal
+ * @param value - The value to stringify.
+ * @returns The stable JSON string.
+ */
+declare const stringify: (value: unknown) => string;
+//#endregion
+export { AggregatedError, type Artifact, type ArtifactKind, type CacheOptions, type CacheSnapshot, Client, type ClientOptions, type DataOf, type Exchange, ExchangeError, type ExchangeErrorExtensionsMap, type ExchangeExtensionMap, type ExchangeIO, type ExchangeResult, type FragmentOptions, type FragmentRefs, GraphQLError, type HttpOptions, type MutationOptions, type Operation, type OperationError, type OperationMetadata, type OperationMetadataMap, type OperationResult, type QueryOptions, type RequiredAction, RequiredFieldError, type RetryOptions, type SchemaMeta, type SubscriptionClient, type SubscriptionExchangeOptions, type SubscriptionOptions, type VariablesOf, cacheExchange, createClient, dedupExchange, fragmentExchange, httpExchange, isAggregatedError, isExchangeError, isGraphQLError, requiredExchange, retryExchange, stringify, subscriptionExchange };