@azure-rest/onlineexperimentation 1.0.0-alpha.20250613.5

package/dist/react-native/isUnexpected.js

@@ -0,0 +1,72 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+const responseMap = {
+    "GET /experiment-metrics/{experimentMetricId}": ["200"],
+    "PATCH /experiment-metrics/{experimentMetricId}": ["200", "201"],
+    "DELETE /experiment-metrics/{experimentMetricId}": ["204"],
+    "POST /experiment-metrics:validate": ["200"],
+    "GET /experiment-metrics": ["200"],
+};
+export function isUnexpected(response) {
+    const lroOriginal = response.headers["x-ms-original-url"];
+    const url = new URL(lroOriginal ?? response.request.url);
+    const method = response.request.method;
+    let pathDetails = responseMap[`${method} ${url.pathname}`];
+    if (!pathDetails) {
+        pathDetails = getParametrizedPathSuccess(method, url.pathname);
+    }
+    return !pathDetails.includes(response.status);
+}
+function getParametrizedPathSuccess(method, path) {
+    const pathParts = path.split("/");
+    // Traverse list to match the longest candidate
+    // matchedLen: the length of candidate path
+    // matchedValue: the matched status code array
+    let matchedLen = -1, matchedValue = [];
+    // Iterate the responseMap to find a match
+    for (const [key, value] of Object.entries(responseMap)) {
+        // Extracting the path from the map key which is in format
+        // GET /path/foo
+        if (!key.startsWith(method)) {
+            continue;
+        }
+        const candidatePath = getPathFromMapKey(key);
+        // Get each part of the url path
+        const candidateParts = candidatePath.split("/");
+        // track if we have found a match to return the values found.
+        let found = true;
+        for (let i = candidateParts.length - 1, j = pathParts.length - 1; i >= 1 && j >= 1; i--, j--) {
+            if (candidateParts[i]?.startsWith("{") && candidateParts[i]?.indexOf("}") !== -1) {
+                const start = candidateParts[i].indexOf("}") + 1, end = candidateParts[i]?.length;
+                // If the current part of the candidate is a "template" part
+                // Try to use the suffix of pattern to match the path
+                // {guid} ==> $
+                // {guid}:export ==> :export$
+                const isMatched = new RegExp(`${candidateParts[i]?.slice(start, end)}`).test(pathParts[j] || "");
+                if (!isMatched) {
+                    found = false;
+                    break;
+                }
+                continue;
+            }
+            // If the candidate part is not a template and
+            // the parts don't match mark the candidate as not found
+            // to move on with the next candidate path.
+            if (candidateParts[i] !== pathParts[j]) {
+                found = false;
+                break;
+            }
+        }
+        // We finished evaluating the current candidate parts
+        // Update the matched value if and only if we found the longer pattern
+        if (found && candidatePath.length > matchedLen) {
+            matchedLen = candidatePath.length;
+            matchedValue = value;
+        }
+    }
+    return matchedValue;
+}
+function getPathFromMapKey(mapKey) {
+    const pathStart = mapKey.indexOf("/");
+    return mapKey.slice(pathStart);
+}

package/dist/react-native/logger.d.ts

@@ -0,0 +1 @@
+export declare const logger: import("@azure/logger").AzureLogger;

package/dist/react-native/logger.js

@@ -0,0 +1,4 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import { createClientLogger } from "@azure/logger";
+export const logger = createClientLogger("onlineexperimentation");

package/dist/react-native/models.d.ts

@@ -0,0 +1,104 @@
+/** Defines experiment metric metadata and computation details. */
+export interface ExperimentMetric {
+    /**
+     * Determines whether it is included in experiment analysis.
+     *
+     * Possible values: "Active", "Inactive"
+     */
+    lifecycle: LifecycleStage;
+    /** A user-friendly display name for the experiment metric shown in reports and dashboards. */
+    displayName: string;
+    /** A detailed description of the experiment metric. */
+    description: string;
+    /** Categories associated with the experiment metric. Used for organizing and filtering metrics. */
+    categories: string[];
+    /**
+     * The desired direction for changes in the metric value.
+     *
+     * Possible values: "Increase", "Decrease", "Neutral"
+     */
+    desiredDirection: DesiredDirection;
+    /** The metric definition specifying how the metric value is calculated from event data. */
+    definition: ExperimentMetricDefinition;
+}
+/** The metric definition, which determines how the metric value is calculated from event data. */
+export interface ExperimentMetricDefinitionParent {
+    type: string;
+}
+/** The definition of an EventCount metric definition. Counts the occurrences of a specified event. */
+export interface EventCountMetricDefinition extends ExperimentMetricDefinitionParent {
+    /** The type of metric. */
+    type: "EventCount";
+    /** Event to observe. */
+    event: ObservedEvent;
+}
+/** An event observed by a metric. */
+export interface ObservedEvent {
+    /** The name of the event. */
+    eventName: string;
+    /** [Optional] A condition to filter events. */
+    filter?: string;
+}
+/** The definition of a UserCount metric definition. Counts unique users who encounter a specified event. */
+export interface UserCountMetricDefinition extends ExperimentMetricDefinitionParent {
+    /** The type of metric. */
+    type: "UserCount";
+    /** Event to observe. */
+    event: ObservedEvent;
+}
+/** The definition of an EventRate metric definition. Calculates the percentage of events satisfying a specified condition. */
+export interface EventRateMetricDefinition extends ExperimentMetricDefinitionParent {
+    /** The type of metric. */
+    type: "EventRate";
+    /** Event to observe as the rate denominator. */
+    event: ObservedEvent;
+    /** The event contributes to the rate numerator if it satisfies this condition. */
+    rateCondition: string;
+}
+/** The definition of a UserRate metric definition. Calculates the percentage of users who encounter a start event and subsequently an end event. Users must encounter events in the specified order. */
+export interface UserRateMetricDefinition extends ExperimentMetricDefinitionParent {
+    /** The type of metric. */
+    type: "UserRate";
+    /** The start event to observe as the rate denominator. */
+    startEvent: ObservedEvent;
+    /** The end event to observe, which is a condition for the rate numerator. */
+    endEvent: ObservedEvent;
+}
+/** The definition of a Sum metric definition. Calculates the sum of a specified event property. Experiment analysis accounts for unequal traffic allocation. */
+export interface SumMetricDefinition extends ExperimentMetricDefinitionParent {
+    /** The type of metric. */
+    type: "Sum";
+    /** The value to aggregate. */
+    value: AggregatedValue;
+}
+/** An event property value aggregated by a metric. */
+export interface AggregatedValue {
+    /** The name of the event. */
+    eventName: string;
+    /** [Optional] A condition to filter events. */
+    filter?: string;
+    /** The key of the event property to aggregate. */
+    eventProperty: string;
+}
+/** The definition of an Average metric definition. Calculates the average value of a specified event property. */
+export interface AverageMetricDefinition extends ExperimentMetricDefinitionParent {
+    /** The type of metric. */
+    type: "Average";
+    /** The value to aggregate. */
+    value: AggregatedValue;
+}
+/** The definition of a Percentile metric definition. Calculates a specified percentile of an event property. */
+export interface PercentileMetricDefinition extends ExperimentMetricDefinitionParent {
+    /** The type of metric. */
+    type: "Percentile";
+    /** The value to aggregate, including the event name and property to measure. */
+    value: AggregatedValue;
+    /** The percentile to measure. */
+    percentile: number;
+}
+/** The metric definition, which determines how the metric value is calculated from event data. */
+export type ExperimentMetricDefinition = ExperimentMetricDefinitionParent | EventCountMetricDefinition | UserCountMetricDefinition | EventRateMetricDefinition | UserRateMetricDefinition | SumMetricDefinition | AverageMetricDefinition | PercentileMetricDefinition;
+/** Alias for LifecycleStage */
+export type LifecycleStage = string;
+/** Alias for DesiredDirection */
+export type DesiredDirection = string;

package/dist/react-native/models.js

@@ -0,0 +1,3 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+export {};

package/dist/react-native/onlineExperimentationClient.d.ts

@@ -0,0 +1,15 @@
+import type { ClientOptions } from "@azure-rest/core-client";
+import type { TokenCredential } from "@azure/core-auth";
+import type { OnlineExperimentationClient } from "./clientDefinitions.js";
+/** The optional parameters for the client */
+export interface OnlineExperimentationClientOptions extends ClientOptions {
+    /** The api version option of the client */
+    apiVersion?: string;
+}
+/**
+ * Initialize a new instance of `OnlineExperimentationClient`
+ * @param endpointParam - Endpoint URL for the Online Experimentation workspace.
+ * @param credentials - uniquely identify client credential
+ * @param options - the parameter for all optional parameters
+ */
+export default function createClient(endpointParam: string, credentials: TokenCredential, { apiVersion, ...options }?: OnlineExperimentationClientOptions): OnlineExperimentationClient;

package/dist/react-native/onlineExperimentationClient.js

@@ -0,0 +1,45 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import { getClient } from "@azure-rest/core-client";
+import { logger } from "./logger.js";
+/**
+ * Initialize a new instance of `OnlineExperimentationClient`
+ * @param endpointParam - Endpoint URL for the Online Experimentation workspace.
+ * @param credentials - uniquely identify client credential
+ * @param options - the parameter for all optional parameters
+ */
+export default function createClient(endpointParam, credentials, { apiVersion = "2025-05-31-preview", ...options } = {}) {
+    const endpointUrl = options.endpoint ?? options.baseUrl ?? `${endpointParam}`;
+    const userAgentInfo = `azsdk-js-@azure-rest/onlineexperimentation/1.0.0-beta.1`;
+    const userAgentPrefix = options.userAgentOptions && options.userAgentOptions.userAgentPrefix
+        ? `${options.userAgentOptions.userAgentPrefix} ${userAgentInfo}`
+        : `${userAgentInfo}`;
+    const clientOptions = {
+        ...options,
+        userAgentOptions: {
+            userAgentPrefix,
+        },
+        loggingOptions: {
+            logger: options.loggingOptions?.logger ?? logger.info,
+        },
+        credentials: {
+            scopes: options.credentials?.scopes ?? ["https://exp.azure.net/.default"],
+        },
+    };
+    const client = getClient(endpointUrl, credentials, clientOptions);
+    client.pipeline.removePolicy({ name: "ApiVersionPolicy" });
+    client.pipeline.addPolicy({
+        name: "ClientApiVersionPolicy",
+        sendRequest: (req, next) => {
+            // Use the apiVersion defined in request url directly
+            // Append one if there is no apiVersion and we have one at client options
+            const url = new URL(req.url);
+            if (!url.searchParams.get("api-version") && apiVersion) {
+                // eslint-disable-next-line no-param-reassign
+                req.url = `${req.url}${Array.from(url.searchParams.keys()).length > 0 ? "&" : "?"}api-version=${apiVersion}`;
+            }
+            return next(req);
+        },
+    });
+    return client;
+}

package/dist/react-native/outputModels.d.ts

@@ -0,0 +1,137 @@
+/** Defines experiment metric metadata and computation details. */
+export interface ExperimentMetricOutput {
+    /** Identifier for this experiment metric. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. */
+    readonly id: string;
+    /**
+     * Determines whether it is included in experiment analysis.
+     *
+     * Possible values: "Active", "Inactive"
+     */
+    lifecycle: LifecycleStageOutput;
+    /** A user-friendly display name for the experiment metric shown in reports and dashboards. */
+    displayName: string;
+    /** A detailed description of the experiment metric. */
+    description: string;
+    /** Categories associated with the experiment metric. Used for organizing and filtering metrics. */
+    categories: string[];
+    /**
+     * The desired direction for changes in the metric value.
+     *
+     * Possible values: "Increase", "Decrease", "Neutral"
+     */
+    desiredDirection: DesiredDirectionOutput;
+    /** The metric definition specifying how the metric value is calculated from event data. */
+    definition: ExperimentMetricDefinitionOutput;
+    /** ETag of the experiment metric. */
+    readonly eTag: string;
+    /** The timestamp (UTC) of the last modification to the experiment metric resource. */
+    readonly lastModifiedAt: string;
+}
+/** The metric definition, which determines how the metric value is calculated from event data. */
+export interface ExperimentMetricDefinitionOutputParent {
+    type: string;
+}
+/** The definition of an EventCount metric definition. Counts the occurrences of a specified event. */
+export interface EventCountMetricDefinitionOutput extends ExperimentMetricDefinitionOutputParent {
+    /** The type of metric. */
+    type: "EventCount";
+    /** Event to observe. */
+    event: ObservedEventOutput;
+}
+/** An event observed by a metric. */
+export interface ObservedEventOutput {
+    /** The name of the event. */
+    eventName: string;
+    /** [Optional] A condition to filter events. */
+    filter?: string;
+}
+/** The definition of a UserCount metric definition. Counts unique users who encounter a specified event. */
+export interface UserCountMetricDefinitionOutput extends ExperimentMetricDefinitionOutputParent {
+    /** The type of metric. */
+    type: "UserCount";
+    /** Event to observe. */
+    event: ObservedEventOutput;
+}
+/** The definition of an EventRate metric definition. Calculates the percentage of events satisfying a specified condition. */
+export interface EventRateMetricDefinitionOutput extends ExperimentMetricDefinitionOutputParent {
+    /** The type of metric. */
+    type: "EventRate";
+    /** Event to observe as the rate denominator. */
+    event: ObservedEventOutput;
+    /** The event contributes to the rate numerator if it satisfies this condition. */
+    rateCondition: string;
+}
+/** The definition of a UserRate metric definition. Calculates the percentage of users who encounter a start event and subsequently an end event. Users must encounter events in the specified order. */
+export interface UserRateMetricDefinitionOutput extends ExperimentMetricDefinitionOutputParent {
+    /** The type of metric. */
+    type: "UserRate";
+    /** The start event to observe as the rate denominator. */
+    startEvent: ObservedEventOutput;
+    /** The end event to observe, which is a condition for the rate numerator. */
+    endEvent: ObservedEventOutput;
+}
+/** The definition of a Sum metric definition. Calculates the sum of a specified event property. Experiment analysis accounts for unequal traffic allocation. */
+export interface SumMetricDefinitionOutput extends ExperimentMetricDefinitionOutputParent {
+    /** The type of metric. */
+    type: "Sum";
+    /** The value to aggregate. */
+    value: AggregatedValueOutput;
+}
+/** An event property value aggregated by a metric. */
+export interface AggregatedValueOutput {
+    /** The name of the event. */
+    eventName: string;
+    /** [Optional] A condition to filter events. */
+    filter?: string;
+    /** The key of the event property to aggregate. */
+    eventProperty: string;
+}
+/** The definition of an Average metric definition. Calculates the average value of a specified event property. */
+export interface AverageMetricDefinitionOutput extends ExperimentMetricDefinitionOutputParent {
+    /** The type of metric. */
+    type: "Average";
+    /** The value to aggregate. */
+    value: AggregatedValueOutput;
+}
+/** The definition of a Percentile metric definition. Calculates a specified percentile of an event property. */
+export interface PercentileMetricDefinitionOutput extends ExperimentMetricDefinitionOutputParent {
+    /** The type of metric. */
+    type: "Percentile";
+    /** The value to aggregate, including the event name and property to measure. */
+    value: AggregatedValueOutput;
+    /** The percentile to measure. */
+    percentile: number;
+}
+/** The result of validating an experiment metric. */
+export interface ExperimentMetricValidationResultOutput {
+    /** Indicates whether the experiment metric is valid. */
+    isValid: boolean;
+    /** Diagnostic details from the validation process. */
+    readonly diagnostics: Array<DiagnosticDetailOutput>;
+}
+/** Diagnostic details for validation errors. */
+export interface DiagnosticDetailOutput {
+    /** A human-readable error message. */
+    readonly message: string;
+    /**
+     * The diagnostic error code.
+     *
+     * Possible values: "FailedSchemaValidation", "InvalidEventCondition", "UnsupportedEventCondition", "InvalidExperimentMetricDefinition"
+     */
+    readonly code: DiagnosticCodeOutput;
+}
+/** Paged collection of ExperimentMetric items */
+export interface PagedExperimentMetricOutput {
+    /** The ExperimentMetric items on this page */
+    value: Array<ExperimentMetricOutput>;
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+/** The metric definition, which determines how the metric value is calculated from event data. */
+export type ExperimentMetricDefinitionOutput = ExperimentMetricDefinitionOutputParent | EventCountMetricDefinitionOutput | UserCountMetricDefinitionOutput | EventRateMetricDefinitionOutput | UserRateMetricDefinitionOutput | SumMetricDefinitionOutput | AverageMetricDefinitionOutput | PercentileMetricDefinitionOutput;
+/** Alias for LifecycleStageOutput */
+export type LifecycleStageOutput = string;
+/** Alias for DesiredDirectionOutput */
+export type DesiredDirectionOutput = string;
+/** Alias for DiagnosticCodeOutput */
+export type DiagnosticCodeOutput = string;

package/dist/react-native/outputModels.js

@@ -0,0 +1,3 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+export {};

package/dist/react-native/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/dist/react-native/paginateHelper.d.ts

@@ -0,0 +1,67 @@
+import type { Client, PathUncheckedResponse } from "@azure-rest/core-client";
+/**
+ * An interface that tracks the settings for paged iteration
+ */
+export interface PageSettings {
+    /**
+     * The token that keeps track of where to continue the iterator
+     */
+    continuationToken?: string;
+}
+/**
+ * An interface that allows async iterable iteration both to completion and by page.
+ */
+export interface PagedAsyncIterableIterator<TElement, TPage = TElement[], TPageSettings = PageSettings> {
+    /**
+     * The next method, part of the iteration protocol
+     */
+    next(): Promise<IteratorResult<TElement>>;
+    /**
+     * The connection to the async iterator, part of the iteration protocol
+     */
+    [Symbol.asyncIterator](): PagedAsyncIterableIterator<TElement, TPage, TPageSettings>;
+    /**
+     * Return an AsyncIterableIterator that works a page at a time
+     */
+    byPage: (settings?: TPageSettings) => AsyncIterableIterator<TPage>;
+}
+/**
+ * Helper type to extract the type of an array
+ */
+export type GetArrayType<T> = T extends Array<infer TData> ? TData : never;
+/**
+ * The type of a custom function that defines how to get a page and a link to the next one if any.
+ */
+export type GetPage<TPage> = (pageLink: string) => Promise<{
+    page: TPage;
+    nextPageLink?: string;
+}>;
+/**
+ * Options for the paging helper
+ */
+export interface PagingOptions<TResponse> {
+    /**
+     * Custom function to extract pagination details for crating the PagedAsyncIterableIterator
+     */
+    customGetPage?: GetPage<PaginateReturn<TResponse>[]>;
+}
+/**
+ * Helper type to infer the Type of the paged elements from the response type
+ * This type is generated based on the swagger information for x-ms-pageable
+ * specifically on the itemName property which indicates the property of the response
+ * where the page items are found. The default value is `value`.
+ * This type will allow us to provide strongly typed Iterator based on the response we get as second parameter
+ */
+export type PaginateReturn<TResult> = TResult extends {
+    body: {
+        value?: infer TPage;
+    };
+} ? GetArrayType<TPage> : Array<unknown>;
+/**
+ * Helper to paginate results from an initial response that follows the specification of Autorest `x-ms-pageable` extension
+ * @param client - Client to use for sending the next page requests
+ * @param initialResponse - Initial response containing the nextLink and current page of elements
+ * @param customGetPage - Optional - Function to define how to extract the page and next link to be used to paginate the results
+ * @returns - PagedAsyncIterableIterator to iterate the elements
+ */
+export declare function paginate<TResponse extends PathUncheckedResponse>(client: Client, initialResponse: TResponse, options?: PagingOptions<TResponse>): PagedAsyncIterableIterator<PaginateReturn<TResponse>>;

package/dist/react-native/paginateHelper.js

@@ -0,0 +1,136 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import { createRestError } from "@azure-rest/core-client";
+/**
+ * returns an async iterator that iterates over results. It also has a `byPage`
+ * method that returns pages of items at once.
+ *
+ * @param pagedResult - an object that specifies how to get pages.
+ * @returns a paged async iterator that iterates over results.
+ */
+function getPagedAsyncIterator(pagedResult) {
+    const iter = getItemAsyncIterator(pagedResult);
+    return {
+        next() {
+            return iter.next();
+        },
+        [Symbol.asyncIterator]() {
+            return this;
+        },
+        byPage: pagedResult?.byPage ??
+            ((settings) => {
+                const { continuationToken } = settings ?? {};
+                return getPageAsyncIterator(pagedResult, {
+                    pageLink: continuationToken,
+                });
+            }),
+    };
+}
+async function* getItemAsyncIterator(pagedResult) {
+    const pages = getPageAsyncIterator(pagedResult);
+    const firstVal = await pages.next();
+    // if the result does not have an array shape, i.e. TPage = TElement, then we return it as is
+    if (!Array.isArray(firstVal.value)) {
+        // can extract elements from this page
+        const { toElements } = pagedResult;
+        if (toElements) {
+            yield* toElements(firstVal.value);
+            for await (const page of pages) {
+                yield* toElements(page);
+            }
+        }
+        else {
+            yield firstVal.value;
+            // `pages` is of type `AsyncIterableIterator<TPage>` but TPage = TElement in this case
+            yield* pages;
+        }
+    }
+    else {
+        yield* firstVal.value;
+        for await (const page of pages) {
+            // pages is of type `AsyncIterableIterator<TPage>` so `page` is of type `TPage`. In this branch,
+            // it must be the case that `TPage = TElement[]`
+            yield* page;
+        }
+    }
+}
+async function* getPageAsyncIterator(pagedResult, options = {}) {
+    const { pageLink } = options;
+    let response = await pagedResult.getPage(pageLink ?? pagedResult.firstPageLink);
+    if (!response) {
+        return;
+    }
+    yield response.page;
+    while (response.nextPageLink) {
+        response = await pagedResult.getPage(response.nextPageLink);
+        if (!response) {
+            return;
+        }
+        yield response.page;
+    }
+}
+/**
+ * Helper to paginate results from an initial response that follows the specification of Autorest `x-ms-pageable` extension
+ * @param client - Client to use for sending the next page requests
+ * @param initialResponse - Initial response containing the nextLink and current page of elements
+ * @param customGetPage - Optional - Function to define how to extract the page and next link to be used to paginate the results
+ * @returns - PagedAsyncIterableIterator to iterate the elements
+ */
+export function paginate(client, initialResponse, options = {}) {
+    let firstRun = true;
+    const itemName = "value";
+    const nextLinkName = "nextLink";
+    const { customGetPage } = options;
+    const pagedResult = {
+        firstPageLink: "",
+        getPage: typeof customGetPage === "function"
+            ? customGetPage
+            : async (pageLink) => {
+                const result = firstRun ? initialResponse : await client.pathUnchecked(pageLink).get();
+                firstRun = false;
+                checkPagingRequest(result);
+                const nextLink = getNextLink(result.body, nextLinkName);
+                const values = getElements(result.body, itemName);
+                return {
+                    page: values,
+                    nextPageLink: nextLink,
+                };
+            },
+    };
+    return getPagedAsyncIterator(pagedResult);
+}
+/**
+ * Gets for the value of nextLink in the body
+ */
+function getNextLink(body, nextLinkName) {
+    if (!nextLinkName) {
+        return undefined;
+    }
+    const nextLink = body[nextLinkName];
+    if (typeof nextLink !== "string" && typeof nextLink !== "undefined") {
+        throw new Error(`Body Property ${nextLinkName} should be a string or undefined`);
+    }
+    return nextLink;
+}
+/**
+ * Gets the elements of the current request in the body.
+ */
+function getElements(body, itemName) {
+    const value = body[itemName];
+    // value has to be an array according to the x-ms-pageable extension.
+    // The fact that this must be an array is used above to calculate the
+    // type of elements in the page in PaginateReturn
+    if (!Array.isArray(value)) {
+        throw new Error(`Couldn't paginate response\n Body doesn't contain an array property with name: ${itemName}`);
+    }
+    return value ?? [];
+}
+/**
+ * Checks if a request failed
+ */
+function checkPagingRequest(response) {
+    const Http2xxStatusCodes = ["200", "201", "202", "203", "204", "205", "206", "207", "208", "226"];
+    if (!Http2xxStatusCodes.includes(response.status)) {
+        throw createRestError(`Pagination failed with unexpected statusCode ${response.status}`, response);
+    }
+}