@kontent-ai/core-sdk 12.0.0-preview.11 → 12.0.0-preview.13

package/lib/sdk/paging-sdk-query.ts

@@ -0,0 +1,253 @@
+/**
+ * Paging query helpers built on top of core query. Fetches multiple pages (continuation token or next page URL)
+ * and aggregates results.
+ */
+
+import { match, P } from "ts-pattern";
+import type { GetNextPageData, PaginationConfig, RequestBody } from "../http/http.models.js";
+import type { JsonValue } from "../models/json.models.js";
+import { createSdkError } from "../utils/error.utils.js";
+import type { NextPageStateWithRequest, PagingQuery, PagingQueryResult, QueryResponse } from "./sdk-models.js";
+import { createQuery, type QueryPromiseResult, type ResolveQueryData, resolveQueryAsync } from "./sdk-query.js";
+
+type PagingQueryPromiseResult<TResponsePayload extends JsonValue, TMeta> = ReturnType<
+	Pick<PagingQuery<TResponsePayload, TMeta>, "toAllPromise">["toAllPromise"]
+>;
+
+type NoNextPageState = {
+	readonly hasNextPage: false;
+};
+
+type NextPageState = NextPageStateWithRequest | NoNextPageState;
+
+type FetchAllPagesResult<TResponsePayload extends JsonValue, TMeta> =
+	| {
+			readonly success: true;
+			readonly responses: readonly QueryResponse<TResponsePayload, TMeta>[];
+			readonly error?: never;
+	  }
+	| {
+			readonly success: false;
+			readonly responses?: never;
+			readonly error: ReturnType<typeof createSdkError>;
+	  };
+
+export function createPagingQuery<TResponsePayload extends JsonValue, TRequestBody extends RequestBody, TMeta>(
+	data: Omit<ResolveQueryData<TResponsePayload, TRequestBody, TMeta>, "nextPageState" | "pageIndex"> & {
+		readonly getNextPageData: GetNextPageData<TResponsePayload, TMeta>;
+	},
+): PagingQuery<TResponsePayload, TMeta> {
+	const getPagingData: (
+		config: PaginationConfig | undefined,
+	) => Parameters<typeof resolvePagingQueryAsync<TResponsePayload, TRequestBody, TMeta>>[0] = (config) => {
+		return {
+			...data,
+			pageIndex: 0,
+			paginationConfig: config ?? {},
+		};
+	};
+
+	return {
+		toUrl: () => {
+			return data.request.url;
+		},
+		...createQuery<TResponsePayload, TRequestBody, TMeta>(data),
+		toAllPromise: async (config?: PaginationConfig) => {
+			return await resolvePagingQueryAsync<TResponsePayload, TRequestBody, TMeta>(getPagingData(config));
+		},
+		pages: (config?: PaginationConfig) => createPagingQueryIterator<TResponsePayload, TRequestBody, TMeta>(getPagingData(config)),
+	};
+}
+
+async function* createPagingQueryIterator<TResponsePayload extends JsonValue, TRequestBody extends RequestBody, TMeta>(
+	data: Omit<Parameters<typeof resolvePagingQueryAsync<TResponsePayload, TRequestBody, TMeta>>[0], "pageIndex">,
+): AsyncGenerator<QueryResponse<TResponsePayload, TMeta>> {
+	let nextPageState: NextPageState = { hasNextPage: true, pageSource: "firstRequest" };
+	let pageIndex: number = 0;
+
+	while (isNextPageAvailable(nextPageState)) {
+		const result: Awaited<QueryPromiseResult<TResponsePayload, TMeta>> = await resolveQueryAsync<TResponsePayload, TRequestBody, TMeta>(
+			{
+				...data,
+				nextPageState: nextPageState,
+			},
+		);
+
+		if (!result.success) {
+			throw result.error;
+		}
+
+		yield result.response;
+
+		pageIndex++;
+		nextPageState = resolveNextPageState({
+			getNextPageData: data.getNextPageData,
+			paginationConfig: data.paginationConfig,
+			pageIndex: pageIndex,
+			response: result.response,
+		});
+	}
+}
+
+function resolveNextPageState<TResponsePayload extends JsonValue, TMeta>({
+	paginationConfig,
+	getNextPageData,
+	pageIndex,
+	response,
+}: {
+	readonly getNextPageData: GetNextPageData<TResponsePayload, TMeta>;
+	readonly paginationConfig: PaginationConfig;
+	readonly pageIndex: number;
+	readonly response: QueryResponse<TResponsePayload, TMeta> | undefined;
+}): NextPageState {
+	return match({ getNextPageData, paginationConfig, pageIndex, response })
+		.returnType<NextPageState>()
+		.with({ response: undefined }, () => ({
+			hasNextPage: true,
+			pageSource: "firstRequest",
+		}))
+		.with({ paginationConfig: { maxPagesCount: 0 } }, () => ({
+			hasNextPage: false,
+		}))
+		.with({ paginationConfig: { maxPagesCount: pageIndex } }, () => ({
+			hasNextPage: false,
+		}))
+		.with({ response: P.not(undefined) }, (m) => {
+			const responsePageData = m.getNextPageData(m.response);
+
+			return match(responsePageData)
+				.returnType<NextPageState>()
+				.with({ continuationToken: P.string.minLength(1) }, (m) => ({
+					hasNextPage: true,
+					pageSource: "continuationToken",
+					continuationToken: m.continuationToken,
+				}))
+				.with({ nextPageUrl: P.string.minLength(1) }, (m) => ({
+					hasNextPage: true,
+					pageSource: "nextPageUrl",
+					nextPageUrl: m.nextPageUrl,
+				}))
+				.otherwise(() => ({
+					hasNextPage: false,
+				}));
+		})
+		.otherwise(() => {
+			return {
+				hasNextPage: false,
+			};
+		});
+}
+
+async function resolvePagingQueryAsync<TResponsePayload extends JsonValue, TRequestBody extends RequestBody, TMeta>(
+	data: Omit<ResolveQueryData<TResponsePayload, TRequestBody, TMeta>, "nextPageState" | "getNextPageData"> & {
+		readonly getNextPageData: GetNextPageData<TResponsePayload, TMeta>;
+		readonly paginationConfig: PaginationConfig;
+		readonly pageIndex: number;
+	},
+): Promise<PagingQueryPromiseResult<TResponsePayload, TMeta>> {
+	const { success, error, responses } = await fetchAllPagesAsync<TResponsePayload, TRequestBody, TMeta>(data);
+
+	if (!success) {
+		return {
+			success: false,
+			error,
+		};
+	}
+
+	return validateAndBuildPagingResult(responses, data.request.url);
+}
+
+async function fetchAllPagesAsync<TResponsePayload extends JsonValue, TRequestBody extends RequestBody, TMeta>(
+	data: Omit<ResolveQueryData<TResponsePayload, TRequestBody, TMeta>, "nextPageState"> & {
+		readonly getNextPageData: GetNextPageData<TResponsePayload, TMeta>;
+		readonly paginationConfig: PaginationConfig;
+		readonly pageIndex: number;
+	},
+): Promise<FetchAllPagesResult<TResponsePayload, TMeta>> {
+	const initialPageState: NextPageState = resolveNextPageState({
+		getNextPageData: data.getNextPageData,
+		paginationConfig: data.paginationConfig,
+		pageIndex: data.pageIndex,
+		response: undefined,
+	});
+
+	return await fetchAllPagesInternal<TResponsePayload, TRequestBody, TMeta>({
+		queryData: data,
+		nextPageState: initialPageState,
+		responses: [],
+	});
+}
+
+async function fetchAllPagesInternal<TResponsePayload extends JsonValue, TRequestBody extends RequestBody, TMeta>({
+	queryData,
+	nextPageState,
+	responses,
+}: {
+	readonly queryData: Omit<ResolveQueryData<TResponsePayload, TRequestBody, TMeta>, "nextPageState"> & {
+		readonly getNextPageData: GetNextPageData<TResponsePayload, TMeta>;
+		readonly paginationConfig: PaginationConfig;
+		readonly pageIndex: number;
+	};
+	readonly nextPageState: NextPageState;
+	readonly responses: readonly QueryResponse<TResponsePayload, TMeta>[];
+}): Promise<FetchAllPagesResult<TResponsePayload, TMeta>> {
+	if (!isNextPageAvailable(nextPageState)) {
+		return {
+			success: true,
+			responses,
+		};
+	}
+
+	const { success, error, response } = await resolveQueryAsync<TResponsePayload, TRequestBody, TMeta>({
+		...queryData,
+		nextPageState: nextPageState,
+	});
+
+	if (!success) {
+		return {
+			success: false,
+			error: error,
+		};
+	}
+
+	const updatedResponses: readonly QueryResponse<TResponsePayload, TMeta>[] = [...responses, response];
+
+	return await fetchAllPagesInternal<TResponsePayload, TRequestBody, TMeta>({
+		queryData: queryData,
+		nextPageState: resolveNextPageState({
+			getNextPageData: queryData.getNextPageData,
+			paginationConfig: queryData.paginationConfig,
+			pageIndex: updatedResponses.length,
+			response: response,
+		}),
+		responses: updatedResponses,
+	});
+}
+
+function validateAndBuildPagingResult<TResponsePayload extends JsonValue, TMeta>(
+	responses: readonly QueryResponse<TResponsePayload, TMeta>[],
+	requestUrl: string,
+): PagingQueryResult<QueryResponse<TResponsePayload, TMeta>> {
+	const lastResponse = responses.at(-1);
+
+	if (!lastResponse) {
+		return {
+			success: false,
+			error: createSdkError({
+				reason: "noResponses",
+				url: requestUrl,
+				message: "No responses were processed. Expected at least one response to be fetched when using paging queries.",
+			}),
+		};
+	}
+
+	return {
+		success: true,
+		responses: [...responses],
+		lastContinuationToken: lastResponse.meta.continuationToken,
+	};
+}
+
+function isNextPageAvailable(nextPageState: NextPageState): nextPageState is NextPageStateWithRequest {
+	return nextPageState.hasNextPage;
+}

package/lib/sdk/sdk-models.ts

@@ -5,7 +5,6 @@
 
 import type { AdapterResponse, HttpResponse, HttpService, PaginationConfig, RequestBody, ResponseData } from "../http/http.models.js";
 import type { KontentSdkError } from "../models/error.models.js";
-import type { Prettify } from "../models/utility.models.js";
 
 export type QueryResponseMeta<TMeta = unknown> = Pick<AdapterResponse, "status" | "responseHeaders" | "url"> & {
 	readonly continuationToken?: string;
@@ -47,21 +46,38 @@ export type SdkConfig = {
 	};
 };
 
-export type Query<TResponsePayload, TMeta = unknown> = {
+export type Query<TResponsePayload, TMeta> = {
 	toUrl(): string;
 	toPromise(): Promise<QueryResult<QueryResponse<TResponsePayload, TMeta>>>;
 };
 
-export type PagingQuery<TResponsePayload, TMeta = unknown> = Query<TResponsePayload, TMeta> & {
+export type PagingQuery<TResponsePayload, TMeta> = Query<TResponsePayload, TMeta> & {
 	toAllPromise(config?: PaginationConfig): Promise<PagingQueryResult<QueryResponse<TResponsePayload, TMeta>>>;
+	pages(config?: PaginationConfig): AsyncGenerator<QueryResponse<TResponsePayload, TMeta>>;
 };
 
-export type SuccessfulHttpResponse<TResponsePayload extends ResponseData, TRequestBody extends RequestBody> = Prettify<
-	Extract<HttpResponse<TResponsePayload, TRequestBody>, { readonly success: true }>["response"]
->;
+export type NextPageStateWithRequest =
+	| {
+			readonly pageSource: "continuationToken";
+			readonly hasNextPage: true;
+			readonly continuationToken: string;
+			readonly nextPageUrl?: never;
+	  }
+	| {
+			readonly pageSource: "nextPageUrl";
+			readonly hasNextPage: true;
+			readonly continuationToken?: never;
+			readonly nextPageUrl: string;
+	  }
+	| {
+			readonly pageSource: "firstRequest";
+			readonly hasNextPage: true;
+			readonly continuationToken?: never;
+			readonly nextPageUrl?: never;
+	  };
 
-export type ResultOfSuccessfulQuery<TQuery extends Query<unknown>> = Extract<
-	Awaited<ReturnType<TQuery["toPromise"]>>,
+export type SuccessfulHttpResponse<TResponsePayload extends ResponseData, TRequestBody extends RequestBody> = Extract<
+	HttpResponse<TResponsePayload, TRequestBody>,
 	{ readonly success: true }
 >["response"];
 

package/lib/sdk/sdk-query.ts

@@ -0,0 +1,190 @@
+/**
+ * Shared query models/types intended to be reused across SDKs (e.g. Sync, Delivery, Management)
+ * to keep common code and behavior consistent.
+ */
+
+import type { ZodError, ZodType } from "zod";
+import type { HttpService, RequestBody } from "../http/http.models.js";
+import { getDefaultHttpService } from "../http/http.service.js";
+import type { CommonHeaderNames, ContinuationHeaderName, Header, SDKInfo } from "../models/core.models.js";
+import type { JsonValue } from "../models/json.models.js";
+import { createSdkError } from "../utils/error.utils.js";
+import { getSdkIdHeader } from "../utils/header.utils.js";
+import type { NextPageStateWithRequest, Query, SdkConfig, SuccessfulHttpResponse } from "./sdk-models.js";
+
+export type QueryPromiseResult<TResponsePayload extends JsonValue, TMeta> = ReturnType<
+	Pick<Query<TResponsePayload, TMeta>, "toPromise">["toPromise"]
+>;
+
+type MetadataContextData = {
+	readonly continuationToken?: string;
+};
+
+type MetadataMapper<TResponsePayload extends JsonValue, TRequestBody extends RequestBody, TMeta> = (
+	response: SuccessfulHttpResponse<TResponsePayload, TRequestBody>,
+	data: MetadataContextData,
+) => TMeta;
+type MetadataMapperConfig<TResponsePayload extends JsonValue, TRequestBody extends RequestBody, TMeta> = {
+	readonly mapMetadata: MetadataMapper<TResponsePayload, TRequestBody, TMeta>;
+};
+
+export type ResolveQueryData<TResponsePayload extends JsonValue, TRequestBody extends RequestBody, TMeta> = {
+	readonly nextPageState: NextPageStateWithRequest;
+	readonly request: Parameters<HttpService["requestAsync"]>[number] & { readonly body: TRequestBody };
+	readonly config: SdkConfig;
+	readonly zodSchema: ZodType<TResponsePayload>;
+	readonly sdkInfo: SDKInfo;
+	readonly authorizationApiKey: string | undefined;
+} & MetadataMapperConfig<TResponsePayload, TRequestBody, TMeta>;
+
+export function createQuery<TResponsePayload extends JsonValue, TRequestBody extends RequestBody, TMeta>(
+	data: Omit<ResolveQueryData<TResponsePayload, TRequestBody, TMeta>, "continuationToken" | "nextPageState" | "pageIndex">,
+): Pick<Query<TResponsePayload, TMeta>, "toPromise"> {
+	return {
+		toPromise: async () => {
+			return await resolveQueryAsync<TResponsePayload, TRequestBody, TMeta>({
+				...data,
+				nextPageState: {
+					hasNextPage: true,
+					pageSource: "firstRequest",
+				},
+			});
+		},
+	};
+}
+
+export function extractContinuationToken(responseHeaders: readonly Header[]): string | undefined {
+	return responseHeaders.find((header) => header.name.toLowerCase() === ("X-Continuation" satisfies ContinuationHeaderName).toLowerCase())
+		?.value;
+}
+
+function getHttpService(config: SdkConfig) {
+	return config.httpService ?? getDefaultHttpService();
+}
+
+function getCombinedRequestHeaders({
+	requestHeaders,
+	continuationToken,
+	authorizationApiKey,
+	sdkInfo,
+}: {
+	readonly requestHeaders: readonly Header[];
+	readonly continuationToken: string | undefined;
+	readonly authorizationApiKey: string | undefined;
+	readonly sdkInfo: SDKInfo;
+}): readonly Header[] {
+	return [
+		getSdkIdHeader({
+			host: sdkInfo.host,
+			name: sdkInfo.name,
+			version: sdkInfo.version,
+		}),
+		...requestHeaders,
+		...(continuationToken
+			? [
+					{
+						name: "X-Continuation" satisfies CommonHeaderNames,
+						value: continuationToken,
+					},
+				]
+			: []),
+		...(authorizationApiKey
+			? [
+					{
+						name: "Authorization" satisfies CommonHeaderNames,
+						value: `Bearer ${authorizationApiKey}`,
+					},
+				]
+			: []),
+	];
+}
+
+export async function resolveQueryAsync<TResponsePayload extends JsonValue, TRequestBody extends RequestBody, TMeta>({
+	config,
+	request,
+	mapMetadata,
+	zodSchema,
+	sdkInfo,
+	authorizationApiKey,
+	nextPageState,
+}: ResolveQueryData<TResponsePayload, TRequestBody, TMeta>): QueryPromiseResult<TResponsePayload, TMeta> {
+	const { success, response, error } = await getHttpService(config).requestAsync<TResponsePayload, TRequestBody>({
+		body: request.body,
+		url: nextPageState?.nextPageUrl ?? request.url,
+		method: request.method,
+		requestHeaders: getCombinedRequestHeaders({
+			requestHeaders: request.requestHeaders ?? [],
+			continuationToken: nextPageState?.continuationToken,
+			authorizationApiKey: authorizationApiKey,
+			sdkInfo,
+		}),
+	});
+
+	if (!success) {
+		return {
+			success: false,
+			error,
+		};
+	}
+
+	if (config.responseValidation?.enable) {
+		const { isValid, error: validationError } = await validateResponseSchemaAsync(response.payload, zodSchema);
+		if (!isValid) {
+			return {
+				success: false,
+				error: createSdkError({
+					message: `Failed to validate response schema for url '${request.url}'`,
+					reason: "validationFailed",
+					zodError: validationError,
+					response,
+					url: request.url,
+				}),
+			};
+		}
+	}
+
+	const continuationTokenFromResponse = extractContinuationToken(response.adapterResponse.responseHeaders);
+
+	const result: Awaited<QueryPromiseResult<TResponsePayload, TMeta>> = {
+		success: true,
+		response: {
+			payload: response.payload,
+			meta: {
+				url: response.adapterResponse.url,
+				responseHeaders: response.adapterResponse.responseHeaders,
+				status: response.adapterResponse.status,
+				continuationToken: continuationTokenFromResponse,
+				...mapMetadata(response, { continuationToken: continuationTokenFromResponse }),
+			},
+		},
+	};
+
+	return result;
+}
+
+async function validateResponseSchemaAsync<TResponsePayload extends JsonValue>(
+	payload: TResponsePayload,
+	zodSchema: ZodType<TResponsePayload>,
+): Promise<
+	| {
+			readonly isValid: true;
+			readonly error?: never;
+	  }
+	| {
+			readonly isValid: false;
+			readonly error: ZodError;
+	  }
+> {
+	const validateResult = await zodSchema.safeParseAsync(payload);
+
+	if (validateResult.success) {
+		return {
+			isValid: true,
+		};
+	}
+
+	return {
+		isValid: false,
+		error: validateResult.error,
+	};
+}

package/lib/utils/error.utils.ts

@@ -8,8 +8,12 @@ export function createSdkError(details: ErrorDetails): KontentSdkError {
 	return new KontentSdkError(details);
 }
 
-export function isKontent404Error(error: KontentSdkError): boolean {
-	return error.details.reason === "notFound";
+export function isKontent404Error(error: unknown): boolean {
+	return isKontentSdkError(error) && error.details.reason === "notFound";
+}
+
+export function isKontentSdkError(error: unknown): error is KontentSdkError {
+	return error instanceof KontentSdkError;
 }
 
 export function getErrorMessage({

package/lib/utils/retry.utils.ts

@@ -106,7 +106,7 @@ export function toRequiredRetryStrategyOptions(options?: RetryStrategyOptions):
 	};
 }
 
-export function getDefaultRetryAttemptLogMessage(retryAttempt: number, maxRetries: number, url: string): string {
+function getDefaultRetryAttemptLogMessage(retryAttempt: number, maxRetries: number, url: string): string {
 	return `Retry attempt '${retryAttempt}' from a maximum of '${maxRetries}' retries. Requested url: '${url}'`;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@kontent-ai/core-sdk",
-	"version": "12.0.0-preview.11",
+	"version": "12.0.0-preview.13",
 	"repository": {
 		"type": "git",
 		"url": "https://github.com/kontent-ai/core-sdk-js"
@@ -46,23 +46,24 @@
 		"clean": "tsx scripts/clean.ts",
 		"update:version": "tsx ./scripts/update-version.ts"
 	},
-	"dependencies": {
-		"zod": "4.3.6",
-		"ts-pattern": "5.9.0"
-	},
 	"peerDependencies": {
-		"zod": "4.3.6"
+		"ts-pattern": "^5.9.0",
+		"zod": "^4.3.6"
 	},
+
 	"devDependencies": {
 		"@kontent-ai/biome-config": "0.7.0",
-		"@kontent-ai/eslint-config": "2.3.0",
-		"eslint": "10.0.0",
-		"@biomejs/biome": "2.3.15",
-		"@types/node": "25.2.3",
+		"@kontent-ai/eslint-config": "2.4.1",
+		"eslint": "10.0.2",
+		"@biomejs/biome": "2.4.4",
+		"@types/node": "25.3.0",
 		"chalk": "5.6.2",
 		"typescript": "5.9.3",
 		"vitest": "4.0.18",
-		"dotenv": "17.2.4",
+		"dotenv": "17.3.1",
 		"tsx": "4.21.0"
+	},
+	"overrides": {
+		"minimatch": "10.2.3"
 	}
 }

package/dist/sdk/sdk-queries.d.ts

@@ -1,49 +0,0 @@
-/**
- * Shared query models/types intended to be reused across SDKs (e.g. Sync, Delivery, Management)
- * to keep common code and behavior consistent.
- */
-import type { ZodType } from "zod";
-import type { GetNextPageData, HttpService, RequestBody } from "../http/http.models.js";
-import type { Header, SDKInfo } from "../models/core.models.js";
-import type { JsonValue } from "../models/json.models.js";
-import type { EmptyObject } from "../models/utility.models.js";
-import type { PagingQuery, Query, SdkConfig, SuccessfulHttpResponse } from "./sdk-models.js";
-type MetadataContextData = {
-    readonly continuationToken?: string;
-};
-type MetadataMapper<TResponsePayload extends JsonValue, TRequestBody extends RequestBody, TMeta> = (response: SuccessfulHttpResponse<TResponsePayload, TRequestBody>, data: MetadataContextData) => TMeta;
-type MetadataMapperConfig<TResponsePayload extends JsonValue, TRequestBody extends RequestBody, TMeta> = {
-    readonly mapMetadata: MetadataMapper<TResponsePayload, TRequestBody, TMeta>;
-};
-type ResolveQueryData<TResponsePayload extends JsonValue, TRequestBody extends RequestBody, TMeta> = {
-    readonly nextPageState: NextPageStateWithRequest;
-    readonly request: Parameters<HttpService["requestAsync"]>[number] & {
-        readonly body: TRequestBody;
-    };
-    readonly config: SdkConfig;
-    readonly zodSchema: ZodType<TResponsePayload>;
-    readonly sdkInfo: SDKInfo;
-    readonly authorizationApiKey: string | undefined;
-} & MetadataMapperConfig<TResponsePayload, TRequestBody, TMeta>;
-type NextPageStateWithRequest = {
-    readonly pageSource: "continuationToken";
-    readonly hasNextPage: true;
-    readonly continuationToken: string;
-    readonly nextPageUrl?: never;
-} | {
-    readonly pageSource: "nextPageUrl";
-    readonly hasNextPage: true;
-    readonly continuationToken?: never;
-    readonly nextPageUrl: string;
-} | {
-    readonly pageSource: "firstRequest";
-    readonly hasNextPage: true;
-    readonly continuationToken?: never;
-    readonly nextPageUrl?: never;
-};
-export declare function createQuery<TResponsePayload extends JsonValue, TRequestBody extends RequestBody, TMeta = EmptyObject>(data: Omit<ResolveQueryData<TResponsePayload, TRequestBody, TMeta>, "continuationToken" | "nextPageState" | "pageIndex">): Pick<Query<TResponsePayload, TMeta>, "toPromise">;
-export declare function createPagingQuery<TResponsePayload extends JsonValue, TRequestBody extends RequestBody, TMeta = EmptyObject>(data: Omit<ResolveQueryData<TResponsePayload, TRequestBody, TMeta>, "nextPageState" | "pageIndex"> & {
-    readonly getNextPageData: GetNextPageData<TResponsePayload, TMeta>;
-}): Pick<PagingQuery<TResponsePayload, TMeta>, "toPromise" | "toAllPromise">;
-export declare function extractContinuationToken(responseHeaders: readonly Header[]): string | undefined;
-export {};