// AUTO-GENERATED by scripts/generate.ts from .generated-specs. Do not edit.
import * as S from "@distilled.cloud/core/schema";
import * as API from "@distilled.cloud/core/api";
import * as T from "../traits.ts";
import {
  CloudflareProtocol,
  CloudflarePaginatedProtocol,
  type CloudflareOpError,
  type CloudflareOpContext,
} from "../protocol.ts";
import { cloudflarePaginate, ResultInfo } from "../pagination.ts";
import { CloudflareError, CloudflareRateLimited } from "../errors.ts";
import * as Retry from "../retry.ts";

export type { CloudflareOpError, CloudflareOpContext };

/** Fallback camelCase→wire mapping for opaque content (mined from the distilled SDK). */
const KEY_DICTIONARY: Record<string, string | ReadonlyArray<string>> = {
  perPage: "per_page",
  resultInfo: "result_info",
  totalCount: "total_count",
};

export class Forbidden
  extends /*@__PURE__*/ T.applyErrorMatchers(
    /*@__PURE__*/ S.TaggedError<Forbidden>()("Forbidden", {
      code: S.Number,
      message: S.String,
    }),
    [{ status: 403 }],
  ) {}

export class TestScheduleAlreadyExists
  extends /*@__PURE__*/ T.applyErrorMatchers(
    /*@__PURE__*/ S.TaggedError<TestScheduleAlreadyExists>()(
      "TestScheduleAlreadyExists",
      {
        code: S.Number,
        message: S.String,
      },
    ),
    [{ code: 400, message: { includes: "scheduled_test_already_exists" } }],
  ) {}

export class TestScheduleNotFound
  extends /*@__PURE__*/ T.applyErrorMatchers(
    /*@__PURE__*/ S.TaggedError<TestScheduleNotFound>()(
      "TestScheduleNotFound",
      {
        code: S.Number,
        message: S.String,
      },
    ),
    [
      { code: 404, message: { includes: "schedule_not_found" } },
      { status: 404 },
    ],
  ) {}

export class TestScheduleQuotaReached
  extends /*@__PURE__*/ T.applyErrorMatchers(
    /*@__PURE__*/ S.TaggedError<TestScheduleQuotaReached>()(
      "TestScheduleQuotaReached",
      {
        code: S.Number,
        message: S.String,
      },
    ),
    [{ code: 429, message: { includes: "quota reached" } }],
  ) {}

export type PagesTestsCreateRequestRegion =
  | "asia-east1"
  | "asia-northeast1"
  | "asia-northeast2"
  | "asia-south1"
  | "asia-southeast1"
  | "australia-southeast1"
  | "europe-north1"
  | "europe-southwest1"
  | "europe-west1"
  | "europe-west2"
  | "europe-west3"
  | "europe-west4"
  | "europe-west8"
  | "europe-west9"
  | "me-west1"
  | "southamerica-east1"
  | "us-central1"
  | "us-east1"
  | "us-east4"
  | "us-south1"
  | "us-west1";
export const PagesTestsCreateRequestRegion = /*@__PURE__*/ S.String;

export interface CreatePageTestRequest {
  /** Identifier. */
  zoneId: string;
  /** A URL. */
  url: string;
  /** A test region. */
  region?: PagesTestsCreateRequestRegion | (string & {});
}
export const CreatePageTestRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    zoneId: S.String.pipe(T.Label("zone_id")),
    url: S.String.pipe(T.Label()),
    region: S.optional(PagesTestsCreateRequestRegion),
  })
    .pipe(
      T.Http({
        method: "POST",
        uri: "/zones/{zone_id}/speed_api/pages/{url}/tests",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreatePageTestRequest",
}) as any as S.Schema<CreatePageTestRequest>;

export type PagesTestsCreateResponseDesktopReportDeviceType =
  | "DESKTOP"
  | "MOBILE";
export const PagesTestsCreateResponseDesktopReportDeviceType =
  /*@__PURE__*/ S.String;

export type PagesTestsCreateResponseDesktopReportErrorCode =
  | "NOT_REACHABLE"
  | "DNS_FAILURE"
  | "NOT_HTML"
  | "LIGHTHOUSE_TIMEOUT"
  | "UNKNOWN";
export const PagesTestsCreateResponseDesktopReportErrorCode =
  /*@__PURE__*/ S.String;

export interface PagesTestsCreateResponseDesktopReportError {
  /** The error code of the Lighthouse result. */
  code?: PagesTestsCreateResponseDesktopReportErrorCode | null;
  /** Detailed error message. */
  detail?: string | null;
  /** The final URL displayed to the user. */
  finalDisplayedUrl?: string | null;
}
export const PagesTestsCreateResponseDesktopReportError =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      code: S.optional(
        S.NullOr(PagesTestsCreateResponseDesktopReportErrorCode),
      ),
      detail: S.optional(S.NullOr(S.String)),
      finalDisplayedUrl: S.optional(S.NullOr(S.String)),
    }),
  ).annotate({
    identifier: "PagesTestsCreateResponseDesktopReportError",
  }) as any as S.Schema<PagesTestsCreateResponseDesktopReportError>;

export type PagesTestsCreateResponseDesktopReportState =
  | "RUNNING"
  | "COMPLETE"
  | "FAILED";
export const PagesTestsCreateResponseDesktopReportState =
  /*@__PURE__*/ S.String;

export interface PagesTestsCreateResponseDesktopReport {
  /** Cumulative Layout Shift. */
  cls?: number | null;
  /** The type of device. */
  deviceType?: PagesTestsCreateResponseDesktopReportDeviceType | null;
  error?: PagesTestsCreateResponseDesktopReportError | null;
  /** First Contentful Paint. */
  fcp?: number | null;
  /** The URL to the full Lighthouse JSON report. */
  jsonReportUrl?: string | null;
  /** Largest Contentful Paint. */
  lcp?: number | null;
  /** The Lighthouse performance score. */
  performanceScore?: number | null;
  /** Speed Index. */
  si?: number | null;
  /** The state of the Lighthouse report. */
  state?: PagesTestsCreateResponseDesktopReportState | null;
  /** Total Blocking Time. */
  tbt?: number | null;
  /** Time To First Byte. */
  ttfb?: number | null;
  /** Time To Interactive. */
  tti?: number | null;
}
export const PagesTestsCreateResponseDesktopReport = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      cls: S.optional(S.NullOr(S.Number)),
      deviceType: S.optional(
        S.NullOr(PagesTestsCreateResponseDesktopReportDeviceType),
      ),
      error: S.optional(S.NullOr(PagesTestsCreateResponseDesktopReportError)),
      fcp: S.optional(S.NullOr(S.Number)),
      jsonReportUrl: S.optional(S.NullOr(S.String)),
      lcp: S.optional(S.NullOr(S.Number)),
      performanceScore: S.optional(S.NullOr(S.Number)),
      si: S.optional(S.NullOr(S.Number)),
      state: S.optional(S.NullOr(PagesTestsCreateResponseDesktopReportState)),
      tbt: S.optional(S.NullOr(S.Number)),
      ttfb: S.optional(S.NullOr(S.Number)),
      tti: S.optional(S.NullOr(S.Number)),
    }),
).annotate({
  identifier: "PagesTestsCreateResponseDesktopReport",
}) as any as S.Schema<PagesTestsCreateResponseDesktopReport>;

export type PagesTestsCreateResponseRegionValue =
  | "asia-east1"
  | "asia-northeast1"
  | "asia-northeast2"
  | "asia-south1"
  | "asia-southeast1"
  | "australia-southeast1"
  | "europe-north1"
  | "europe-southwest1"
  | "europe-west1"
  | "europe-west2"
  | "europe-west3"
  | "europe-west4"
  | "europe-west8"
  | "europe-west9"
  | "me-west1"
  | "southamerica-east1"
  | "us-central1"
  | "us-east1"
  | "us-east4"
  | "us-south1"
  | "us-west1";
export const PagesTestsCreateResponseRegionValue = /*@__PURE__*/ S.String;

export interface PagesTestsCreateResponseRegion {
  label?: string | null;
  /** A test region. */
  value?: PagesTestsCreateResponseRegionValue | null;
}
export const PagesTestsCreateResponseRegion = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    label: S.optional(S.NullOr(S.String)),
    value: S.optional(S.NullOr(PagesTestsCreateResponseRegionValue)),
  }),
).annotate({
  identifier: "PagesTestsCreateResponseRegion",
}) as any as S.Schema<PagesTestsCreateResponseRegion>;

export type PagesTestsCreateResponseScheduleFrequency = "DAILY" | "WEEKLY";
export const PagesTestsCreateResponseScheduleFrequency = /*@__PURE__*/ S.String;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface CreatePageTestResponse {
  /** UUID. */
  id?: string | null;
  date?: string | null;
  /** The Lighthouse report. */
  desktopReport?: PagesTestsCreateResponseDesktopReport | null;
  /** The Lighthouse report. */
  mobileReport?: PagesTestsCreateResponseDesktopReport | null;
  /** A test region with a label. */
  region?: PagesTestsCreateResponseRegion | null;
  /** The frequency of the test. */
  scheduleFrequency?: PagesTestsCreateResponseScheduleFrequency | null;
  /** A URL. */
  url?: string | null;
}
export const CreatePageTestResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.optional(S.NullOr(S.String)),
    date: S.optional(S.NullOr(S.String)),
    desktopReport: S.optional(S.NullOr(PagesTestsCreateResponseDesktopReport)),
    mobileReport: S.optional(S.NullOr(PagesTestsCreateResponseDesktopReport)),
    region: S.optional(S.NullOr(PagesTestsCreateResponseRegion)),
    scheduleFrequency: S.optional(
      S.NullOr(PagesTestsCreateResponseScheduleFrequency),
    ),
    url: S.optional(S.NullOr(S.String)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreatePageTestResponse",
}) as any as S.Schema<CreatePageTestResponse>;

export type ScheduleCreateRequestFrequency = "DAILY" | "WEEKLY";
export const ScheduleCreateRequestFrequency = /*@__PURE__*/ S.String;

export type ScheduleCreateRequestRegion =
  | "asia-east1"
  | "asia-northeast1"
  | "asia-northeast2"
  | "asia-south1"
  | "asia-southeast1"
  | "australia-southeast1"
  | "europe-north1"
  | "europe-southwest1"
  | "europe-west1"
  | "europe-west2"
  | "europe-west3"
  | "europe-west4"
  | "europe-west8"
  | "europe-west9"
  | "me-west1"
  | "southamerica-east1"
  | "us-central1"
  | "us-east1"
  | "us-east4"
  | "us-south1"
  | "us-west1";
export const ScheduleCreateRequestRegion = /*@__PURE__*/ S.String;

export interface CreateScheduleRequest {
  /** Identifier. */
  zoneId: string;
  /** A URL. */
  url: string;
  /** The frequency of the scheduled test. Defaults to WEEKLY for free plans, DAILY for paid plans. */
  frequency?: ScheduleCreateRequestFrequency | (string & {});
  /** A test region. */
  region?: ScheduleCreateRequestRegion | (string & {});
}
export const CreateScheduleRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    zoneId: S.String.pipe(T.Label("zone_id")),
    url: S.String.pipe(T.Label()),
    frequency: S.optional(ScheduleCreateRequestFrequency.pipe(T.Query())),
    region: S.optional(ScheduleCreateRequestRegion.pipe(T.Query())),
  })
    .pipe(
      T.Http({
        method: "POST",
        uri: "/zones/{zone_id}/speed_api/schedule/{url}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateScheduleRequest",
}) as any as S.Schema<CreateScheduleRequest>;

export type ScheduleCreateResponseScheduleFrequency = "DAILY" | "WEEKLY";
export const ScheduleCreateResponseScheduleFrequency = /*@__PURE__*/ S.String;

export type ScheduleCreateResponseScheduleRegion =
  | "asia-east1"
  | "asia-northeast1"
  | "asia-northeast2"
  | "asia-south1"
  | "asia-southeast1"
  | "australia-southeast1"
  | "europe-north1"
  | "europe-southwest1"
  | "europe-west1"
  | "europe-west2"
  | "europe-west3"
  | "europe-west4"
  | "europe-west8"
  | "europe-west9"
  | "me-west1"
  | "southamerica-east1"
  | "us-central1"
  | "us-east1"
  | "us-east4"
  | "us-south1"
  | "us-west1";
export const ScheduleCreateResponseScheduleRegion = /*@__PURE__*/ S.String;

export interface ScheduleCreateResponseSchedule {
  /** The frequency of the test. */
  frequency?: ScheduleCreateResponseScheduleFrequency | null;
  /** A test region. */
  region?: ScheduleCreateResponseScheduleRegion | null;
  /** A URL. */
  url?: string | null;
}
export const ScheduleCreateResponseSchedule = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    frequency: S.optional(S.NullOr(ScheduleCreateResponseScheduleFrequency)),
    region: S.optional(S.NullOr(ScheduleCreateResponseScheduleRegion)),
    url: S.optional(S.NullOr(S.String)),
  }),
).annotate({
  identifier: "ScheduleCreateResponseSchedule",
}) as any as S.Schema<ScheduleCreateResponseSchedule>;

export type ScheduleCreateResponseTestDesktopReportDeviceType =
  | "DESKTOP"
  | "MOBILE";
export const ScheduleCreateResponseTestDesktopReportDeviceType =
  /*@__PURE__*/ S.String;

export type ScheduleCreateResponseTestDesktopReportErrorCode =
  | "NOT_REACHABLE"
  | "DNS_FAILURE"
  | "NOT_HTML"
  | "LIGHTHOUSE_TIMEOUT"
  | "UNKNOWN";
export const ScheduleCreateResponseTestDesktopReportErrorCode =
  /*@__PURE__*/ S.String;

export interface ScheduleCreateResponseTestDesktopReportError {
  /** The error code of the Lighthouse result. */
  code?: ScheduleCreateResponseTestDesktopReportErrorCode | null;
  /** Detailed error message. */
  detail?: string | null;
  /** The final URL displayed to the user. */
  finalDisplayedUrl?: string | null;
}
export const ScheduleCreateResponseTestDesktopReportError =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      code: S.optional(
        S.NullOr(ScheduleCreateResponseTestDesktopReportErrorCode),
      ),
      detail: S.optional(S.NullOr(S.String)),
      finalDisplayedUrl: S.optional(S.NullOr(S.String)),
    }),
  ).annotate({
    identifier: "ScheduleCreateResponseTestDesktopReportError",
  }) as any as S.Schema<ScheduleCreateResponseTestDesktopReportError>;

export type ScheduleCreateResponseTestDesktopReportState =
  | "RUNNING"
  | "COMPLETE"
  | "FAILED";
export const ScheduleCreateResponseTestDesktopReportState =
  /*@__PURE__*/ S.String;

export interface ScheduleCreateResponseTestDesktopReport {
  /** Cumulative Layout Shift. */
  cls?: number | null;
  /** The type of device. */
  deviceType?: ScheduleCreateResponseTestDesktopReportDeviceType | null;
  error?: ScheduleCreateResponseTestDesktopReportError | null;
  /** First Contentful Paint. */
  fcp?: number | null;
  /** The URL to the full Lighthouse JSON report. */
  jsonReportUrl?: string | null;
  /** Largest Contentful Paint. */
  lcp?: number | null;
  /** The Lighthouse performance score. */
  performanceScore?: number | null;
  /** Speed Index. */
  si?: number | null;
  /** The state of the Lighthouse report. */
  state?: ScheduleCreateResponseTestDesktopReportState | null;
  /** Total Blocking Time. */
  tbt?: number | null;
  /** Time To First Byte. */
  ttfb?: number | null;
  /** Time To Interactive. */
  tti?: number | null;
}
export const ScheduleCreateResponseTestDesktopReport = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      cls: S.optional(S.NullOr(S.Number)),
      deviceType: S.optional(
        S.NullOr(ScheduleCreateResponseTestDesktopReportDeviceType),
      ),
      error: S.optional(S.NullOr(ScheduleCreateResponseTestDesktopReportError)),
      fcp: S.optional(S.NullOr(S.Number)),
      jsonReportUrl: S.optional(S.NullOr(S.String)),
      lcp: S.optional(S.NullOr(S.Number)),
      performanceScore: S.optional(S.NullOr(S.Number)),
      si: S.optional(S.NullOr(S.Number)),
      state: S.optional(S.NullOr(ScheduleCreateResponseTestDesktopReportState)),
      tbt: S.optional(S.NullOr(S.Number)),
      ttfb: S.optional(S.NullOr(S.Number)),
      tti: S.optional(S.NullOr(S.Number)),
    }),
).annotate({
  identifier: "ScheduleCreateResponseTestDesktopReport",
}) as any as S.Schema<ScheduleCreateResponseTestDesktopReport>;

export type ScheduleCreateResponseTestRegionValue =
  | "asia-east1"
  | "asia-northeast1"
  | "asia-northeast2"
  | "asia-south1"
  | "asia-southeast1"
  | "australia-southeast1"
  | "europe-north1"
  | "europe-southwest1"
  | "europe-west1"
  | "europe-west2"
  | "europe-west3"
  | "europe-west4"
  | "europe-west8"
  | "europe-west9"
  | "me-west1"
  | "southamerica-east1"
  | "us-central1"
  | "us-east1"
  | "us-east4"
  | "us-south1"
  | "us-west1";
export const ScheduleCreateResponseTestRegionValue = /*@__PURE__*/ S.String;

export interface ScheduleCreateResponseTestRegion {
  label?: string | null;
  /** A test region. */
  value?: ScheduleCreateResponseTestRegionValue | null;
}
export const ScheduleCreateResponseTestRegion = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    label: S.optional(S.NullOr(S.String)),
    value: S.optional(S.NullOr(ScheduleCreateResponseTestRegionValue)),
  }),
).annotate({
  identifier: "ScheduleCreateResponseTestRegion",
}) as any as S.Schema<ScheduleCreateResponseTestRegion>;

export type ScheduleCreateResponseTestScheduleFrequency = "DAILY" | "WEEKLY";
export const ScheduleCreateResponseTestScheduleFrequency =
  /*@__PURE__*/ S.String;

export interface ScheduleCreateResponseTest {
  /** UUID. */
  id?: string | null;
  date?: string | null;
  /** The Lighthouse report. */
  desktopReport?: ScheduleCreateResponseTestDesktopReport | null;
  /** The Lighthouse report. */
  mobileReport?: ScheduleCreateResponseTestDesktopReport | null;
  /** A test region with a label. */
  region?: ScheduleCreateResponseTestRegion | null;
  /** The frequency of the test. */
  scheduleFrequency?: ScheduleCreateResponseTestScheduleFrequency | null;
  /** A URL. */
  url?: string | null;
}
export const ScheduleCreateResponseTest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.optional(S.NullOr(S.String)),
    date: S.optional(S.NullOr(S.String)),
    desktopReport: S.optional(
      S.NullOr(ScheduleCreateResponseTestDesktopReport),
    ),
    mobileReport: S.optional(S.NullOr(ScheduleCreateResponseTestDesktopReport)),
    region: S.optional(S.NullOr(ScheduleCreateResponseTestRegion)),
    scheduleFrequency: S.optional(
      S.NullOr(ScheduleCreateResponseTestScheduleFrequency),
    ),
    url: S.optional(S.NullOr(S.String)),
  }),
).annotate({
  identifier: "ScheduleCreateResponseTest",
}) as any as S.Schema<ScheduleCreateResponseTest>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface CreateScheduleResponse {
  /** The test schedule. */
  schedule?: ScheduleCreateResponseSchedule | null;
  test?: ScheduleCreateResponseTest | null;
}
export const CreateScheduleResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    schedule: S.optional(S.NullOr(ScheduleCreateResponseSchedule)),
    test: S.optional(S.NullOr(ScheduleCreateResponseTest)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateScheduleResponse",
}) as any as S.Schema<CreateScheduleResponse>;

export type PagesTestsDeleteRequestRegion =
  | "asia-east1"
  | "asia-northeast1"
  | "asia-northeast2"
  | "asia-south1"
  | "asia-southeast1"
  | "australia-southeast1"
  | "europe-north1"
  | "europe-southwest1"
  | "europe-west1"
  | "europe-west2"
  | "europe-west3"
  | "europe-west4"
  | "europe-west8"
  | "europe-west9"
  | "me-west1"
  | "southamerica-east1"
  | "us-central1"
  | "us-east1"
  | "us-east4"
  | "us-south1"
  | "us-west1";
export const PagesTestsDeleteRequestRegion = /*@__PURE__*/ S.String;

export interface DeletePageTestRequest {
  /** Identifier. */
  zoneId: string;
  /** A URL. */
  url: string;
  /** A test region. */
  region?: PagesTestsDeleteRequestRegion | (string & {});
}
export const DeletePageTestRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    zoneId: S.String.pipe(T.Label("zone_id")),
    url: S.String.pipe(T.Label()),
    region: S.optional(PagesTestsDeleteRequestRegion.pipe(T.Query())),
  })
    .pipe(
      T.Http({
        method: "DELETE",
        uri: "/zones/{zone_id}/speed_api/pages/{url}/tests",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeletePageTestRequest",
}) as any as S.Schema<DeletePageTestRequest>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface DeletePageTestResponse {
  /** Number of items affected. */
  count?: number | null;
}
export const DeletePageTestResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    count: S.optional(S.NullOr(S.Number)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeletePageTestResponse",
}) as any as S.Schema<DeletePageTestResponse>;

export type ScheduleDeleteRequestRegion =
  | "asia-east1"
  | "asia-northeast1"
  | "asia-northeast2"
  | "asia-south1"
  | "asia-southeast1"
  | "australia-southeast1"
  | "europe-north1"
  | "europe-southwest1"
  | "europe-west1"
  | "europe-west2"
  | "europe-west3"
  | "europe-west4"
  | "europe-west8"
  | "europe-west9"
  | "me-west1"
  | "southamerica-east1"
  | "us-central1"
  | "us-east1"
  | "us-east4"
  | "us-south1"
  | "us-west1";
export const ScheduleDeleteRequestRegion = /*@__PURE__*/ S.String;

export interface DeleteScheduleRequest {
  /** Identifier. */
  zoneId: string;
  /** A URL. */
  url: string;
  /** A test region. */
  region?: ScheduleDeleteRequestRegion | (string & {});
}
export const DeleteScheduleRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    zoneId: S.String.pipe(T.Label("zone_id")),
    url: S.String.pipe(T.Label()),
    region: S.optional(ScheduleDeleteRequestRegion.pipe(T.Query())),
  })
    .pipe(
      T.Http({
        method: "DELETE",
        uri: "/zones/{zone_id}/speed_api/schedule/{url}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteScheduleRequest",
}) as any as S.Schema<DeleteScheduleRequest>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface DeleteScheduleResponse {
  /** Number of items affected. */
  count?: number | null;
}
export const DeleteScheduleResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    count: S.optional(S.NullOr(S.Number)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteScheduleResponse",
}) as any as S.Schema<DeleteScheduleResponse>;

export interface GetPageTestRequest {
  /** Identifier. */
  zoneId: string;
  /** A URL. */
  url: string;
  testId: string;
}
export const GetPageTestRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    zoneId: S.String.pipe(T.Label("zone_id")),
    url: S.String.pipe(T.Label()),
    testId: S.String.pipe(T.Label("test_id")),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/zones/{zone_id}/speed_api/pages/{url}/tests/{test_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetPageTestRequest",
}) as any as S.Schema<GetPageTestRequest>;

export type PagesTestsGetResponseDesktopReportDeviceType = "DESKTOP" | "MOBILE";
export const PagesTestsGetResponseDesktopReportDeviceType =
  /*@__PURE__*/ S.String;

export type PagesTestsGetResponseDesktopReportErrorCode =
  | "NOT_REACHABLE"
  | "DNS_FAILURE"
  | "NOT_HTML"
  | "LIGHTHOUSE_TIMEOUT"
  | "UNKNOWN";
export const PagesTestsGetResponseDesktopReportErrorCode =
  /*@__PURE__*/ S.String;

export interface PagesTestsGetResponseDesktopReportError {
  /** The error code of the Lighthouse result. */
  code?: PagesTestsGetResponseDesktopReportErrorCode | null;
  /** Detailed error message. */
  detail?: string | null;
  /** The final URL displayed to the user. */
  finalDisplayedUrl?: string | null;
}
export const PagesTestsGetResponseDesktopReportError = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      code: S.optional(S.NullOr(PagesTestsGetResponseDesktopReportErrorCode)),
      detail: S.optional(S.NullOr(S.String)),
      finalDisplayedUrl: S.optional(S.NullOr(S.String)),
    }),
).annotate({
  identifier: "PagesTestsGetResponseDesktopReportError",
}) as any as S.Schema<PagesTestsGetResponseDesktopReportError>;

export type PagesTestsGetResponseDesktopReportState =
  | "RUNNING"
  | "COMPLETE"
  | "FAILED";
export const PagesTestsGetResponseDesktopReportState = /*@__PURE__*/ S.String;

export interface PagesTestsGetResponseDesktopReport {
  /** Cumulative Layout Shift. */
  cls?: number | null;
  /** The type of device. */
  deviceType?: PagesTestsGetResponseDesktopReportDeviceType | null;
  error?: PagesTestsGetResponseDesktopReportError | null;
  /** First Contentful Paint. */
  fcp?: number | null;
  /** The URL to the full Lighthouse JSON report. */
  jsonReportUrl?: string | null;
  /** Largest Contentful Paint. */
  lcp?: number | null;
  /** The Lighthouse performance score. */
  performanceScore?: number | null;
  /** Speed Index. */
  si?: number | null;
  /** The state of the Lighthouse report. */
  state?: PagesTestsGetResponseDesktopReportState | null;
  /** Total Blocking Time. */
  tbt?: number | null;
  /** Time To First Byte. */
  ttfb?: number | null;
  /** Time To Interactive. */
  tti?: number | null;
}
export const PagesTestsGetResponseDesktopReport = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    cls: S.optional(S.NullOr(S.Number)),
    deviceType: S.optional(
      S.NullOr(PagesTestsGetResponseDesktopReportDeviceType),
    ),
    error: S.optional(S.NullOr(PagesTestsGetResponseDesktopReportError)),
    fcp: S.optional(S.NullOr(S.Number)),
    jsonReportUrl: S.optional(S.NullOr(S.String)),
    lcp: S.optional(S.NullOr(S.Number)),
    performanceScore: S.optional(S.NullOr(S.Number)),
    si: S.optional(S.NullOr(S.Number)),
    state: S.optional(S.NullOr(PagesTestsGetResponseDesktopReportState)),
    tbt: S.optional(S.NullOr(S.Number)),
    ttfb: S.optional(S.NullOr(S.Number)),
    tti: S.optional(S.NullOr(S.Number)),
  }),
).annotate({
  identifier: "PagesTestsGetResponseDesktopReport",
}) as any as S.Schema<PagesTestsGetResponseDesktopReport>;

export type PagesTestsGetResponseRegionValue =
  | "asia-east1"
  | "asia-northeast1"
  | "asia-northeast2"
  | "asia-south1"
  | "asia-southeast1"
  | "australia-southeast1"
  | "europe-north1"
  | "europe-southwest1"
  | "europe-west1"
  | "europe-west2"
  | "europe-west3"
  | "europe-west4"
  | "europe-west8"
  | "europe-west9"
  | "me-west1"
  | "southamerica-east1"
  | "us-central1"
  | "us-east1"
  | "us-east4"
  | "us-south1"
  | "us-west1";
export const PagesTestsGetResponseRegionValue = /*@__PURE__*/ S.String;

export interface PagesTestsGetResponseRegion {
  label?: string | null;
  /** A test region. */
  value?: PagesTestsGetResponseRegionValue | null;
}
export const PagesTestsGetResponseRegion = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    label: S.optional(S.NullOr(S.String)),
    value: S.optional(S.NullOr(PagesTestsGetResponseRegionValue)),
  }),
).annotate({
  identifier: "PagesTestsGetResponseRegion",
}) as any as S.Schema<PagesTestsGetResponseRegion>;

export type PagesTestsGetResponseScheduleFrequency = "DAILY" | "WEEKLY";
export const PagesTestsGetResponseScheduleFrequency = /*@__PURE__*/ S.String;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface GetPageTestResponse {
  /** UUID. */
  id?: string | null;
  date?: string | null;
  /** The Lighthouse report. */
  desktopReport?: PagesTestsGetResponseDesktopReport | null;
  /** The Lighthouse report. */
  mobileReport?: PagesTestsGetResponseDesktopReport | null;
  /** A test region with a label. */
  region?: PagesTestsGetResponseRegion | null;
  /** The frequency of the test. */
  scheduleFrequency?: PagesTestsGetResponseScheduleFrequency | null;
  /** A URL. */
  url?: string | null;
}
export const GetPageTestResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.optional(S.NullOr(S.String)),
    date: S.optional(S.NullOr(S.String)),
    desktopReport: S.optional(S.NullOr(PagesTestsGetResponseDesktopReport)),
    mobileReport: S.optional(S.NullOr(PagesTestsGetResponseDesktopReport)),
    region: S.optional(S.NullOr(PagesTestsGetResponseRegion)),
    scheduleFrequency: S.optional(
      S.NullOr(PagesTestsGetResponseScheduleFrequency),
    ),
    url: S.optional(S.NullOr(S.String)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetPageTestResponse",
}) as any as S.Schema<GetPageTestResponse>;

export type ScheduleGetRequestRegion =
  | "asia-east1"
  | "asia-northeast1"
  | "asia-northeast2"
  | "asia-south1"
  | "asia-southeast1"
  | "australia-southeast1"
  | "europe-north1"
  | "europe-southwest1"
  | "europe-west1"
  | "europe-west2"
  | "europe-west3"
  | "europe-west4"
  | "europe-west8"
  | "europe-west9"
  | "me-west1"
  | "southamerica-east1"
  | "us-central1"
  | "us-east1"
  | "us-east4"
  | "us-south1"
  | "us-west1";
export const ScheduleGetRequestRegion = /*@__PURE__*/ S.String;

export interface GetScheduleRequest {
  /** Identifier. */
  zoneId: string;
  /** A URL. */
  url: string;
  /** A test region. */
  region?: ScheduleGetRequestRegion | (string & {});
}
export const GetScheduleRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    zoneId: S.String.pipe(T.Label("zone_id")),
    url: S.String.pipe(T.Label()),
    region: S.optional(ScheduleGetRequestRegion.pipe(T.Query())),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/zones/{zone_id}/speed_api/schedule/{url}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetScheduleRequest",
}) as any as S.Schema<GetScheduleRequest>;

export type ScheduleGetResponseFrequency = "DAILY" | "WEEKLY";
export const ScheduleGetResponseFrequency = /*@__PURE__*/ S.String;

export type ScheduleGetResponseRegion =
  | "asia-east1"
  | "asia-northeast1"
  | "asia-northeast2"
  | "asia-south1"
  | "asia-southeast1"
  | "australia-southeast1"
  | "europe-north1"
  | "europe-southwest1"
  | "europe-west1"
  | "europe-west2"
  | "europe-west3"
  | "europe-west4"
  | "europe-west8"
  | "europe-west9"
  | "me-west1"
  | "southamerica-east1"
  | "us-central1"
  | "us-east1"
  | "us-east4"
  | "us-south1"
  | "us-west1";
export const ScheduleGetResponseRegion = /*@__PURE__*/ S.String;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface GetScheduleResponse {
  /** The frequency of the test. */
  frequency?: ScheduleGetResponseFrequency | null;
  /** A test region. */
  region?: ScheduleGetResponseRegion | null;
  /** A URL. */
  url?: string | null;
}
export const GetScheduleResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    frequency: S.optional(S.NullOr(ScheduleGetResponseFrequency)),
    region: S.optional(S.NullOr(ScheduleGetResponseRegion)),
    url: S.optional(S.NullOr(S.String)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetScheduleResponse",
}) as any as S.Schema<GetScheduleResponse>;

export interface ListAvailabilitiesRequest {
  /** Identifier. */
  zoneId: string;
}
export const ListAvailabilitiesRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    zoneId: S.String.pipe(T.Label("zone_id")),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/zones/{zone_id}/speed_api/availabilities",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListAvailabilitiesRequest",
}) as any as S.Schema<ListAvailabilitiesRequest>;

export interface AvailabilitiesListResponseQuotaQuotasPerPlanValue {
  business?: number | null;
  enterprise?: number | null;
  free?: number | null;
  pro?: number | null;
}
export const AvailabilitiesListResponseQuotaQuotasPerPlanValue =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      business: S.optional(S.NullOr(S.Number)),
      enterprise: S.optional(S.NullOr(S.Number)),
      free: S.optional(S.NullOr(S.Number)),
      pro: S.optional(S.NullOr(S.Number)),
    }),
  ).annotate({
    identifier: "AvailabilitiesListResponseQuotaQuotasPerPlanValue",
  }) as any as S.Schema<AvailabilitiesListResponseQuotaQuotasPerPlanValue>;

export interface AvailabilitiesListResponseQuotaQuotasPerPlan {
  /** Counts per account plan. */
  value?: AvailabilitiesListResponseQuotaQuotasPerPlanValue | null;
}
export const AvailabilitiesListResponseQuotaQuotasPerPlan =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      value: S.optional(
        S.NullOr(AvailabilitiesListResponseQuotaQuotasPerPlanValue),
      ),
    }),
  ).annotate({
    identifier: "AvailabilitiesListResponseQuotaQuotasPerPlan",
  }) as any as S.Schema<AvailabilitiesListResponseQuotaQuotasPerPlan>;

export type AvailabilitiesListResponseQuotaScheduleQuotasPerPlanValue =
  AvailabilitiesListResponseQuotaQuotasPerPlanValue;
export const AvailabilitiesListResponseQuotaScheduleQuotasPerPlanValue =
  AvailabilitiesListResponseQuotaQuotasPerPlanValue;

export type AvailabilitiesListResponseQuotaScheduleQuotasPerPlan =
  AvailabilitiesListResponseQuotaQuotasPerPlan;
export const AvailabilitiesListResponseQuotaScheduleQuotasPerPlan =
  AvailabilitiesListResponseQuotaQuotasPerPlan;

export interface AvailabilitiesListResponseQuota {
  /** Cloudflare plan. */
  plan?: string | null;
  /** The number of tests available per plan. */
  quotasPerPlan?: AvailabilitiesListResponseQuotaQuotasPerPlan | null;
  /** The number of remaining schedules available. */
  remainingSchedules?: number | null;
  /** The number of remaining tests available. */
  remainingTests?: number | null;
  /** The number of schedules available per plan. */
  scheduleQuotasPerPlan?: AvailabilitiesListResponseQuotaQuotasPerPlan | null;
}
export const AvailabilitiesListResponseQuota = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    plan: S.optional(S.NullOr(S.String)),
    quotasPerPlan: S.optional(
      S.NullOr(AvailabilitiesListResponseQuotaQuotasPerPlan),
    ),
    remainingSchedules: S.optional(S.NullOr(S.Number)),
    remainingTests: S.optional(S.NullOr(S.Number)),
    scheduleQuotasPerPlan: S.optional(
      S.NullOr(AvailabilitiesListResponseQuotaQuotasPerPlan),
    ),
  }),
).annotate({
  identifier: "AvailabilitiesListResponseQuota",
}) as any as S.Schema<AvailabilitiesListResponseQuota>;

export type AvailabilitiesListResponseRegionsItemValue =
  | "asia-east1"
  | "asia-northeast1"
  | "asia-northeast2"
  | "asia-south1"
  | "asia-southeast1"
  | "australia-southeast1"
  | "europe-north1"
  | "europe-southwest1"
  | "europe-west1"
  | "europe-west2"
  | "europe-west3"
  | "europe-west4"
  | "europe-west8"
  | "europe-west9"
  | "me-west1"
  | "southamerica-east1"
  | "us-central1"
  | "us-east1"
  | "us-east4"
  | "us-south1"
  | "us-west1";
export const AvailabilitiesListResponseRegionsItemValue =
  /*@__PURE__*/ S.String;

export interface AvailabilitiesListResponseRegionsItem {
  label?: string | null;
  /** A test region. */
  value?: AvailabilitiesListResponseRegionsItemValue | null;
}
export const AvailabilitiesListResponseRegionsItem = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      label: S.optional(S.NullOr(S.String)),
      value: S.optional(S.NullOr(AvailabilitiesListResponseRegionsItemValue)),
    }),
).annotate({
  identifier: "AvailabilitiesListResponseRegionsItem",
}) as any as S.Schema<AvailabilitiesListResponseRegionsItem>;

export type AvailabilitiesListResponseRegionsList =
  Array<AvailabilitiesListResponseRegionsItem>;
export const AvailabilitiesListResponseRegionsList = /*@__PURE__*/ S.Array(
  AvailabilitiesListResponseRegionsItem,
) as any as S.Schema<AvailabilitiesListResponseRegionsList>;

export interface AvailabilitiesListResponseRegionsPerPlanBusinessItem {
  label?: string | null;
  /** A test region. */
  value?: string | null;
}
export const AvailabilitiesListResponseRegionsPerPlanBusinessItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      label: S.optional(S.NullOr(S.String)),
      value: S.optional(S.NullOr(S.String)),
    }),
  ).annotate({
    identifier: "AvailabilitiesListResponseRegionsPerPlanBusinessItem",
  }) as any as S.Schema<AvailabilitiesListResponseRegionsPerPlanBusinessItem>;

export type AvailabilitiesListResponseRegionsPerPlanBusinessList =
  Array<AvailabilitiesListResponseRegionsPerPlanBusinessItem>;
export const AvailabilitiesListResponseRegionsPerPlanBusinessList =
  /*@__PURE__*/ S.Array(
    AvailabilitiesListResponseRegionsPerPlanBusinessItem,
  ) as any as S.Schema<AvailabilitiesListResponseRegionsPerPlanBusinessList>;

export type AvailabilitiesListResponseRegionsPerPlanEnterpriseItem =
  AvailabilitiesListResponseRegionsPerPlanBusinessItem;
export const AvailabilitiesListResponseRegionsPerPlanEnterpriseItem =
  AvailabilitiesListResponseRegionsPerPlanBusinessItem;

export type AvailabilitiesListResponseRegionsPerPlanEnterpriseList =
  Array<AvailabilitiesListResponseRegionsPerPlanBusinessItem>;
export const AvailabilitiesListResponseRegionsPerPlanEnterpriseList =
  /*@__PURE__*/ S.Array(
    AvailabilitiesListResponseRegionsPerPlanBusinessItem,
  ) as any as S.Schema<AvailabilitiesListResponseRegionsPerPlanEnterpriseList>;

export type AvailabilitiesListResponseRegionsPerPlanFreeItem =
  AvailabilitiesListResponseRegionsPerPlanBusinessItem;
export const AvailabilitiesListResponseRegionsPerPlanFreeItem =
  AvailabilitiesListResponseRegionsPerPlanBusinessItem;

export type AvailabilitiesListResponseRegionsPerPlanFreeList =
  Array<AvailabilitiesListResponseRegionsPerPlanBusinessItem>;
export const AvailabilitiesListResponseRegionsPerPlanFreeList =
  /*@__PURE__*/ S.Array(
    AvailabilitiesListResponseRegionsPerPlanBusinessItem,
  ) as any as S.Schema<AvailabilitiesListResponseRegionsPerPlanFreeList>;

export type AvailabilitiesListResponseRegionsPerPlanProItem =
  AvailabilitiesListResponseRegionsPerPlanBusinessItem;
export const AvailabilitiesListResponseRegionsPerPlanProItem =
  AvailabilitiesListResponseRegionsPerPlanBusinessItem;

export type AvailabilitiesListResponseRegionsPerPlanProList =
  Array<AvailabilitiesListResponseRegionsPerPlanBusinessItem>;
export const AvailabilitiesListResponseRegionsPerPlanProList =
  /*@__PURE__*/ S.Array(
    AvailabilitiesListResponseRegionsPerPlanBusinessItem,
  ) as any as S.Schema<AvailabilitiesListResponseRegionsPerPlanProList>;

export interface AvailabilitiesListResponseRegionsPerPlan {
  business?: AvailabilitiesListResponseRegionsPerPlanBusinessList | null;
  enterprise?: AvailabilitiesListResponseRegionsPerPlanEnterpriseList | null;
  free?: AvailabilitiesListResponseRegionsPerPlanFreeList | null;
  pro?: AvailabilitiesListResponseRegionsPerPlanProList | null;
}
export const AvailabilitiesListResponseRegionsPerPlan = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      business: S.optional(
        S.NullOr(AvailabilitiesListResponseRegionsPerPlanBusinessList),
      ),
      enterprise: S.optional(
        S.NullOr(AvailabilitiesListResponseRegionsPerPlanEnterpriseList),
      ),
      free: S.optional(
        S.NullOr(AvailabilitiesListResponseRegionsPerPlanFreeList),
      ),
      pro: S.optional(
        S.NullOr(AvailabilitiesListResponseRegionsPerPlanProList),
      ),
    }),
).annotate({
  identifier: "AvailabilitiesListResponseRegionsPerPlan",
}) as any as S.Schema<AvailabilitiesListResponseRegionsPerPlan>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface ListAvailabilitiesResponse {
  quota?: AvailabilitiesListResponseQuota | null;
  regions?: AvailabilitiesListResponseRegionsList | null;
  /** Available regions. */
  regionsPerPlan?: AvailabilitiesListResponseRegionsPerPlan | null;
}
export const ListAvailabilitiesResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    quota: S.optional(S.NullOr(AvailabilitiesListResponseQuota)),
    regions: S.optional(S.NullOr(AvailabilitiesListResponseRegionsList)),
    regionsPerPlan: S.optional(
      S.NullOr(AvailabilitiesListResponseRegionsPerPlan),
    ),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListAvailabilitiesResponse",
}) as any as S.Schema<ListAvailabilitiesResponse>;

export interface ListPagesRequest {
  /** Identifier. */
  zoneId: string;
}
export const ListPagesRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    zoneId: S.String.pipe(T.Label("zone_id")),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/zones/{zone_id}/speed_api/pages",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListPagesRequest",
}) as any as S.Schema<ListPagesRequest>;

export type PagesListResultItemRegionValue =
  | "asia-east1"
  | "asia-northeast1"
  | "asia-northeast2"
  | "asia-south1"
  | "asia-southeast1"
  | "australia-southeast1"
  | "europe-north1"
  | "europe-southwest1"
  | "europe-west1"
  | "europe-west2"
  | "europe-west3"
  | "europe-west4"
  | "europe-west8"
  | "europe-west9"
  | "me-west1"
  | "southamerica-east1"
  | "us-central1"
  | "us-east1"
  | "us-east4"
  | "us-south1"
  | "us-west1";
export const PagesListResultItemRegionValue = /*@__PURE__*/ S.String;

export interface PagesListResultItemRegion {
  label?: string | null;
  /** A test region. */
  value?: PagesListResultItemRegionValue | null;
}
export const PagesListResultItemRegion = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    label: S.optional(S.NullOr(S.String)),
    value: S.optional(S.NullOr(PagesListResultItemRegionValue)),
  }),
).annotate({
  identifier: "PagesListResultItemRegion",
}) as any as S.Schema<PagesListResultItemRegion>;

export type PagesListResultItemScheduleFrequency = "DAILY" | "WEEKLY";
export const PagesListResultItemScheduleFrequency = /*@__PURE__*/ S.String;

export type PagesListResultItemTestsItemDesktopReportDeviceType =
  | "DESKTOP"
  | "MOBILE";
export const PagesListResultItemTestsItemDesktopReportDeviceType =
  /*@__PURE__*/ S.String;

export type PagesListResultItemTestsItemDesktopReportErrorCode =
  | "NOT_REACHABLE"
  | "DNS_FAILURE"
  | "NOT_HTML"
  | "LIGHTHOUSE_TIMEOUT"
  | "UNKNOWN";
export const PagesListResultItemTestsItemDesktopReportErrorCode =
  /*@__PURE__*/ S.String;

export interface PagesListResultItemTestsItemDesktopReportError {
  /** The error code of the Lighthouse result. */
  code?: PagesListResultItemTestsItemDesktopReportErrorCode | null;
  /** Detailed error message. */
  detail?: string | null;
  /** The final URL displayed to the user. */
  finalDisplayedUrl?: string | null;
}
export const PagesListResultItemTestsItemDesktopReportError =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      code: S.optional(
        S.NullOr(PagesListResultItemTestsItemDesktopReportErrorCode),
      ),
      detail: S.optional(S.NullOr(S.String)),
      finalDisplayedUrl: S.optional(S.NullOr(S.String)),
    }),
  ).annotate({
    identifier: "PagesListResultItemTestsItemDesktopReportError",
  }) as any as S.Schema<PagesListResultItemTestsItemDesktopReportError>;

export type PagesListResultItemTestsItemDesktopReportState =
  | "RUNNING"
  | "COMPLETE"
  | "FAILED";
export const PagesListResultItemTestsItemDesktopReportState =
  /*@__PURE__*/ S.String;

export interface PagesListResultItemTestsItemDesktopReport {
  /** Cumulative Layout Shift. */
  cls?: number | null;
  /** The type of device. */
  deviceType?: PagesListResultItemTestsItemDesktopReportDeviceType | null;
  error?: PagesListResultItemTestsItemDesktopReportError | null;
  /** First Contentful Paint. */
  fcp?: number | null;
  /** The URL to the full Lighthouse JSON report. */
  jsonReportUrl?: string | null;
  /** Largest Contentful Paint. */
  lcp?: number | null;
  /** The Lighthouse performance score. */
  performanceScore?: number | null;
  /** Speed Index. */
  si?: number | null;
  /** The state of the Lighthouse report. */
  state?: PagesListResultItemTestsItemDesktopReportState | null;
  /** Total Blocking Time. */
  tbt?: number | null;
  /** Time To First Byte. */
  ttfb?: number | null;
  /** Time To Interactive. */
  tti?: number | null;
}
export const PagesListResultItemTestsItemDesktopReport =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      cls: S.optional(S.NullOr(S.Number)),
      deviceType: S.optional(
        S.NullOr(PagesListResultItemTestsItemDesktopReportDeviceType),
      ),
      error: S.optional(
        S.NullOr(PagesListResultItemTestsItemDesktopReportError),
      ),
      fcp: S.optional(S.NullOr(S.Number)),
      jsonReportUrl: S.optional(S.NullOr(S.String)),
      lcp: S.optional(S.NullOr(S.Number)),
      performanceScore: S.optional(S.NullOr(S.Number)),
      si: S.optional(S.NullOr(S.Number)),
      state: S.optional(
        S.NullOr(PagesListResultItemTestsItemDesktopReportState),
      ),
      tbt: S.optional(S.NullOr(S.Number)),
      ttfb: S.optional(S.NullOr(S.Number)),
      tti: S.optional(S.NullOr(S.Number)),
    }),
  ).annotate({
    identifier: "PagesListResultItemTestsItemDesktopReport",
  }) as any as S.Schema<PagesListResultItemTestsItemDesktopReport>;

export type PagesListResultItemTestsItemScheduleFrequency = "DAILY" | "WEEKLY";
export const PagesListResultItemTestsItemScheduleFrequency =
  /*@__PURE__*/ S.String;

export interface PagesListResultItemTestsItem {
  /** UUID. */
  id?: string | null;
  date?: string | null;
  /** The Lighthouse report. */
  desktopReport?: PagesListResultItemTestsItemDesktopReport | null;
  /** The Lighthouse report. */
  mobileReport?: PagesListResultItemTestsItemDesktopReport | null;
  /** A test region with a label. */
  region?: PagesListResultItemRegion | null;
  /** The frequency of the test. */
  scheduleFrequency?: PagesListResultItemTestsItemScheduleFrequency | null;
  /** A URL. */
  url?: string | null;
}
export const PagesListResultItemTestsItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.optional(S.NullOr(S.String)),
    date: S.optional(S.NullOr(S.String)),
    desktopReport: S.optional(
      S.NullOr(PagesListResultItemTestsItemDesktopReport),
    ),
    mobileReport: S.optional(
      S.NullOr(PagesListResultItemTestsItemDesktopReport),
    ),
    region: S.optional(S.NullOr(PagesListResultItemRegion)),
    scheduleFrequency: S.optional(
      S.NullOr(PagesListResultItemTestsItemScheduleFrequency),
    ),
    url: S.optional(S.NullOr(S.String)),
  }),
).annotate({
  identifier: "PagesListResultItemTestsItem",
}) as any as S.Schema<PagesListResultItemTestsItem>;

export type PagesListResultItemTestsList = Array<PagesListResultItemTestsItem>;
export const PagesListResultItemTestsList = /*@__PURE__*/ S.Array(
  PagesListResultItemTestsItem,
) as any as S.Schema<PagesListResultItemTestsList>;

export interface PagesListResultItem {
  /** A test region with a label. */
  region?: PagesListResultItemRegion | null;
  /** The frequency of the test. */
  scheduleFrequency?: PagesListResultItemScheduleFrequency | null;
  tests?: PagesListResultItemTestsList | null;
  /** A URL. */
  url?: string | null;
}
export const PagesListResultItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    region: S.optional(S.NullOr(PagesListResultItemRegion)),
    scheduleFrequency: S.optional(
      S.NullOr(PagesListResultItemScheduleFrequency),
    ),
    tests: S.optional(S.NullOr(PagesListResultItemTestsList)),
    url: S.optional(S.NullOr(S.String)),
  }),
).annotate({
  identifier: "PagesListResultItem",
}) as any as S.Schema<PagesListResultItem>;

export type PagesListResultList = Array<PagesListResultItem>;
export const PagesListResultList = /*@__PURE__*/ S.Array(
  PagesListResultItem,
) as any as S.Schema<PagesListResultList>;

export interface ListPagesResponse {
  /** The unwrapped `result` payload of the v4 response envelope. */
  result: PagesListResultList;
  /** Pagination info from the envelope's `result_info`. */
  resultInfo?: ResultInfo | null;
}
export const ListPagesResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    result: PagesListResultList.pipe(T.EnvelopePayload()),
    resultInfo: S.optional(S.NullOr(ResultInfo).pipe(T.ResultInfo())),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListPagesResponse",
}) as any as S.Schema<ListPagesResponse>;

export type PagesTestsListRequestRegion =
  | "asia-east1"
  | "asia-northeast1"
  | "asia-northeast2"
  | "asia-south1"
  | "asia-southeast1"
  | "australia-southeast1"
  | "europe-north1"
  | "europe-southwest1"
  | "europe-west1"
  | "europe-west2"
  | "europe-west3"
  | "europe-west4"
  | "europe-west8"
  | "europe-west9"
  | "me-west1"
  | "southamerica-east1"
  | "us-central1"
  | "us-east1"
  | "us-east4"
  | "us-south1"
  | "us-west1";
export const PagesTestsListRequestRegion = /*@__PURE__*/ S.String;

export interface ListPageTestsRequest {
  /** Identifier. */
  zoneId: string;
  /** A URL. */
  url: string;
  page?: number;
  perPage?: number;
  /** A test region. */
  region?: PagesTestsListRequestRegion | (string & {});
}
export const ListPageTestsRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    zoneId: S.String.pipe(T.Label("zone_id")),
    url: S.String.pipe(T.Label()),
    page: S.optional(S.Number.pipe(T.Query())),
    perPage: S.optional(S.Number.pipe(T.Query("per_page"))),
    region: S.optional(PagesTestsListRequestRegion.pipe(T.Query())),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/zones/{zone_id}/speed_api/pages/{url}/tests",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListPageTestsRequest",
}) as any as S.Schema<ListPageTestsRequest>;

export type PagesTestsListResultItemDesktopReportDeviceType =
  | "DESKTOP"
  | "MOBILE";
export const PagesTestsListResultItemDesktopReportDeviceType =
  /*@__PURE__*/ S.String;

export type PagesTestsListResultItemDesktopReportErrorCode =
  | "NOT_REACHABLE"
  | "DNS_FAILURE"
  | "NOT_HTML"
  | "LIGHTHOUSE_TIMEOUT"
  | "UNKNOWN";
export const PagesTestsListResultItemDesktopReportErrorCode =
  /*@__PURE__*/ S.String;

export interface PagesTestsListResultItemDesktopReportError {
  /** The error code of the Lighthouse result. */
  code?: PagesTestsListResultItemDesktopReportErrorCode | null;
  /** Detailed error message. */
  detail?: string | null;
  /** The final URL displayed to the user. */
  finalDisplayedUrl?: string | null;
}
export const PagesTestsListResultItemDesktopReportError =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      code: S.optional(
        S.NullOr(PagesTestsListResultItemDesktopReportErrorCode),
      ),
      detail: S.optional(S.NullOr(S.String)),
      finalDisplayedUrl: S.optional(S.NullOr(S.String)),
    }),
  ).annotate({
    identifier: "PagesTestsListResultItemDesktopReportError",
  }) as any as S.Schema<PagesTestsListResultItemDesktopReportError>;

export type PagesTestsListResultItemDesktopReportState =
  | "RUNNING"
  | "COMPLETE"
  | "FAILED";
export const PagesTestsListResultItemDesktopReportState =
  /*@__PURE__*/ S.String;

export interface PagesTestsListResultItemDesktopReport {
  /** Cumulative Layout Shift. */
  cls?: number | null;
  /** The type of device. */
  deviceType?: PagesTestsListResultItemDesktopReportDeviceType | null;
  error?: PagesTestsListResultItemDesktopReportError | null;
  /** First Contentful Paint. */
  fcp?: number | null;
  /** The URL to the full Lighthouse JSON report. */
  jsonReportUrl?: string | null;
  /** Largest Contentful Paint. */
  lcp?: number | null;
  /** The Lighthouse performance score. */
  performanceScore?: number | null;
  /** Speed Index. */
  si?: number | null;
  /** The state of the Lighthouse report. */
  state?: PagesTestsListResultItemDesktopReportState | null;
  /** Total Blocking Time. */
  tbt?: number | null;
  /** Time To First Byte. */
  ttfb?: number | null;
  /** Time To Interactive. */
  tti?: number | null;
}
export const PagesTestsListResultItemDesktopReport = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      cls: S.optional(S.NullOr(S.Number)),
      deviceType: S.optional(
        S.NullOr(PagesTestsListResultItemDesktopReportDeviceType),
      ),
      error: S.optional(S.NullOr(PagesTestsListResultItemDesktopReportError)),
      fcp: S.optional(S.NullOr(S.Number)),
      jsonReportUrl: S.optional(S.NullOr(S.String)),
      lcp: S.optional(S.NullOr(S.Number)),
      performanceScore: S.optional(S.NullOr(S.Number)),
      si: S.optional(S.NullOr(S.Number)),
      state: S.optional(S.NullOr(PagesTestsListResultItemDesktopReportState)),
      tbt: S.optional(S.NullOr(S.Number)),
      ttfb: S.optional(S.NullOr(S.Number)),
      tti: S.optional(S.NullOr(S.Number)),
    }),
).annotate({
  identifier: "PagesTestsListResultItemDesktopReport",
}) as any as S.Schema<PagesTestsListResultItemDesktopReport>;

export type PagesTestsListResultItemRegionValue =
  | "asia-east1"
  | "asia-northeast1"
  | "asia-northeast2"
  | "asia-south1"
  | "asia-southeast1"
  | "australia-southeast1"
  | "europe-north1"
  | "europe-southwest1"
  | "europe-west1"
  | "europe-west2"
  | "europe-west3"
  | "europe-west4"
  | "europe-west8"
  | "europe-west9"
  | "me-west1"
  | "southamerica-east1"
  | "us-central1"
  | "us-east1"
  | "us-east4"
  | "us-south1"
  | "us-west1";
export const PagesTestsListResultItemRegionValue = /*@__PURE__*/ S.String;

export interface PagesTestsListResultItemRegion {
  label?: string | null;
  /** A test region. */
  value?: PagesTestsListResultItemRegionValue | null;
}
export const PagesTestsListResultItemRegion = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    label: S.optional(S.NullOr(S.String)),
    value: S.optional(S.NullOr(PagesTestsListResultItemRegionValue)),
  }),
).annotate({
  identifier: "PagesTestsListResultItemRegion",
}) as any as S.Schema<PagesTestsListResultItemRegion>;

export type PagesTestsListResultItemScheduleFrequency = "DAILY" | "WEEKLY";
export const PagesTestsListResultItemScheduleFrequency = /*@__PURE__*/ S.String;

export interface PagesTestsListResultItem {
  /** UUID. */
  id?: string | null;
  date?: string | null;
  /** The Lighthouse report. */
  desktopReport?: PagesTestsListResultItemDesktopReport | null;
  /** The Lighthouse report. */
  mobileReport?: PagesTestsListResultItemDesktopReport | null;
  /** A test region with a label. */
  region?: PagesTestsListResultItemRegion | null;
  /** The frequency of the test. */
  scheduleFrequency?: PagesTestsListResultItemScheduleFrequency | null;
  /** A URL. */
  url?: string | null;
}
export const PagesTestsListResultItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.optional(S.NullOr(S.String)),
    date: S.optional(S.NullOr(S.String)),
    desktopReport: S.optional(S.NullOr(PagesTestsListResultItemDesktopReport)),
    mobileReport: S.optional(S.NullOr(PagesTestsListResultItemDesktopReport)),
    region: S.optional(S.NullOr(PagesTestsListResultItemRegion)),
    scheduleFrequency: S.optional(
      S.NullOr(PagesTestsListResultItemScheduleFrequency),
    ),
    url: S.optional(S.NullOr(S.String)),
  }),
).annotate({
  identifier: "PagesTestsListResultItem",
}) as any as S.Schema<PagesTestsListResultItem>;

export type PagesTestsListResultList = Array<PagesTestsListResultItem>;
export const PagesTestsListResultList = /*@__PURE__*/ S.Array(
  PagesTestsListResultItem,
) as any as S.Schema<PagesTestsListResultList>;

export interface ListPageTestsResponse {
  /** The unwrapped `result` payload of the v4 response envelope. */
  result: PagesTestsListResultList;
  /** Pagination info from the envelope's `result_info`. */
  resultInfo?: ResultInfo | null;
}
export const ListPageTestsResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    result: PagesTestsListResultList.pipe(T.EnvelopePayload()),
    resultInfo: S.optional(S.NullOr(ResultInfo).pipe(T.ResultInfo())),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListPageTestsResponse",
}) as any as S.Schema<ListPageTestsResponse>;

export type PagesTrendRequestDeviceType = "DESKTOP" | "MOBILE";
export const PagesTrendRequestDeviceType = /*@__PURE__*/ S.String;

export type PagesTrendRequestRegion =
  | "asia-east1"
  | "asia-northeast1"
  | "asia-northeast2"
  | "asia-south1"
  | "asia-southeast1"
  | "australia-southeast1"
  | "europe-north1"
  | "europe-southwest1"
  | "europe-west1"
  | "europe-west2"
  | "europe-west3"
  | "europe-west4"
  | "europe-west8"
  | "europe-west9"
  | "me-west1"
  | "southamerica-east1"
  | "us-central1"
  | "us-east1"
  | "us-east4"
  | "us-south1"
  | "us-west1";
export const PagesTrendRequestRegion = /*@__PURE__*/ S.String;

export interface TrendPageRequest {
  /** Identifier. */
  zoneId: string;
  /** A URL. */
  url: string;
  /** The type of device. */
  deviceType: PagesTrendRequestDeviceType | (string & {});
  /** A comma-separated list of metrics to include in the results. */
  metrics: string;
  /** A test region. */
  region: PagesTrendRequestRegion | (string & {});
  start: string;
  /** The timezone of the start and end timestamps. */
  tz: string;
  end?: string;
}
export const TrendPageRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    zoneId: S.String.pipe(T.Label("zone_id")),
    url: S.String.pipe(T.Label()),
    deviceType: PagesTrendRequestDeviceType.pipe(T.Query()),
    metrics: S.String.pipe(T.Query()),
    region: PagesTrendRequestRegion.pipe(T.Query()),
    start: S.String.pipe(T.Query()),
    tz: S.String.pipe(T.Query()),
    end: S.optional(S.String.pipe(T.Query())),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/zones/{zone_id}/speed_api/pages/{url}/trend",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "TrendPageRequest",
}) as any as S.Schema<TrendPageRequest>;

export type PagesTrendResponseClsList = Array<number>;
export const PagesTrendResponseClsList = /*@__PURE__*/ S.Array(
  S.Number,
) as any as S.Schema<PagesTrendResponseClsList>;

export type PagesTrendResponseFcpList = Array<number>;
export const PagesTrendResponseFcpList = /*@__PURE__*/ S.Array(
  S.Number,
) as any as S.Schema<PagesTrendResponseFcpList>;

export type PagesTrendResponseLcpList = Array<number>;
export const PagesTrendResponseLcpList = /*@__PURE__*/ S.Array(
  S.Number,
) as any as S.Schema<PagesTrendResponseLcpList>;

export type PagesTrendResponsePerformanceScoreList = Array<number>;
export const PagesTrendResponsePerformanceScoreList = /*@__PURE__*/ S.Array(
  S.Number,
) as any as S.Schema<PagesTrendResponsePerformanceScoreList>;

export type PagesTrendResponseSiList = Array<number>;
export const PagesTrendResponseSiList = /*@__PURE__*/ S.Array(
  S.Number,
) as any as S.Schema<PagesTrendResponseSiList>;

export type PagesTrendResponseTbtList = Array<number>;
export const PagesTrendResponseTbtList = /*@__PURE__*/ S.Array(
  S.Number,
) as any as S.Schema<PagesTrendResponseTbtList>;

export type PagesTrendResponseTtfbList = Array<number>;
export const PagesTrendResponseTtfbList = /*@__PURE__*/ S.Array(
  S.Number,
) as any as S.Schema<PagesTrendResponseTtfbList>;

export type PagesTrendResponseTtiList = Array<number>;
export const PagesTrendResponseTtiList = /*@__PURE__*/ S.Array(
  S.Number,
) as any as S.Schema<PagesTrendResponseTtiList>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface TrendPageResponse {
  /** Cumulative Layout Shift trend. */
  cls?: PagesTrendResponseClsList | null;
  /** First Contentful Paint trend. */
  fcp?: PagesTrendResponseFcpList | null;
  /** Largest Contentful Paint trend. */
  lcp?: PagesTrendResponseLcpList | null;
  /** The Lighthouse score trend. */
  performanceScore?: PagesTrendResponsePerformanceScoreList | null;
  /** Speed Index trend. */
  si?: PagesTrendResponseSiList | null;
  /** Total Blocking Time trend. */
  tbt?: PagesTrendResponseTbtList | null;
  /** Time To First Byte trend. */
  ttfb?: PagesTrendResponseTtfbList | null;
  /** Time To Interactive trend. */
  tti?: PagesTrendResponseTtiList | null;
}
export const TrendPageResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    cls: S.optional(S.NullOr(PagesTrendResponseClsList)),
    fcp: S.optional(S.NullOr(PagesTrendResponseFcpList)),
    lcp: S.optional(S.NullOr(PagesTrendResponseLcpList)),
    performanceScore: S.optional(
      S.NullOr(PagesTrendResponsePerformanceScoreList),
    ),
    si: S.optional(S.NullOr(PagesTrendResponseSiList)),
    tbt: S.optional(S.NullOr(PagesTrendResponseTbtList)),
    ttfb: S.optional(S.NullOr(PagesTrendResponseTtfbList)),
    tti: S.optional(S.NullOr(PagesTrendResponseTtiList)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "TrendPageResponse",
}) as any as S.Schema<TrendPageResponse>;

export type CreatePageTestError = CloudflareOpError;
/** Starts a test for a specific webpage, in a specific region. */
export const createPageTest: API.OperationMethod<
  CreatePageTestRequest,
  CreatePageTestResponse,
  CreatePageTestError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: CreatePageTestRequest,
  output: CreatePageTestResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type CreateScheduleError =
  | TestScheduleAlreadyExists
  | TestScheduleQuotaReached
  | Forbidden
  | CloudflareOpError;
/** Creates a scheduled test for a page. */
export const createSchedule: API.OperationMethod<
  CreateScheduleRequest,
  CreateScheduleResponse,
  CreateScheduleError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: CreateScheduleRequest,
  output: CreateScheduleResponse,
  errors: [
    TestScheduleAlreadyExists,
    TestScheduleQuotaReached,
    Forbidden,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type DeletePageTestError = CloudflareOpError;
/** Deletes all tests for a specific webpage from a specific region. Deleted tests are still counted as part of the quota. */
export const deletePageTest: API.OperationMethod<
  DeletePageTestRequest,
  DeletePageTestResponse,
  DeletePageTestError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: DeletePageTestRequest,
  output: DeletePageTestResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type DeleteScheduleError =
  | TestScheduleNotFound
  | Forbidden
  | CloudflareOpError;
/** Deletes a scheduled test for a page. */
export const deleteSchedule: API.OperationMethod<
  DeleteScheduleRequest,
  DeleteScheduleResponse,
  DeleteScheduleError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: DeleteScheduleRequest,
  output: DeleteScheduleResponse,
  errors: [
    TestScheduleNotFound,
    Forbidden,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetPageTestError = CloudflareOpError;
/** Retrieves the result of a specific test. */
export const getPageTest: API.OperationMethod<
  GetPageTestRequest,
  GetPageTestResponse,
  GetPageTestError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetPageTestRequest,
  output: GetPageTestResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetScheduleError =
  | TestScheduleNotFound
  | Forbidden
  | CloudflareOpError;
/** Retrieves the test schedule for a page in a specific region. */
export const getSchedule: API.OperationMethod<
  GetScheduleRequest,
  GetScheduleResponse,
  GetScheduleError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetScheduleRequest,
  output: GetScheduleResponse,
  errors: [
    TestScheduleNotFound,
    Forbidden,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type ListAvailabilitiesError = CloudflareOpError;
/** Retrieves quota for all plans, as well as the current zone quota. */
export const listAvailabilities: API.OperationMethod<
  ListAvailabilitiesRequest,
  ListAvailabilitiesResponse,
  ListAvailabilitiesError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: ListAvailabilitiesRequest,
  output: ListAvailabilitiesResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type ListPagesError = CloudflareOpError;
/** Lists all webpages which have been tested. */
export const listPages: API.PaginatedOperationMethod<
  ListPagesRequest,
  ListPagesResponse,
  ListPagesError,
  CloudflareOpContext,
  PagesListResultItem
> = /*@__PURE__*/ API.makePaginated(
  () => ({
    input: ListPagesRequest,
    output: ListPagesResponse,
    errors: [CloudflareRateLimited, CloudflareError],
    protocol: CloudflarePaginatedProtocol,
    retry: Retry.Retry,
    pagination: { mode: "single", items: "result" } as const,
  }),
  cloudflarePaginate,
) as any;

export type ListPageTestsError = CloudflareOpError;
/** Test history (list of tests) for a specific webpage. */
export const listPageTests: API.PaginatedOperationMethod<
  ListPageTestsRequest,
  ListPageTestsResponse,
  ListPageTestsError,
  CloudflareOpContext,
  PagesTestsListResultItem
> = /*@__PURE__*/ API.makePaginated(
  () => ({
    input: ListPageTestsRequest,
    output: ListPageTestsResponse,
    errors: [CloudflareRateLimited, CloudflareError],
    protocol: CloudflarePaginatedProtocol,
    retry: Retry.Retry,
    pagination: {
      mode: "page",
      inputToken: "page",
      outputToken: "resultInfo.page",
      items: "result",
      pageSize: "perPage",
    } as const,
  }),
  cloudflarePaginate,
) as any;

export type TrendPageError = CloudflareOpError;
/** Lists the core web vital metrics trend over time for a specific page. */
export const trendPage: API.OperationMethod<
  TrendPageRequest,
  TrendPageResponse,
  TrendPageError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: TrendPageRequest,
  output: TrendPageResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));