Api Report Incremental.Api

import type { ApolloLink } from '@apollo/client/link';
import type { DeepPartial } from '@apollo/client/utilities';
import type { DocumentNode } from 'graphql';
import type { FormattedExecutionResult } from 'graphql';
import type { GraphQLFormattedError } from 'graphql';
import type { HKT } from '@apollo/client/utilities';

// @public (undocumented)
namespace Defer20220824Handler {
    // (undocumented)
    type Chunk<TData extends Record<string, unknown>> = InitialResult<TData> | SubsequentResult<TData>;
    // (undocumented)
    interface Defer20220824Result extends HKT {
        // (undocumented)
        arg1: unknown;
        // (undocumented)
        arg2: unknown;
        // (undocumented)
        return: Defer20220824Handler.Chunk<Record<string, unknown>>;
    }
    // (undocumented)
    type IncrementalDeferResult<TData = Record<string, unknown>> = {
        data?: TData | null;
        errors?: ReadonlyArray<GraphQLFormattedError>;
        extensions?: Record<string, unknown>;
        path?: Incremental.Path;
        label?: string;
    };
    // (undocumented)
    type IncrementalResult<TData = Record<string, unknown>> = IncrementalDeferResult<TData> | IncrementalStreamResult<TData>;
    // (undocumented)
    type IncrementalStreamResult<TData = Array<unknown>> = {
        errors?: ReadonlyArray<GraphQLFormattedError>;
        items?: TData;
        path?: Incremental.Path;
        label?: string;
        extensions?: Record<string, unknown>;
    };
    // (undocumented)
    type InitialResult<TData = Record<string, unknown>> = {
        data?: TData | null | undefined;
        errors?: ReadonlyArray<GraphQLFormattedError>;
        extensions?: Record<string, unknown>;
        hasNext: boolean;
        incremental?: ReadonlyArray<IncrementalResult<TData>>;
    };
    // (undocumented)
    type SubsequentResult<TData = Record<string, unknown>> = {
        extensions?: Record<string, unknown>;
        hasNext: boolean;
        incremental?: Array<IncrementalResult<TData>>;
    };
    // (undocumented)
    interface TypeOverrides {
        // (undocumented)
        AdditionalApolloLinkResultTypes: Defer20220824Result;
    }
}

// @public
class Defer20220824Handler implements Incremental.Handler<Defer20220824Handler.Chunk<any>> {
    // (undocumented)
    extractErrors(result: ApolloLink.Result<any>): GraphQLFormattedError[] | undefined;
    // (undocumented)
    isIncrementalResult(result: Record<string, any>): result is Defer20220824Handler.SubsequentResult | Defer20220824Handler.InitialResult;
    // (undocumented)
    prepareRequest(request: ApolloLink.Request): ApolloLink.Request;
    // Warning: (ae-forgotten-export) The symbol "DeferRequest" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    startRequest<TData extends Record<string, unknown>>(_: {
        query: DocumentNode;
    }): DeferRequest<TData>;
}
export { Defer20220824Handler }
export { Defer20220824Handler as GraphQL17Alpha2Handler }

// @public (undocumented)
class DeferRequest<TData extends Record<string, unknown>> implements Incremental.IncrementalRequest<Defer20220824Handler.Chunk<TData>, TData> {
    // (undocumented)
    handle(cacheData: TData | DeepPartial<TData> | null | undefined, chunk: Defer20220824Handler.Chunk<TData>): FormattedExecutionResult<TData>;
    // (undocumented)
    hasNext: boolean;
}

// @public (undocumented)
export namespace GraphQL17Alpha9Handler {
    // (undocumented)
    export type Chunk<TData> = InitialResult<TData> | SubsequentResult<TData>;
    // (undocumented)
    export interface CompletedResult {
        // (undocumented)
        errors?: ReadonlyArray<GraphQLFormattedError>;
        // (undocumented)
        id: string;
    }
    // (undocumented)
    export interface GraphQL17Alpha9Result extends HKT {
        // (undocumented)
        arg1: unknown;
        // (undocumented)
        arg2: unknown;
        // (undocumented)
        return: GraphQL17Alpha9Handler.Chunk<Record<string, unknown>>;
    }
    // (undocumented)
    export interface IncrementalDeferResult<TData = Record<string, unknown>> {
        // (undocumented)
        data: TData;
        // (undocumented)
        errors?: ReadonlyArray<GraphQLFormattedError>;
        // (undocumented)
        extensions?: Record<string, unknown>;
        // (undocumented)
        id: string;
        // (undocumented)
        subPath?: Incremental.Path;
    }
    // (undocumented)
    export type IncrementalResult<TData = unknown> = IncrementalDeferResult<TData> | IncrementalStreamResult<TData>;
    // (undocumented)
    export interface IncrementalStreamResult<TData = ReadonlyArray<unknown>> {
        // (undocumented)
        errors?: ReadonlyArray<GraphQLFormattedError>;
        // (undocumented)
        extensions?: Record<string, unknown>;
        // (undocumented)
        id: string;
        // (undocumented)
        items: TData;
        // (undocumented)
        subPath?: Incremental.Path;
    }
    // (undocumented)
    export type InitialResult<TData = Record<string, unknown>> = {
        data: TData;
        errors?: ReadonlyArray<GraphQLFormattedError>;
        pending: ReadonlyArray<PendingResult>;
        hasNext: boolean;
        extensions?: Record<string, unknown>;
    };
    // (undocumented)
    export interface PendingResult {
        // (undocumented)
        id: string;
        // (undocumented)
        label?: string;
        // (undocumented)
        path: Incremental.Path;
    }
    // (undocumented)
    export type SubsequentResult<TData = unknown> = {
        hasNext: boolean;
        pending?: ReadonlyArray<PendingResult>;
        incremental?: ReadonlyArray<IncrementalResult<TData>>;
        completed?: ReadonlyArray<CompletedResult>;
        extensions?: Record<string, unknown>;
    };
    // (undocumented)
    export interface TypeOverrides {
        // (undocumented)
        AdditionalApolloLinkResultTypes: GraphQL17Alpha9Result;
    }
}

// @public
export class GraphQL17Alpha9Handler implements Incremental.Handler<GraphQL17Alpha9Handler.Chunk<any>> {
    // @internal @deprecated (undocumented)
    extractErrors(result: ApolloLink.Result<any>): GraphQLFormattedError[] | undefined;
    // @internal @deprecated (undocumented)
    isIncrementalResult(result: ApolloLink.Result<any>): result is GraphQL17Alpha9Handler.InitialResult | GraphQL17Alpha9Handler.SubsequentResult;
    // @internal @deprecated (undocumented)
    prepareRequest(request: ApolloLink.Request): ApolloLink.Request;
    // Warning: (ae-forgotten-export) The symbol "IncrementalRequest" needs to be exported by the entry point index.d.ts
    //
    // @internal @deprecated (undocumented)
    startRequest<TData>(_: {
        query: DocumentNode;
    }): IncrementalRequest<TData>;
}

// @public (undocumented)
export namespace Incremental {
    // @internal @deprecated (undocumented)
    export interface Handler<Chunk extends Record<string, unknown> = Record<string, unknown>> {
        // (undocumented)
        extractErrors: (result: ApolloLink.Result<any>) => readonly GraphQLFormattedError[] | undefined | void;
        // (undocumented)
        isIncrementalResult: (result: ApolloLink.Result<any>) => result is Chunk;
        // (undocumented)
        prepareRequest: (request: ApolloLink.Request) => ApolloLink.Request;
        // (undocumented)
        startRequest: <TData extends Record<string, unknown>>(request: {
            query: DocumentNode;
        }) => IncrementalRequest<Chunk, TData>;
    }
    // (undocumented)
    export interface IncrementalRequest<Chunk extends Record<string, unknown>, TData> {
        // (undocumented)
        handle: (cacheData: TData | DeepPartial<TData> | undefined | null, chunk: Chunk) => FormattedExecutionResult<TData>;
        // (undocumented)
        hasNext: boolean;
    }
    // (undocumented)
    export type Path = ReadonlyArray<string | number>;
    // @internal @deprecated (undocumented)
    export interface StreamFieldInfo {
        // (undocumented)
        isFirstChunk: boolean;
        // (undocumented)
        isLastChunk: boolean;
    }
}

// @public (undocumented)
class IncrementalRequest<TData> implements Incremental.IncrementalRequest<GraphQL17Alpha9Handler.Chunk<TData>, TData> {
    // (undocumented)
    handle(cacheData: TData | DeepPartial<TData> | null | undefined, chunk: GraphQL17Alpha9Handler.Chunk<TData>): FormattedExecutionResult<TData>;
    // (undocumented)
    hasNext: boolean;
}

// @public (undocumented)
export namespace NotImplementedHandler {
    // (undocumented)
    export interface NotImplementedResult extends HKT {
        // (undocumented)
        arg1: unknown;
        // (undocumented)
        arg2: unknown;
        // (undocumented)
        return: never;
    }
    // (undocumented)
    export interface TypeOverrides {
        // (undocumented)
        AdditionalApolloLinkResultTypes: NotImplementedResult;
    }
}

// @public (undocumented)
export class NotImplementedHandler implements Incremental.Handler<never> {
    // (undocumented)
    extractErrors(): void;
    // (undocumented)
    isIncrementalResult(_: any): _ is never;
    // (undocumented)
    prepareRequest(request: ApolloLink.Request): ApolloLink.Request;
    // (undocumented)
    startRequest: any;
}

// (No @packageDocumentation comment for this package)