// 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,
  type CloudflareOpError,
  type CloudflareOpContext,
} from "../protocol.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>> = {
  browser: "Browser",
  customAi: "custom_ai",
  jobId: "job_id",
  jsonSchema: "json_schema",
  protocolVersion: "Protocol-Version",
  responseFormat: "response_format",
  userAgent: "User-Agent",
  v8Version: "V8-Version",
  webKitVersion: "WebKit-Version",
};

export interface ActivateDevtoolBrowserTargetRequest {
  /** Account ID. */
  accountId: string;
  /** Browser session ID. */
  sessionId: string;
  /** Target ID to activate. */
  targetId: string;
}
export const ActivateDevtoolBrowserTargetRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    sessionId: S.String.pipe(T.Label("session_id")),
    targetId: S.String.pipe(T.Label("target_id")),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/browser-rendering/devtools/browser/{session_id}/json/activate/{target_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ActivateDevtoolBrowserTargetRequest",
}) as any as S.Schema<ActivateDevtoolBrowserTargetRequest>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface ActivateDevtoolBrowserTargetResponse {
  /** Target activated. */
  message: string;
}
export const ActivateDevtoolBrowserTargetResponse = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      message: S.String,
    }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ActivateDevtoolBrowserTargetResponse",
}) as any as S.Schema<ActivateDevtoolBrowserTargetResponse>;

export interface CloseDevtoolBrowserTargetRequest {
  /** Account ID. */
  accountId: string;
  /** Browser session ID. */
  sessionId: string;
  /** Target ID to close. */
  targetId: string;
}
export const CloseDevtoolBrowserTargetRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    sessionId: S.String.pipe(T.Label("session_id")),
    targetId: S.String.pipe(T.Label("target_id")),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/browser-rendering/devtools/browser/{session_id}/json/close/{target_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CloseDevtoolBrowserTargetRequest",
}) as any as S.Schema<CloseDevtoolBrowserTargetRequest>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface CloseDevtoolBrowserTargetResponse {
  /** Target is closing. */
  message: string;
}
export const CloseDevtoolBrowserTargetResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    message: S.String,
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CloseDevtoolBrowserTargetResponse",
}) as any as S.Schema<CloseDevtoolBrowserTargetResponse>;

export interface ConnectDevtoolBrowserRequest {
  /** Account ID. */
  accountId: string;
  /** Browser session ID to connect to. */
  sessionId: string;
  /** Keep-alive time in ms (only valid when acquiring new session). */
  keepAlive?: number;
  /** Use experimental browser. */
  lab?: boolean;
  recording?: boolean;
}
export const ConnectDevtoolBrowserRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    sessionId: S.String.pipe(T.Label("session_id")),
    keepAlive: S.optional(S.Number.pipe(T.Query("keep_alive"))),
    lab: S.optional(S.Boolean.pipe(T.Query())),
    recording: S.optional(S.Boolean.pipe(T.Query())),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/browser-rendering/devtools/browser/{session_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ConnectDevtoolBrowserRequest",
}) as any as S.Schema<ConnectDevtoolBrowserRequest>;

export interface ConnectDevtoolBrowserResponse {}
export const ConnectDevtoolBrowserResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({}).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ConnectDevtoolBrowserResponse",
}) as any as S.Schema<ConnectDevtoolBrowserResponse>;

export interface ContentCreateRequestAddScriptTagItem {
  id?: string;
  content?: string;
  type?: string;
  url?: string;
}
export const ContentCreateRequestAddScriptTagItem = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      id: S.optional(S.String),
      content: S.optional(S.String),
      type: S.optional(S.String),
      url: S.optional(S.String),
    }),
).annotate({
  identifier: "ContentCreateRequestAddScriptTagItem",
}) as any as S.Schema<ContentCreateRequestAddScriptTagItem>;

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

export interface ContentCreateRequestAddStyleTagItem {
  content?: string;
  url?: string;
}
export const ContentCreateRequestAddStyleTagItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    content: S.optional(S.String),
    url: S.optional(S.String),
  }),
).annotate({
  identifier: "ContentCreateRequestAddStyleTagItem",
}) as any as S.Schema<ContentCreateRequestAddStyleTagItem>;

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

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

export type ContentCreateRequestAllowResourceTypesItem =
  | "document"
  | "stylesheet"
  | "image"
  | "media"
  | "font"
  | "script"
  | "texttrack"
  | "xhr"
  | "fetch"
  | "prefetch"
  | "eventsource"
  | "websocket"
  | "manifest"
  | "signedexchange"
  | "ping"
  | "cspviolationreport"
  | "preflight"
  | "other";
export const ContentCreateRequestAllowResourceTypesItem =
  /*@__PURE__*/ S.String;

export type ContentCreateRequestAllowResourceTypesList = Array<
  ContentCreateRequestAllowResourceTypesItem | (string & {})
>;
export const ContentCreateRequestAllowResourceTypesList = /*@__PURE__*/ S.Array(
  ContentCreateRequestAllowResourceTypesItem,
) as any as S.Schema<ContentCreateRequestAllowResourceTypesList>;

export interface ContentCreateRequestAuthenticate {
  password: string;
  username: string;
}
export const ContentCreateRequestAuthenticate = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    password: S.String,
    username: S.String,
  }),
).annotate({
  identifier: "ContentCreateRequestAuthenticate",
}) as any as S.Schema<ContentCreateRequestAuthenticate>;

export type ContentCreateRequestCookiesItemPriority = "Low" | "Medium" | "High";
export const ContentCreateRequestCookiesItemPriority = /*@__PURE__*/ S.String;

export type ContentCreateRequestCookiesItemSameSite = "Strict" | "Lax" | "None";
export const ContentCreateRequestCookiesItemSameSite = /*@__PURE__*/ S.String;

export type ContentCreateRequestCookiesItemSourceScheme =
  | "Unset"
  | "NonSecure"
  | "Secure";
export const ContentCreateRequestCookiesItemSourceScheme =
  /*@__PURE__*/ S.String;

export interface ContentCreateRequestCookiesItem {
  /** Cookie name. */
  name: string;
  value: string;
  domain?: string;
  expires?: number;
  httpOnly?: boolean;
  partitionKey?: string;
  path?: string;
  priority?: ContentCreateRequestCookiesItemPriority | (string & {});
  sameParty?: boolean;
  sameSite?: ContentCreateRequestCookiesItemSameSite | (string & {});
  secure?: boolean;
  sourcePort?: number;
  sourceScheme?: ContentCreateRequestCookiesItemSourceScheme | (string & {});
  url?: string;
}
export const ContentCreateRequestCookiesItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    name: S.String,
    value: S.String,
    domain: S.optional(S.String),
    expires: S.optional(S.Number),
    httpOnly: S.optional(S.Boolean),
    partitionKey: S.optional(S.String),
    path: S.optional(S.String),
    priority: S.optional(ContentCreateRequestCookiesItemPriority),
    sameParty: S.optional(S.Boolean),
    sameSite: S.optional(ContentCreateRequestCookiesItemSameSite),
    secure: S.optional(S.Boolean),
    sourcePort: S.optional(S.Number),
    sourceScheme: S.optional(ContentCreateRequestCookiesItemSourceScheme),
    url: S.optional(S.String),
  }),
).annotate({
  identifier: "ContentCreateRequestCookiesItem",
}) as any as S.Schema<ContentCreateRequestCookiesItem>;

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

export type ContentCreateRequestGotoOptionsWaitUntilCase0 =
  | "load"
  | "domcontentloaded"
  | "networkidle0"
  | "networkidle2";
export const ContentCreateRequestGotoOptionsWaitUntilCase0 =
  /*@__PURE__*/ S.String;

export type ContentCreateRequestGotoOptionsWaitUntilCase1Item =
  | "load"
  | "domcontentloaded"
  | "networkidle0"
  | "networkidle2";
export const ContentCreateRequestGotoOptionsWaitUntilCase1Item =
  /*@__PURE__*/ S.String;

export type ContentCreateRequestGotoOptionsWaitUntilCase1List = Array<
  ContentCreateRequestGotoOptionsWaitUntilCase1Item | (string & {})
>;
export const ContentCreateRequestGotoOptionsWaitUntilCase1List =
  /*@__PURE__*/ S.Array(
    ContentCreateRequestGotoOptionsWaitUntilCase1Item,
  ) as any as S.Schema<ContentCreateRequestGotoOptionsWaitUntilCase1List>;

export type ContentCreateRequestGotoOptionsWaitUntil =
  | ContentCreateRequestGotoOptionsWaitUntilCase0
  | (string & {})
  | ContentCreateRequestGotoOptionsWaitUntilCase1List;
export const ContentCreateRequestGotoOptionsWaitUntil =
  /*@__PURE__*/ S.Unknown.pipe(T.UnionCases([[], []]));

export interface ContentCreateRequestGotoOptions {
  referer?: string;
  referrerPolicy?: string;
  timeout?: number;
  waitUntil?: ContentCreateRequestGotoOptionsWaitUntil;
}
export const ContentCreateRequestGotoOptions = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    referer: S.optional(S.String),
    referrerPolicy: S.optional(S.String),
    timeout: S.optional(S.Number),
    waitUntil: S.optional(ContentCreateRequestGotoOptionsWaitUntil),
  }),
).annotate({
  identifier: "ContentCreateRequestGotoOptions",
}) as any as S.Schema<ContentCreateRequestGotoOptions>;

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

export type ContentCreateRequestRejectResourceTypesItem =
  | "document"
  | "stylesheet"
  | "image"
  | "media"
  | "font"
  | "script"
  | "texttrack"
  | "xhr"
  | "fetch"
  | "prefetch"
  | "eventsource"
  | "websocket"
  | "manifest"
  | "signedexchange"
  | "ping"
  | "cspviolationreport"
  | "preflight"
  | "other";
export const ContentCreateRequestRejectResourceTypesItem =
  /*@__PURE__*/ S.String;

export type ContentCreateRequestRejectResourceTypesList = Array<
  ContentCreateRequestRejectResourceTypesItem | (string & {})
>;
export const ContentCreateRequestRejectResourceTypesList =
  /*@__PURE__*/ S.Array(
    ContentCreateRequestRejectResourceTypesItem,
  ) as any as S.Schema<ContentCreateRequestRejectResourceTypesList>;

export type ContentCreateRequestSetExtraHTTPHeadersMap = {
  [key: string]: string | undefined;
};
export const ContentCreateRequestSetExtraHTTPHeadersMap =
  /*@__PURE__*/ S.Record(
    S.String,
    S.String,
  ) as any as S.Schema<ContentCreateRequestSetExtraHTTPHeadersMap>;

export interface ContentCreateRequestViewport {
  height: number;
  width: number;
  deviceScaleFactor?: number;
  hasTouch?: boolean;
  isLandscape?: boolean;
  isMobile?: boolean;
}
export const ContentCreateRequestViewport = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    height: S.Number,
    width: S.Number,
    deviceScaleFactor: S.optional(S.Number),
    hasTouch: S.optional(S.Boolean),
    isLandscape: S.optional(S.Boolean),
    isMobile: S.optional(S.Boolean),
  }),
).annotate({
  identifier: "ContentCreateRequestViewport",
}) as any as S.Schema<ContentCreateRequestViewport>;

export interface ContentCreateRequestWaitForSelector {
  selector: string;
  hidden?: boolean;
  timeout?: number;
  visible?: boolean;
}
export const ContentCreateRequestWaitForSelector = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    selector: S.String,
    hidden: S.optional(S.Boolean),
    timeout: S.optional(S.Number),
    visible: S.optional(S.Boolean),
  }),
).annotate({
  identifier: "ContentCreateRequestWaitForSelector",
}) as any as S.Schema<ContentCreateRequestWaitForSelector>;

export interface CreateContentRequest {
  /** Account ID. */
  accountId: string;
  /** Cache TTL default is 5s. Set to 0 to disable. */
  cacheTTL?: number;
  /** URL to navigate to, eg. `https://example.com`. */
  url?: string;
  /** The maximum duration allowed for the browser action to complete after the page has loaded (such as taking screenshots, extracting content, or generating PDFs). If this time limit is exceeded, the action stops and returns a timeout error. */
  actionTimeout?: number;
  /** Adds a `<script>` tag into the page with the desired URL or content. */
  addScriptTag?: ContentCreateRequestAddScriptTagList;
  /** Adds a `<link rel="stylesheet">` tag into the page with the desired URL or a `<style type="text/css">` tag with the content. */
  addStyleTag?: ContentCreateRequestAddStyleTagList;
  /** Only allow requests that match the provided regex patterns, eg. '/^.*.(css)'. */
  allowRequestPattern?: ContentCreateRequestAllowRequestPatternList;
  /** Only allow requests that match the provided resource types, eg. 'image' or 'script'. */
  allowResourceTypes?: ContentCreateRequestAllowResourceTypesList;
  /** Provide credentials for HTTP authentication. */
  authenticate?: ContentCreateRequestAuthenticate;
  /** Attempt to proceed when 'awaited' events fail or timeout. */
  bestAttempt?: boolean;
  /** Check [options](https://pptr.dev/api/puppeteer.page.setcookie). */
  cookies?: ContentCreateRequestCookiesList;
  emulateMediaType?: string;
  /** Check [options](https://pptr.dev/api/puppeteer.gotooptions). */
  gotoOptions?: ContentCreateRequestGotoOptions;
  /** Block undesired requests that match the provided regex patterns, eg. '/^.*.(css)'. */
  rejectRequestPattern?: ContentCreateRequestRejectRequestPatternList;
  /** Block undesired requests that match the provided resource types, eg. 'image' or 'script'. */
  rejectResourceTypes?: ContentCreateRequestRejectResourceTypesList;
  setExtraHTTPHeaders?: ContentCreateRequestSetExtraHTTPHeadersMap;
  setJavaScriptEnabled?: boolean;
  userAgent?: string;
  /** Check [options](https://pptr.dev/api/puppeteer.page.setviewport). */
  viewport?: ContentCreateRequestViewport;
  /** Wait for the selector to appear in page. Check [options](https://pptr.dev/api/puppeteer.page.waitforselector). */
  waitForSelector?: ContentCreateRequestWaitForSelector;
  /** Waits for a specified timeout before continuing. */
  waitForTimeout?: number;
  /** Set the content of the page, eg: `<h1>Hello World!!</h1>`. Either `html` or `url` must be set. */
  html?: string;
}
export const CreateContentRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    cacheTTL: S.optional(S.Number.pipe(T.Query())),
    url: S.optional(S.String),
    actionTimeout: S.optional(S.Number),
    addScriptTag: S.optional(ContentCreateRequestAddScriptTagList),
    addStyleTag: S.optional(ContentCreateRequestAddStyleTagList),
    allowRequestPattern: S.optional(
      ContentCreateRequestAllowRequestPatternList,
    ),
    allowResourceTypes: S.optional(ContentCreateRequestAllowResourceTypesList),
    authenticate: S.optional(ContentCreateRequestAuthenticate),
    bestAttempt: S.optional(S.Boolean),
    cookies: S.optional(ContentCreateRequestCookiesList),
    emulateMediaType: S.optional(S.String),
    gotoOptions: S.optional(ContentCreateRequestGotoOptions),
    rejectRequestPattern: S.optional(
      ContentCreateRequestRejectRequestPatternList,
    ),
    rejectResourceTypes: S.optional(
      ContentCreateRequestRejectResourceTypesList,
    ),
    setExtraHTTPHeaders: S.optional(ContentCreateRequestSetExtraHTTPHeadersMap),
    setJavaScriptEnabled: S.optional(S.Boolean),
    userAgent: S.optional(S.String),
    viewport: S.optional(ContentCreateRequestViewport),
    waitForSelector: S.optional(ContentCreateRequestWaitForSelector),
    waitForTimeout: S.optional(S.Number),
    html: S.optional(S.String),
  })
    .pipe(
      T.Http({
        method: "POST",
        uri: "/accounts/{account_id}/browser-rendering/content",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateContentRequest",
}) as any as S.Schema<CreateContentRequest>;

export type CreateContentResponse = string;
export const CreateContentResponse = /*@__PURE__*/ S.suspend(() =>
  S.String.pipe(T.EnvelopePayloadRoot(), T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateContentResponse",
}) as any as S.Schema<CreateContentResponse>;

export type CrawlCreateRequestAddScriptTagItem =
  ContentCreateRequestAddScriptTagItem;
export const CrawlCreateRequestAddScriptTagItem =
  ContentCreateRequestAddScriptTagItem;

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

export type CrawlCreateRequestAddStyleTagItem =
  ContentCreateRequestAddStyleTagItem;
export const CrawlCreateRequestAddStyleTagItem =
  ContentCreateRequestAddStyleTagItem;

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

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

export type CrawlCreateRequestAllowResourceTypesItem =
  | "document"
  | "stylesheet"
  | "image"
  | "media"
  | "font"
  | "script"
  | "texttrack"
  | "xhr"
  | "fetch"
  | "prefetch"
  | "eventsource"
  | "websocket"
  | "manifest"
  | "signedexchange"
  | "ping"
  | "cspviolationreport"
  | "preflight"
  | "other";
export const CrawlCreateRequestAllowResourceTypesItem = /*@__PURE__*/ S.String;

export type CrawlCreateRequestAllowResourceTypesList = Array<
  CrawlCreateRequestAllowResourceTypesItem | (string & {})
>;
export const CrawlCreateRequestAllowResourceTypesList = /*@__PURE__*/ S.Array(
  CrawlCreateRequestAllowResourceTypesItem,
) as any as S.Schema<CrawlCreateRequestAllowResourceTypesList>;

export type CrawlCreateRequestAuthenticate = ContentCreateRequestAuthenticate;
export const CrawlCreateRequestAuthenticate = ContentCreateRequestAuthenticate;

export type CrawlCreateRequestCookiesItemPriority = "Low" | "Medium" | "High";
export const CrawlCreateRequestCookiesItemPriority = /*@__PURE__*/ S.String;

export type CrawlCreateRequestCookiesItemSameSite = "Strict" | "Lax" | "None";
export const CrawlCreateRequestCookiesItemSameSite = /*@__PURE__*/ S.String;

export type CrawlCreateRequestCookiesItemSourceScheme =
  | "Unset"
  | "NonSecure"
  | "Secure";
export const CrawlCreateRequestCookiesItemSourceScheme = /*@__PURE__*/ S.String;

export interface CrawlCreateRequestCookiesItem {
  /** Cookie name. */
  name: string;
  value: string;
  domain?: string;
  expires?: number;
  httpOnly?: boolean;
  partitionKey?: string;
  path?: string;
  priority?: CrawlCreateRequestCookiesItemPriority | (string & {});
  sameParty?: boolean;
  sameSite?: CrawlCreateRequestCookiesItemSameSite | (string & {});
  secure?: boolean;
  sourcePort?: number;
  sourceScheme?: CrawlCreateRequestCookiesItemSourceScheme | (string & {});
  url?: string;
}
export const CrawlCreateRequestCookiesItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    name: S.String,
    value: S.String,
    domain: S.optional(S.String),
    expires: S.optional(S.Number),
    httpOnly: S.optional(S.Boolean),
    partitionKey: S.optional(S.String),
    path: S.optional(S.String),
    priority: S.optional(CrawlCreateRequestCookiesItemPriority),
    sameParty: S.optional(S.Boolean),
    sameSite: S.optional(CrawlCreateRequestCookiesItemSameSite),
    secure: S.optional(S.Boolean),
    sourcePort: S.optional(S.Number),
    sourceScheme: S.optional(CrawlCreateRequestCookiesItemSourceScheme),
    url: S.optional(S.String),
  }),
).annotate({
  identifier: "CrawlCreateRequestCookiesItem",
}) as any as S.Schema<CrawlCreateRequestCookiesItem>;

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

export type CrawlCreateRequestCrawlPurposesItem =
  | "search"
  | "ai-input"
  | "ai-train";
export const CrawlCreateRequestCrawlPurposesItem = /*@__PURE__*/ S.String;

export type CrawlCreateRequestCrawlPurposesList = Array<
  CrawlCreateRequestCrawlPurposesItem | (string & {})
>;
export const CrawlCreateRequestCrawlPurposesList = /*@__PURE__*/ S.Array(
  CrawlCreateRequestCrawlPurposesItem,
) as any as S.Schema<CrawlCreateRequestCrawlPurposesList>;

export type CrawlCreateRequestFormatsItem = "html" | "markdown" | "json";
export const CrawlCreateRequestFormatsItem = /*@__PURE__*/ S.String;

export type CrawlCreateRequestFormatsList = Array<
  CrawlCreateRequestFormatsItem | (string & {})
>;
export const CrawlCreateRequestFormatsList = /*@__PURE__*/ S.Array(
  CrawlCreateRequestFormatsItem,
) as any as S.Schema<CrawlCreateRequestFormatsList>;

export type CrawlCreateRequestGotoOptionsWaitUntilCase0 =
  | "load"
  | "domcontentloaded"
  | "networkidle0"
  | "networkidle2";
export const CrawlCreateRequestGotoOptionsWaitUntilCase0 =
  /*@__PURE__*/ S.String;

export type CrawlCreateRequestGotoOptionsWaitUntilCase1Item =
  | "load"
  | "domcontentloaded"
  | "networkidle0"
  | "networkidle2";
export const CrawlCreateRequestGotoOptionsWaitUntilCase1Item =
  /*@__PURE__*/ S.String;

export type CrawlCreateRequestGotoOptionsWaitUntilCase1List = Array<
  CrawlCreateRequestGotoOptionsWaitUntilCase1Item | (string & {})
>;
export const CrawlCreateRequestGotoOptionsWaitUntilCase1List =
  /*@__PURE__*/ S.Array(
    CrawlCreateRequestGotoOptionsWaitUntilCase1Item,
  ) as any as S.Schema<CrawlCreateRequestGotoOptionsWaitUntilCase1List>;

export type CrawlCreateRequestGotoOptionsWaitUntil =
  | CrawlCreateRequestGotoOptionsWaitUntilCase0
  | (string & {})
  | CrawlCreateRequestGotoOptionsWaitUntilCase1List;
export const CrawlCreateRequestGotoOptionsWaitUntil =
  /*@__PURE__*/ S.Unknown.pipe(T.UnionCases([[], []]));

export interface CrawlCreateRequestGotoOptions {
  referer?: string;
  referrerPolicy?: string;
  timeout?: number;
  waitUntil?: CrawlCreateRequestGotoOptionsWaitUntil;
}
export const CrawlCreateRequestGotoOptions = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    referer: S.optional(S.String),
    referrerPolicy: S.optional(S.String),
    timeout: S.optional(S.Number),
    waitUntil: S.optional(CrawlCreateRequestGotoOptionsWaitUntil),
  }),
).annotate({
  identifier: "CrawlCreateRequestGotoOptions",
}) as any as S.Schema<CrawlCreateRequestGotoOptions>;

export interface CrawlCreateRequestJsonOptionsCustomAiItem {
  /** AI model to use for the request. Must be formed as `<provider>/<model_name>`, e.g. `workers-ai/@cf/meta/llama-3.3-70b-instruct-fp8-fast`. */
  model: string;
  /** Authorization token for the AI model: `Bearer <token>`. Not needed for workers-ai models. */
  authorization?: string;
}
export const CrawlCreateRequestJsonOptionsCustomAiItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      model: S.String,
      authorization: S.optional(S.String),
    }),
  ).annotate({
    identifier: "CrawlCreateRequestJsonOptionsCustomAiItem",
  }) as any as S.Schema<CrawlCreateRequestJsonOptionsCustomAiItem>;

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

export interface CrawlCreateRequestJsonOptionsResponseFormat {
  type: string;
  /** Schema for the response format. More information here: https://developers.cloudflare.com/workers-ai/json-mode/ */
  jsonSchema?: unknown;
}
export const CrawlCreateRequestJsonOptionsResponseFormat =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      type: S.String,
      jsonSchema: S.optional(S.Unknown.pipe(T.Body("json_schema"))),
    }),
  ).annotate({
    identifier: "CrawlCreateRequestJsonOptionsResponseFormat",
  }) as any as S.Schema<CrawlCreateRequestJsonOptionsResponseFormat>;

export interface CrawlCreateRequestJsonOptions {
  /** Optional list of custom AI models to use for the request. The models will be tried in the order provided, and in case a model returns an error, the next one will be used as fallback. */
  customAi?: CrawlCreateRequestJsonOptionsCustomAiList;
  prompt?: string;
  responseFormat?: CrawlCreateRequestJsonOptionsResponseFormat;
}
export const CrawlCreateRequestJsonOptions = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    customAi: S.optional(
      CrawlCreateRequestJsonOptionsCustomAiList.pipe(T.Body("custom_ai")),
    ),
    prompt: S.optional(S.String),
    responseFormat: S.optional(
      CrawlCreateRequestJsonOptionsResponseFormat.pipe(
        T.Body("response_format"),
      ),
    ),
  }),
).annotate({
  identifier: "CrawlCreateRequestJsonOptions",
}) as any as S.Schema<CrawlCreateRequestJsonOptions>;

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

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

export interface CrawlCreateRequestOptions {
  /** Exclude links matching the provided wildcard patterns in the crawl job. Example: 'https://example.com/privacy/**'. */
  excludePatterns?: CrawlCreateRequestOptionsExcludePatternsList;
  /** Include external links in the crawl job. If set to true, includeSubdomains is ignored. */
  includeExternalLinks?: boolean;
  /** Include only links matching the provided wildcard patterns in the crawl job. Include patterns are evaluated before exclude patterns. URLs that match any of the specified include patterns will be included in the crawl job. Example: 'https://example.com/blog/**'. */
  includePatterns?: CrawlCreateRequestOptionsIncludePatternsList;
  /** Include links to subdomains in the crawl job. This option is ignored if includeExternalLinks is true. */
  includeSubdomains?: boolean;
}
export const CrawlCreateRequestOptions = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    excludePatterns: S.optional(CrawlCreateRequestOptionsExcludePatternsList),
    includeExternalLinks: S.optional(S.Boolean),
    includePatterns: S.optional(CrawlCreateRequestOptionsIncludePatternsList),
    includeSubdomains: S.optional(S.Boolean),
  }),
).annotate({
  identifier: "CrawlCreateRequestOptions",
}) as any as S.Schema<CrawlCreateRequestOptions>;

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

export type CrawlCreateRequestRejectResourceTypesItem =
  | "document"
  | "stylesheet"
  | "image"
  | "media"
  | "font"
  | "script"
  | "texttrack"
  | "xhr"
  | "fetch"
  | "prefetch"
  | "eventsource"
  | "websocket"
  | "manifest"
  | "signedexchange"
  | "ping"
  | "cspviolationreport"
  | "preflight"
  | "other";
export const CrawlCreateRequestRejectResourceTypesItem = /*@__PURE__*/ S.String;

export type CrawlCreateRequestRejectResourceTypesList = Array<
  CrawlCreateRequestRejectResourceTypesItem | (string & {})
>;
export const CrawlCreateRequestRejectResourceTypesList = /*@__PURE__*/ S.Array(
  CrawlCreateRequestRejectResourceTypesItem,
) as any as S.Schema<CrawlCreateRequestRejectResourceTypesList>;

export type CrawlCreateRequestSetExtraHTTPHeadersMap = {
  [key: string]: string | undefined;
};
export const CrawlCreateRequestSetExtraHTTPHeadersMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<CrawlCreateRequestSetExtraHTTPHeadersMap>;

export type CrawlCreateRequestSource = "sitemaps" | "links" | "all";
export const CrawlCreateRequestSource = /*@__PURE__*/ S.String;

export type CrawlCreateRequestViewport = ContentCreateRequestViewport;
export const CrawlCreateRequestViewport = ContentCreateRequestViewport;

export type CrawlCreateRequestWaitForSelector =
  ContentCreateRequestWaitForSelector;
export const CrawlCreateRequestWaitForSelector =
  ContentCreateRequestWaitForSelector;

export interface CreateCrawlRequest {
  /** Account ID. */
  accountId: string;
  /** Cache TTL default is 5s. Set to 0 to disable. */
  cacheTTL?: number;
  /** URL to navigate to, eg. `https://example.com`. */
  url: string;
  /** The maximum duration allowed for the browser action to complete after the page has loaded (such as taking screenshots, extracting content, or generating PDFs). If this time limit is exceeded, the action stops and returns a timeout error. */
  actionTimeout?: number;
  /** Adds a `<script>` tag into the page with the desired URL or content. */
  addScriptTag?: CrawlCreateRequestAddScriptTagList;
  /** Adds a `<link rel="stylesheet">` tag into the page with the desired URL or a `<style type="text/css">` tag with the content. */
  addStyleTag?: CrawlCreateRequestAddStyleTagList;
  /** Only allow requests that match the provided regex patterns, eg. '/^.*.(css)'. */
  allowRequestPattern?: CrawlCreateRequestAllowRequestPatternList;
  /** Only allow requests that match the provided resource types, eg. 'image' or 'script'. */
  allowResourceTypes?: CrawlCreateRequestAllowResourceTypesList;
  /** Provide credentials for HTTP authentication. */
  authenticate?: ContentCreateRequestAuthenticate;
  /** Attempt to proceed when 'awaited' events fail or timeout. */
  bestAttempt?: boolean;
  /** Check [options](https://pptr.dev/api/puppeteer.page.setcookie). */
  cookies?: CrawlCreateRequestCookiesList;
  /** List of crawl purposes to respect Content-Signal directives in robots.txt. Allowed values: 'search', 'ai-input', 'ai-train'. Learn more: https://contentsignals.org/. Default: ['search', 'ai-input', 'ai-train']. */
  crawlPurposes?: CrawlCreateRequestCrawlPurposesList;
  /** Maximum number of levels deep the crawler will traverse from the starting URL. */
  depth?: number;
  emulateMediaType?: string;
  /** Formats to return. Default is `html`. */
  formats?: CrawlCreateRequestFormatsList;
  /** Check [options](https://pptr.dev/api/puppeteer.gotooptions). */
  gotoOptions?: CrawlCreateRequestGotoOptions;
  /** Options for JSON extraction. */
  jsonOptions?: CrawlCreateRequestJsonOptions;
  /** Maximum number of URLs to crawl. */
  limit?: number;
  /** Maximum age of a resource that can be returned from cache in seconds. Default is 1 day. */
  maxAge?: number;
  /** Unix timestamp (seconds since epoch) indicating to only crawl pages that were modified since this time. For sitemap URLs with a lastmod field, this is compared directly. For other URLs, the crawler will use If-Modified-Since header when fetching. URLs without modification information (no lastmod in sitemap and no Last-Modified header support) will be crawled. Note: This works in conjunction with maxAge - both filters must pass for a cached resource to be used. Must be within the last year and not in the future. */
  modifiedSince?: number;
  /** Additional options for the crawler. */
  options?: CrawlCreateRequestOptions;
  /** Block undesired requests that match the provided regex patterns, eg. '/^.*.(css)'. */
  rejectRequestPattern?: CrawlCreateRequestRejectRequestPatternList;
  /** Block undesired requests that match the provided resource types, eg. 'image' or 'script'. */
  rejectResourceTypes?: CrawlCreateRequestRejectResourceTypesList;
  /** Whether to render the page or fetch static content. True by default. */
  render?: boolean;
  setExtraHTTPHeaders?: CrawlCreateRequestSetExtraHTTPHeadersMap;
  setJavaScriptEnabled?: boolean;
  /** Source of links to crawl. 'sitemaps' - only crawl URLs from sitemaps, 'links' - only crawl URLs scraped from pages, 'all' - crawl both sitemap and scraped links (default). */
  source?: CrawlCreateRequestSource | (string & {});
  /** Check [options](https://pptr.dev/api/puppeteer.page.setviewport). */
  viewport?: ContentCreateRequestViewport;
  /** Wait for the selector to appear in page. Check [options](https://pptr.dev/api/puppeteer.page.waitforselector). */
  waitForSelector?: ContentCreateRequestWaitForSelector;
  /** Waits for a specified timeout before continuing. */
  waitForTimeout?: number;
}
export const CreateCrawlRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    cacheTTL: S.optional(S.Number.pipe(T.Query())),
    url: S.String,
    actionTimeout: S.optional(S.Number),
    addScriptTag: S.optional(CrawlCreateRequestAddScriptTagList),
    addStyleTag: S.optional(CrawlCreateRequestAddStyleTagList),
    allowRequestPattern: S.optional(CrawlCreateRequestAllowRequestPatternList),
    allowResourceTypes: S.optional(CrawlCreateRequestAllowResourceTypesList),
    authenticate: S.optional(ContentCreateRequestAuthenticate),
    bestAttempt: S.optional(S.Boolean),
    cookies: S.optional(CrawlCreateRequestCookiesList),
    crawlPurposes: S.optional(CrawlCreateRequestCrawlPurposesList),
    depth: S.optional(S.Number),
    emulateMediaType: S.optional(S.String),
    formats: S.optional(CrawlCreateRequestFormatsList),
    gotoOptions: S.optional(CrawlCreateRequestGotoOptions),
    jsonOptions: S.optional(CrawlCreateRequestJsonOptions),
    limit: S.optional(S.Number),
    maxAge: S.optional(S.Number),
    modifiedSince: S.optional(S.Number),
    options: S.optional(CrawlCreateRequestOptions),
    rejectRequestPattern: S.optional(
      CrawlCreateRequestRejectRequestPatternList,
    ),
    rejectResourceTypes: S.optional(CrawlCreateRequestRejectResourceTypesList),
    render: S.optional(S.Boolean),
    setExtraHTTPHeaders: S.optional(CrawlCreateRequestSetExtraHTTPHeadersMap),
    setJavaScriptEnabled: S.optional(S.Boolean),
    source: S.optional(CrawlCreateRequestSource),
    viewport: S.optional(ContentCreateRequestViewport),
    waitForSelector: S.optional(ContentCreateRequestWaitForSelector),
    waitForTimeout: S.optional(S.Number),
  })
    .pipe(
      T.Http({
        method: "POST",
        uri: "/accounts/{account_id}/browser-rendering/crawl",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateCrawlRequest",
}) as any as S.Schema<CreateCrawlRequest>;

export type CreateCrawlResponse = string;
export const CreateCrawlResponse = /*@__PURE__*/ S.suspend(() =>
  S.String.pipe(T.EnvelopePayloadRoot(), T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateCrawlResponse",
}) as any as S.Schema<CreateCrawlResponse>;

export interface CreateDevtoolBrowserRequest {
  /** Account ID. */
  accountId: string;
  /** Keep-alive time in milliseconds. */
  keepAlive?: number;
  /** Use experimental browser. */
  lab?: boolean;
  /** How long the live view URL remains valid, in milliseconds (max 60 minutes). Only used when targets is true. */
  liveViewUrlExpiresInMs?: number;
  recording?: boolean;
  /** Include browser targets in response. */
  targets?: boolean;
}
export const CreateDevtoolBrowserRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    keepAlive: S.optional(S.Number.pipe(T.Query("keep_alive"))),
    lab: S.optional(S.Boolean.pipe(T.Query())),
    liveViewUrlExpiresInMs: S.optional(S.Number.pipe(T.Query())),
    recording: S.optional(S.Boolean.pipe(T.Query())),
    targets: S.optional(S.Boolean.pipe(T.Query())),
  })
    .pipe(
      T.Http({
        method: "POST",
        uri: "/accounts/{account_id}/browser-rendering/devtools/browser",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateDevtoolBrowserRequest",
}) as any as S.Schema<CreateDevtoolBrowserRequest>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface CreateDevtoolBrowserResponse {
  /** Browser session ID. */
  sessionId: string;
  /** WebSocket URL for the session. */
  webSocketDebuggerUrl?: string | null;
}
export const CreateDevtoolBrowserResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    sessionId: S.String,
    webSocketDebuggerUrl: S.optional(S.NullOr(S.String)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateDevtoolBrowserResponse",
}) as any as S.Schema<CreateDevtoolBrowserResponse>;

export interface CreateDevtoolBrowserTargetRequest {
  /** Account ID. */
  accountId: string;
  /** Browser session ID. */
  sessionId: string;
  /** How long the live view URL remains valid, in milliseconds (max 60 minutes) */
  liveViewUrlExpiresInMs?: number;
  url?: string;
}
export const CreateDevtoolBrowserTargetRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    sessionId: S.String.pipe(T.Label("session_id")),
    liveViewUrlExpiresInMs: S.optional(S.Number.pipe(T.Query())),
    url: S.optional(S.String.pipe(T.Query())),
  })
    .pipe(
      T.Http({
        method: "PUT",
        uri: "/accounts/{account_id}/browser-rendering/devtools/browser/{session_id}/json/new",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateDevtoolBrowserTargetRequest",
}) as any as S.Schema<CreateDevtoolBrowserTargetRequest>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface CreateDevtoolBrowserTargetResponse {
  /** Target ID. */
  id: string;
  /** Target type (page, background_page, worker, etc.). */
  type: string;
  /** URL of the target. */
  url: string;
  /** Target description. */
  description?: string | null;
  /** DevTools frontend URL. */
  devtoolsFrontendUrl?: string | null;
  /** Title of the target. */
  title?: string | null;
  /** WebSocket URL for debugging this target. */
  webSocketDebuggerUrl?: string | null;
}
export const CreateDevtoolBrowserTargetResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    type: S.String,
    url: S.String,
    description: S.optional(S.NullOr(S.String)),
    devtoolsFrontendUrl: S.optional(S.NullOr(S.String)),
    title: S.optional(S.NullOr(S.String)),
    webSocketDebuggerUrl: S.optional(S.NullOr(S.String)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateDevtoolBrowserTargetResponse",
}) as any as S.Schema<CreateDevtoolBrowserTargetResponse>;

export type JsonCreateRequestAddScriptTagItem =
  ContentCreateRequestAddScriptTagItem;
export const JsonCreateRequestAddScriptTagItem =
  ContentCreateRequestAddScriptTagItem;

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

export type JsonCreateRequestAddStyleTagItem =
  ContentCreateRequestAddStyleTagItem;
export const JsonCreateRequestAddStyleTagItem =
  ContentCreateRequestAddStyleTagItem;

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

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

export type JsonCreateRequestAllowResourceTypesItem =
  | "document"
  | "stylesheet"
  | "image"
  | "media"
  | "font"
  | "script"
  | "texttrack"
  | "xhr"
  | "fetch"
  | "prefetch"
  | "eventsource"
  | "websocket"
  | "manifest"
  | "signedexchange"
  | "ping"
  | "cspviolationreport"
  | "preflight"
  | "other";
export const JsonCreateRequestAllowResourceTypesItem = /*@__PURE__*/ S.String;

export type JsonCreateRequestAllowResourceTypesList = Array<
  JsonCreateRequestAllowResourceTypesItem | (string & {})
>;
export const JsonCreateRequestAllowResourceTypesList = /*@__PURE__*/ S.Array(
  JsonCreateRequestAllowResourceTypesItem,
) as any as S.Schema<JsonCreateRequestAllowResourceTypesList>;

export type JsonCreateRequestAuthenticate = ContentCreateRequestAuthenticate;
export const JsonCreateRequestAuthenticate = ContentCreateRequestAuthenticate;

export type JsonCreateRequestCookiesItemPriority = "Low" | "Medium" | "High";
export const JsonCreateRequestCookiesItemPriority = /*@__PURE__*/ S.String;

export type JsonCreateRequestCookiesItemSameSite = "Strict" | "Lax" | "None";
export const JsonCreateRequestCookiesItemSameSite = /*@__PURE__*/ S.String;

export type JsonCreateRequestCookiesItemSourceScheme =
  | "Unset"
  | "NonSecure"
  | "Secure";
export const JsonCreateRequestCookiesItemSourceScheme = /*@__PURE__*/ S.String;

export interface JsonCreateRequestCookiesItem {
  /** Cookie name. */
  name: string;
  value: string;
  domain?: string;
  expires?: number;
  httpOnly?: boolean;
  partitionKey?: string;
  path?: string;
  priority?: JsonCreateRequestCookiesItemPriority | (string & {});
  sameParty?: boolean;
  sameSite?: JsonCreateRequestCookiesItemSameSite | (string & {});
  secure?: boolean;
  sourcePort?: number;
  sourceScheme?: JsonCreateRequestCookiesItemSourceScheme | (string & {});
  url?: string;
}
export const JsonCreateRequestCookiesItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    name: S.String,
    value: S.String,
    domain: S.optional(S.String),
    expires: S.optional(S.Number),
    httpOnly: S.optional(S.Boolean),
    partitionKey: S.optional(S.String),
    path: S.optional(S.String),
    priority: S.optional(JsonCreateRequestCookiesItemPriority),
    sameParty: S.optional(S.Boolean),
    sameSite: S.optional(JsonCreateRequestCookiesItemSameSite),
    secure: S.optional(S.Boolean),
    sourcePort: S.optional(S.Number),
    sourceScheme: S.optional(JsonCreateRequestCookiesItemSourceScheme),
    url: S.optional(S.String),
  }),
).annotate({
  identifier: "JsonCreateRequestCookiesItem",
}) as any as S.Schema<JsonCreateRequestCookiesItem>;

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

export type JsonCreateRequestCustomAiItem =
  CrawlCreateRequestJsonOptionsCustomAiItem;
export const JsonCreateRequestCustomAiItem =
  CrawlCreateRequestJsonOptionsCustomAiItem;

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

export type JsonCreateRequestGotoOptionsWaitUntilCase0 =
  | "load"
  | "domcontentloaded"
  | "networkidle0"
  | "networkidle2";
export const JsonCreateRequestGotoOptionsWaitUntilCase0 =
  /*@__PURE__*/ S.String;

export type JsonCreateRequestGotoOptionsWaitUntilCase1Item =
  | "load"
  | "domcontentloaded"
  | "networkidle0"
  | "networkidle2";
export const JsonCreateRequestGotoOptionsWaitUntilCase1Item =
  /*@__PURE__*/ S.String;

export type JsonCreateRequestGotoOptionsWaitUntilCase1List = Array<
  JsonCreateRequestGotoOptionsWaitUntilCase1Item | (string & {})
>;
export const JsonCreateRequestGotoOptionsWaitUntilCase1List =
  /*@__PURE__*/ S.Array(
    JsonCreateRequestGotoOptionsWaitUntilCase1Item,
  ) as any as S.Schema<JsonCreateRequestGotoOptionsWaitUntilCase1List>;

export type JsonCreateRequestGotoOptionsWaitUntil =
  | JsonCreateRequestGotoOptionsWaitUntilCase0
  | (string & {})
  | JsonCreateRequestGotoOptionsWaitUntilCase1List;
export const JsonCreateRequestGotoOptionsWaitUntil =
  /*@__PURE__*/ S.Unknown.pipe(T.UnionCases([[], []]));

export interface JsonCreateRequestGotoOptions {
  referer?: string;
  referrerPolicy?: string;
  timeout?: number;
  waitUntil?: JsonCreateRequestGotoOptionsWaitUntil;
}
export const JsonCreateRequestGotoOptions = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    referer: S.optional(S.String),
    referrerPolicy: S.optional(S.String),
    timeout: S.optional(S.Number),
    waitUntil: S.optional(JsonCreateRequestGotoOptionsWaitUntil),
  }),
).annotate({
  identifier: "JsonCreateRequestGotoOptions",
}) as any as S.Schema<JsonCreateRequestGotoOptions>;

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

export type JsonCreateRequestRejectResourceTypesItem =
  | "document"
  | "stylesheet"
  | "image"
  | "media"
  | "font"
  | "script"
  | "texttrack"
  | "xhr"
  | "fetch"
  | "prefetch"
  | "eventsource"
  | "websocket"
  | "manifest"
  | "signedexchange"
  | "ping"
  | "cspviolationreport"
  | "preflight"
  | "other";
export const JsonCreateRequestRejectResourceTypesItem = /*@__PURE__*/ S.String;

export type JsonCreateRequestRejectResourceTypesList = Array<
  JsonCreateRequestRejectResourceTypesItem | (string & {})
>;
export const JsonCreateRequestRejectResourceTypesList = /*@__PURE__*/ S.Array(
  JsonCreateRequestRejectResourceTypesItem,
) as any as S.Schema<JsonCreateRequestRejectResourceTypesList>;

export type JsonCreateRequestResponseFormat =
  CrawlCreateRequestJsonOptionsResponseFormat;
export const JsonCreateRequestResponseFormat =
  CrawlCreateRequestJsonOptionsResponseFormat;

export type JsonCreateRequestSetExtraHTTPHeadersMap = {
  [key: string]: string | undefined;
};
export const JsonCreateRequestSetExtraHTTPHeadersMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<JsonCreateRequestSetExtraHTTPHeadersMap>;

export type JsonCreateRequestViewport = ContentCreateRequestViewport;
export const JsonCreateRequestViewport = ContentCreateRequestViewport;

export type JsonCreateRequestWaitForSelector =
  ContentCreateRequestWaitForSelector;
export const JsonCreateRequestWaitForSelector =
  ContentCreateRequestWaitForSelector;

export interface CreateJsonRequest {
  /** Account ID. */
  accountId: string;
  /** Cache TTL default is 5s. Set to 0 to disable. */
  cacheTTL?: number;
  /** Set the content of the page, eg: `<h1>Hello World!!</h1>`. Either `html` or `url` must be set. */
  html?: string;
  /** The maximum duration allowed for the browser action to complete after the page has loaded (such as taking screenshots, extracting content, or generating PDFs). If this time limit is exceeded, the action stops and returns a timeout error. */
  actionTimeout?: number;
  /** Adds a `<script>` tag into the page with the desired URL or content. */
  addScriptTag?: JsonCreateRequestAddScriptTagList;
  /** Adds a `<link rel="stylesheet">` tag into the page with the desired URL or a `<style type="text/css">` tag with the content. */
  addStyleTag?: JsonCreateRequestAddStyleTagList;
  /** Only allow requests that match the provided regex patterns, eg. '/^.*.(css)'. */
  allowRequestPattern?: JsonCreateRequestAllowRequestPatternList;
  /** Only allow requests that match the provided resource types, eg. 'image' or 'script'. */
  allowResourceTypes?: JsonCreateRequestAllowResourceTypesList;
  /** Provide credentials for HTTP authentication. */
  authenticate?: ContentCreateRequestAuthenticate;
  /** Attempt to proceed when 'awaited' events fail or timeout. */
  bestAttempt?: boolean;
  /** Check [options](https://pptr.dev/api/puppeteer.page.setcookie). */
  cookies?: JsonCreateRequestCookiesList;
  /** Optional list of custom AI models to use for the request. The models will be tried in the order provided, and in case a model returns an error, the next one will be used as fallback. */
  customAi?: JsonCreateRequestCustomAiList;
  emulateMediaType?: string;
  /** Check [options](https://pptr.dev/api/puppeteer.gotooptions). */
  gotoOptions?: JsonCreateRequestGotoOptions;
  prompt?: string;
  /** Block undesired requests that match the provided regex patterns, eg. '/^.*.(css)'. */
  rejectRequestPattern?: JsonCreateRequestRejectRequestPatternList;
  /** Block undesired requests that match the provided resource types, eg. 'image' or 'script'. */
  rejectResourceTypes?: JsonCreateRequestRejectResourceTypesList;
  responseFormat?: CrawlCreateRequestJsonOptionsResponseFormat;
  setExtraHTTPHeaders?: JsonCreateRequestSetExtraHTTPHeadersMap;
  setJavaScriptEnabled?: boolean;
  userAgent?: string;
  /** Check [options](https://pptr.dev/api/puppeteer.page.setviewport). */
  viewport?: ContentCreateRequestViewport;
  /** Wait for the selector to appear in page. Check [options](https://pptr.dev/api/puppeteer.page.waitforselector). */
  waitForSelector?: ContentCreateRequestWaitForSelector;
  /** Waits for a specified timeout before continuing. */
  waitForTimeout?: number;
  /** URL to navigate to, eg. `https://example.com`. */
  url?: string;
}
export const CreateJsonRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    cacheTTL: S.optional(S.Number.pipe(T.Query())),
    html: S.optional(S.String),
    actionTimeout: S.optional(S.Number),
    addScriptTag: S.optional(JsonCreateRequestAddScriptTagList),
    addStyleTag: S.optional(JsonCreateRequestAddStyleTagList),
    allowRequestPattern: S.optional(JsonCreateRequestAllowRequestPatternList),
    allowResourceTypes: S.optional(JsonCreateRequestAllowResourceTypesList),
    authenticate: S.optional(ContentCreateRequestAuthenticate),
    bestAttempt: S.optional(S.Boolean),
    cookies: S.optional(JsonCreateRequestCookiesList),
    customAi: S.optional(
      JsonCreateRequestCustomAiList.pipe(T.Body("custom_ai")),
    ),
    emulateMediaType: S.optional(S.String),
    gotoOptions: S.optional(JsonCreateRequestGotoOptions),
    prompt: S.optional(S.String),
    rejectRequestPattern: S.optional(JsonCreateRequestRejectRequestPatternList),
    rejectResourceTypes: S.optional(JsonCreateRequestRejectResourceTypesList),
    responseFormat: S.optional(
      CrawlCreateRequestJsonOptionsResponseFormat.pipe(
        T.Body("response_format"),
      ),
    ),
    setExtraHTTPHeaders: S.optional(JsonCreateRequestSetExtraHTTPHeadersMap),
    setJavaScriptEnabled: S.optional(S.Boolean),
    userAgent: S.optional(S.String),
    viewport: S.optional(ContentCreateRequestViewport),
    waitForSelector: S.optional(ContentCreateRequestWaitForSelector),
    waitForTimeout: S.optional(S.Number),
    url: S.optional(S.String),
  })
    .pipe(
      T.Http({
        method: "POST",
        uri: "/accounts/{account_id}/browser-rendering/json",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateJsonRequest",
}) as any as S.Schema<CreateJsonRequest>;

export type JsonCreateResultMap = { [key: string]: unknown | undefined };
export const JsonCreateResultMap = /*@__PURE__*/ S.Record(
  S.String,
  S.Unknown,
) as any as S.Schema<JsonCreateResultMap>;

export type CreateJsonResponse = JsonCreateResultMap;
export const CreateJsonResponse = /*@__PURE__*/ S.suspend(() =>
  JsonCreateResultMap.pipe(
    T.EnvelopePayloadRoot(),
    T.KeyDictionary(KEY_DICTIONARY),
  ),
).annotate({
  identifier: "CreateJsonResponse",
}) as any as S.Schema<CreateJsonResponse>;

export type LinksCreateRequestAddScriptTagItem =
  ContentCreateRequestAddScriptTagItem;
export const LinksCreateRequestAddScriptTagItem =
  ContentCreateRequestAddScriptTagItem;

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

export type LinksCreateRequestAddStyleTagItem =
  ContentCreateRequestAddStyleTagItem;
export const LinksCreateRequestAddStyleTagItem =
  ContentCreateRequestAddStyleTagItem;

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

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

export type LinksCreateRequestAllowResourceTypesItem =
  | "document"
  | "stylesheet"
  | "image"
  | "media"
  | "font"
  | "script"
  | "texttrack"
  | "xhr"
  | "fetch"
  | "prefetch"
  | "eventsource"
  | "websocket"
  | "manifest"
  | "signedexchange"
  | "ping"
  | "cspviolationreport"
  | "preflight"
  | "other";
export const LinksCreateRequestAllowResourceTypesItem = /*@__PURE__*/ S.String;

export type LinksCreateRequestAllowResourceTypesList = Array<
  LinksCreateRequestAllowResourceTypesItem | (string & {})
>;
export const LinksCreateRequestAllowResourceTypesList = /*@__PURE__*/ S.Array(
  LinksCreateRequestAllowResourceTypesItem,
) as any as S.Schema<LinksCreateRequestAllowResourceTypesList>;

export type LinksCreateRequestAuthenticate = ContentCreateRequestAuthenticate;
export const LinksCreateRequestAuthenticate = ContentCreateRequestAuthenticate;

export type LinksCreateRequestCookiesItemPriority = "Low" | "Medium" | "High";
export const LinksCreateRequestCookiesItemPriority = /*@__PURE__*/ S.String;

export type LinksCreateRequestCookiesItemSameSite = "Strict" | "Lax" | "None";
export const LinksCreateRequestCookiesItemSameSite = /*@__PURE__*/ S.String;

export type LinksCreateRequestCookiesItemSourceScheme =
  | "Unset"
  | "NonSecure"
  | "Secure";
export const LinksCreateRequestCookiesItemSourceScheme = /*@__PURE__*/ S.String;

export interface LinksCreateRequestCookiesItem {
  /** Cookie name. */
  name: string;
  value: string;
  domain?: string;
  expires?: number;
  httpOnly?: boolean;
  partitionKey?: string;
  path?: string;
  priority?: LinksCreateRequestCookiesItemPriority | (string & {});
  sameParty?: boolean;
  sameSite?: LinksCreateRequestCookiesItemSameSite | (string & {});
  secure?: boolean;
  sourcePort?: number;
  sourceScheme?: LinksCreateRequestCookiesItemSourceScheme | (string & {});
  url?: string;
}
export const LinksCreateRequestCookiesItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    name: S.String,
    value: S.String,
    domain: S.optional(S.String),
    expires: S.optional(S.Number),
    httpOnly: S.optional(S.Boolean),
    partitionKey: S.optional(S.String),
    path: S.optional(S.String),
    priority: S.optional(LinksCreateRequestCookiesItemPriority),
    sameParty: S.optional(S.Boolean),
    sameSite: S.optional(LinksCreateRequestCookiesItemSameSite),
    secure: S.optional(S.Boolean),
    sourcePort: S.optional(S.Number),
    sourceScheme: S.optional(LinksCreateRequestCookiesItemSourceScheme),
    url: S.optional(S.String),
  }),
).annotate({
  identifier: "LinksCreateRequestCookiesItem",
}) as any as S.Schema<LinksCreateRequestCookiesItem>;

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

export type LinksCreateRequestGotoOptionsWaitUntilCase0 =
  | "load"
  | "domcontentloaded"
  | "networkidle0"
  | "networkidle2";
export const LinksCreateRequestGotoOptionsWaitUntilCase0 =
  /*@__PURE__*/ S.String;

export type LinksCreateRequestGotoOptionsWaitUntilCase1Item =
  | "load"
  | "domcontentloaded"
  | "networkidle0"
  | "networkidle2";
export const LinksCreateRequestGotoOptionsWaitUntilCase1Item =
  /*@__PURE__*/ S.String;

export type LinksCreateRequestGotoOptionsWaitUntilCase1List = Array<
  LinksCreateRequestGotoOptionsWaitUntilCase1Item | (string & {})
>;
export const LinksCreateRequestGotoOptionsWaitUntilCase1List =
  /*@__PURE__*/ S.Array(
    LinksCreateRequestGotoOptionsWaitUntilCase1Item,
  ) as any as S.Schema<LinksCreateRequestGotoOptionsWaitUntilCase1List>;

export type LinksCreateRequestGotoOptionsWaitUntil =
  | LinksCreateRequestGotoOptionsWaitUntilCase0
  | (string & {})
  | LinksCreateRequestGotoOptionsWaitUntilCase1List;
export const LinksCreateRequestGotoOptionsWaitUntil =
  /*@__PURE__*/ S.Unknown.pipe(T.UnionCases([[], []]));

export interface LinksCreateRequestGotoOptions {
  referer?: string;
  referrerPolicy?: string;
  timeout?: number;
  waitUntil?: LinksCreateRequestGotoOptionsWaitUntil;
}
export const LinksCreateRequestGotoOptions = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    referer: S.optional(S.String),
    referrerPolicy: S.optional(S.String),
    timeout: S.optional(S.Number),
    waitUntil: S.optional(LinksCreateRequestGotoOptionsWaitUntil),
  }),
).annotate({
  identifier: "LinksCreateRequestGotoOptions",
}) as any as S.Schema<LinksCreateRequestGotoOptions>;

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

export type LinksCreateRequestRejectResourceTypesItem =
  | "document"
  | "stylesheet"
  | "image"
  | "media"
  | "font"
  | "script"
  | "texttrack"
  | "xhr"
  | "fetch"
  | "prefetch"
  | "eventsource"
  | "websocket"
  | "manifest"
  | "signedexchange"
  | "ping"
  | "cspviolationreport"
  | "preflight"
  | "other";
export const LinksCreateRequestRejectResourceTypesItem = /*@__PURE__*/ S.String;

export type LinksCreateRequestRejectResourceTypesList = Array<
  LinksCreateRequestRejectResourceTypesItem | (string & {})
>;
export const LinksCreateRequestRejectResourceTypesList = /*@__PURE__*/ S.Array(
  LinksCreateRequestRejectResourceTypesItem,
) as any as S.Schema<LinksCreateRequestRejectResourceTypesList>;

export type LinksCreateRequestSetExtraHTTPHeadersMap = {
  [key: string]: string | undefined;
};
export const LinksCreateRequestSetExtraHTTPHeadersMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<LinksCreateRequestSetExtraHTTPHeadersMap>;

export type LinksCreateRequestViewport = ContentCreateRequestViewport;
export const LinksCreateRequestViewport = ContentCreateRequestViewport;

export type LinksCreateRequestWaitForSelector =
  ContentCreateRequestWaitForSelector;
export const LinksCreateRequestWaitForSelector =
  ContentCreateRequestWaitForSelector;

export interface CreateLinkRequest {
  /** Account ID. */
  accountId: string;
  /** Cache TTL default is 5s. Set to 0 to disable. */
  cacheTTL?: number;
  /** Set the content of the page, eg: `<h1>Hello World!!</h1>`. Either `html` or `url` must be set. */
  html?: string;
  /** The maximum duration allowed for the browser action to complete after the page has loaded (such as taking screenshots, extracting content, or generating PDFs). If this time limit is exceeded, the action stops and returns a timeout error. */
  actionTimeout?: number;
  /** Adds a `<script>` tag into the page with the desired URL or content. */
  addScriptTag?: LinksCreateRequestAddScriptTagList;
  /** Adds a `<link rel="stylesheet">` tag into the page with the desired URL or a `<style type="text/css">` tag with the content. */
  addStyleTag?: LinksCreateRequestAddStyleTagList;
  /** Only allow requests that match the provided regex patterns, eg. '/^.*.(css)'. */
  allowRequestPattern?: LinksCreateRequestAllowRequestPatternList;
  /** Only allow requests that match the provided resource types, eg. 'image' or 'script'. */
  allowResourceTypes?: LinksCreateRequestAllowResourceTypesList;
  /** Provide credentials for HTTP authentication. */
  authenticate?: ContentCreateRequestAuthenticate;
  /** Attempt to proceed when 'awaited' events fail or timeout. */
  bestAttempt?: boolean;
  /** Check [options](https://pptr.dev/api/puppeteer.page.setcookie). */
  cookies?: LinksCreateRequestCookiesList;
  emulateMediaType?: string;
  excludeExternalLinks?: boolean;
  /** Check [options](https://pptr.dev/api/puppeteer.gotooptions). */
  gotoOptions?: LinksCreateRequestGotoOptions;
  /** Block undesired requests that match the provided regex patterns, eg. '/^.*.(css)'. */
  rejectRequestPattern?: LinksCreateRequestRejectRequestPatternList;
  /** Block undesired requests that match the provided resource types, eg. 'image' or 'script'. */
  rejectResourceTypes?: LinksCreateRequestRejectResourceTypesList;
  setExtraHTTPHeaders?: LinksCreateRequestSetExtraHTTPHeadersMap;
  setJavaScriptEnabled?: boolean;
  userAgent?: string;
  /** Check [options](https://pptr.dev/api/puppeteer.page.setviewport). */
  viewport?: ContentCreateRequestViewport;
  visibleLinksOnly?: boolean;
  /** Wait for the selector to appear in page. Check [options](https://pptr.dev/api/puppeteer.page.waitforselector). */
  waitForSelector?: ContentCreateRequestWaitForSelector;
  /** Waits for a specified timeout before continuing. */
  waitForTimeout?: number;
  /** URL to navigate to, eg. `https://example.com`. */
  url?: string;
}
export const CreateLinkRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    cacheTTL: S.optional(S.Number.pipe(T.Query())),
    html: S.optional(S.String),
    actionTimeout: S.optional(S.Number),
    addScriptTag: S.optional(LinksCreateRequestAddScriptTagList),
    addStyleTag: S.optional(LinksCreateRequestAddStyleTagList),
    allowRequestPattern: S.optional(LinksCreateRequestAllowRequestPatternList),
    allowResourceTypes: S.optional(LinksCreateRequestAllowResourceTypesList),
    authenticate: S.optional(ContentCreateRequestAuthenticate),
    bestAttempt: S.optional(S.Boolean),
    cookies: S.optional(LinksCreateRequestCookiesList),
    emulateMediaType: S.optional(S.String),
    excludeExternalLinks: S.optional(S.Boolean),
    gotoOptions: S.optional(LinksCreateRequestGotoOptions),
    rejectRequestPattern: S.optional(
      LinksCreateRequestRejectRequestPatternList,
    ),
    rejectResourceTypes: S.optional(LinksCreateRequestRejectResourceTypesList),
    setExtraHTTPHeaders: S.optional(LinksCreateRequestSetExtraHTTPHeadersMap),
    setJavaScriptEnabled: S.optional(S.Boolean),
    userAgent: S.optional(S.String),
    viewport: S.optional(ContentCreateRequestViewport),
    visibleLinksOnly: S.optional(S.Boolean),
    waitForSelector: S.optional(ContentCreateRequestWaitForSelector),
    waitForTimeout: S.optional(S.Number),
    url: S.optional(S.String),
  })
    .pipe(
      T.Http({
        method: "POST",
        uri: "/accounts/{account_id}/browser-rendering/links",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateLinkRequest",
}) as any as S.Schema<CreateLinkRequest>;

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

export type CreateLinkResponse = LinksCreateResultList;
export const CreateLinkResponse = /*@__PURE__*/ S.suspend(() =>
  LinksCreateResultList.pipe(
    T.EnvelopePayloadRoot(),
    T.KeyDictionary(KEY_DICTIONARY),
  ),
).annotate({
  identifier: "CreateLinkResponse",
}) as any as S.Schema<CreateLinkResponse>;

export type MarkdownCreateRequestAddScriptTagItem =
  ContentCreateRequestAddScriptTagItem;
export const MarkdownCreateRequestAddScriptTagItem =
  ContentCreateRequestAddScriptTagItem;

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

export type MarkdownCreateRequestAddStyleTagItem =
  ContentCreateRequestAddStyleTagItem;
export const MarkdownCreateRequestAddStyleTagItem =
  ContentCreateRequestAddStyleTagItem;

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

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

export type MarkdownCreateRequestAllowResourceTypesItem =
  | "document"
  | "stylesheet"
  | "image"
  | "media"
  | "font"
  | "script"
  | "texttrack"
  | "xhr"
  | "fetch"
  | "prefetch"
  | "eventsource"
  | "websocket"
  | "manifest"
  | "signedexchange"
  | "ping"
  | "cspviolationreport"
  | "preflight"
  | "other";
export const MarkdownCreateRequestAllowResourceTypesItem =
  /*@__PURE__*/ S.String;

export type MarkdownCreateRequestAllowResourceTypesList = Array<
  MarkdownCreateRequestAllowResourceTypesItem | (string & {})
>;
export const MarkdownCreateRequestAllowResourceTypesList =
  /*@__PURE__*/ S.Array(
    MarkdownCreateRequestAllowResourceTypesItem,
  ) as any as S.Schema<MarkdownCreateRequestAllowResourceTypesList>;

export type MarkdownCreateRequestAuthenticate =
  ContentCreateRequestAuthenticate;
export const MarkdownCreateRequestAuthenticate =
  ContentCreateRequestAuthenticate;

export type MarkdownCreateRequestCookiesItemPriority =
  | "Low"
  | "Medium"
  | "High";
export const MarkdownCreateRequestCookiesItemPriority = /*@__PURE__*/ S.String;

export type MarkdownCreateRequestCookiesItemSameSite =
  | "Strict"
  | "Lax"
  | "None";
export const MarkdownCreateRequestCookiesItemSameSite = /*@__PURE__*/ S.String;

export type MarkdownCreateRequestCookiesItemSourceScheme =
  | "Unset"
  | "NonSecure"
  | "Secure";
export const MarkdownCreateRequestCookiesItemSourceScheme =
  /*@__PURE__*/ S.String;

export interface MarkdownCreateRequestCookiesItem {
  /** Cookie name. */
  name: string;
  value: string;
  domain?: string;
  expires?: number;
  httpOnly?: boolean;
  partitionKey?: string;
  path?: string;
  priority?: MarkdownCreateRequestCookiesItemPriority | (string & {});
  sameParty?: boolean;
  sameSite?: MarkdownCreateRequestCookiesItemSameSite | (string & {});
  secure?: boolean;
  sourcePort?: number;
  sourceScheme?: MarkdownCreateRequestCookiesItemSourceScheme | (string & {});
  url?: string;
}
export const MarkdownCreateRequestCookiesItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    name: S.String,
    value: S.String,
    domain: S.optional(S.String),
    expires: S.optional(S.Number),
    httpOnly: S.optional(S.Boolean),
    partitionKey: S.optional(S.String),
    path: S.optional(S.String),
    priority: S.optional(MarkdownCreateRequestCookiesItemPriority),
    sameParty: S.optional(S.Boolean),
    sameSite: S.optional(MarkdownCreateRequestCookiesItemSameSite),
    secure: S.optional(S.Boolean),
    sourcePort: S.optional(S.Number),
    sourceScheme: S.optional(MarkdownCreateRequestCookiesItemSourceScheme),
    url: S.optional(S.String),
  }),
).annotate({
  identifier: "MarkdownCreateRequestCookiesItem",
}) as any as S.Schema<MarkdownCreateRequestCookiesItem>;

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

export type MarkdownCreateRequestGotoOptionsWaitUntilCase0 =
  | "load"
  | "domcontentloaded"
  | "networkidle0"
  | "networkidle2";
export const MarkdownCreateRequestGotoOptionsWaitUntilCase0 =
  /*@__PURE__*/ S.String;

export type MarkdownCreateRequestGotoOptionsWaitUntilCase1Item =
  | "load"
  | "domcontentloaded"
  | "networkidle0"
  | "networkidle2";
export const MarkdownCreateRequestGotoOptionsWaitUntilCase1Item =
  /*@__PURE__*/ S.String;

export type MarkdownCreateRequestGotoOptionsWaitUntilCase1List = Array<
  MarkdownCreateRequestGotoOptionsWaitUntilCase1Item | (string & {})
>;
export const MarkdownCreateRequestGotoOptionsWaitUntilCase1List =
  /*@__PURE__*/ S.Array(
    MarkdownCreateRequestGotoOptionsWaitUntilCase1Item,
  ) as any as S.Schema<MarkdownCreateRequestGotoOptionsWaitUntilCase1List>;

export type MarkdownCreateRequestGotoOptionsWaitUntil =
  | MarkdownCreateRequestGotoOptionsWaitUntilCase0
  | (string & {})
  | MarkdownCreateRequestGotoOptionsWaitUntilCase1List;
export const MarkdownCreateRequestGotoOptionsWaitUntil =
  /*@__PURE__*/ S.Unknown.pipe(T.UnionCases([[], []]));

export interface MarkdownCreateRequestGotoOptions {
  referer?: string;
  referrerPolicy?: string;
  timeout?: number;
  waitUntil?: MarkdownCreateRequestGotoOptionsWaitUntil;
}
export const MarkdownCreateRequestGotoOptions = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    referer: S.optional(S.String),
    referrerPolicy: S.optional(S.String),
    timeout: S.optional(S.Number),
    waitUntil: S.optional(MarkdownCreateRequestGotoOptionsWaitUntil),
  }),
).annotate({
  identifier: "MarkdownCreateRequestGotoOptions",
}) as any as S.Schema<MarkdownCreateRequestGotoOptions>;

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

export type MarkdownCreateRequestRejectResourceTypesItem =
  | "document"
  | "stylesheet"
  | "image"
  | "media"
  | "font"
  | "script"
  | "texttrack"
  | "xhr"
  | "fetch"
  | "prefetch"
  | "eventsource"
  | "websocket"
  | "manifest"
  | "signedexchange"
  | "ping"
  | "cspviolationreport"
  | "preflight"
  | "other";
export const MarkdownCreateRequestRejectResourceTypesItem =
  /*@__PURE__*/ S.String;

export type MarkdownCreateRequestRejectResourceTypesList = Array<
  MarkdownCreateRequestRejectResourceTypesItem | (string & {})
>;
export const MarkdownCreateRequestRejectResourceTypesList =
  /*@__PURE__*/ S.Array(
    MarkdownCreateRequestRejectResourceTypesItem,
  ) as any as S.Schema<MarkdownCreateRequestRejectResourceTypesList>;

export type MarkdownCreateRequestSetExtraHTTPHeadersMap = {
  [key: string]: string | undefined;
};
export const MarkdownCreateRequestSetExtraHTTPHeadersMap =
  /*@__PURE__*/ S.Record(
    S.String,
    S.String,
  ) as any as S.Schema<MarkdownCreateRequestSetExtraHTTPHeadersMap>;

export type MarkdownCreateRequestViewport = ContentCreateRequestViewport;
export const MarkdownCreateRequestViewport = ContentCreateRequestViewport;

export type MarkdownCreateRequestWaitForSelector =
  ContentCreateRequestWaitForSelector;
export const MarkdownCreateRequestWaitForSelector =
  ContentCreateRequestWaitForSelector;

export interface CreateMarkdownRequest {
  /** Account ID. */
  accountId: string;
  /** Cache TTL default is 5s. Set to 0 to disable. */
  cacheTTL?: number;
  /** URL to navigate to, eg. `https://example.com`. */
  url?: string;
  /** The maximum duration allowed for the browser action to complete after the page has loaded (such as taking screenshots, extracting content, or generating PDFs). If this time limit is exceeded, the action stops and returns a timeout error. */
  actionTimeout?: number;
  /** Adds a `<script>` tag into the page with the desired URL or content. */
  addScriptTag?: MarkdownCreateRequestAddScriptTagList;
  /** Adds a `<link rel="stylesheet">` tag into the page with the desired URL or a `<style type="text/css">` tag with the content. */
  addStyleTag?: MarkdownCreateRequestAddStyleTagList;
  /** Only allow requests that match the provided regex patterns, eg. '/^.*.(css)'. */
  allowRequestPattern?: MarkdownCreateRequestAllowRequestPatternList;
  /** Only allow requests that match the provided resource types, eg. 'image' or 'script'. */
  allowResourceTypes?: MarkdownCreateRequestAllowResourceTypesList;
  /** Provide credentials for HTTP authentication. */
  authenticate?: ContentCreateRequestAuthenticate;
  /** Attempt to proceed when 'awaited' events fail or timeout. */
  bestAttempt?: boolean;
  /** Check [options](https://pptr.dev/api/puppeteer.page.setcookie). */
  cookies?: MarkdownCreateRequestCookiesList;
  emulateMediaType?: string;
  /** Check [options](https://pptr.dev/api/puppeteer.gotooptions). */
  gotoOptions?: MarkdownCreateRequestGotoOptions;
  /** Block undesired requests that match the provided regex patterns, eg. '/^.*.(css)'. */
  rejectRequestPattern?: MarkdownCreateRequestRejectRequestPatternList;
  /** Block undesired requests that match the provided resource types, eg. 'image' or 'script'. */
  rejectResourceTypes?: MarkdownCreateRequestRejectResourceTypesList;
  setExtraHTTPHeaders?: MarkdownCreateRequestSetExtraHTTPHeadersMap;
  setJavaScriptEnabled?: boolean;
  userAgent?: string;
  /** Check [options](https://pptr.dev/api/puppeteer.page.setviewport). */
  viewport?: ContentCreateRequestViewport;
  /** Wait for the selector to appear in page. Check [options](https://pptr.dev/api/puppeteer.page.waitforselector). */
  waitForSelector?: ContentCreateRequestWaitForSelector;
  /** Waits for a specified timeout before continuing. */
  waitForTimeout?: number;
  /** Set the content of the page, eg: `<h1>Hello World!!</h1>`. Either `html` or `url` must be set. */
  html?: string;
}
export const CreateMarkdownRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    cacheTTL: S.optional(S.Number.pipe(T.Query())),
    url: S.optional(S.String),
    actionTimeout: S.optional(S.Number),
    addScriptTag: S.optional(MarkdownCreateRequestAddScriptTagList),
    addStyleTag: S.optional(MarkdownCreateRequestAddStyleTagList),
    allowRequestPattern: S.optional(
      MarkdownCreateRequestAllowRequestPatternList,
    ),
    allowResourceTypes: S.optional(MarkdownCreateRequestAllowResourceTypesList),
    authenticate: S.optional(ContentCreateRequestAuthenticate),
    bestAttempt: S.optional(S.Boolean),
    cookies: S.optional(MarkdownCreateRequestCookiesList),
    emulateMediaType: S.optional(S.String),
    gotoOptions: S.optional(MarkdownCreateRequestGotoOptions),
    rejectRequestPattern: S.optional(
      MarkdownCreateRequestRejectRequestPatternList,
    ),
    rejectResourceTypes: S.optional(
      MarkdownCreateRequestRejectResourceTypesList,
    ),
    setExtraHTTPHeaders: S.optional(
      MarkdownCreateRequestSetExtraHTTPHeadersMap,
    ),
    setJavaScriptEnabled: S.optional(S.Boolean),
    userAgent: S.optional(S.String),
    viewport: S.optional(ContentCreateRequestViewport),
    waitForSelector: S.optional(ContentCreateRequestWaitForSelector),
    waitForTimeout: S.optional(S.Number),
    html: S.optional(S.String),
  })
    .pipe(
      T.Http({
        method: "POST",
        uri: "/accounts/{account_id}/browser-rendering/markdown",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateMarkdownRequest",
}) as any as S.Schema<CreateMarkdownRequest>;

export type CreateMarkdownResponse = string;
export const CreateMarkdownResponse = /*@__PURE__*/ S.suspend(() =>
  S.String.pipe(T.EnvelopePayloadRoot(), T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateMarkdownResponse",
}) as any as S.Schema<CreateMarkdownResponse>;

export type PdfCreateRequestAddScriptTagItem =
  ContentCreateRequestAddScriptTagItem;
export const PdfCreateRequestAddScriptTagItem =
  ContentCreateRequestAddScriptTagItem;

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

export type PdfCreateRequestAddStyleTagItem =
  ContentCreateRequestAddStyleTagItem;
export const PdfCreateRequestAddStyleTagItem =
  ContentCreateRequestAddStyleTagItem;

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

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

export type PdfCreateRequestAllowResourceTypesItem =
  | "document"
  | "stylesheet"
  | "image"
  | "media"
  | "font"
  | "script"
  | "texttrack"
  | "xhr"
  | "fetch"
  | "prefetch"
  | "eventsource"
  | "websocket"
  | "manifest"
  | "signedexchange"
  | "ping"
  | "cspviolationreport"
  | "preflight"
  | "other";
export const PdfCreateRequestAllowResourceTypesItem = /*@__PURE__*/ S.String;

export type PdfCreateRequestAllowResourceTypesList = Array<
  PdfCreateRequestAllowResourceTypesItem | (string & {})
>;
export const PdfCreateRequestAllowResourceTypesList = /*@__PURE__*/ S.Array(
  PdfCreateRequestAllowResourceTypesItem,
) as any as S.Schema<PdfCreateRequestAllowResourceTypesList>;

export type PdfCreateRequestAuthenticate = ContentCreateRequestAuthenticate;
export const PdfCreateRequestAuthenticate = ContentCreateRequestAuthenticate;

export type PdfCreateRequestCookiesItemPriority = "Low" | "Medium" | "High";
export const PdfCreateRequestCookiesItemPriority = /*@__PURE__*/ S.String;

export type PdfCreateRequestCookiesItemSameSite = "Strict" | "Lax" | "None";
export const PdfCreateRequestCookiesItemSameSite = /*@__PURE__*/ S.String;

export type PdfCreateRequestCookiesItemSourceScheme =
  | "Unset"
  | "NonSecure"
  | "Secure";
export const PdfCreateRequestCookiesItemSourceScheme = /*@__PURE__*/ S.String;

export interface PdfCreateRequestCookiesItem {
  /** Cookie name. */
  name: string;
  value: string;
  domain?: string;
  expires?: number;
  httpOnly?: boolean;
  partitionKey?: string;
  path?: string;
  priority?: PdfCreateRequestCookiesItemPriority | (string & {});
  sameParty?: boolean;
  sameSite?: PdfCreateRequestCookiesItemSameSite | (string & {});
  secure?: boolean;
  sourcePort?: number;
  sourceScheme?: PdfCreateRequestCookiesItemSourceScheme | (string & {});
  url?: string;
}
export const PdfCreateRequestCookiesItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    name: S.String,
    value: S.String,
    domain: S.optional(S.String),
    expires: S.optional(S.Number),
    httpOnly: S.optional(S.Boolean),
    partitionKey: S.optional(S.String),
    path: S.optional(S.String),
    priority: S.optional(PdfCreateRequestCookiesItemPriority),
    sameParty: S.optional(S.Boolean),
    sameSite: S.optional(PdfCreateRequestCookiesItemSameSite),
    secure: S.optional(S.Boolean),
    sourcePort: S.optional(S.Number),
    sourceScheme: S.optional(PdfCreateRequestCookiesItemSourceScheme),
    url: S.optional(S.String),
  }),
).annotate({
  identifier: "PdfCreateRequestCookiesItem",
}) as any as S.Schema<PdfCreateRequestCookiesItem>;

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

export type PdfCreateRequestGotoOptionsWaitUntilCase0 =
  | "load"
  | "domcontentloaded"
  | "networkidle0"
  | "networkidle2";
export const PdfCreateRequestGotoOptionsWaitUntilCase0 = /*@__PURE__*/ S.String;

export type PdfCreateRequestGotoOptionsWaitUntilCase1Item =
  | "load"
  | "domcontentloaded"
  | "networkidle0"
  | "networkidle2";
export const PdfCreateRequestGotoOptionsWaitUntilCase1Item =
  /*@__PURE__*/ S.String;

export type PdfCreateRequestGotoOptionsWaitUntilCase1List = Array<
  PdfCreateRequestGotoOptionsWaitUntilCase1Item | (string & {})
>;
export const PdfCreateRequestGotoOptionsWaitUntilCase1List =
  /*@__PURE__*/ S.Array(
    PdfCreateRequestGotoOptionsWaitUntilCase1Item,
  ) as any as S.Schema<PdfCreateRequestGotoOptionsWaitUntilCase1List>;

export type PdfCreateRequestGotoOptionsWaitUntil =
  | PdfCreateRequestGotoOptionsWaitUntilCase0
  | (string & {})
  | PdfCreateRequestGotoOptionsWaitUntilCase1List;
export const PdfCreateRequestGotoOptionsWaitUntil =
  /*@__PURE__*/ S.Unknown.pipe(T.UnionCases([[], []]));

export interface PdfCreateRequestGotoOptions {
  referer?: string;
  referrerPolicy?: string;
  timeout?: number;
  waitUntil?: PdfCreateRequestGotoOptionsWaitUntil;
}
export const PdfCreateRequestGotoOptions = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    referer: S.optional(S.String),
    referrerPolicy: S.optional(S.String),
    timeout: S.optional(S.Number),
    waitUntil: S.optional(PdfCreateRequestGotoOptionsWaitUntil),
  }),
).annotate({
  identifier: "PdfCreateRequestGotoOptions",
}) as any as S.Schema<PdfCreateRequestGotoOptions>;

export type PdfCreateRequestPdfOptionsFormat =
  | "letter"
  | "legal"
  | "tabloid"
  | "ledger"
  | "a0"
  | "a1"
  | "a2"
  | "a3"
  | "a4"
  | "a5"
  | "a6";
export const PdfCreateRequestPdfOptionsFormat = /*@__PURE__*/ S.String;

export type PdfCreateRequestPdfOptionsHeight = string | number;
export const PdfCreateRequestPdfOptionsHeight = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([[], []]),
);

export type PdfCreateRequestPdfOptionsMarginBottom = string | number;
export const PdfCreateRequestPdfOptionsMarginBottom =
  /*@__PURE__*/ S.Unknown.pipe(T.UnionCases([[], []]));

export type PdfCreateRequestPdfOptionsMarginLeft = string | number;
export const PdfCreateRequestPdfOptionsMarginLeft =
  /*@__PURE__*/ S.Unknown.pipe(T.UnionCases([[], []]));

export type PdfCreateRequestPdfOptionsMarginRight = string | number;
export const PdfCreateRequestPdfOptionsMarginRight =
  /*@__PURE__*/ S.Unknown.pipe(T.UnionCases([[], []]));

export type PdfCreateRequestPdfOptionsMarginTop = string | number;
export const PdfCreateRequestPdfOptionsMarginTop = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([[], []]),
);

export interface PdfCreateRequestPdfOptionsMargin {
  bottom?: PdfCreateRequestPdfOptionsMarginBottom;
  left?: PdfCreateRequestPdfOptionsMarginLeft;
  right?: PdfCreateRequestPdfOptionsMarginRight;
  top?: PdfCreateRequestPdfOptionsMarginTop;
}
export const PdfCreateRequestPdfOptionsMargin = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    bottom: S.optional(PdfCreateRequestPdfOptionsMarginBottom),
    left: S.optional(PdfCreateRequestPdfOptionsMarginLeft),
    right: S.optional(PdfCreateRequestPdfOptionsMarginRight),
    top: S.optional(PdfCreateRequestPdfOptionsMarginTop),
  }),
).annotate({
  identifier: "PdfCreateRequestPdfOptionsMargin",
}) as any as S.Schema<PdfCreateRequestPdfOptionsMargin>;

export type PdfCreateRequestPdfOptionsWidth = string | number;
export const PdfCreateRequestPdfOptionsWidth = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([[], []]),
);

export interface PdfCreateRequestPdfOptions {
  /** Whether to show the header and footer. */
  displayHeaderFooter?: boolean;
  /** HTML template for the print footer. */
  footerTemplate?: string;
  /** Paper format. Takes priority over width and height if set. */
  format?: PdfCreateRequestPdfOptionsFormat | (string & {});
  /** HTML template for the print header. */
  headerTemplate?: string;
  /** Sets the height of paper. Can be a number or string with unit. */
  height?: PdfCreateRequestPdfOptionsHeight;
  /** Whether to print in landscape orientation. */
  landscape?: boolean;
  /** Set the PDF margins. Useful when setting header and footer. */
  margin?: PdfCreateRequestPdfOptionsMargin;
  /** Hides default white background and allows generating pdfs with transparency. */
  omitBackground?: boolean;
  /** Generate document outline. */
  outline?: boolean;
  /** Paper ranges to print, e.g. '1-5, 8, 11-13'. */
  pageRanges?: string;
  /** Give CSS @page size priority over other size declarations. */
  preferCSSPageSize?: boolean;
  /** Set to true to print background graphics. */
  printBackground?: boolean;
  /** Scales the rendering of the web page. Amount must be between 0.1 and 2. */
  scale?: number;
  /** Generate tagged (accessible) PDF. */
  tagged?: boolean;
  /** Timeout in milliseconds. */
  timeout?: number;
  /** Sets the width of paper. Can be a number or string with unit. */
  width?: PdfCreateRequestPdfOptionsWidth;
}
export const PdfCreateRequestPdfOptions = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    displayHeaderFooter: S.optional(S.Boolean),
    footerTemplate: S.optional(S.String),
    format: S.optional(PdfCreateRequestPdfOptionsFormat),
    headerTemplate: S.optional(S.String),
    height: S.optional(PdfCreateRequestPdfOptionsHeight),
    landscape: S.optional(S.Boolean),
    margin: S.optional(PdfCreateRequestPdfOptionsMargin),
    omitBackground: S.optional(S.Boolean),
    outline: S.optional(S.Boolean),
    pageRanges: S.optional(S.String),
    preferCSSPageSize: S.optional(S.Boolean),
    printBackground: S.optional(S.Boolean),
    scale: S.optional(S.Number),
    tagged: S.optional(S.Boolean),
    timeout: S.optional(S.Number),
    width: S.optional(PdfCreateRequestPdfOptionsWidth),
  }),
).annotate({
  identifier: "PdfCreateRequestPdfOptions",
}) as any as S.Schema<PdfCreateRequestPdfOptions>;

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

export type PdfCreateRequestRejectResourceTypesItem =
  | "document"
  | "stylesheet"
  | "image"
  | "media"
  | "font"
  | "script"
  | "texttrack"
  | "xhr"
  | "fetch"
  | "prefetch"
  | "eventsource"
  | "websocket"
  | "manifest"
  | "signedexchange"
  | "ping"
  | "cspviolationreport"
  | "preflight"
  | "other";
export const PdfCreateRequestRejectResourceTypesItem = /*@__PURE__*/ S.String;

export type PdfCreateRequestRejectResourceTypesList = Array<
  PdfCreateRequestRejectResourceTypesItem | (string & {})
>;
export const PdfCreateRequestRejectResourceTypesList = /*@__PURE__*/ S.Array(
  PdfCreateRequestRejectResourceTypesItem,
) as any as S.Schema<PdfCreateRequestRejectResourceTypesList>;

export type PdfCreateRequestSetExtraHTTPHeadersMap = {
  [key: string]: string | undefined;
};
export const PdfCreateRequestSetExtraHTTPHeadersMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<PdfCreateRequestSetExtraHTTPHeadersMap>;

export type PdfCreateRequestViewport = ContentCreateRequestViewport;
export const PdfCreateRequestViewport = ContentCreateRequestViewport;

export type PdfCreateRequestWaitForSelector =
  ContentCreateRequestWaitForSelector;
export const PdfCreateRequestWaitForSelector =
  ContentCreateRequestWaitForSelector;

export interface CreatePdfRequest {
  /** Account ID. */
  accountId: string;
  /** Cache TTL default is 5s. Set to 0 to disable. */
  cacheTTL?: number;
  /** Set the content of the page, eg: `<h1>Hello World!!</h1>`. Either `html` or `url` must be set. */
  html?: string;
  /** The maximum duration allowed for the browser action to complete after the page has loaded (such as taking screenshots, extracting content, or generating PDFs). If this time limit is exceeded, the action stops and returns a timeout error. */
  actionTimeout?: number;
  /** Adds a `<script>` tag into the page with the desired URL or content. */
  addScriptTag?: PdfCreateRequestAddScriptTagList;
  /** Adds a `<link rel="stylesheet">` tag into the page with the desired URL or a `<style type="text/css">` tag with the content. */
  addStyleTag?: PdfCreateRequestAddStyleTagList;
  /** Only allow requests that match the provided regex patterns, eg. '/^.*.(css)'. */
  allowRequestPattern?: PdfCreateRequestAllowRequestPatternList;
  /** Only allow requests that match the provided resource types, eg. 'image' or 'script'. */
  allowResourceTypes?: PdfCreateRequestAllowResourceTypesList;
  /** Provide credentials for HTTP authentication. */
  authenticate?: ContentCreateRequestAuthenticate;
  /** Attempt to proceed when 'awaited' events fail or timeout. */
  bestAttempt?: boolean;
  /** Check [options](https://pptr.dev/api/puppeteer.page.setcookie). */
  cookies?: PdfCreateRequestCookiesList;
  emulateMediaType?: string;
  /** Check [options](https://pptr.dev/api/puppeteer.gotooptions). */
  gotoOptions?: PdfCreateRequestGotoOptions;
  /** Check [options](https://pptr.dev/api/puppeteer.pdfoptions). */
  pdfOptions?: PdfCreateRequestPdfOptions;
  /** Block undesired requests that match the provided regex patterns, eg. '/^.*.(css)'. */
  rejectRequestPattern?: PdfCreateRequestRejectRequestPatternList;
  /** Block undesired requests that match the provided resource types, eg. 'image' or 'script'. */
  rejectResourceTypes?: PdfCreateRequestRejectResourceTypesList;
  setExtraHTTPHeaders?: PdfCreateRequestSetExtraHTTPHeadersMap;
  setJavaScriptEnabled?: boolean;
  userAgent?: string;
  /** Check [options](https://pptr.dev/api/puppeteer.page.setviewport). */
  viewport?: ContentCreateRequestViewport;
  /** Wait for the selector to appear in page. Check [options](https://pptr.dev/api/puppeteer.page.waitforselector). */
  waitForSelector?: ContentCreateRequestWaitForSelector;
  /** Waits for a specified timeout before continuing. */
  waitForTimeout?: number;
  /** URL to navigate to, eg. `https://example.com`. */
  url?: string;
}
export const CreatePdfRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    cacheTTL: S.optional(S.Number.pipe(T.Query())),
    html: S.optional(S.String),
    actionTimeout: S.optional(S.Number),
    addScriptTag: S.optional(PdfCreateRequestAddScriptTagList),
    addStyleTag: S.optional(PdfCreateRequestAddStyleTagList),
    allowRequestPattern: S.optional(PdfCreateRequestAllowRequestPatternList),
    allowResourceTypes: S.optional(PdfCreateRequestAllowResourceTypesList),
    authenticate: S.optional(ContentCreateRequestAuthenticate),
    bestAttempt: S.optional(S.Boolean),
    cookies: S.optional(PdfCreateRequestCookiesList),
    emulateMediaType: S.optional(S.String),
    gotoOptions: S.optional(PdfCreateRequestGotoOptions),
    pdfOptions: S.optional(PdfCreateRequestPdfOptions),
    rejectRequestPattern: S.optional(PdfCreateRequestRejectRequestPatternList),
    rejectResourceTypes: S.optional(PdfCreateRequestRejectResourceTypesList),
    setExtraHTTPHeaders: S.optional(PdfCreateRequestSetExtraHTTPHeadersMap),
    setJavaScriptEnabled: S.optional(S.Boolean),
    userAgent: S.optional(S.String),
    viewport: S.optional(ContentCreateRequestViewport),
    waitForSelector: S.optional(ContentCreateRequestWaitForSelector),
    waitForTimeout: S.optional(S.Number),
    url: S.optional(S.String),
  })
    .pipe(
      T.Http({
        method: "POST",
        uri: "/accounts/{account_id}/browser-rendering/pdf",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreatePdfRequest",
}) as any as S.Schema<CreatePdfRequest>;

export interface CreatePdfResponse {}
export const CreatePdfResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({}).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreatePdfResponse",
}) as any as S.Schema<CreatePdfResponse>;

export interface ScrapeCreateRequestElementsItem {
  selector: string;
}
export const ScrapeCreateRequestElementsItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    selector: S.String,
  }),
).annotate({
  identifier: "ScrapeCreateRequestElementsItem",
}) as any as S.Schema<ScrapeCreateRequestElementsItem>;

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

export type ScrapeCreateRequestAddScriptTagItem =
  ContentCreateRequestAddScriptTagItem;
export const ScrapeCreateRequestAddScriptTagItem =
  ContentCreateRequestAddScriptTagItem;

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

export type ScrapeCreateRequestAddStyleTagItem =
  ContentCreateRequestAddStyleTagItem;
export const ScrapeCreateRequestAddStyleTagItem =
  ContentCreateRequestAddStyleTagItem;

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

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

export type ScrapeCreateRequestAllowResourceTypesItem =
  | "document"
  | "stylesheet"
  | "image"
  | "media"
  | "font"
  | "script"
  | "texttrack"
  | "xhr"
  | "fetch"
  | "prefetch"
  | "eventsource"
  | "websocket"
  | "manifest"
  | "signedexchange"
  | "ping"
  | "cspviolationreport"
  | "preflight"
  | "other";
export const ScrapeCreateRequestAllowResourceTypesItem = /*@__PURE__*/ S.String;

export type ScrapeCreateRequestAllowResourceTypesList = Array<
  ScrapeCreateRequestAllowResourceTypesItem | (string & {})
>;
export const ScrapeCreateRequestAllowResourceTypesList = /*@__PURE__*/ S.Array(
  ScrapeCreateRequestAllowResourceTypesItem,
) as any as S.Schema<ScrapeCreateRequestAllowResourceTypesList>;

export type ScrapeCreateRequestAuthenticate = ContentCreateRequestAuthenticate;
export const ScrapeCreateRequestAuthenticate = ContentCreateRequestAuthenticate;

export type ScrapeCreateRequestCookiesItemPriority = "Low" | "Medium" | "High";
export const ScrapeCreateRequestCookiesItemPriority = /*@__PURE__*/ S.String;

export type ScrapeCreateRequestCookiesItemSameSite = "Strict" | "Lax" | "None";
export const ScrapeCreateRequestCookiesItemSameSite = /*@__PURE__*/ S.String;

export type ScrapeCreateRequestCookiesItemSourceScheme =
  | "Unset"
  | "NonSecure"
  | "Secure";
export const ScrapeCreateRequestCookiesItemSourceScheme =
  /*@__PURE__*/ S.String;

export interface ScrapeCreateRequestCookiesItem {
  /** Cookie name. */
  name: string;
  value: string;
  domain?: string;
  expires?: number;
  httpOnly?: boolean;
  partitionKey?: string;
  path?: string;
  priority?: ScrapeCreateRequestCookiesItemPriority | (string & {});
  sameParty?: boolean;
  sameSite?: ScrapeCreateRequestCookiesItemSameSite | (string & {});
  secure?: boolean;
  sourcePort?: number;
  sourceScheme?: ScrapeCreateRequestCookiesItemSourceScheme | (string & {});
  url?: string;
}
export const ScrapeCreateRequestCookiesItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    name: S.String,
    value: S.String,
    domain: S.optional(S.String),
    expires: S.optional(S.Number),
    httpOnly: S.optional(S.Boolean),
    partitionKey: S.optional(S.String),
    path: S.optional(S.String),
    priority: S.optional(ScrapeCreateRequestCookiesItemPriority),
    sameParty: S.optional(S.Boolean),
    sameSite: S.optional(ScrapeCreateRequestCookiesItemSameSite),
    secure: S.optional(S.Boolean),
    sourcePort: S.optional(S.Number),
    sourceScheme: S.optional(ScrapeCreateRequestCookiesItemSourceScheme),
    url: S.optional(S.String),
  }),
).annotate({
  identifier: "ScrapeCreateRequestCookiesItem",
}) as any as S.Schema<ScrapeCreateRequestCookiesItem>;

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

export type ScrapeCreateRequestGotoOptionsWaitUntilCase0 =
  | "load"
  | "domcontentloaded"
  | "networkidle0"
  | "networkidle2";
export const ScrapeCreateRequestGotoOptionsWaitUntilCase0 =
  /*@__PURE__*/ S.String;

export type ScrapeCreateRequestGotoOptionsWaitUntilCase1Item =
  | "load"
  | "domcontentloaded"
  | "networkidle0"
  | "networkidle2";
export const ScrapeCreateRequestGotoOptionsWaitUntilCase1Item =
  /*@__PURE__*/ S.String;

export type ScrapeCreateRequestGotoOptionsWaitUntilCase1List = Array<
  ScrapeCreateRequestGotoOptionsWaitUntilCase1Item | (string & {})
>;
export const ScrapeCreateRequestGotoOptionsWaitUntilCase1List =
  /*@__PURE__*/ S.Array(
    ScrapeCreateRequestGotoOptionsWaitUntilCase1Item,
  ) as any as S.Schema<ScrapeCreateRequestGotoOptionsWaitUntilCase1List>;

export type ScrapeCreateRequestGotoOptionsWaitUntil =
  | ScrapeCreateRequestGotoOptionsWaitUntilCase0
  | (string & {})
  | ScrapeCreateRequestGotoOptionsWaitUntilCase1List;
export const ScrapeCreateRequestGotoOptionsWaitUntil =
  /*@__PURE__*/ S.Unknown.pipe(T.UnionCases([[], []]));

export interface ScrapeCreateRequestGotoOptions {
  referer?: string;
  referrerPolicy?: string;
  timeout?: number;
  waitUntil?: ScrapeCreateRequestGotoOptionsWaitUntil;
}
export const ScrapeCreateRequestGotoOptions = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    referer: S.optional(S.String),
    referrerPolicy: S.optional(S.String),
    timeout: S.optional(S.Number),
    waitUntil: S.optional(ScrapeCreateRequestGotoOptionsWaitUntil),
  }),
).annotate({
  identifier: "ScrapeCreateRequestGotoOptions",
}) as any as S.Schema<ScrapeCreateRequestGotoOptions>;

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

export type ScrapeCreateRequestRejectResourceTypesItem =
  | "document"
  | "stylesheet"
  | "image"
  | "media"
  | "font"
  | "script"
  | "texttrack"
  | "xhr"
  | "fetch"
  | "prefetch"
  | "eventsource"
  | "websocket"
  | "manifest"
  | "signedexchange"
  | "ping"
  | "cspviolationreport"
  | "preflight"
  | "other";
export const ScrapeCreateRequestRejectResourceTypesItem =
  /*@__PURE__*/ S.String;

export type ScrapeCreateRequestRejectResourceTypesList = Array<
  ScrapeCreateRequestRejectResourceTypesItem | (string & {})
>;
export const ScrapeCreateRequestRejectResourceTypesList = /*@__PURE__*/ S.Array(
  ScrapeCreateRequestRejectResourceTypesItem,
) as any as S.Schema<ScrapeCreateRequestRejectResourceTypesList>;

export type ScrapeCreateRequestSetExtraHTTPHeadersMap = {
  [key: string]: string | undefined;
};
export const ScrapeCreateRequestSetExtraHTTPHeadersMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<ScrapeCreateRequestSetExtraHTTPHeadersMap>;

export type ScrapeCreateRequestViewport = ContentCreateRequestViewport;
export const ScrapeCreateRequestViewport = ContentCreateRequestViewport;

export type ScrapeCreateRequestWaitForSelector =
  ContentCreateRequestWaitForSelector;
export const ScrapeCreateRequestWaitForSelector =
  ContentCreateRequestWaitForSelector;

export interface CreateScrapeRequest {
  /** Account ID. */
  accountId: string;
  /** Cache TTL default is 5s. Set to 0 to disable. */
  cacheTTL?: number;
  elements: ScrapeCreateRequestElementsList;
  /** Set the content of the page, eg: `<h1>Hello World!!</h1>`. Either `html` or `url` must be set. */
  html?: string;
  /** The maximum duration allowed for the browser action to complete after the page has loaded (such as taking screenshots, extracting content, or generating PDFs). If this time limit is exceeded, the action stops and returns a timeout error. */
  actionTimeout?: number;
  /** Adds a `<script>` tag into the page with the desired URL or content. */
  addScriptTag?: ScrapeCreateRequestAddScriptTagList;
  /** Adds a `<link rel="stylesheet">` tag into the page with the desired URL or a `<style type="text/css">` tag with the content. */
  addStyleTag?: ScrapeCreateRequestAddStyleTagList;
  /** Only allow requests that match the provided regex patterns, eg. '/^.*.(css)'. */
  allowRequestPattern?: ScrapeCreateRequestAllowRequestPatternList;
  /** Only allow requests that match the provided resource types, eg. 'image' or 'script'. */
  allowResourceTypes?: ScrapeCreateRequestAllowResourceTypesList;
  /** Provide credentials for HTTP authentication. */
  authenticate?: ContentCreateRequestAuthenticate;
  /** Attempt to proceed when 'awaited' events fail or timeout. */
  bestAttempt?: boolean;
  /** Check [options](https://pptr.dev/api/puppeteer.page.setcookie). */
  cookies?: ScrapeCreateRequestCookiesList;
  emulateMediaType?: string;
  /** Check [options](https://pptr.dev/api/puppeteer.gotooptions). */
  gotoOptions?: ScrapeCreateRequestGotoOptions;
  /** Block undesired requests that match the provided regex patterns, eg. '/^.*.(css)'. */
  rejectRequestPattern?: ScrapeCreateRequestRejectRequestPatternList;
  /** Block undesired requests that match the provided resource types, eg. 'image' or 'script'. */
  rejectResourceTypes?: ScrapeCreateRequestRejectResourceTypesList;
  setExtraHTTPHeaders?: ScrapeCreateRequestSetExtraHTTPHeadersMap;
  setJavaScriptEnabled?: boolean;
  userAgent?: string;
  /** Check [options](https://pptr.dev/api/puppeteer.page.setviewport). */
  viewport?: ContentCreateRequestViewport;
  /** Wait for the selector to appear in page. Check [options](https://pptr.dev/api/puppeteer.page.waitforselector). */
  waitForSelector?: ContentCreateRequestWaitForSelector;
  /** Waits for a specified timeout before continuing. */
  waitForTimeout?: number;
  /** URL to navigate to, eg. `https://example.com`. */
  url?: string;
}
export const CreateScrapeRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    cacheTTL: S.optional(S.Number.pipe(T.Query())),
    elements: ScrapeCreateRequestElementsList,
    html: S.optional(S.String),
    actionTimeout: S.optional(S.Number),
    addScriptTag: S.optional(ScrapeCreateRequestAddScriptTagList),
    addStyleTag: S.optional(ScrapeCreateRequestAddStyleTagList),
    allowRequestPattern: S.optional(ScrapeCreateRequestAllowRequestPatternList),
    allowResourceTypes: S.optional(ScrapeCreateRequestAllowResourceTypesList),
    authenticate: S.optional(ContentCreateRequestAuthenticate),
    bestAttempt: S.optional(S.Boolean),
    cookies: S.optional(ScrapeCreateRequestCookiesList),
    emulateMediaType: S.optional(S.String),
    gotoOptions: S.optional(ScrapeCreateRequestGotoOptions),
    rejectRequestPattern: S.optional(
      ScrapeCreateRequestRejectRequestPatternList,
    ),
    rejectResourceTypes: S.optional(ScrapeCreateRequestRejectResourceTypesList),
    setExtraHTTPHeaders: S.optional(ScrapeCreateRequestSetExtraHTTPHeadersMap),
    setJavaScriptEnabled: S.optional(S.Boolean),
    userAgent: S.optional(S.String),
    viewport: S.optional(ContentCreateRequestViewport),
    waitForSelector: S.optional(ContentCreateRequestWaitForSelector),
    waitForTimeout: S.optional(S.Number),
    url: S.optional(S.String),
  })
    .pipe(
      T.Http({
        method: "POST",
        uri: "/accounts/{account_id}/browser-rendering/scrape",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateScrapeRequest",
}) as any as S.Schema<CreateScrapeRequest>;

export interface ScrapeCreateResultItemResultsAttributesItem {
  /** Attribute name. */
  name: string;
  /** Attribute value. */
  value: string;
}
export const ScrapeCreateResultItemResultsAttributesItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      name: S.String,
      value: S.String,
    }),
  ).annotate({
    identifier: "ScrapeCreateResultItemResultsAttributesItem",
  }) as any as S.Schema<ScrapeCreateResultItemResultsAttributesItem>;

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

export interface ScrapeCreateResultItemResults {
  attributes: ScrapeCreateResultItemResultsAttributesList;
  /** Element height. */
  height: number;
  /** HTML content. */
  html: string;
  /** Element left. */
  left: number;
  /** Text content. */
  text: string;
  /** Element top. */
  top: number;
  /** Element width. */
  width: number;
}
export const ScrapeCreateResultItemResults = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    attributes: ScrapeCreateResultItemResultsAttributesList,
    height: S.Number,
    html: S.String,
    left: S.Number,
    text: S.String,
    top: S.Number,
    width: S.Number,
  }),
).annotate({
  identifier: "ScrapeCreateResultItemResults",
}) as any as S.Schema<ScrapeCreateResultItemResults>;

export interface ScrapeCreateResultItem {
  results: ScrapeCreateResultItemResults;
  /** Selector. */
  selector: string;
}
export const ScrapeCreateResultItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    results: ScrapeCreateResultItemResults,
    selector: S.String,
  }),
).annotate({
  identifier: "ScrapeCreateResultItem",
}) as any as S.Schema<ScrapeCreateResultItem>;

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

export type CreateScrapeResponse = ScrapeCreateResultList;
export const CreateScrapeResponse = /*@__PURE__*/ S.suspend(() =>
  ScrapeCreateResultList.pipe(
    T.EnvelopePayloadRoot(),
    T.KeyDictionary(KEY_DICTIONARY),
  ),
).annotate({
  identifier: "CreateScrapeResponse",
}) as any as S.Schema<CreateScrapeResponse>;

export type ScreenshotCreateRequestAddScriptTagItem =
  ContentCreateRequestAddScriptTagItem;
export const ScreenshotCreateRequestAddScriptTagItem =
  ContentCreateRequestAddScriptTagItem;

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

export type ScreenshotCreateRequestAddStyleTagItem =
  ContentCreateRequestAddStyleTagItem;
export const ScreenshotCreateRequestAddStyleTagItem =
  ContentCreateRequestAddStyleTagItem;

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

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

export type ScreenshotCreateRequestAllowResourceTypesItem =
  | "document"
  | "stylesheet"
  | "image"
  | "media"
  | "font"
  | "script"
  | "texttrack"
  | "xhr"
  | "fetch"
  | "prefetch"
  | "eventsource"
  | "websocket"
  | "manifest"
  | "signedexchange"
  | "ping"
  | "cspviolationreport"
  | "preflight"
  | "other";
export const ScreenshotCreateRequestAllowResourceTypesItem =
  /*@__PURE__*/ S.String;

export type ScreenshotCreateRequestAllowResourceTypesList = Array<
  ScreenshotCreateRequestAllowResourceTypesItem | (string & {})
>;
export const ScreenshotCreateRequestAllowResourceTypesList =
  /*@__PURE__*/ S.Array(
    ScreenshotCreateRequestAllowResourceTypesItem,
  ) as any as S.Schema<ScreenshotCreateRequestAllowResourceTypesList>;

export type ScreenshotCreateRequestAuthenticate =
  ContentCreateRequestAuthenticate;
export const ScreenshotCreateRequestAuthenticate =
  ContentCreateRequestAuthenticate;

export type ScreenshotCreateRequestCookiesItemPriority =
  | "Low"
  | "Medium"
  | "High";
export const ScreenshotCreateRequestCookiesItemPriority =
  /*@__PURE__*/ S.String;

export type ScreenshotCreateRequestCookiesItemSameSite =
  | "Strict"
  | "Lax"
  | "None";
export const ScreenshotCreateRequestCookiesItemSameSite =
  /*@__PURE__*/ S.String;

export type ScreenshotCreateRequestCookiesItemSourceScheme =
  | "Unset"
  | "NonSecure"
  | "Secure";
export const ScreenshotCreateRequestCookiesItemSourceScheme =
  /*@__PURE__*/ S.String;

export interface ScreenshotCreateRequestCookiesItem {
  /** Cookie name. */
  name: string;
  value: string;
  domain?: string;
  expires?: number;
  httpOnly?: boolean;
  partitionKey?: string;
  path?: string;
  priority?: ScreenshotCreateRequestCookiesItemPriority | (string & {});
  sameParty?: boolean;
  sameSite?: ScreenshotCreateRequestCookiesItemSameSite | (string & {});
  secure?: boolean;
  sourcePort?: number;
  sourceScheme?: ScreenshotCreateRequestCookiesItemSourceScheme | (string & {});
  url?: string;
}
export const ScreenshotCreateRequestCookiesItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    name: S.String,
    value: S.String,
    domain: S.optional(S.String),
    expires: S.optional(S.Number),
    httpOnly: S.optional(S.Boolean),
    partitionKey: S.optional(S.String),
    path: S.optional(S.String),
    priority: S.optional(ScreenshotCreateRequestCookiesItemPriority),
    sameParty: S.optional(S.Boolean),
    sameSite: S.optional(ScreenshotCreateRequestCookiesItemSameSite),
    secure: S.optional(S.Boolean),
    sourcePort: S.optional(S.Number),
    sourceScheme: S.optional(ScreenshotCreateRequestCookiesItemSourceScheme),
    url: S.optional(S.String),
  }),
).annotate({
  identifier: "ScreenshotCreateRequestCookiesItem",
}) as any as S.Schema<ScreenshotCreateRequestCookiesItem>;

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

export type ScreenshotCreateRequestGotoOptionsWaitUntilCase0 =
  | "load"
  | "domcontentloaded"
  | "networkidle0"
  | "networkidle2";
export const ScreenshotCreateRequestGotoOptionsWaitUntilCase0 =
  /*@__PURE__*/ S.String;

export type ScreenshotCreateRequestGotoOptionsWaitUntilCase1Item =
  | "load"
  | "domcontentloaded"
  | "networkidle0"
  | "networkidle2";
export const ScreenshotCreateRequestGotoOptionsWaitUntilCase1Item =
  /*@__PURE__*/ S.String;

export type ScreenshotCreateRequestGotoOptionsWaitUntilCase1List = Array<
  ScreenshotCreateRequestGotoOptionsWaitUntilCase1Item | (string & {})
>;
export const ScreenshotCreateRequestGotoOptionsWaitUntilCase1List =
  /*@__PURE__*/ S.Array(
    ScreenshotCreateRequestGotoOptionsWaitUntilCase1Item,
  ) as any as S.Schema<ScreenshotCreateRequestGotoOptionsWaitUntilCase1List>;

export type ScreenshotCreateRequestGotoOptionsWaitUntil =
  | ScreenshotCreateRequestGotoOptionsWaitUntilCase0
  | (string & {})
  | ScreenshotCreateRequestGotoOptionsWaitUntilCase1List;
export const ScreenshotCreateRequestGotoOptionsWaitUntil =
  /*@__PURE__*/ S.Unknown.pipe(T.UnionCases([[], []]));

export interface ScreenshotCreateRequestGotoOptions {
  referer?: string;
  referrerPolicy?: string;
  timeout?: number;
  waitUntil?: ScreenshotCreateRequestGotoOptionsWaitUntil;
}
export const ScreenshotCreateRequestGotoOptions = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    referer: S.optional(S.String),
    referrerPolicy: S.optional(S.String),
    timeout: S.optional(S.Number),
    waitUntil: S.optional(ScreenshotCreateRequestGotoOptionsWaitUntil),
  }),
).annotate({
  identifier: "ScreenshotCreateRequestGotoOptions",
}) as any as S.Schema<ScreenshotCreateRequestGotoOptions>;

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

export type ScreenshotCreateRequestRejectResourceTypesItem =
  | "document"
  | "stylesheet"
  | "image"
  | "media"
  | "font"
  | "script"
  | "texttrack"
  | "xhr"
  | "fetch"
  | "prefetch"
  | "eventsource"
  | "websocket"
  | "manifest"
  | "signedexchange"
  | "ping"
  | "cspviolationreport"
  | "preflight"
  | "other";
export const ScreenshotCreateRequestRejectResourceTypesItem =
  /*@__PURE__*/ S.String;

export type ScreenshotCreateRequestRejectResourceTypesList = Array<
  ScreenshotCreateRequestRejectResourceTypesItem | (string & {})
>;
export const ScreenshotCreateRequestRejectResourceTypesList =
  /*@__PURE__*/ S.Array(
    ScreenshotCreateRequestRejectResourceTypesItem,
  ) as any as S.Schema<ScreenshotCreateRequestRejectResourceTypesList>;

export interface ScreenshotCreateRequestScreenshotOptionsClip {
  height: number;
  width: number;
  x: number;
  y: number;
  scale?: number;
}
export const ScreenshotCreateRequestScreenshotOptionsClip =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      height: S.Number,
      width: S.Number,
      x: S.Number,
      y: S.Number,
      scale: S.optional(S.Number),
    }),
  ).annotate({
    identifier: "ScreenshotCreateRequestScreenshotOptionsClip",
  }) as any as S.Schema<ScreenshotCreateRequestScreenshotOptionsClip>;

export type ScreenshotCreateRequestScreenshotOptionsEncoding =
  | "binary"
  | "base64";
export const ScreenshotCreateRequestScreenshotOptionsEncoding =
  /*@__PURE__*/ S.String;

export type ScreenshotCreateRequestScreenshotOptionsType =
  | "png"
  | "jpeg"
  | "webp";
export const ScreenshotCreateRequestScreenshotOptionsType =
  /*@__PURE__*/ S.String;

export interface ScreenshotCreateRequestScreenshotOptions {
  captureBeyondViewport?: boolean;
  clip?: ScreenshotCreateRequestScreenshotOptionsClip;
  encoding?: ScreenshotCreateRequestScreenshotOptionsEncoding | (string & {});
  fromSurface?: boolean;
  fullPage?: boolean;
  omitBackground?: boolean;
  optimizeForSpeed?: boolean;
  quality?: number;
  type?: ScreenshotCreateRequestScreenshotOptionsType | (string & {});
}
export const ScreenshotCreateRequestScreenshotOptions = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      captureBeyondViewport: S.optional(S.Boolean),
      clip: S.optional(ScreenshotCreateRequestScreenshotOptionsClip),
      encoding: S.optional(ScreenshotCreateRequestScreenshotOptionsEncoding),
      fromSurface: S.optional(S.Boolean),
      fullPage: S.optional(S.Boolean),
      omitBackground: S.optional(S.Boolean),
      optimizeForSpeed: S.optional(S.Boolean),
      quality: S.optional(S.Number),
      type: S.optional(ScreenshotCreateRequestScreenshotOptionsType),
    }),
).annotate({
  identifier: "ScreenshotCreateRequestScreenshotOptions",
}) as any as S.Schema<ScreenshotCreateRequestScreenshotOptions>;

export type ScreenshotCreateRequestSetExtraHTTPHeadersMap = {
  [key: string]: string | undefined;
};
export const ScreenshotCreateRequestSetExtraHTTPHeadersMap =
  /*@__PURE__*/ S.Record(
    S.String,
    S.String,
  ) as any as S.Schema<ScreenshotCreateRequestSetExtraHTTPHeadersMap>;

export type ScreenshotCreateRequestViewport = ContentCreateRequestViewport;
export const ScreenshotCreateRequestViewport = ContentCreateRequestViewport;

export type ScreenshotCreateRequestWaitForSelector =
  ContentCreateRequestWaitForSelector;
export const ScreenshotCreateRequestWaitForSelector =
  ContentCreateRequestWaitForSelector;

export interface CreateScreenshotRequest {
  /** Account ID. */
  accountId: string;
  /** Cache TTL default is 5s. Set to 0 to disable. */
  cacheTTL?: number;
  /** Set the content of the page, eg: `<h1>Hello World!!</h1>`. Either `html` or `url` must be set. */
  html?: string;
  /** The maximum duration allowed for the browser action to complete after the page has loaded (such as taking screenshots, extracting content, or generating PDFs). If this time limit is exceeded, the action stops and returns a timeout error. */
  actionTimeout?: number;
  /** Adds a `<script>` tag into the page with the desired URL or content. */
  addScriptTag?: ScreenshotCreateRequestAddScriptTagList;
  /** Adds a `<link rel="stylesheet">` tag into the page with the desired URL or a `<style type="text/css">` tag with the content. */
  addStyleTag?: ScreenshotCreateRequestAddStyleTagList;
  /** Only allow requests that match the provided regex patterns, eg. '/^.*.(css)'. */
  allowRequestPattern?: ScreenshotCreateRequestAllowRequestPatternList;
  /** Only allow requests that match the provided resource types, eg. 'image' or 'script'. */
  allowResourceTypes?: ScreenshotCreateRequestAllowResourceTypesList;
  /** Provide credentials for HTTP authentication. */
  authenticate?: ContentCreateRequestAuthenticate;
  /** Attempt to proceed when 'awaited' events fail or timeout. */
  bestAttempt?: boolean;
  /** Check [options](https://pptr.dev/api/puppeteer.page.setcookie). */
  cookies?: ScreenshotCreateRequestCookiesList;
  emulateMediaType?: string;
  /** Check [options](https://pptr.dev/api/puppeteer.gotooptions). */
  gotoOptions?: ScreenshotCreateRequestGotoOptions;
  /** Block undesired requests that match the provided regex patterns, eg. '/^.*.(css)'. */
  rejectRequestPattern?: ScreenshotCreateRequestRejectRequestPatternList;
  /** Block undesired requests that match the provided resource types, eg. 'image' or 'script'. */
  rejectResourceTypes?: ScreenshotCreateRequestRejectResourceTypesList;
  /** Check [options](https://pptr.dev/api/puppeteer.screenshotoptions). */
  screenshotOptions?: ScreenshotCreateRequestScreenshotOptions;
  scrollPage?: boolean;
  selector?: string;
  setExtraHTTPHeaders?: ScreenshotCreateRequestSetExtraHTTPHeadersMap;
  setJavaScriptEnabled?: boolean;
  userAgent?: string;
  /** Check [options](https://pptr.dev/api/puppeteer.page.setviewport). */
  viewport?: ContentCreateRequestViewport;
  /** Wait for the selector to appear in page. Check [options](https://pptr.dev/api/puppeteer.page.waitforselector). */
  waitForSelector?: ContentCreateRequestWaitForSelector;
  /** Waits for a specified timeout before continuing. */
  waitForTimeout?: number;
  /** URL to navigate to, eg. `https://example.com`. */
  url?: string;
}
export const CreateScreenshotRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    cacheTTL: S.optional(S.Number.pipe(T.Query())),
    html: S.optional(S.String),
    actionTimeout: S.optional(S.Number),
    addScriptTag: S.optional(ScreenshotCreateRequestAddScriptTagList),
    addStyleTag: S.optional(ScreenshotCreateRequestAddStyleTagList),
    allowRequestPattern: S.optional(
      ScreenshotCreateRequestAllowRequestPatternList,
    ),
    allowResourceTypes: S.optional(
      ScreenshotCreateRequestAllowResourceTypesList,
    ),
    authenticate: S.optional(ContentCreateRequestAuthenticate),
    bestAttempt: S.optional(S.Boolean),
    cookies: S.optional(ScreenshotCreateRequestCookiesList),
    emulateMediaType: S.optional(S.String),
    gotoOptions: S.optional(ScreenshotCreateRequestGotoOptions),
    rejectRequestPattern: S.optional(
      ScreenshotCreateRequestRejectRequestPatternList,
    ),
    rejectResourceTypes: S.optional(
      ScreenshotCreateRequestRejectResourceTypesList,
    ),
    screenshotOptions: S.optional(ScreenshotCreateRequestScreenshotOptions),
    scrollPage: S.optional(S.Boolean),
    selector: S.optional(S.String),
    setExtraHTTPHeaders: S.optional(
      ScreenshotCreateRequestSetExtraHTTPHeadersMap,
    ),
    setJavaScriptEnabled: S.optional(S.Boolean),
    userAgent: S.optional(S.String),
    viewport: S.optional(ContentCreateRequestViewport),
    waitForSelector: S.optional(ContentCreateRequestWaitForSelector),
    waitForTimeout: S.optional(S.Number),
    url: S.optional(S.String),
  })
    .pipe(
      T.Http({
        method: "POST",
        uri: "/accounts/{account_id}/browser-rendering/screenshot",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateScreenshotRequest",
}) as any as S.Schema<CreateScreenshotRequest>;

export interface CreateScreenshotResponse {}
export const CreateScreenshotResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({}).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateScreenshotResponse",
}) as any as S.Schema<CreateScreenshotResponse>;

export type SnapshotCreateRequestAddScriptTagItem =
  ContentCreateRequestAddScriptTagItem;
export const SnapshotCreateRequestAddScriptTagItem =
  ContentCreateRequestAddScriptTagItem;

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

export type SnapshotCreateRequestAddStyleTagItem =
  ContentCreateRequestAddStyleTagItem;
export const SnapshotCreateRequestAddStyleTagItem =
  ContentCreateRequestAddStyleTagItem;

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

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

export type SnapshotCreateRequestAllowResourceTypesItem =
  | "document"
  | "stylesheet"
  | "image"
  | "media"
  | "font"
  | "script"
  | "texttrack"
  | "xhr"
  | "fetch"
  | "prefetch"
  | "eventsource"
  | "websocket"
  | "manifest"
  | "signedexchange"
  | "ping"
  | "cspviolationreport"
  | "preflight"
  | "other";
export const SnapshotCreateRequestAllowResourceTypesItem =
  /*@__PURE__*/ S.String;

export type SnapshotCreateRequestAllowResourceTypesList = Array<
  SnapshotCreateRequestAllowResourceTypesItem | (string & {})
>;
export const SnapshotCreateRequestAllowResourceTypesList =
  /*@__PURE__*/ S.Array(
    SnapshotCreateRequestAllowResourceTypesItem,
  ) as any as S.Schema<SnapshotCreateRequestAllowResourceTypesList>;

export type SnapshotCreateRequestAuthenticate =
  ContentCreateRequestAuthenticate;
export const SnapshotCreateRequestAuthenticate =
  ContentCreateRequestAuthenticate;

export type SnapshotCreateRequestCookiesItemPriority =
  | "Low"
  | "Medium"
  | "High";
export const SnapshotCreateRequestCookiesItemPriority = /*@__PURE__*/ S.String;

export type SnapshotCreateRequestCookiesItemSameSite =
  | "Strict"
  | "Lax"
  | "None";
export const SnapshotCreateRequestCookiesItemSameSite = /*@__PURE__*/ S.String;

export type SnapshotCreateRequestCookiesItemSourceScheme =
  | "Unset"
  | "NonSecure"
  | "Secure";
export const SnapshotCreateRequestCookiesItemSourceScheme =
  /*@__PURE__*/ S.String;

export interface SnapshotCreateRequestCookiesItem {
  /** Cookie name. */
  name: string;
  value: string;
  domain?: string;
  expires?: number;
  httpOnly?: boolean;
  partitionKey?: string;
  path?: string;
  priority?: SnapshotCreateRequestCookiesItemPriority | (string & {});
  sameParty?: boolean;
  sameSite?: SnapshotCreateRequestCookiesItemSameSite | (string & {});
  secure?: boolean;
  sourcePort?: number;
  sourceScheme?: SnapshotCreateRequestCookiesItemSourceScheme | (string & {});
  url?: string;
}
export const SnapshotCreateRequestCookiesItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    name: S.String,
    value: S.String,
    domain: S.optional(S.String),
    expires: S.optional(S.Number),
    httpOnly: S.optional(S.Boolean),
    partitionKey: S.optional(S.String),
    path: S.optional(S.String),
    priority: S.optional(SnapshotCreateRequestCookiesItemPriority),
    sameParty: S.optional(S.Boolean),
    sameSite: S.optional(SnapshotCreateRequestCookiesItemSameSite),
    secure: S.optional(S.Boolean),
    sourcePort: S.optional(S.Number),
    sourceScheme: S.optional(SnapshotCreateRequestCookiesItemSourceScheme),
    url: S.optional(S.String),
  }),
).annotate({
  identifier: "SnapshotCreateRequestCookiesItem",
}) as any as S.Schema<SnapshotCreateRequestCookiesItem>;

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

export type SnapshotCreateRequestFormatsItem =
  | "content"
  | "screenshot"
  | "markdown"
  | "accessibilityTree";
export const SnapshotCreateRequestFormatsItem = /*@__PURE__*/ S.String;

export type SnapshotCreateRequestFormatsList = Array<
  SnapshotCreateRequestFormatsItem | (string & {})
>;
export const SnapshotCreateRequestFormatsList = /*@__PURE__*/ S.Array(
  SnapshotCreateRequestFormatsItem,
) as any as S.Schema<SnapshotCreateRequestFormatsList>;

export type SnapshotCreateRequestGotoOptionsWaitUntilCase0 =
  | "load"
  | "domcontentloaded"
  | "networkidle0"
  | "networkidle2";
export const SnapshotCreateRequestGotoOptionsWaitUntilCase0 =
  /*@__PURE__*/ S.String;

export type SnapshotCreateRequestGotoOptionsWaitUntilCase1Item =
  | "load"
  | "domcontentloaded"
  | "networkidle0"
  | "networkidle2";
export const SnapshotCreateRequestGotoOptionsWaitUntilCase1Item =
  /*@__PURE__*/ S.String;

export type SnapshotCreateRequestGotoOptionsWaitUntilCase1List = Array<
  SnapshotCreateRequestGotoOptionsWaitUntilCase1Item | (string & {})
>;
export const SnapshotCreateRequestGotoOptionsWaitUntilCase1List =
  /*@__PURE__*/ S.Array(
    SnapshotCreateRequestGotoOptionsWaitUntilCase1Item,
  ) as any as S.Schema<SnapshotCreateRequestGotoOptionsWaitUntilCase1List>;

export type SnapshotCreateRequestGotoOptionsWaitUntil =
  | SnapshotCreateRequestGotoOptionsWaitUntilCase0
  | (string & {})
  | SnapshotCreateRequestGotoOptionsWaitUntilCase1List;
export const SnapshotCreateRequestGotoOptionsWaitUntil =
  /*@__PURE__*/ S.Unknown.pipe(T.UnionCases([[], []]));

export interface SnapshotCreateRequestGotoOptions {
  referer?: string;
  referrerPolicy?: string;
  timeout?: number;
  waitUntil?: SnapshotCreateRequestGotoOptionsWaitUntil;
}
export const SnapshotCreateRequestGotoOptions = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    referer: S.optional(S.String),
    referrerPolicy: S.optional(S.String),
    timeout: S.optional(S.Number),
    waitUntil: S.optional(SnapshotCreateRequestGotoOptionsWaitUntil),
  }),
).annotate({
  identifier: "SnapshotCreateRequestGotoOptions",
}) as any as S.Schema<SnapshotCreateRequestGotoOptions>;

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

export type SnapshotCreateRequestRejectResourceTypesItem =
  | "document"
  | "stylesheet"
  | "image"
  | "media"
  | "font"
  | "script"
  | "texttrack"
  | "xhr"
  | "fetch"
  | "prefetch"
  | "eventsource"
  | "websocket"
  | "manifest"
  | "signedexchange"
  | "ping"
  | "cspviolationreport"
  | "preflight"
  | "other";
export const SnapshotCreateRequestRejectResourceTypesItem =
  /*@__PURE__*/ S.String;

export type SnapshotCreateRequestRejectResourceTypesList = Array<
  SnapshotCreateRequestRejectResourceTypesItem | (string & {})
>;
export const SnapshotCreateRequestRejectResourceTypesList =
  /*@__PURE__*/ S.Array(
    SnapshotCreateRequestRejectResourceTypesItem,
  ) as any as S.Schema<SnapshotCreateRequestRejectResourceTypesList>;

export type SnapshotCreateRequestScreenshotOptionsClip =
  ScreenshotCreateRequestScreenshotOptionsClip;
export const SnapshotCreateRequestScreenshotOptionsClip =
  ScreenshotCreateRequestScreenshotOptionsClip;

export type SnapshotCreateRequestScreenshotOptionsType =
  | "png"
  | "jpeg"
  | "webp";
export const SnapshotCreateRequestScreenshotOptionsType =
  /*@__PURE__*/ S.String;

export interface SnapshotCreateRequestScreenshotOptions {
  captureBeyondViewport?: boolean;
  clip?: ScreenshotCreateRequestScreenshotOptionsClip;
  fromSurface?: boolean;
  fullPage?: boolean;
  omitBackground?: boolean;
  optimizeForSpeed?: boolean;
  quality?: number;
  type?: SnapshotCreateRequestScreenshotOptionsType | (string & {});
}
export const SnapshotCreateRequestScreenshotOptions = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      captureBeyondViewport: S.optional(S.Boolean),
      clip: S.optional(ScreenshotCreateRequestScreenshotOptionsClip),
      fromSurface: S.optional(S.Boolean),
      fullPage: S.optional(S.Boolean),
      omitBackground: S.optional(S.Boolean),
      optimizeForSpeed: S.optional(S.Boolean),
      quality: S.optional(S.Number),
      type: S.optional(SnapshotCreateRequestScreenshotOptionsType),
    }),
).annotate({
  identifier: "SnapshotCreateRequestScreenshotOptions",
}) as any as S.Schema<SnapshotCreateRequestScreenshotOptions>;

export type SnapshotCreateRequestSetExtraHTTPHeadersMap = {
  [key: string]: string | undefined;
};
export const SnapshotCreateRequestSetExtraHTTPHeadersMap =
  /*@__PURE__*/ S.Record(
    S.String,
    S.String,
  ) as any as S.Schema<SnapshotCreateRequestSetExtraHTTPHeadersMap>;

export type SnapshotCreateRequestViewport = ContentCreateRequestViewport;
export const SnapshotCreateRequestViewport = ContentCreateRequestViewport;

export type SnapshotCreateRequestWaitForSelector =
  ContentCreateRequestWaitForSelector;
export const SnapshotCreateRequestWaitForSelector =
  ContentCreateRequestWaitForSelector;

export interface CreateSnapshotRequest {
  /** Account ID. */
  accountId: string;
  /** Cache TTL default is 5s. Set to 0 to disable. */
  cacheTTL?: number;
  /** Set the content of the page, eg: `<h1>Hello World!!</h1>`. Either `html` or `url` must be set. */
  html?: string;
  /** The maximum duration allowed for the browser action to complete after the page has loaded (such as taking screenshots, extracting content, or generating PDFs). If this time limit is exceeded, the action stops and returns a timeout error. */
  actionTimeout?: number;
  /** Adds a `<script>` tag into the page with the desired URL or content. */
  addScriptTag?: SnapshotCreateRequestAddScriptTagList;
  /** Adds a `<link rel="stylesheet">` tag into the page with the desired URL or a `<style type="text/css">` tag with the content. */
  addStyleTag?: SnapshotCreateRequestAddStyleTagList;
  /** Only allow requests that match the provided regex patterns, eg. '/^.*.(css)'. */
  allowRequestPattern?: SnapshotCreateRequestAllowRequestPatternList;
  /** Only allow requests that match the provided resource types, eg. 'image' or 'script'. */
  allowResourceTypes?: SnapshotCreateRequestAllowResourceTypesList;
  /** Provide credentials for HTTP authentication. */
  authenticate?: ContentCreateRequestAuthenticate;
  /** Attempt to proceed when 'awaited' events fail or timeout. */
  bestAttempt?: boolean;
  /** Check [options](https://pptr.dev/api/puppeteer.page.setcookie). */
  cookies?: SnapshotCreateRequestCookiesList;
  emulateMediaType?: string;
  formats?: SnapshotCreateRequestFormatsList;
  /** Check [options](https://pptr.dev/api/puppeteer.gotooptions). */
  gotoOptions?: SnapshotCreateRequestGotoOptions;
  /** Block undesired requests that match the provided regex patterns, eg. '/^.*.(css)'. */
  rejectRequestPattern?: SnapshotCreateRequestRejectRequestPatternList;
  /** Block undesired requests that match the provided resource types, eg. 'image' or 'script'. */
  rejectResourceTypes?: SnapshotCreateRequestRejectResourceTypesList;
  screenshotOptions?: SnapshotCreateRequestScreenshotOptions;
  setExtraHTTPHeaders?: SnapshotCreateRequestSetExtraHTTPHeadersMap;
  setJavaScriptEnabled?: boolean;
  userAgent?: string;
  /** Check [options](https://pptr.dev/api/puppeteer.page.setviewport). */
  viewport?: ContentCreateRequestViewport;
  /** Wait for the selector to appear in page. Check [options](https://pptr.dev/api/puppeteer.page.waitforselector). */
  waitForSelector?: ContentCreateRequestWaitForSelector;
  /** Waits for a specified timeout before continuing. */
  waitForTimeout?: number;
  /** URL to navigate to, eg. `https://example.com`. */
  url?: string;
}
export const CreateSnapshotRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    cacheTTL: S.optional(S.Number.pipe(T.Query())),
    html: S.optional(S.String),
    actionTimeout: S.optional(S.Number),
    addScriptTag: S.optional(SnapshotCreateRequestAddScriptTagList),
    addStyleTag: S.optional(SnapshotCreateRequestAddStyleTagList),
    allowRequestPattern: S.optional(
      SnapshotCreateRequestAllowRequestPatternList,
    ),
    allowResourceTypes: S.optional(SnapshotCreateRequestAllowResourceTypesList),
    authenticate: S.optional(ContentCreateRequestAuthenticate),
    bestAttempt: S.optional(S.Boolean),
    cookies: S.optional(SnapshotCreateRequestCookiesList),
    emulateMediaType: S.optional(S.String),
    formats: S.optional(SnapshotCreateRequestFormatsList),
    gotoOptions: S.optional(SnapshotCreateRequestGotoOptions),
    rejectRequestPattern: S.optional(
      SnapshotCreateRequestRejectRequestPatternList,
    ),
    rejectResourceTypes: S.optional(
      SnapshotCreateRequestRejectResourceTypesList,
    ),
    screenshotOptions: S.optional(SnapshotCreateRequestScreenshotOptions),
    setExtraHTTPHeaders: S.optional(
      SnapshotCreateRequestSetExtraHTTPHeadersMap,
    ),
    setJavaScriptEnabled: S.optional(S.Boolean),
    userAgent: S.optional(S.String),
    viewport: S.optional(ContentCreateRequestViewport),
    waitForSelector: S.optional(ContentCreateRequestWaitForSelector),
    waitForTimeout: S.optional(S.Number),
    url: S.optional(S.String),
  })
    .pipe(
      T.Http({
        method: "POST",
        uri: "/accounts/{account_id}/browser-rendering/snapshot",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateSnapshotRequest",
}) as any as S.Schema<CreateSnapshotRequest>;

export type SnapshotCreateResponseAccessibilityTreeChecked = "mixed";
export const SnapshotCreateResponseAccessibilityTreeChecked =
  /*@__PURE__*/ S.String;

export type SnapshotCreateResponseAccessibilityTreeChecked2 =
  | SnapshotCreateResponseAccessibilityTreeChecked
  | boolean;
export const SnapshotCreateResponseAccessibilityTreeChecked2 =
  /*@__PURE__*/ S.Unknown.pipe(T.UnionCases([[], []]));

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

export type SnapshotCreateResponseAccessibilityTreePressed = "mixed";
export const SnapshotCreateResponseAccessibilityTreePressed =
  /*@__PURE__*/ S.String;

export type SnapshotCreateResponseAccessibilityTreePressed2 =
  | SnapshotCreateResponseAccessibilityTreePressed
  | boolean;
export const SnapshotCreateResponseAccessibilityTreePressed2 =
  /*@__PURE__*/ S.Unknown.pipe(T.UnionCases([[], []]));

export type SnapshotCreateResponseAccessibilityTreeValue = string | number;
export const SnapshotCreateResponseAccessibilityTreeValue =
  /*@__PURE__*/ S.Unknown.pipe(T.UnionCases([[], []]));

export interface SnapshotCreateResponseAccessibilityTree {
  role: string;
  autocomplete?: string | null;
  checked?: SnapshotCreateResponseAccessibilityTreeChecked2 | null;
  children?: SnapshotCreateResponseAccessibilityTreeChildrenList | null;
  description?: string | null;
  disabled?: boolean | null;
  expanded?: boolean | null;
  focused?: boolean | null;
  haspopup?: string | null;
  invalid?: string | null;
  keyshortcuts?: string | null;
  level?: number | null;
  modal?: boolean | null;
  multiline?: boolean | null;
  multiselectable?: boolean | null;
  name?: string | null;
  orientation?: string | null;
  pressed?: SnapshotCreateResponseAccessibilityTreePressed2 | null;
  readonly?: boolean | null;
  required?: boolean | null;
  roledescription?: string | null;
  selected?: boolean | null;
  value?: SnapshotCreateResponseAccessibilityTreeValue | null;
  valuemax?: number | null;
  valuemin?: number | null;
  valuetext?: string | null;
}
export const SnapshotCreateResponseAccessibilityTree = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      role: S.String,
      autocomplete: S.optional(S.NullOr(S.String)),
      checked: S.optional(
        S.NullOr(SnapshotCreateResponseAccessibilityTreeChecked2),
      ),
      children: S.optional(
        S.NullOr(SnapshotCreateResponseAccessibilityTreeChildrenList),
      ),
      description: S.optional(S.NullOr(S.String)),
      disabled: S.optional(S.NullOr(S.Boolean)),
      expanded: S.optional(S.NullOr(S.Boolean)),
      focused: S.optional(S.NullOr(S.Boolean)),
      haspopup: S.optional(S.NullOr(S.String)),
      invalid: S.optional(S.NullOr(S.String)),
      keyshortcuts: S.optional(S.NullOr(S.String)),
      level: S.optional(S.NullOr(S.Number)),
      modal: S.optional(S.NullOr(S.Boolean)),
      multiline: S.optional(S.NullOr(S.Boolean)),
      multiselectable: S.optional(S.NullOr(S.Boolean)),
      name: S.optional(S.NullOr(S.String)),
      orientation: S.optional(S.NullOr(S.String)),
      pressed: S.optional(
        S.NullOr(SnapshotCreateResponseAccessibilityTreePressed2),
      ),
      readonly: S.optional(S.NullOr(S.Boolean)),
      required: S.optional(S.NullOr(S.Boolean)),
      roledescription: S.optional(S.NullOr(S.String)),
      selected: S.optional(S.NullOr(S.Boolean)),
      value: S.optional(S.NullOr(SnapshotCreateResponseAccessibilityTreeValue)),
      valuemax: S.optional(S.NullOr(S.Number)),
      valuemin: S.optional(S.NullOr(S.Number)),
      valuetext: S.optional(S.NullOr(S.String)),
    }),
).annotate({
  identifier: "SnapshotCreateResponseAccessibilityTree",
}) as any as S.Schema<SnapshotCreateResponseAccessibilityTree>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface CreateSnapshotResponse {
  /** Accessibility tree node */
  accessibilityTree?: SnapshotCreateResponseAccessibilityTree | null;
  /** HTML content. */
  content?: string | null;
  /** Markdown content. */
  markdown?: string | null;
  /** Base64 encoded image. */
  screenshot?: string | null;
}
export const CreateSnapshotResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accessibilityTree: S.optional(
      S.NullOr(SnapshotCreateResponseAccessibilityTree),
    ),
    content: S.optional(S.NullOr(S.String)),
    markdown: S.optional(S.NullOr(S.String)),
    screenshot: S.optional(S.NullOr(S.String)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateSnapshotResponse",
}) as any as S.Schema<CreateSnapshotResponse>;

export interface DeleteCrawlRequest {
  /** Account ID. */
  accountId: string;
  /** The ID of the crawl job to cancel. */
  jobId: string;
}
export const DeleteCrawlRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    jobId: S.String.pipe(T.Label("job_id")),
  })
    .pipe(
      T.Http({
        method: "DELETE",
        uri: "/accounts/{account_id}/browser-rendering/crawl/{job_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteCrawlRequest",
}) as any as S.Schema<DeleteCrawlRequest>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface DeleteCrawlResponse {
  /** The ID of the cancelled job. */
  jobId: string;
  /** Cancellation confirmation message. */
  message: string;
}
export const DeleteCrawlResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    jobId: S.String.pipe(T.Body("job_id")),
    message: S.String,
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteCrawlResponse",
}) as any as S.Schema<DeleteCrawlResponse>;

export interface DeleteDevtoolBrowserRequest {
  /** Account ID. */
  accountId: string;
  /** Browser session ID to close. */
  sessionId: string;
}
export const DeleteDevtoolBrowserRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    sessionId: S.String.pipe(T.Label("session_id")),
  })
    .pipe(
      T.Http({
        method: "DELETE",
        uri: "/accounts/{account_id}/browser-rendering/devtools/browser/{session_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteDevtoolBrowserRequest",
}) as any as S.Schema<DeleteDevtoolBrowserRequest>;

export type DevtoolsBrowserDeleteResponseStatus = "closing" | "closed";
export const DevtoolsBrowserDeleteResponseStatus = /*@__PURE__*/ S.String;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface DeleteDevtoolBrowserResponse {
  status: DevtoolsBrowserDeleteResponseStatus;
}
export const DeleteDevtoolBrowserResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    status: DevtoolsBrowserDeleteResponseStatus,
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteDevtoolBrowserResponse",
}) as any as S.Schema<DeleteDevtoolBrowserResponse>;

export type CrawlGetRequestStatus =
  | "queued"
  | "errored"
  | "completed"
  | "disallowed"
  | "skipped"
  | "cancelled";
export const CrawlGetRequestStatus = /*@__PURE__*/ S.String;

export interface GetCrawlRequest {
  /** Account ID. */
  accountId: string;
  /** Crawl job ID. */
  jobId: string;
  /** Cache TTL default is 5s. Set to 0 to disable. */
  cacheTTL?: number;
  /** Cursor for pagination. */
  cursor?: number;
  /** Limit for pagination. */
  limit?: number;
  /** Filter by URL status. */
  status?: CrawlGetRequestStatus | (string & {});
}
export const GetCrawlRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    jobId: S.String.pipe(T.Label("job_id")),
    cacheTTL: S.optional(S.Number.pipe(T.Query())),
    cursor: S.optional(S.Number.pipe(T.Query())),
    limit: S.optional(S.Number.pipe(T.Query())),
    status: S.optional(CrawlGetRequestStatus.pipe(T.Query())),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/browser-rendering/crawl/{job_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetCrawlRequest",
}) as any as S.Schema<GetCrawlRequest>;

export interface CrawlGetResponseRecordsItemMetadata {
  /** HTTP status code of the crawled page. */
  status: number;
  /** Final URL of the crawled page. */
  url: string;
  /** Title of the crawled page. */
  title?: string | null;
}
export const CrawlGetResponseRecordsItemMetadata = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    status: S.Number,
    url: S.String,
    title: S.optional(S.NullOr(S.String)),
  }),
).annotate({
  identifier: "CrawlGetResponseRecordsItemMetadata",
}) as any as S.Schema<CrawlGetResponseRecordsItemMetadata>;

export type CrawlGetResponseRecordsItemStatus =
  | "queued"
  | "errored"
  | "completed"
  | "disallowed"
  | "skipped"
  | "cancelled";
export const CrawlGetResponseRecordsItemStatus = /*@__PURE__*/ S.String;

export type CrawlGetResponseRecordsItemJsonMap = {
  [key: string]: unknown | undefined;
};
export const CrawlGetResponseRecordsItemJsonMap = /*@__PURE__*/ S.Record(
  S.String,
  S.Unknown,
) as any as S.Schema<CrawlGetResponseRecordsItemJsonMap>;

export interface CrawlGetResponseRecordsItem {
  metadata?: CrawlGetResponseRecordsItemMetadata | null;
  /** Current status of the crawled URL. */
  status: CrawlGetResponseRecordsItemStatus;
  /** Crawled URL. */
  url: string;
  /** HTML content of the crawled URL. */
  html?: string | null;
  /** JSON of the content of the crawled URL. */
  json?: CrawlGetResponseRecordsItemJsonMap | null;
  /** Markdown of the content of the crawled URL. */
  markdown?: string | null;
}
export const CrawlGetResponseRecordsItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    metadata: S.optional(S.NullOr(CrawlGetResponseRecordsItemMetadata)),
    status: CrawlGetResponseRecordsItemStatus,
    url: S.String,
    html: S.optional(S.NullOr(S.String)),
    json: S.optional(S.NullOr(CrawlGetResponseRecordsItemJsonMap)),
    markdown: S.optional(S.NullOr(S.String)),
  }),
).annotate({
  identifier: "CrawlGetResponseRecordsItem",
}) as any as S.Schema<CrawlGetResponseRecordsItem>;

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

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface GetCrawlResponse {
  /** Crawl job ID. */
  id: string;
  /** Total seconds spent in browser so far. */
  browserSecondsUsed: number;
  /** Total number of URLs that have been crawled so far. */
  finished: number;
  /** List of crawl job records. */
  records: CrawlGetResponseRecordsList;
  /** Total number of URLs that were skipped due to include/exclude/subdomain filters. Skipped URLs are included in records but are not counted toward total/finished. */
  skipped: number;
  /** Current crawl job status. */
  status: string;
  /** Total current number of URLs in the crawl job. */
  total: number;
  /** Cursor for pagination. */
  cursor?: number | null;
}
export const GetCrawlResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    browserSecondsUsed: S.Number,
    finished: S.Number,
    records: CrawlGetResponseRecordsList,
    skipped: S.Number,
    status: S.String,
    total: S.Number,
    cursor: S.optional(S.NullOr(S.Number)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetCrawlResponse",
}) as any as S.Schema<GetCrawlResponse>;

export interface GetDevtoolBrowserPageRequest {
  /** Account ID. */
  accountId: string;
  /** Browser session ID. */
  sessionId: string;
  /** Target ID, e.g. page ID. */
  targetId: string;
}
export const GetDevtoolBrowserPageRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    sessionId: S.String.pipe(T.Label("session_id")),
    targetId: S.String.pipe(T.Label("target_id")),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/browser-rendering/devtools/browser/{session_id}/page/{target_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetDevtoolBrowserPageRequest",
}) as any as S.Schema<GetDevtoolBrowserPageRequest>;

export interface GetDevtoolBrowserPageResponse {}
export const GetDevtoolBrowserPageResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({}).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetDevtoolBrowserPageResponse",
}) as any as S.Schema<GetDevtoolBrowserPageResponse>;

export interface GetDevtoolBrowserTargetRequest {
  /** Account ID. */
  accountId: string;
  /** Browser session ID. */
  sessionId: string;
  /** Target ID. */
  targetId: string;
}
export const GetDevtoolBrowserTargetRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    sessionId: S.String.pipe(T.Label("session_id")),
    targetId: S.String.pipe(T.Label("target_id")),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/browser-rendering/devtools/browser/{session_id}/json/list/{target_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetDevtoolBrowserTargetRequest",
}) as any as S.Schema<GetDevtoolBrowserTargetRequest>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface GetDevtoolBrowserTargetResponse {
  /** Target ID. */
  id: string;
  /** Target type (page, background_page, worker, etc.). */
  type: string;
  /** URL of the target. */
  url: string;
  /** Target description. */
  description?: string | null;
  /** DevTools frontend URL. */
  devtoolsFrontendUrl?: string | null;
  /** Title of the target. */
  title?: string | null;
  /** WebSocket URL for debugging this target. */
  webSocketDebuggerUrl?: string | null;
}
export const GetDevtoolBrowserTargetResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    type: S.String,
    url: S.String,
    description: S.optional(S.NullOr(S.String)),
    devtoolsFrontendUrl: S.optional(S.NullOr(S.String)),
    title: S.optional(S.NullOr(S.String)),
    webSocketDebuggerUrl: S.optional(S.NullOr(S.String)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetDevtoolBrowserTargetResponse",
}) as any as S.Schema<GetDevtoolBrowserTargetResponse>;

export interface GetDevtoolSessionRequest {
  /** Account ID. */
  accountId: string;
  /** Session ID. */
  sessionId: string;
}
export const GetDevtoolSessionRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    sessionId: S.String.pipe(T.Label("session_id")),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/browser-rendering/devtools/session/{session_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetDevtoolSessionRequest",
}) as any as S.Schema<GetDevtoolSessionRequest>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface GetDevtoolSessionResponse {
  /** Session ID. */
  sessionId: string;
  /** Reason for session closure. */
  closeReason?: string | null;
  /** Human-readable close reason. */
  closeReasonText?: string | null;
  /** Connection end time. */
  connectionEndTime?: number | null;
  /** Connection ID. */
  connectionId?: string | null;
  /** Connection start time. */
  connectionStartTime?: number | null;
  /** DevTools frontend URL. */
  devtoolsFrontendUrl?: string | null;
  /** Session end time. */
  endTime?: number | null;
  /** Last updated timestamp. */
  lastUpdated?: number | null;
  /** Session start time. */
  startTime?: number | null;
  /** WebSocket URL for debugging this target. */
  webSocketDebuggerUrl?: string | null;
}
export const GetDevtoolSessionResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    sessionId: S.String,
    closeReason: S.optional(S.NullOr(S.String)),
    closeReasonText: S.optional(S.NullOr(S.String)),
    connectionEndTime: S.optional(S.NullOr(S.Number)),
    connectionId: S.optional(S.NullOr(S.String)),
    connectionStartTime: S.optional(S.NullOr(S.Number)),
    devtoolsFrontendUrl: S.optional(S.NullOr(S.String)),
    endTime: S.optional(S.NullOr(S.Number)),
    lastUpdated: S.optional(S.NullOr(S.Number)),
    startTime: S.optional(S.NullOr(S.Number)),
    webSocketDebuggerUrl: S.optional(S.NullOr(S.String)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetDevtoolSessionResponse",
}) as any as S.Schema<GetDevtoolSessionResponse>;

export interface LaunchDevtoolBrowserRequest {
  /** Account ID. */
  accountId: string;
  /** Keep-alive time in ms (only valid when acquiring new session). */
  keepAlive?: number;
  /** Use experimental browser. */
  lab?: boolean;
  recording?: boolean;
}
export const LaunchDevtoolBrowserRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    keepAlive: S.optional(S.Number.pipe(T.Query("keep_alive"))),
    lab: S.optional(S.Boolean.pipe(T.Query())),
    recording: S.optional(S.Boolean.pipe(T.Query())),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/browser-rendering/devtools/browser",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "LaunchDevtoolBrowserRequest",
}) as any as S.Schema<LaunchDevtoolBrowserRequest>;

export interface LaunchDevtoolBrowserResponse {}
export const LaunchDevtoolBrowserResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({}).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "LaunchDevtoolBrowserResponse",
}) as any as S.Schema<LaunchDevtoolBrowserResponse>;

export interface ListDevtoolBrowserTargetsRequest {
  /** Account ID. */
  accountId: string;
  /** Browser session ID. */
  sessionId: string;
  /** How long the live view URLs remain valid, in milliseconds (max 60 minutes) */
  liveViewUrlExpiresInMs?: number;
}
export const ListDevtoolBrowserTargetsRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    sessionId: S.String.pipe(T.Label("session_id")),
    liveViewUrlExpiresInMs: S.optional(S.Number.pipe(T.Query())),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/browser-rendering/devtools/browser/{session_id}/json/list",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListDevtoolBrowserTargetsRequest",
}) as any as S.Schema<ListDevtoolBrowserTargetsRequest>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface ListDevtoolBrowserTargetsResponse {
  /** Target ID. */
  id: string;
  /** Target type (page, background_page, worker, etc.). */
  type: string;
  /** URL of the target. */
  url: string;
  /** Target description. */
  description?: string | null;
  /** DevTools frontend URL. */
  devtoolsFrontendUrl?: string | null;
  /** Title of the target. */
  title?: string | null;
  /** WebSocket URL for debugging this target. */
  webSocketDebuggerUrl?: string | null;
}
export const ListDevtoolBrowserTargetsResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    type: S.String,
    url: S.String,
    description: S.optional(S.NullOr(S.String)),
    devtoolsFrontendUrl: S.optional(S.NullOr(S.String)),
    title: S.optional(S.NullOr(S.String)),
    webSocketDebuggerUrl: S.optional(S.NullOr(S.String)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListDevtoolBrowserTargetsResponse",
}) as any as S.Schema<ListDevtoolBrowserTargetsResponse>;

export interface ListDevtoolSessionsRequest {
  /** Account ID. */
  accountId: string;
  limit?: number;
  offset?: number;
}
export const ListDevtoolSessionsRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    limit: S.optional(S.Number.pipe(T.Query())),
    offset: S.optional(S.Number.pipe(T.Query())),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/browser-rendering/devtools/session",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListDevtoolSessionsRequest",
}) as any as S.Schema<ListDevtoolSessionsRequest>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface ListDevtoolSessionsResponse {
  /** Session ID. */
  sessionId: string;
  /** Reason for session closure. */
  closeReason?: string | null;
  /** Human-readable close reason. */
  closeReasonText?: string | null;
  /** Connection end time. */
  connectionEndTime?: number | null;
  /** Connection ID. */
  connectionId?: string | null;
  /** Connection start time. */
  connectionStartTime?: number | null;
  /** DevTools frontend URL. */
  devtoolsFrontendUrl?: string | null;
  /** Session end time. */
  endTime?: number | null;
  /** Last updated timestamp. */
  lastUpdated?: number | null;
  /** Session start time. */
  startTime?: number | null;
  /** WebSocket URL for debugging this target. */
  webSocketDebuggerUrl?: string | null;
}
export const ListDevtoolSessionsResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    sessionId: S.String,
    closeReason: S.optional(S.NullOr(S.String)),
    closeReasonText: S.optional(S.NullOr(S.String)),
    connectionEndTime: S.optional(S.NullOr(S.Number)),
    connectionId: S.optional(S.NullOr(S.String)),
    connectionStartTime: S.optional(S.NullOr(S.Number)),
    devtoolsFrontendUrl: S.optional(S.NullOr(S.String)),
    endTime: S.optional(S.NullOr(S.Number)),
    lastUpdated: S.optional(S.NullOr(S.Number)),
    startTime: S.optional(S.NullOr(S.Number)),
    webSocketDebuggerUrl: S.optional(S.NullOr(S.String)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListDevtoolSessionsResponse",
}) as any as S.Schema<ListDevtoolSessionsResponse>;

export interface ProtocolDevtoolBrowserRequest {
  /** Account ID. */
  accountId: string;
  /** Browser session ID. */
  sessionId: string;
}
export const ProtocolDevtoolBrowserRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    sessionId: S.String.pipe(T.Label("session_id")),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/browser-rendering/devtools/browser/{session_id}/json/protocol",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ProtocolDevtoolBrowserRequest",
}) as any as S.Schema<ProtocolDevtoolBrowserRequest>;

export type DevtoolsBrowserProtocolResponseDomainsItemCommandsItemMap = {
  [key: string]: unknown | undefined;
};
export const DevtoolsBrowserProtocolResponseDomainsItemCommandsItemMap =
  /*@__PURE__*/ S.Record(
    S.String,
    S.Unknown,
  ) as any as S.Schema<DevtoolsBrowserProtocolResponseDomainsItemCommandsItemMap>;

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

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

export type DevtoolsBrowserProtocolResponseDomainsItemEventsItemMap = {
  [key: string]: unknown | undefined;
};
export const DevtoolsBrowserProtocolResponseDomainsItemEventsItemMap =
  /*@__PURE__*/ S.Record(
    S.String,
    S.Unknown,
  ) as any as S.Schema<DevtoolsBrowserProtocolResponseDomainsItemEventsItemMap>;

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

export type DevtoolsBrowserProtocolResponseDomainsItemTypesItemMap = {
  [key: string]: unknown | undefined;
};
export const DevtoolsBrowserProtocolResponseDomainsItemTypesItemMap =
  /*@__PURE__*/ S.Record(
    S.String,
    S.Unknown,
  ) as any as S.Schema<DevtoolsBrowserProtocolResponseDomainsItemTypesItemMap>;

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

export interface DevtoolsBrowserProtocolResponseDomainsItem {
  /** Domain name. */
  domain: string;
  /** Available commands. */
  commands?: DevtoolsBrowserProtocolResponseDomainsItemCommandsList | null;
  /** Domain dependencies. */
  dependencies?: DevtoolsBrowserProtocolResponseDomainsItemDependenciesList | null;
  /** Available events. */
  events?: DevtoolsBrowserProtocolResponseDomainsItemEventsList | null;
  /** Whether this domain is experimental. */
  experimental?: boolean | null;
  /** Type definitions. */
  types?: DevtoolsBrowserProtocolResponseDomainsItemTypesList | null;
}
export const DevtoolsBrowserProtocolResponseDomainsItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      domain: S.String,
      commands: S.optional(
        S.NullOr(DevtoolsBrowserProtocolResponseDomainsItemCommandsList),
      ),
      dependencies: S.optional(
        S.NullOr(DevtoolsBrowserProtocolResponseDomainsItemDependenciesList),
      ),
      events: S.optional(
        S.NullOr(DevtoolsBrowserProtocolResponseDomainsItemEventsList),
      ),
      experimental: S.optional(S.NullOr(S.Boolean)),
      types: S.optional(
        S.NullOr(DevtoolsBrowserProtocolResponseDomainsItemTypesList),
      ),
    }),
  ).annotate({
    identifier: "DevtoolsBrowserProtocolResponseDomainsItem",
  }) as any as S.Schema<DevtoolsBrowserProtocolResponseDomainsItem>;

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

export interface DevtoolsBrowserProtocolResponseVersion {
  /** Major version. */
  major: string;
  /** Minor version. */
  minor: string;
}
export const DevtoolsBrowserProtocolResponseVersion = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      major: S.String,
      minor: S.String,
    }),
).annotate({
  identifier: "DevtoolsBrowserProtocolResponseVersion",
}) as any as S.Schema<DevtoolsBrowserProtocolResponseVersion>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface ProtocolDevtoolBrowserResponse {
  /** List of protocol domains. */
  domains: DevtoolsBrowserProtocolResponseDomainsList;
  /** Protocol version. */
  version?: DevtoolsBrowserProtocolResponseVersion | null;
}
export const ProtocolDevtoolBrowserResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    domains: DevtoolsBrowserProtocolResponseDomainsList,
    version: S.optional(S.NullOr(DevtoolsBrowserProtocolResponseVersion)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ProtocolDevtoolBrowserResponse",
}) as any as S.Schema<ProtocolDevtoolBrowserResponse>;

export interface VersionDevtoolBrowserRequest {
  /** Account ID. */
  accountId: string;
  /** Browser session ID. */
  sessionId: string;
}
export const VersionDevtoolBrowserRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    sessionId: S.String.pipe(T.Label("session_id")),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/browser-rendering/devtools/browser/{session_id}/json/version",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "VersionDevtoolBrowserRequest",
}) as any as S.Schema<VersionDevtoolBrowserRequest>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface VersionDevtoolBrowserResponse {
  /** Browser name and version. */
  browser: string;
  /** Chrome DevTools Protocol version. */
  protocolVersion: string;
  /** User agent string. */
  userAgent: string;
  /** V8 JavaScript engine version. */
  v8Version: string;
  /** WebKit version. */
  webKitVersion: string;
  /** WebSocket URL for debugging the browser. */
  webSocketDebuggerUrl: string;
}
export const VersionDevtoolBrowserResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    browser: S.String.pipe(T.Body("Browser")),
    protocolVersion: S.String.pipe(T.Body("Protocol-Version")),
    userAgent: S.String.pipe(T.Body("User-Agent")),
    v8Version: S.String.pipe(T.Body("V8-Version")),
    webKitVersion: S.String.pipe(T.Body("WebKit-Version")),
    webSocketDebuggerUrl: S.String,
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "VersionDevtoolBrowserResponse",
}) as any as S.Schema<VersionDevtoolBrowserResponse>;

export type ActivateDevtoolBrowserTargetError = CloudflareOpError;
/** Activates (brings to front) a specific browser target by its ID. */
export const activateDevtoolBrowserTarget: API.OperationMethod<
  ActivateDevtoolBrowserTargetRequest,
  ActivateDevtoolBrowserTargetResponse,
  ActivateDevtoolBrowserTargetError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: ActivateDevtoolBrowserTargetRequest,
  output: ActivateDevtoolBrowserTargetResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type CloseDevtoolBrowserTargetError = CloudflareOpError;
/** Closes a specific browser target (tab, page, etc.) by its ID. Returns 'Target is closing' on success or an error if the target is not found. */
export const closeDevtoolBrowserTarget: API.OperationMethod<
  CloseDevtoolBrowserTargetRequest,
  CloseDevtoolBrowserTargetResponse,
  CloseDevtoolBrowserTargetError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: CloseDevtoolBrowserTargetRequest,
  output: CloseDevtoolBrowserTargetResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type ConnectDevtoolBrowserError = CloudflareOpError;
/** Establishes a WebSocket connection to an existing browser session. */
export const connectDevtoolBrowser: API.OperationMethod<
  ConnectDevtoolBrowserRequest,
  ConnectDevtoolBrowserResponse,
  ConnectDevtoolBrowserError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: ConnectDevtoolBrowserRequest,
  output: ConnectDevtoolBrowserResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type CreateContentError = CloudflareOpError;
/** Fetches rendered HTML content from provided URL or HTML. Check available options like `gotoOptions` and `waitFor*` to control page load behaviour. */
export const createContent: API.OperationMethod<
  CreateContentRequest,
  CreateContentResponse,
  CreateContentError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: CreateContentRequest,
  output: CreateContentResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type CreateCrawlError = CloudflareOpError;
/** Starts a crawl job for the provided URL and its children. Check available options like `gotoOptions` and `waitFor*` to control page load behaviour. */
export const createCrawl: API.OperationMethod<
  CreateCrawlRequest,
  CreateCrawlResponse,
  CreateCrawlError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: CreateCrawlRequest,
  output: CreateCrawlResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type CreateDevtoolBrowserError = CloudflareOpError;
/** Acquires a browser and returns its session ID and websocket URL. */
export const createDevtoolBrowser: API.OperationMethod<
  CreateDevtoolBrowserRequest,
  CreateDevtoolBrowserResponse,
  CreateDevtoolBrowserError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: CreateDevtoolBrowserRequest,
  output: CreateDevtoolBrowserResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type CreateDevtoolBrowserTargetError = CloudflareOpError;
/** Opens a new tab in the browser. Optionally specify a URL to navigate to. */
export const createDevtoolBrowserTarget: API.OperationMethod<
  CreateDevtoolBrowserTargetRequest,
  CreateDevtoolBrowserTargetResponse,
  CreateDevtoolBrowserTargetError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: CreateDevtoolBrowserTargetRequest,
  output: CreateDevtoolBrowserTargetResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type CreateJsonError = CloudflareOpError;
/** Gets json from a webpage from a provided URL or HTML. Pass `prompt` or `schema` in the body. Control page loading with `gotoOptions` and `waitFor*` options. */
export const createJson: API.OperationMethod<
  CreateJsonRequest,
  CreateJsonResponse,
  CreateJsonError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: CreateJsonRequest,
  output: CreateJsonResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type CreateLinkError = CloudflareOpError;
/** Get links from a web page. */
export const createLink: API.OperationMethod<
  CreateLinkRequest,
  CreateLinkResponse,
  CreateLinkError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: CreateLinkRequest,
  output: CreateLinkResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type CreateMarkdownError = CloudflareOpError;
/** Gets markdown of a webpage from provided URL or HTML. Control page loading with `gotoOptions` and `waitFor*` options. */
export const createMarkdown: API.OperationMethod<
  CreateMarkdownRequest,
  CreateMarkdownResponse,
  CreateMarkdownError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: CreateMarkdownRequest,
  output: CreateMarkdownResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type CreatePdfError = CloudflareOpError;
/** Fetches rendered PDF from provided URL or HTML. Check available options like `gotoOptions` and `waitFor*` to control page load behaviour. */
export const createPdf: API.OperationMethod<
  CreatePdfRequest,
  CreatePdfResponse,
  CreatePdfError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: CreatePdfRequest,
  output: CreatePdfResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type CreateScrapeError = CloudflareOpError;
/** Get meta attributes like height, width, text and others of selected elements. */
export const createScrape: API.OperationMethod<
  CreateScrapeRequest,
  CreateScrapeResponse,
  CreateScrapeError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: CreateScrapeRequest,
  output: CreateScrapeResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type CreateScreenshotError = CloudflareOpError;
/** Takes a screenshot of a webpage from provided URL or HTML. Control page loading with `gotoOptions` and `waitFor*` options. Customize screenshots with `viewport`, `fullPage`, `clip` and others. */
export const createScreenshot: API.OperationMethod<
  CreateScreenshotRequest,
  CreateScreenshotResponse,
  CreateScreenshotError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: CreateScreenshotRequest,
  output: CreateScreenshotResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type CreateSnapshotError = CloudflareOpError;
/** Returns the page's HTML content and screenshot. Control page loading with `gotoOptions` and `waitFor*` options. Customize screenshots with `viewport`, `fullPage`, `clip` and others. */
export const createSnapshot: API.OperationMethod<
  CreateSnapshotRequest,
  CreateSnapshotResponse,
  CreateSnapshotError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: CreateSnapshotRequest,
  output: CreateSnapshotResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type DeleteCrawlError = CloudflareOpError;
/** Cancels an ongoing crawl job by setting its status to cancelled and stopping all queued URLs. */
export const deleteCrawl: API.OperationMethod<
  DeleteCrawlRequest,
  DeleteCrawlResponse,
  DeleteCrawlError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: DeleteCrawlRequest,
  output: DeleteCrawlResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type DeleteDevtoolBrowserError = CloudflareOpError;
/** Closes an existing browser session. */
export const deleteDevtoolBrowser: API.OperationMethod<
  DeleteDevtoolBrowserRequest,
  DeleteDevtoolBrowserResponse,
  DeleteDevtoolBrowserError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: DeleteDevtoolBrowserRequest,
  output: DeleteDevtoolBrowserResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetCrawlError = CloudflareOpError;
/** Returns the result of a crawl job. */
export const getCrawl: API.OperationMethod<
  GetCrawlRequest,
  GetCrawlResponse,
  GetCrawlError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetCrawlRequest,
  output: GetCrawlResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetDevtoolBrowserPageError = CloudflareOpError;
/** Establishes a WebSocket connection to a specific Chrome DevTools target or page. */
export const getDevtoolBrowserPage: API.OperationMethod<
  GetDevtoolBrowserPageRequest,
  GetDevtoolBrowserPageResponse,
  GetDevtoolBrowserPageError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetDevtoolBrowserPageRequest,
  output: GetDevtoolBrowserPageResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetDevtoolBrowserTargetError = CloudflareOpError;
/** Returns the debuggable target with the given ID. */
export const getDevtoolBrowserTarget: API.OperationMethod<
  GetDevtoolBrowserTargetRequest,
  GetDevtoolBrowserTargetResponse,
  GetDevtoolBrowserTargetError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetDevtoolBrowserTargetRequest,
  output: GetDevtoolBrowserTargetResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetDevtoolSessionError = CloudflareOpError;
/** Get details for a specific browser session. */
export const getDevtoolSession: API.OperationMethod<
  GetDevtoolSessionRequest,
  GetDevtoolSessionResponse,
  GetDevtoolSessionError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetDevtoolSessionRequest,
  output: GetDevtoolSessionResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type LaunchDevtoolBrowserError = CloudflareOpError;
/** Acquires and establishes a WebSocket connection to a browser session. */
export const launchDevtoolBrowser: API.OperationMethod<
  LaunchDevtoolBrowserRequest,
  LaunchDevtoolBrowserResponse,
  LaunchDevtoolBrowserError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: LaunchDevtoolBrowserRequest,
  output: LaunchDevtoolBrowserResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type ListDevtoolBrowserTargetsError = CloudflareOpError;
/** Returns a list of all debuggable targets including tabs, pages, service workers, and other browser contexts. */
export const listDevtoolBrowserTargets: API.OperationMethod<
  ListDevtoolBrowserTargetsRequest,
  ListDevtoolBrowserTargetsResponse,
  ListDevtoolBrowserTargetsError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: ListDevtoolBrowserTargetsRequest,
  output: ListDevtoolBrowserTargetsResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type ListDevtoolSessionsError = CloudflareOpError;
/** List active browser sessions. */
export const listDevtoolSessions: API.OperationMethod<
  ListDevtoolSessionsRequest,
  ListDevtoolSessionsResponse,
  ListDevtoolSessionsError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: ListDevtoolSessionsRequest,
  output: ListDevtoolSessionsResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type ProtocolDevtoolBrowserError = CloudflareOpError;
/** Returns the complete Chrome DevTools Protocol schema including all domains, commands, events, and types. This schema describes the entire CDP API surface. */
export const protocolDevtoolBrowser: API.OperationMethod<
  ProtocolDevtoolBrowserRequest,
  ProtocolDevtoolBrowserResponse,
  ProtocolDevtoolBrowserError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: ProtocolDevtoolBrowserRequest,
  output: ProtocolDevtoolBrowserResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type VersionDevtoolBrowserError = CloudflareOpError;
/** Get browser version metadata. */
export const versionDevtoolBrowser: API.OperationMethod<
  VersionDevtoolBrowserRequest,
  VersionDevtoolBrowserResponse,
  VersionDevtoolBrowserError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: VersionDevtoolBrowserRequest,
  output: VersionDevtoolBrowserResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));