// 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>> = {
  aiInput: "ai-input",
  aiTrain: "ai-train",
  countryName: "country_name",
  dnssecValid: "dnssec_valid",
  ipv6Percentage: "IPv6Percentage",
  phishingV2: "phishing_v2",
  superCategoryId: "super_category_id",
};

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

export type ScansBulkCreateRequestBodyItemScreenshotsResolutionsItem =
  | "desktop"
  | "mobile"
  | "tablet";
export const ScansBulkCreateRequestBodyItemScreenshotsResolutionsItem =
  /*@__PURE__*/ S.String;

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

export type ScansBulkCreateRequestBodyItemVisibility = "Public" | "Unlisted";
export const ScansBulkCreateRequestBodyItemVisibility = /*@__PURE__*/ S.String;

export interface ScansBulkCreateRequestBodyItem {
  url: string;
  /** Enable agent readiness checks. */
  agentReadiness?: boolean;
  customagent?: string;
  /** Set custom headers. */
  customHeaders?: ScansBulkCreateRequestBodyItemCustomHeadersMap;
  referer?: string;
  /** Take multiple screenshots targeting different device types. */
  screenshotsResolutions?: ScansBulkCreateRequestBodyItemScreenshotsResolutionsList;
  /** The option `Public` means it will be included in listings like recent scans and search results. `Unlisted` means it will not be included in the aforementioned listings, users will need to have the scan's ID to access it. A a scan will be automatically marked as unlisted if it fails, if it contains potential PII or other sensitive material. */
  visibility?: ScansBulkCreateRequestBodyItemVisibility | (string & {});
}
export const ScansBulkCreateRequestBodyItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    url: S.String,
    agentReadiness: S.optional(S.Boolean),
    customagent: S.optional(S.String),
    customHeaders: S.optional(ScansBulkCreateRequestBodyItemCustomHeadersMap),
    referer: S.optional(S.String),
    screenshotsResolutions: S.optional(
      ScansBulkCreateRequestBodyItemScreenshotsResolutionsList,
    ),
    visibility: S.optional(ScansBulkCreateRequestBodyItemVisibility),
  }),
).annotate({
  identifier: "ScansBulkCreateRequestBodyItem",
}) as any as S.Schema<ScansBulkCreateRequestBodyItem>;

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

export interface BulkCreateScansRequest {
  /** Account ID. */
  accountId: string;
  /** List of urls to scan (up to a 100). */
  body?: ScansBulkCreateRequestBodyList;
}
export const BulkCreateScansRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    body: S.optional(ScansBulkCreateRequestBodyList.pipe(T.HttpBody())),
  })
    .pipe(
      T.Http({
        method: "POST",
        uri: "/accounts/{account_id}/urlscanner/v2/bulk",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "BulkCreateScansRequest",
}) as any as S.Schema<BulkCreateScansRequest>;

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

export type ScansCreateRequestCountry =
  | "AF"
  | "AL"
  | "DZ"
  | "AD"
  | "AO"
  | "AG"
  | "AR"
  | "AM"
  | "AU"
  | "AT"
  | "AZ"
  | "BH"
  | "BD"
  | "BB"
  | "BY"
  | "BE"
  | "BZ"
  | "BJ"
  | "BM"
  | "BT"
  | "BO"
  | "BA"
  | "BW"
  | "BR"
  | "BN"
  | "BG"
  | "BF"
  | "BI"
  | "KH"
  | "CM"
  | "CA"
  | "CV"
  | "KY"
  | "CF"
  | "TD"
  | "CL"
  | "CN"
  | "CO"
  | "KM"
  | "CG"
  | "CR"
  | "CI"
  | "HR"
  | "CU"
  | "CY"
  | "CZ"
  | "CD"
  | "DK"
  | "DJ"
  | "DM"
  | "DO"
  | "EC"
  | "EG"
  | "SV"
  | "GQ"
  | "ER"
  | "EE"
  | "SZ"
  | "ET"
  | "FJ"
  | "FI"
  | "FR"
  | "GA"
  | "GE"
  | "DE"
  | "GH"
  | "GR"
  | "GL"
  | "GD"
  | "GT"
  | "GN"
  | "GW"
  | "GY"
  | "HT"
  | "HN"
  | "HU"
  | "IS"
  | "IN"
  | "ID"
  | "IR"
  | "IQ"
  | "IE"
  | "IL"
  | "IT"
  | "JM"
  | "JP"
  | "JO"
  | "KZ"
  | "KE"
  | "KI"
  | "KW"
  | "KG"
  | "LA"
  | "LV"
  | "LB"
  | "LS"
  | "LR"
  | "LY"
  | "LI"
  | "LT"
  | "LU"
  | "MO"
  | "MG"
  | "MW"
  | "MY"
  | "MV"
  | "ML"
  | "MR"
  | "MU"
  | "MX"
  | "FM"
  | "MD"
  | "MC"
  | "MN"
  | "MS"
  | "MA"
  | "MZ"
  | "MM"
  | "NA"
  | "NR"
  | "NP"
  | "NL"
  | "NZ"
  | "NI"
  | "NE"
  | "NG"
  | "KP"
  | "MK"
  | "NO"
  | "OM"
  | "PK"
  | "PS"
  | "PA"
  | "PG"
  | "PY"
  | "PE"
  | "PH"
  | "PL"
  | "PT"
  | "QA"
  | "RO"
  | "RU"
  | "RW"
  | "SH"
  | "KN"
  | "LC"
  | "VC"
  | "WS"
  | "SM"
  | "ST"
  | "SA"
  | "SN"
  | "RS"
  | "SC"
  | "SL"
  | "SK"
  | "SI"
  | "SB"
  | "SO"
  | "ZA"
  | "KR"
  | "SS"
  | "ES"
  | "LK"
  | "SD"
  | "SR"
  | "SE"
  | "CH"
  | "SY"
  | "TW"
  | "TJ"
  | "TZ"
  | "TH"
  | "BS"
  | "GM"
  | "TL"
  | "TG"
  | "TO"
  | "TT"
  | "TN"
  | "TR"
  | "TM"
  | "UG"
  | "UA"
  | "AE"
  | "GB"
  | "US"
  | "UY"
  | "UZ"
  | "VU"
  | "VE"
  | "VN"
  | "YE"
  | "ZM"
  | "ZW";
export const ScansCreateRequestCountry = /*@__PURE__*/ S.String;

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

export type ScansCreateRequestScreenshotsResolutionsItem =
  | "desktop"
  | "mobile"
  | "tablet";
export const ScansCreateRequestScreenshotsResolutionsItem =
  /*@__PURE__*/ S.String;

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

export type ScansCreateRequestVisibility = "Public" | "Unlisted";
export const ScansCreateRequestVisibility = /*@__PURE__*/ S.String;

export interface CreateScanRequest {
  /** Account ID. */
  accountId: string;
  url: string;
  /** Enable agent readiness checks. */
  agentReadiness?: boolean;
  /** Country to geo egress from */
  country?: ScansCreateRequestCountry | (string & {});
  customagent?: string;
  /** Set custom headers. */
  customHeaders?: ScansCreateRequestCustomHeadersMap;
  referer?: string;
  /** Take multiple screenshots targeting different device types. */
  screenshotsResolutions?: ScansCreateRequestScreenshotsResolutionsList;
  /** The option `Public` means it will be included in listings like recent scans and search results. `Unlisted` means it will not be included in the aforementioned listings, users will need to have the scan's ID to access it. A a scan will be automatically marked as unlisted if it fails, if it contains potential PII or other sensitive material. */
  visibility?: ScansCreateRequestVisibility | (string & {});
}
export const CreateScanRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    url: S.String,
    agentReadiness: S.optional(S.Boolean),
    country: S.optional(ScansCreateRequestCountry),
    customagent: S.optional(S.String),
    customHeaders: S.optional(ScansCreateRequestCustomHeadersMap),
    referer: S.optional(S.String),
    screenshotsResolutions: S.optional(
      ScansCreateRequestScreenshotsResolutionsList,
    ),
    visibility: S.optional(ScansCreateRequestVisibility),
  })
    .pipe(
      T.Http({
        method: "POST",
        uri: "/accounts/{account_id}/urlscanner/v2/scan",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateScanRequest",
}) as any as S.Schema<CreateScanRequest>;

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

export interface DomScanRequest {
  /** Account ID. */
  accountId: string;
  /** Scan UUID. */
  scanId: string;
}
export const DomScanRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    scanId: S.String.pipe(T.Label("scan_id")),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/urlscanner/v2/dom/{scan_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({ identifier: "DomScanRequest" }) as any as S.Schema<DomScanRequest>;

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

export interface GetResponsRequest {
  /** Account ID. */
  accountId: string;
  /** Response hash. */
  responseId: string;
}
export const GetResponsRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    responseId: S.String.pipe(T.Label("response_id")),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/urlscanner/v2/responses/{response_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetResponsRequest",
}) as any as S.Schema<GetResponsRequest>;

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

export interface GetScanRequest {
  /** Account ID. */
  accountId: string;
  /** Scan UUID. */
  scanId: string;
}
export const GetScanRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    scanId: S.String.pipe(T.Label("scan_id")),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/urlscanner/v2/result/{scan_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({ identifier: "GetScanRequest" }) as any as S.Schema<GetScanRequest>;

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

export interface ScansGetResponseDataConsoleItem {
  message: ScansGetResponseDataConsoleItemMessage;
}
export const ScansGetResponseDataConsoleItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    message: ScansGetResponseDataConsoleItemMessage,
  }),
).annotate({
  identifier: "ScansGetResponseDataConsoleItem",
}) as any as S.Schema<ScansGetResponseDataConsoleItem>;

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

export interface ScansGetResponseDataCookiesItem {
  domain: string;
  expires: number;
  httpOnly: boolean;
  name: string;
  path: string;
  priority: string;
  sameParty: boolean;
  secure: boolean;
  session: boolean;
  size: number;
  sourcePort: number;
  sourceScheme: string;
  value: string;
}
export const ScansGetResponseDataCookiesItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    domain: S.String,
    expires: S.Number,
    httpOnly: S.Boolean,
    name: S.String,
    path: S.String,
    priority: S.String,
    sameParty: S.Boolean,
    secure: S.Boolean,
    session: S.Boolean,
    size: S.Number,
    sourcePort: S.Number,
    sourceScheme: S.String,
    value: S.String,
  }),
).annotate({
  identifier: "ScansGetResponseDataCookiesItem",
}) as any as S.Schema<ScansGetResponseDataCookiesItem>;

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

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

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

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

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

export interface ScansGetResponseDataPerformanceItem {
  duration: number;
  entryType: string;
  name: string;
  startTime: number;
}
export const ScansGetResponseDataPerformanceItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    duration: S.Number,
    entryType: S.String,
    name: S.String,
    startTime: S.Number,
  }),
).annotate({
  identifier: "ScansGetResponseDataPerformanceItem",
}) as any as S.Schema<ScansGetResponseDataPerformanceItem>;

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

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

export interface ScansGetResponseDataRequestsItemRequestRequest {
  initialPriority: string;
  isSameSite: boolean;
  method: string;
  mixedContentType: string;
  referrerPolicy: string;
  url: string;
  headers?: unknown | null;
}
export const ScansGetResponseDataRequestsItemRequestRequest =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      initialPriority: S.String,
      isSameSite: S.Boolean,
      method: S.String,
      mixedContentType: S.String,
      referrerPolicy: S.String,
      url: S.String,
      headers: S.optional(S.NullOr(S.Unknown)),
    }),
  ).annotate({
    identifier: "ScansGetResponseDataRequestsItemRequestRequest",
  }) as any as S.Schema<ScansGetResponseDataRequestsItemRequestRequest>;

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

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

export interface ScansGetResponseDataRequestsItemRequestRedirectResponse {
  charset: string;
  mimeType: string;
  protocol: string;
  remoteIPAddress: string;
  remotePort: number;
  securityHeaders: ScansGetResponseDataRequestsItemRequestRedirectResponseSecurityHeadersList;
  securityState: string;
  status: number;
  statusText: string;
  url: string;
  headers?: unknown | null;
}
export const ScansGetResponseDataRequestsItemRequestRedirectResponse =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      charset: S.String,
      mimeType: S.String,
      protocol: S.String,
      remoteIPAddress: S.String,
      remotePort: S.Number,
      securityHeaders:
        ScansGetResponseDataRequestsItemRequestRedirectResponseSecurityHeadersList,
      securityState: S.String,
      status: S.Number,
      statusText: S.String,
      url: S.String,
      headers: S.optional(S.NullOr(S.Unknown)),
    }),
  ).annotate({
    identifier: "ScansGetResponseDataRequestsItemRequestRedirectResponse",
  }) as any as S.Schema<ScansGetResponseDataRequestsItemRequestRedirectResponse>;

export interface ScansGetResponseDataRequestsItemRequest {
  documentURL: string;
  hasUserGesture: boolean;
  initiator: ScansGetResponseDataRequestsItemRequestInitiator;
  redirectHasExtraInfo: boolean;
  request: ScansGetResponseDataRequestsItemRequestRequest;
  requestId: string;
  type: string;
  wallTime: number;
  frameId?: string | null;
  loaderId?: string | null;
  primaryRequest?: boolean | null;
  redirectResponse?: ScansGetResponseDataRequestsItemRequestRedirectResponse | null;
}
export const ScansGetResponseDataRequestsItemRequest = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      documentURL: S.String,
      hasUserGesture: S.Boolean,
      initiator: ScansGetResponseDataRequestsItemRequestInitiator,
      redirectHasExtraInfo: S.Boolean,
      request: ScansGetResponseDataRequestsItemRequestRequest,
      requestId: S.String,
      type: S.String,
      wallTime: S.Number,
      frameId: S.optional(S.NullOr(S.String)),
      loaderId: S.optional(S.NullOr(S.String)),
      primaryRequest: S.optional(S.NullOr(S.Boolean)),
      redirectResponse: S.optional(
        S.NullOr(ScansGetResponseDataRequestsItemRequestRedirectResponse),
      ),
    }),
).annotate({
  identifier: "ScansGetResponseDataRequestsItemRequest",
}) as any as S.Schema<ScansGetResponseDataRequestsItemRequest>;

export interface ScansGetResponseDataRequestsItemResponseAsn {
  asn: string;
  country: string;
  description: string;
  ip: string;
  name: string;
  org: string;
}
export const ScansGetResponseDataRequestsItemResponseAsn =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      asn: S.String,
      country: S.String,
      description: S.String,
      ip: S.String,
      name: S.String,
      org: S.String,
    }),
  ).annotate({
    identifier: "ScansGetResponseDataRequestsItemResponseAsn",
  }) as any as S.Schema<ScansGetResponseDataRequestsItemResponseAsn>;

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

export interface ScansGetResponseDataRequestsItemResponseGeoip {
  city: string;
  country: string;
  countryName: string;
  geonameId: string;
  ll: ScansGetResponseDataRequestsItemResponseGeoipLlList;
  region: string;
}
export const ScansGetResponseDataRequestsItemResponseGeoip =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      city: S.String,
      country: S.String,
      countryName: S.String.pipe(T.Body("country_name")),
      geonameId: S.String,
      ll: ScansGetResponseDataRequestsItemResponseGeoipLlList,
      region: S.String,
    }),
  ).annotate({
    identifier: "ScansGetResponseDataRequestsItemResponseGeoip",
  }) as any as S.Schema<ScansGetResponseDataRequestsItemResponseGeoip>;

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

export interface ScansGetResponseDataRequestsItemResponseResponseSecurityDetails {
  certificateId: number;
  certificateTransparencyCompliance: string;
  cipher: string;
  encryptedClientHello: boolean;
  issuer: string;
  keyExchange: string;
  keyExchangeGroup: string;
  protocol: string;
  sanList: ScansGetResponseDataRequestsItemResponseResponseSecurityDetailsSanListList;
  serverSignatureAlgorithm: number;
  subjectName: string;
  validFrom: number;
  validTo: number;
}
export const ScansGetResponseDataRequestsItemResponseResponseSecurityDetails =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      certificateId: S.Number,
      certificateTransparencyCompliance: S.String,
      cipher: S.String,
      encryptedClientHello: S.Boolean,
      issuer: S.String,
      keyExchange: S.String,
      keyExchangeGroup: S.String,
      protocol: S.String,
      sanList:
        ScansGetResponseDataRequestsItemResponseResponseSecurityDetailsSanListList,
      serverSignatureAlgorithm: S.Number,
      subjectName: S.String,
      validFrom: S.Number,
      validTo: S.Number,
    }),
  ).annotate({
    identifier:
      "ScansGetResponseDataRequestsItemResponseResponseSecurityDetails",
  }) as any as S.Schema<ScansGetResponseDataRequestsItemResponseResponseSecurityDetails>;

export type ScansGetResponseDataRequestsItemResponseResponseSecurityHeadersItem =
  ScansGetResponseDataRequestsItemRequestRedirectResponseSecurityHeadersItem;
export const ScansGetResponseDataRequestsItemResponseResponseSecurityHeadersItem =
  ScansGetResponseDataRequestsItemRequestRedirectResponseSecurityHeadersItem;

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

export interface ScansGetResponseDataRequestsItemResponseResponse {
  charset: string;
  mimeType: string;
  protocol: string;
  remoteIPAddress: string;
  remotePort: number;
  securityDetails: ScansGetResponseDataRequestsItemResponseResponseSecurityDetails;
  securityHeaders: ScansGetResponseDataRequestsItemResponseResponseSecurityHeadersList;
  securityState: string;
  status: number;
  statusText: string;
  url: string;
  headers?: unknown | null;
}
export const ScansGetResponseDataRequestsItemResponseResponse =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      charset: S.String,
      mimeType: S.String,
      protocol: S.String,
      remoteIPAddress: S.String,
      remotePort: S.Number,
      securityDetails:
        ScansGetResponseDataRequestsItemResponseResponseSecurityDetails,
      securityHeaders:
        ScansGetResponseDataRequestsItemResponseResponseSecurityHeadersList,
      securityState: S.String,
      status: S.Number,
      statusText: S.String,
      url: S.String,
      headers: S.optional(S.NullOr(S.Unknown)),
    }),
  ).annotate({
    identifier: "ScansGetResponseDataRequestsItemResponseResponse",
  }) as any as S.Schema<ScansGetResponseDataRequestsItemResponseResponse>;

export interface ScansGetResponseDataRequestsItemResponse {
  asn: ScansGetResponseDataRequestsItemResponseAsn;
  dataLength: number;
  encodedDataLength: number;
  geoip: ScansGetResponseDataRequestsItemResponseGeoip;
  hasExtraInfo: boolean;
  requestId: string;
  response: ScansGetResponseDataRequestsItemResponseResponse;
  size: number;
  type: string;
  contentAvailable?: boolean | null;
  hash?: string | null;
}
export const ScansGetResponseDataRequestsItemResponse = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      asn: ScansGetResponseDataRequestsItemResponseAsn,
      dataLength: S.Number,
      encodedDataLength: S.Number,
      geoip: ScansGetResponseDataRequestsItemResponseGeoip,
      hasExtraInfo: S.Boolean,
      requestId: S.String,
      response: ScansGetResponseDataRequestsItemResponseResponse,
      size: S.Number,
      type: S.String,
      contentAvailable: S.optional(S.NullOr(S.Boolean)),
      hash: S.optional(S.NullOr(S.String)),
    }),
).annotate({
  identifier: "ScansGetResponseDataRequestsItemResponse",
}) as any as S.Schema<ScansGetResponseDataRequestsItemResponse>;

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

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

export interface ScansGetResponseDataRequestsItemRequestsItemRequest {
  headers: ScansGetResponseDataRequestsItemRequestsItemRequestHeaders;
  initialPriority: string;
  isSameSite: boolean;
  method: string;
  mixedContentType: string;
  referrerPolicy: string;
  url: string;
}
export const ScansGetResponseDataRequestsItemRequestsItemRequest =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      headers: ScansGetResponseDataRequestsItemRequestsItemRequestHeaders,
      initialPriority: S.String,
      isSameSite: S.Boolean,
      method: S.String,
      mixedContentType: S.String,
      referrerPolicy: S.String,
      url: S.String,
    }),
  ).annotate({
    identifier: "ScansGetResponseDataRequestsItemRequestsItemRequest",
  }) as any as S.Schema<ScansGetResponseDataRequestsItemRequestsItemRequest>;

export interface ScansGetResponseDataRequestsItemRequestsItem {
  documentURL: string;
  frameId: string;
  hasUserGesture: boolean;
  initiator: ScansGetResponseDataRequestsItemRequestsItemInitiator;
  loaderId: string;
  redirectHasExtraInfo: boolean;
  request: ScansGetResponseDataRequestsItemRequestsItemRequest;
  requestId: string;
  type: string;
  wallTime: number;
}
export const ScansGetResponseDataRequestsItemRequestsItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      documentURL: S.String,
      frameId: S.String,
      hasUserGesture: S.Boolean,
      initiator: ScansGetResponseDataRequestsItemRequestsItemInitiator,
      loaderId: S.String,
      redirectHasExtraInfo: S.Boolean,
      request: ScansGetResponseDataRequestsItemRequestsItemRequest,
      requestId: S.String,
      type: S.String,
      wallTime: S.Number,
    }),
  ).annotate({
    identifier: "ScansGetResponseDataRequestsItemRequestsItem",
  }) as any as S.Schema<ScansGetResponseDataRequestsItemRequestsItem>;

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

export interface ScansGetResponseDataRequestsItem {
  request: ScansGetResponseDataRequestsItemRequest;
  response: ScansGetResponseDataRequestsItemResponse;
  requests?: ScansGetResponseDataRequestsItemRequestsList | null;
}
export const ScansGetResponseDataRequestsItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    request: ScansGetResponseDataRequestsItemRequest,
    response: ScansGetResponseDataRequestsItemResponse,
    requests: S.optional(
      S.NullOr(ScansGetResponseDataRequestsItemRequestsList),
    ),
  }),
).annotate({
  identifier: "ScansGetResponseDataRequestsItem",
}) as any as S.Schema<ScansGetResponseDataRequestsItem>;

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

export interface ScansGetResponseData {
  console: ScansGetResponseDataConsoleList;
  cookies: ScansGetResponseDataCookiesList;
  globals: ScansGetResponseDataGlobalsList;
  links: ScansGetResponseDataLinksList;
  performance: ScansGetResponseDataPerformanceList;
  requests: ScansGetResponseDataRequestsList;
}
export const ScansGetResponseData = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    console: ScansGetResponseDataConsoleList,
    cookies: ScansGetResponseDataCookiesList,
    globals: ScansGetResponseDataGlobalsList,
    links: ScansGetResponseDataLinksList,
    performance: ScansGetResponseDataPerformanceList,
    requests: ScansGetResponseDataRequestsList,
  }),
).annotate({
  identifier: "ScansGetResponseData",
}) as any as S.Schema<ScansGetResponseData>;

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

export interface ScansGetResponseListsCertificatesItem {
  issuer: string;
  subjectName: string;
  validFrom: number;
  validTo: number;
}
export const ScansGetResponseListsCertificatesItem = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      issuer: S.String,
      subjectName: S.String,
      validFrom: S.Number,
      validTo: S.Number,
    }),
).annotate({
  identifier: "ScansGetResponseListsCertificatesItem",
}) as any as S.Schema<ScansGetResponseListsCertificatesItem>;

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

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

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

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

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

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

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

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

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

export interface ScansGetResponseLists {
  asns: ScansGetResponseListsAsnsList;
  certificates: ScansGetResponseListsCertificatesList;
  continents: ScansGetResponseListsContinentsList;
  countries: ScansGetResponseListsCountriesList;
  domains: ScansGetResponseListsDomainsList;
  hashes: ScansGetResponseListsHashesList;
  ips: ScansGetResponseListsIpsList;
  linkDomains: ScansGetResponseListsLinkDomainsList;
  servers: ScansGetResponseListsServersList;
  urls: ScansGetResponseListsUrlsList;
}
export const ScansGetResponseLists = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    asns: ScansGetResponseListsAsnsList,
    certificates: ScansGetResponseListsCertificatesList,
    continents: ScansGetResponseListsContinentsList,
    countries: ScansGetResponseListsCountriesList,
    domains: ScansGetResponseListsDomainsList,
    hashes: ScansGetResponseListsHashesList,
    ips: ScansGetResponseListsIpsList,
    linkDomains: ScansGetResponseListsLinkDomainsList,
    servers: ScansGetResponseListsServersList,
    urls: ScansGetResponseListsUrlsList,
  }),
).annotate({
  identifier: "ScansGetResponseLists",
}) as any as S.Schema<ScansGetResponseLists>;

export interface ScansGetResponseMetaProcessorsAsnDataItem {
  asn: string;
  country: string;
  description: string;
  ip: string;
  name: string;
}
export const ScansGetResponseMetaProcessorsAsnDataItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      asn: S.String,
      country: S.String,
      description: S.String,
      ip: S.String,
      name: S.String,
    }),
  ).annotate({
    identifier: "ScansGetResponseMetaProcessorsAsnDataItem",
  }) as any as S.Schema<ScansGetResponseMetaProcessorsAsnDataItem>;

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

export interface ScansGetResponseMetaProcessorsAsn {
  data: ScansGetResponseMetaProcessorsAsnDataList;
}
export const ScansGetResponseMetaProcessorsAsn = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    data: ScansGetResponseMetaProcessorsAsnDataList,
  }),
).annotate({
  identifier: "ScansGetResponseMetaProcessorsAsn",
}) as any as S.Schema<ScansGetResponseMetaProcessorsAsn>;

export interface ScansGetResponseMetaProcessorsDnsDataItem {
  address: string;
  dnssecValid: boolean;
  name: string;
  type: string;
}
export const ScansGetResponseMetaProcessorsDnsDataItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      address: S.String,
      dnssecValid: S.Boolean.pipe(T.Body("dnssec_valid")),
      name: S.String,
      type: S.String,
    }),
  ).annotate({
    identifier: "ScansGetResponseMetaProcessorsDnsDataItem",
  }) as any as S.Schema<ScansGetResponseMetaProcessorsDnsDataItem>;

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

export interface ScansGetResponseMetaProcessorsDns {
  data: ScansGetResponseMetaProcessorsDnsDataList;
}
export const ScansGetResponseMetaProcessorsDns = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    data: ScansGetResponseMetaProcessorsDnsDataList,
  }),
).annotate({
  identifier: "ScansGetResponseMetaProcessorsDns",
}) as any as S.Schema<ScansGetResponseMetaProcessorsDns>;

export interface ScansGetResponseMetaProcessorsDomainCategoriesDataItem {
  inherited: unknown;
  isPrimary: boolean;
  name: string;
}
export const ScansGetResponseMetaProcessorsDomainCategoriesDataItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      inherited: S.Unknown,
      isPrimary: S.Boolean,
      name: S.String,
    }),
  ).annotate({
    identifier: "ScansGetResponseMetaProcessorsDomainCategoriesDataItem",
  }) as any as S.Schema<ScansGetResponseMetaProcessorsDomainCategoriesDataItem>;

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

export interface ScansGetResponseMetaProcessorsDomainCategories {
  data: ScansGetResponseMetaProcessorsDomainCategoriesDataList;
}
export const ScansGetResponseMetaProcessorsDomainCategories =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      data: ScansGetResponseMetaProcessorsDomainCategoriesDataList,
    }),
  ).annotate({
    identifier: "ScansGetResponseMetaProcessorsDomainCategories",
  }) as any as S.Schema<ScansGetResponseMetaProcessorsDomainCategories>;

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

export interface ScansGetResponseMetaProcessorsGeoipDataItemGeoip {
  city: string;
  country: string;
  countryName: string;
  ll: ScansGetResponseMetaProcessorsGeoipDataItemGeoipLlList;
  region: string;
}
export const ScansGetResponseMetaProcessorsGeoipDataItemGeoip =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      city: S.String,
      country: S.String,
      countryName: S.String.pipe(T.Body("country_name")),
      ll: ScansGetResponseMetaProcessorsGeoipDataItemGeoipLlList,
      region: S.String,
    }),
  ).annotate({
    identifier: "ScansGetResponseMetaProcessorsGeoipDataItemGeoip",
  }) as any as S.Schema<ScansGetResponseMetaProcessorsGeoipDataItemGeoip>;

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

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

export interface ScansGetResponseMetaProcessorsGeoip {
  data: ScansGetResponseMetaProcessorsGeoipDataList;
}
export const ScansGetResponseMetaProcessorsGeoip = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    data: ScansGetResponseMetaProcessorsGeoipDataList,
  }),
).annotate({
  identifier: "ScansGetResponseMetaProcessorsGeoip",
}) as any as S.Schema<ScansGetResponseMetaProcessorsGeoip>;

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

export interface ScansGetResponseMetaProcessorsPhishing {
  data: ScansGetResponseMetaProcessorsPhishingDataList;
}
export const ScansGetResponseMetaProcessorsPhishing = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      data: ScansGetResponseMetaProcessorsPhishingDataList,
    }),
).annotate({
  identifier: "ScansGetResponseMetaProcessorsPhishing",
}) as any as S.Schema<ScansGetResponseMetaProcessorsPhishing>;

export interface ScansGetResponseMetaProcessorsRadarRankDataItem {
  bucket: string;
  hostname: string;
  rank?: number | null;
}
export const ScansGetResponseMetaProcessorsRadarRankDataItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      bucket: S.String,
      hostname: S.String,
      rank: S.optional(S.NullOr(S.Number)),
    }),
  ).annotate({
    identifier: "ScansGetResponseMetaProcessorsRadarRankDataItem",
  }) as any as S.Schema<ScansGetResponseMetaProcessorsRadarRankDataItem>;

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

export interface ScansGetResponseMetaProcessorsRadarRank {
  data: ScansGetResponseMetaProcessorsRadarRankDataList;
}
export const ScansGetResponseMetaProcessorsRadarRank = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      data: ScansGetResponseMetaProcessorsRadarRankDataList,
    }),
).annotate({
  identifier: "ScansGetResponseMetaProcessorsRadarRank",
}) as any as S.Schema<ScansGetResponseMetaProcessorsRadarRank>;

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

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

export interface ScansGetResponseMetaProcessorsWappaDataItemConfidenceItem {
  confidence: number;
  name: string;
  pattern: string;
  patternType: string;
}
export const ScansGetResponseMetaProcessorsWappaDataItemConfidenceItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      confidence: S.Number,
      name: S.String,
      pattern: S.String,
      patternType: S.String,
    }),
  ).annotate({
    identifier: "ScansGetResponseMetaProcessorsWappaDataItemConfidenceItem",
  }) as any as S.Schema<ScansGetResponseMetaProcessorsWappaDataItemConfidenceItem>;

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

export interface ScansGetResponseMetaProcessorsWappaDataItem {
  app: string;
  categories: ScansGetResponseMetaProcessorsWappaDataItemCategoriesList;
  confidence: ScansGetResponseMetaProcessorsWappaDataItemConfidenceList;
  confidenceTotal: number;
  icon: string;
  website: string;
}
export const ScansGetResponseMetaProcessorsWappaDataItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      app: S.String,
      categories: ScansGetResponseMetaProcessorsWappaDataItemCategoriesList,
      confidence: ScansGetResponseMetaProcessorsWappaDataItemConfidenceList,
      confidenceTotal: S.Number,
      icon: S.String,
      website: S.String,
    }),
  ).annotate({
    identifier: "ScansGetResponseMetaProcessorsWappaDataItem",
  }) as any as S.Schema<ScansGetResponseMetaProcessorsWappaDataItem>;

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

export interface ScansGetResponseMetaProcessorsWappa {
  data: ScansGetResponseMetaProcessorsWappaDataList;
}
export const ScansGetResponseMetaProcessorsWappa = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    data: ScansGetResponseMetaProcessorsWappaDataList,
  }),
).annotate({
  identifier: "ScansGetResponseMetaProcessorsWappa",
}) as any as S.Schema<ScansGetResponseMetaProcessorsWappa>;

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

export interface ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemRequest {
  method: string;
  url: string;
  headers?: unknown | null;
}
export const ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemRequest =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      method: S.String,
      url: S.String,
      headers: S.optional(S.NullOr(S.Unknown)),
    }),
  ).annotate({
    identifier:
      "ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemRequest",
  }) as any as S.Schema<ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemRequest>;

export interface ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemResponse {
  status: number;
  statusText: string;
  bodyPreview?: string | null;
  bodySize?: number | null;
  headers?: unknown | null;
  redirectedTo?: string | null;
}
export const ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemResponse =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      status: S.Number,
      statusText: S.String,
      bodyPreview: S.optional(S.NullOr(S.String)),
      bodySize: S.optional(S.NullOr(S.Number)),
      headers: S.optional(S.NullOr(S.Unknown)),
      redirectedTo: S.optional(S.NullOr(S.String)),
    }),
  ).annotate({
    identifier:
      "ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemResponse",
  }) as any as S.Schema<ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemResponse>;

export interface ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItem {
  action: string;
  label: string;
  finding?: ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemFinding | null;
  request?: ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemRequest | null;
  response?: ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemResponse | null;
}
export const ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      action: S.String,
      label: S.String,
      finding: S.optional(
        S.NullOr(
          ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemFinding,
        ),
      ),
      request: S.optional(
        S.NullOr(
          ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemRequest,
        ),
      ),
      response: S.optional(
        S.NullOr(
          ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemResponse,
        ),
      ),
    }),
  ).annotate({
    identifier:
      "ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItem",
  }) as any as S.Schema<ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItem>;

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

export interface ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignals {
  status: string;
  details?: unknown | null;
  durationMs?: number | null;
  evidence?: ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceList | null;
  message?: string | null;
}
export const ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignals =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      status: S.String,
      details: S.optional(S.NullOr(S.Unknown)),
      durationMs: S.optional(S.NullOr(S.Number)),
      evidence: S.optional(
        S.NullOr(
          ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceList,
        ),
      ),
      message: S.optional(S.NullOr(S.String)),
    }),
  ).annotate({
    identifier:
      "ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignals",
  }) as any as S.Schema<ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignals>;

export type ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlRobotsTxtAiRulesEvidenceItemFinding =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemFinding;
export const ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlRobotsTxtAiRulesEvidenceItemFinding =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemFinding;

export type ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlRobotsTxtAiRulesEvidenceItemRequest =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemRequest;
export const ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlRobotsTxtAiRulesEvidenceItemRequest =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemRequest;

export type ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlRobotsTxtAiRulesEvidenceItemResponse =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemResponse;
export const ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlRobotsTxtAiRulesEvidenceItemResponse =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemResponse;

export type ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlRobotsTxtAiRulesEvidenceItem =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItem;
export const ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlRobotsTxtAiRulesEvidenceItem =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItem;

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

export interface ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlRobotsTxtAiRules {
  status: string;
  details?: unknown | null;
  durationMs?: number | null;
  evidence?: ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlRobotsTxtAiRulesEvidenceList | null;
  message?: string | null;
}
export const ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlRobotsTxtAiRules =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      status: S.String,
      details: S.optional(S.NullOr(S.Unknown)),
      durationMs: S.optional(S.NullOr(S.Number)),
      evidence: S.optional(
        S.NullOr(
          ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlRobotsTxtAiRulesEvidenceList,
        ),
      ),
      message: S.optional(S.NullOr(S.String)),
    }),
  ).annotate({
    identifier:
      "ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlRobotsTxtAiRules",
  }) as any as S.Schema<ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlRobotsTxtAiRules>;

export type ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlWebBotAuthEvidenceItemFinding =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemFinding;
export const ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlWebBotAuthEvidenceItemFinding =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemFinding;

export type ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlWebBotAuthEvidenceItemRequest =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemRequest;
export const ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlWebBotAuthEvidenceItemRequest =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemRequest;

export type ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlWebBotAuthEvidenceItemResponse =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemResponse;
export const ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlWebBotAuthEvidenceItemResponse =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemResponse;

export type ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlWebBotAuthEvidenceItem =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItem;
export const ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlWebBotAuthEvidenceItem =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItem;

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

export interface ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlWebBotAuth {
  status: string;
  details?: unknown | null;
  durationMs?: number | null;
  evidence?: ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlWebBotAuthEvidenceList | null;
  message?: string | null;
}
export const ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlWebBotAuth =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      status: S.String,
      details: S.optional(S.NullOr(S.Unknown)),
      durationMs: S.optional(S.NullOr(S.Number)),
      evidence: S.optional(
        S.NullOr(
          ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlWebBotAuthEvidenceList,
        ),
      ),
      message: S.optional(S.NullOr(S.String)),
    }),
  ).annotate({
    identifier:
      "ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlWebBotAuth",
  }) as any as S.Schema<ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlWebBotAuth>;

export interface ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControl {
  contentSignals: ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignals;
  robotsTxtAiRules: ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlRobotsTxtAiRules;
  webBotAuth: ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlWebBotAuth;
}
export const ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControl =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      contentSignals:
        ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignals,
      robotsTxtAiRules:
        ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlRobotsTxtAiRules,
      webBotAuth:
        ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlWebBotAuth,
    }),
  ).annotate({
    identifier:
      "ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControl",
  }) as any as S.Schema<ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControl>;

export type ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceAcpEvidenceItemFinding =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemFinding;
export const ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceAcpEvidenceItemFinding =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemFinding;

export type ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceAcpEvidenceItemRequest =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemRequest;
export const ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceAcpEvidenceItemRequest =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemRequest;

export type ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceAcpEvidenceItemResponse =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemResponse;
export const ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceAcpEvidenceItemResponse =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemResponse;

export type ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceAcpEvidenceItem =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItem;
export const ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceAcpEvidenceItem =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItem;

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

export interface ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceAcp {
  status: string;
  details?: unknown | null;
  durationMs?: number | null;
  evidence?: ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceAcpEvidenceList | null;
  message?: string | null;
}
export const ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceAcp =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      status: S.String,
      details: S.optional(S.NullOr(S.Unknown)),
      durationMs: S.optional(S.NullOr(S.Number)),
      evidence: S.optional(
        S.NullOr(
          ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceAcpEvidenceList,
        ),
      ),
      message: S.optional(S.NullOr(S.String)),
    }),
  ).annotate({
    identifier: "ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceAcp",
  }) as any as S.Schema<ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceAcp>;

export type ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceAp2EvidenceItemFinding =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemFinding;
export const ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceAp2EvidenceItemFinding =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemFinding;

export type ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceAp2EvidenceItemRequest =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemRequest;
export const ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceAp2EvidenceItemRequest =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemRequest;

export type ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceAp2EvidenceItemResponse =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemResponse;
export const ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceAp2EvidenceItemResponse =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemResponse;

export type ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceAp2EvidenceItem =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItem;
export const ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceAp2EvidenceItem =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItem;

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

export interface ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceAp2 {
  status: string;
  details?: unknown | null;
  durationMs?: number | null;
  evidence?: ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceAp2EvidenceList | null;
  message?: string | null;
}
export const ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceAp2 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      status: S.String,
      details: S.optional(S.NullOr(S.Unknown)),
      durationMs: S.optional(S.NullOr(S.Number)),
      evidence: S.optional(
        S.NullOr(
          ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceAp2EvidenceList,
        ),
      ),
      message: S.optional(S.NullOr(S.String)),
    }),
  ).annotate({
    identifier: "ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceAp2",
  }) as any as S.Schema<ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceAp2>;

export type ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceMppEvidenceItemFinding =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemFinding;
export const ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceMppEvidenceItemFinding =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemFinding;

export type ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceMppEvidenceItemRequest =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemRequest;
export const ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceMppEvidenceItemRequest =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemRequest;

export type ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceMppEvidenceItemResponse =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemResponse;
export const ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceMppEvidenceItemResponse =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemResponse;

export type ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceMppEvidenceItem =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItem;
export const ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceMppEvidenceItem =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItem;

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

export interface ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceMpp {
  status: string;
  details?: unknown | null;
  durationMs?: number | null;
  evidence?: ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceMppEvidenceList | null;
  message?: string | null;
}
export const ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceMpp =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      status: S.String,
      details: S.optional(S.NullOr(S.Unknown)),
      durationMs: S.optional(S.NullOr(S.Number)),
      evidence: S.optional(
        S.NullOr(
          ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceMppEvidenceList,
        ),
      ),
      message: S.optional(S.NullOr(S.String)),
    }),
  ).annotate({
    identifier: "ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceMpp",
  }) as any as S.Schema<ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceMpp>;

export type ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceUcpEvidenceItemFinding =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemFinding;
export const ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceUcpEvidenceItemFinding =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemFinding;

export type ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceUcpEvidenceItemRequest =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemRequest;
export const ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceUcpEvidenceItemRequest =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemRequest;

export type ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceUcpEvidenceItemResponse =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemResponse;
export const ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceUcpEvidenceItemResponse =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemResponse;

export type ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceUcpEvidenceItem =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItem;
export const ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceUcpEvidenceItem =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItem;

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

export interface ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceUcp {
  status: string;
  details?: unknown | null;
  durationMs?: number | null;
  evidence?: ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceUcpEvidenceList | null;
  message?: string | null;
}
export const ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceUcp =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      status: S.String,
      details: S.optional(S.NullOr(S.Unknown)),
      durationMs: S.optional(S.NullOr(S.Number)),
      evidence: S.optional(
        S.NullOr(
          ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceUcpEvidenceList,
        ),
      ),
      message: S.optional(S.NullOr(S.String)),
    }),
  ).annotate({
    identifier: "ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceUcp",
  }) as any as S.Schema<ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceUcp>;

export type ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceX402EvidenceItemFinding =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemFinding;
export const ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceX402EvidenceItemFinding =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemFinding;

export type ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceX402EvidenceItemRequest =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemRequest;
export const ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceX402EvidenceItemRequest =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemRequest;

export type ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceX402EvidenceItemResponse =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemResponse;
export const ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceX402EvidenceItemResponse =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemResponse;

export type ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceX402EvidenceItem =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItem;
export const ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceX402EvidenceItem =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItem;

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

export interface ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceX402 {
  status: string;
  details?: unknown | null;
  durationMs?: number | null;
  evidence?: ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceX402EvidenceList | null;
  message?: string | null;
}
export const ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceX402 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      status: S.String,
      details: S.optional(S.NullOr(S.Unknown)),
      durationMs: S.optional(S.NullOr(S.Number)),
      evidence: S.optional(
        S.NullOr(
          ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceX402EvidenceList,
        ),
      ),
      message: S.optional(S.NullOr(S.String)),
    }),
  ).annotate({
    identifier:
      "ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceX402",
  }) as any as S.Schema<ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceX402>;

export interface ScansGetResponseMetaProcessorsAgentReadinessChecksCommerce {
  acp: ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceAcp;
  ap2: ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceAp2;
  mpp: ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceMpp;
  ucp: ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceUcp;
  x402: ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceX402;
}
export const ScansGetResponseMetaProcessorsAgentReadinessChecksCommerce =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      acp: ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceAcp,
      ap2: ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceAp2,
      mpp: ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceMpp,
      ucp: ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceUcp,
      x402: ScansGetResponseMetaProcessorsAgentReadinessChecksCommerceX402,
    }),
  ).annotate({
    identifier: "ScansGetResponseMetaProcessorsAgentReadinessChecksCommerce",
  }) as any as S.Schema<ScansGetResponseMetaProcessorsAgentReadinessChecksCommerce>;

export type ScansGetResponseMetaProcessorsAgentReadinessChecksContentAccessibilityMarkdownNegotiationEvidenceItemFinding =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemFinding;
export const ScansGetResponseMetaProcessorsAgentReadinessChecksContentAccessibilityMarkdownNegotiationEvidenceItemFinding =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemFinding;

export type ScansGetResponseMetaProcessorsAgentReadinessChecksContentAccessibilityMarkdownNegotiationEvidenceItemRequest =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemRequest;
export const ScansGetResponseMetaProcessorsAgentReadinessChecksContentAccessibilityMarkdownNegotiationEvidenceItemRequest =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemRequest;

export type ScansGetResponseMetaProcessorsAgentReadinessChecksContentAccessibilityMarkdownNegotiationEvidenceItemResponse =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemResponse;
export const ScansGetResponseMetaProcessorsAgentReadinessChecksContentAccessibilityMarkdownNegotiationEvidenceItemResponse =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemResponse;

export type ScansGetResponseMetaProcessorsAgentReadinessChecksContentAccessibilityMarkdownNegotiationEvidenceItem =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItem;
export const ScansGetResponseMetaProcessorsAgentReadinessChecksContentAccessibilityMarkdownNegotiationEvidenceItem =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItem;

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

export interface ScansGetResponseMetaProcessorsAgentReadinessChecksContentAccessibilityMarkdownNegotiation {
  status: string;
  details?: unknown | null;
  durationMs?: number | null;
  evidence?: ScansGetResponseMetaProcessorsAgentReadinessChecksContentAccessibilityMarkdownNegotiationEvidenceList | null;
  message?: string | null;
}
export const ScansGetResponseMetaProcessorsAgentReadinessChecksContentAccessibilityMarkdownNegotiation =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      status: S.String,
      details: S.optional(S.NullOr(S.Unknown)),
      durationMs: S.optional(S.NullOr(S.Number)),
      evidence: S.optional(
        S.NullOr(
          ScansGetResponseMetaProcessorsAgentReadinessChecksContentAccessibilityMarkdownNegotiationEvidenceList,
        ),
      ),
      message: S.optional(S.NullOr(S.String)),
    }),
  ).annotate({
    identifier:
      "ScansGetResponseMetaProcessorsAgentReadinessChecksContentAccessibilityMarkdownNegotiation",
  }) as any as S.Schema<ScansGetResponseMetaProcessorsAgentReadinessChecksContentAccessibilityMarkdownNegotiation>;

export interface ScansGetResponseMetaProcessorsAgentReadinessChecksContentAccessibility {
  markdownNegotiation: ScansGetResponseMetaProcessorsAgentReadinessChecksContentAccessibilityMarkdownNegotiation;
}
export const ScansGetResponseMetaProcessorsAgentReadinessChecksContentAccessibility =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      markdownNegotiation:
        ScansGetResponseMetaProcessorsAgentReadinessChecksContentAccessibilityMarkdownNegotiation,
    }),
  ).annotate({
    identifier:
      "ScansGetResponseMetaProcessorsAgentReadinessChecksContentAccessibility",
  }) as any as S.Schema<ScansGetResponseMetaProcessorsAgentReadinessChecksContentAccessibility>;

export type ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoverabilityLinkHeadersEvidenceItemFinding =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemFinding;
export const ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoverabilityLinkHeadersEvidenceItemFinding =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemFinding;

export type ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoverabilityLinkHeadersEvidenceItemRequest =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemRequest;
export const ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoverabilityLinkHeadersEvidenceItemRequest =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemRequest;

export type ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoverabilityLinkHeadersEvidenceItemResponse =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemResponse;
export const ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoverabilityLinkHeadersEvidenceItemResponse =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemResponse;

export type ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoverabilityLinkHeadersEvidenceItem =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItem;
export const ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoverabilityLinkHeadersEvidenceItem =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItem;

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

export interface ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoverabilityLinkHeaders {
  status: string;
  details?: unknown | null;
  durationMs?: number | null;
  evidence?: ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoverabilityLinkHeadersEvidenceList | null;
  message?: string | null;
}
export const ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoverabilityLinkHeaders =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      status: S.String,
      details: S.optional(S.NullOr(S.Unknown)),
      durationMs: S.optional(S.NullOr(S.Number)),
      evidence: S.optional(
        S.NullOr(
          ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoverabilityLinkHeadersEvidenceList,
        ),
      ),
      message: S.optional(S.NullOr(S.String)),
    }),
  ).annotate({
    identifier:
      "ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoverabilityLinkHeaders",
  }) as any as S.Schema<ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoverabilityLinkHeaders>;

export type ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoverabilityRobotsTxtEvidenceItemFinding =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemFinding;
export const ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoverabilityRobotsTxtEvidenceItemFinding =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemFinding;

export type ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoverabilityRobotsTxtEvidenceItemRequest =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemRequest;
export const ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoverabilityRobotsTxtEvidenceItemRequest =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemRequest;

export type ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoverabilityRobotsTxtEvidenceItemResponse =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemResponse;
export const ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoverabilityRobotsTxtEvidenceItemResponse =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemResponse;

export type ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoverabilityRobotsTxtEvidenceItem =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItem;
export const ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoverabilityRobotsTxtEvidenceItem =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItem;

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

export interface ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoverabilityRobotsTxt {
  status: string;
  details?: unknown | null;
  durationMs?: number | null;
  evidence?: ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoverabilityRobotsTxtEvidenceList | null;
  message?: string | null;
}
export const ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoverabilityRobotsTxt =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      status: S.String,
      details: S.optional(S.NullOr(S.Unknown)),
      durationMs: S.optional(S.NullOr(S.Number)),
      evidence: S.optional(
        S.NullOr(
          ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoverabilityRobotsTxtEvidenceList,
        ),
      ),
      message: S.optional(S.NullOr(S.String)),
    }),
  ).annotate({
    identifier:
      "ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoverabilityRobotsTxt",
  }) as any as S.Schema<ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoverabilityRobotsTxt>;

export type ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoverabilitySitemapEvidenceItemFinding =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemFinding;
export const ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoverabilitySitemapEvidenceItemFinding =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemFinding;

export type ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoverabilitySitemapEvidenceItemRequest =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemRequest;
export const ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoverabilitySitemapEvidenceItemRequest =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemRequest;

export type ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoverabilitySitemapEvidenceItemResponse =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemResponse;
export const ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoverabilitySitemapEvidenceItemResponse =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemResponse;

export type ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoverabilitySitemapEvidenceItem =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItem;
export const ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoverabilitySitemapEvidenceItem =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItem;

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

export interface ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoverabilitySitemap {
  status: string;
  details?: unknown | null;
  durationMs?: number | null;
  evidence?: ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoverabilitySitemapEvidenceList | null;
  message?: string | null;
}
export const ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoverabilitySitemap =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      status: S.String,
      details: S.optional(S.NullOr(S.Unknown)),
      durationMs: S.optional(S.NullOr(S.Number)),
      evidence: S.optional(
        S.NullOr(
          ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoverabilitySitemapEvidenceList,
        ),
      ),
      message: S.optional(S.NullOr(S.String)),
    }),
  ).annotate({
    identifier:
      "ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoverabilitySitemap",
  }) as any as S.Schema<ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoverabilitySitemap>;

export interface ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoverability {
  linkHeaders: ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoverabilityLinkHeaders;
  robotsTxt: ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoverabilityRobotsTxt;
  sitemap: ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoverabilitySitemap;
}
export const ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoverability =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      linkHeaders:
        ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoverabilityLinkHeaders,
      robotsTxt:
        ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoverabilityRobotsTxt,
      sitemap:
        ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoverabilitySitemap,
    }),
  ).annotate({
    identifier:
      "ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoverability",
  }) as any as S.Schema<ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoverability>;

export type ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryA2aAgentCardEvidenceItemFinding =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemFinding;
export const ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryA2aAgentCardEvidenceItemFinding =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemFinding;

export type ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryA2aAgentCardEvidenceItemRequest =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemRequest;
export const ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryA2aAgentCardEvidenceItemRequest =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemRequest;

export type ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryA2aAgentCardEvidenceItemResponse =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemResponse;
export const ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryA2aAgentCardEvidenceItemResponse =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemResponse;

export type ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryA2aAgentCardEvidenceItem =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItem;
export const ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryA2aAgentCardEvidenceItem =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItem;

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

export interface ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryA2aAgentCard {
  status: string;
  details?: unknown | null;
  durationMs?: number | null;
  evidence?: ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryA2aAgentCardEvidenceList | null;
  message?: string | null;
}
export const ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryA2aAgentCard =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      status: S.String,
      details: S.optional(S.NullOr(S.Unknown)),
      durationMs: S.optional(S.NullOr(S.Number)),
      evidence: S.optional(
        S.NullOr(
          ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryA2aAgentCardEvidenceList,
        ),
      ),
      message: S.optional(S.NullOr(S.String)),
    }),
  ).annotate({
    identifier:
      "ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryA2aAgentCard",
  }) as any as S.Schema<ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryA2aAgentCard>;

export type ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryAgentSkillsEvidenceItemFinding =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemFinding;
export const ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryAgentSkillsEvidenceItemFinding =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemFinding;

export type ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryAgentSkillsEvidenceItemRequest =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemRequest;
export const ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryAgentSkillsEvidenceItemRequest =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemRequest;

export type ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryAgentSkillsEvidenceItemResponse =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemResponse;
export const ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryAgentSkillsEvidenceItemResponse =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemResponse;

export type ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryAgentSkillsEvidenceItem =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItem;
export const ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryAgentSkillsEvidenceItem =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItem;

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

export interface ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryAgentSkills {
  status: string;
  details?: unknown | null;
  durationMs?: number | null;
  evidence?: ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryAgentSkillsEvidenceList | null;
  message?: string | null;
}
export const ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryAgentSkills =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      status: S.String,
      details: S.optional(S.NullOr(S.Unknown)),
      durationMs: S.optional(S.NullOr(S.Number)),
      evidence: S.optional(
        S.NullOr(
          ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryAgentSkillsEvidenceList,
        ),
      ),
      message: S.optional(S.NullOr(S.String)),
    }),
  ).annotate({
    identifier:
      "ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryAgentSkills",
  }) as any as S.Schema<ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryAgentSkills>;

export type ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryApiCatalogEvidenceItemFinding =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemFinding;
export const ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryApiCatalogEvidenceItemFinding =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemFinding;

export type ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryApiCatalogEvidenceItemRequest =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemRequest;
export const ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryApiCatalogEvidenceItemRequest =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemRequest;

export type ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryApiCatalogEvidenceItemResponse =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemResponse;
export const ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryApiCatalogEvidenceItemResponse =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemResponse;

export type ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryApiCatalogEvidenceItem =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItem;
export const ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryApiCatalogEvidenceItem =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItem;

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

export interface ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryApiCatalog {
  status: string;
  details?: unknown | null;
  durationMs?: number | null;
  evidence?: ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryApiCatalogEvidenceList | null;
  message?: string | null;
}
export const ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryApiCatalog =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      status: S.String,
      details: S.optional(S.NullOr(S.Unknown)),
      durationMs: S.optional(S.NullOr(S.Number)),
      evidence: S.optional(
        S.NullOr(
          ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryApiCatalogEvidenceList,
        ),
      ),
      message: S.optional(S.NullOr(S.String)),
    }),
  ).annotate({
    identifier:
      "ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryApiCatalog",
  }) as any as S.Schema<ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryApiCatalog>;

export type ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryMcpServerCardEvidenceItemFinding =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemFinding;
export const ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryMcpServerCardEvidenceItemFinding =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemFinding;

export type ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryMcpServerCardEvidenceItemRequest =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemRequest;
export const ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryMcpServerCardEvidenceItemRequest =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemRequest;

export type ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryMcpServerCardEvidenceItemResponse =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemResponse;
export const ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryMcpServerCardEvidenceItemResponse =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemResponse;

export type ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryMcpServerCardEvidenceItem =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItem;
export const ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryMcpServerCardEvidenceItem =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItem;

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

export interface ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryMcpServerCard {
  status: string;
  details?: unknown | null;
  durationMs?: number | null;
  evidence?: ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryMcpServerCardEvidenceList | null;
  message?: string | null;
}
export const ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryMcpServerCard =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      status: S.String,
      details: S.optional(S.NullOr(S.Unknown)),
      durationMs: S.optional(S.NullOr(S.Number)),
      evidence: S.optional(
        S.NullOr(
          ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryMcpServerCardEvidenceList,
        ),
      ),
      message: S.optional(S.NullOr(S.String)),
    }),
  ).annotate({
    identifier:
      "ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryMcpServerCard",
  }) as any as S.Schema<ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryMcpServerCard>;

export type ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryOauthDiscoveryEvidenceItemFinding =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemFinding;
export const ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryOauthDiscoveryEvidenceItemFinding =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemFinding;

export type ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryOauthDiscoveryEvidenceItemRequest =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemRequest;
export const ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryOauthDiscoveryEvidenceItemRequest =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemRequest;

export type ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryOauthDiscoveryEvidenceItemResponse =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemResponse;
export const ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryOauthDiscoveryEvidenceItemResponse =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemResponse;

export type ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryOauthDiscoveryEvidenceItem =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItem;
export const ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryOauthDiscoveryEvidenceItem =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItem;

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

export interface ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryOauthDiscovery {
  status: string;
  details?: unknown | null;
  durationMs?: number | null;
  evidence?: ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryOauthDiscoveryEvidenceList | null;
  message?: string | null;
}
export const ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryOauthDiscovery =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      status: S.String,
      details: S.optional(S.NullOr(S.Unknown)),
      durationMs: S.optional(S.NullOr(S.Number)),
      evidence: S.optional(
        S.NullOr(
          ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryOauthDiscoveryEvidenceList,
        ),
      ),
      message: S.optional(S.NullOr(S.String)),
    }),
  ).annotate({
    identifier:
      "ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryOauthDiscovery",
  }) as any as S.Schema<ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryOauthDiscovery>;

export type ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryOauthProtectedResourceEvidenceItemFinding =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemFinding;
export const ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryOauthProtectedResourceEvidenceItemFinding =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemFinding;

export type ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryOauthProtectedResourceEvidenceItemRequest =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemRequest;
export const ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryOauthProtectedResourceEvidenceItemRequest =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemRequest;

export type ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryOauthProtectedResourceEvidenceItemResponse =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemResponse;
export const ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryOauthProtectedResourceEvidenceItemResponse =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemResponse;

export type ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryOauthProtectedResourceEvidenceItem =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItem;
export const ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryOauthProtectedResourceEvidenceItem =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItem;

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

export interface ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryOauthProtectedResource {
  status: string;
  details?: unknown | null;
  durationMs?: number | null;
  evidence?: ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryOauthProtectedResourceEvidenceList | null;
  message?: string | null;
}
export const ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryOauthProtectedResource =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      status: S.String,
      details: S.optional(S.NullOr(S.Unknown)),
      durationMs: S.optional(S.NullOr(S.Number)),
      evidence: S.optional(
        S.NullOr(
          ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryOauthProtectedResourceEvidenceList,
        ),
      ),
      message: S.optional(S.NullOr(S.String)),
    }),
  ).annotate({
    identifier:
      "ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryOauthProtectedResource",
  }) as any as S.Schema<ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryOauthProtectedResource>;

export type ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryWebMcpEvidenceItemFinding =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemFinding;
export const ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryWebMcpEvidenceItemFinding =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemFinding;

export type ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryWebMcpEvidenceItemRequest =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemRequest;
export const ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryWebMcpEvidenceItemRequest =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemRequest;

export type ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryWebMcpEvidenceItemResponse =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemResponse;
export const ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryWebMcpEvidenceItemResponse =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItemResponse;

export type ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryWebMcpEvidenceItem =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItem;
export const ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryWebMcpEvidenceItem =
  ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControlContentSignalsEvidenceItem;

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

export interface ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryWebMcp {
  status: string;
  details?: unknown | null;
  durationMs?: number | null;
  evidence?: ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryWebMcpEvidenceList | null;
  message?: string | null;
}
export const ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryWebMcp =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      status: S.String,
      details: S.optional(S.NullOr(S.Unknown)),
      durationMs: S.optional(S.NullOr(S.Number)),
      evidence: S.optional(
        S.NullOr(
          ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryWebMcpEvidenceList,
        ),
      ),
      message: S.optional(S.NullOr(S.String)),
    }),
  ).annotate({
    identifier:
      "ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryWebMcp",
  }) as any as S.Schema<ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryWebMcp>;

export interface ScansGetResponseMetaProcessorsAgentReadinessChecksDiscovery {
  a2aAgentCard: ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryA2aAgentCard;
  agentSkills: ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryAgentSkills;
  apiCatalog: ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryApiCatalog;
  mcpServerCard: ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryMcpServerCard;
  oauthDiscovery: ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryOauthDiscovery;
  oauthProtectedResource: ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryOauthProtectedResource;
  webMcp: ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryWebMcp;
}
export const ScansGetResponseMetaProcessorsAgentReadinessChecksDiscovery =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      a2aAgentCard:
        ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryA2aAgentCard,
      agentSkills:
        ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryAgentSkills,
      apiCatalog:
        ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryApiCatalog,
      mcpServerCard:
        ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryMcpServerCard,
      oauthDiscovery:
        ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryOauthDiscovery,
      oauthProtectedResource:
        ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryOauthProtectedResource,
      webMcp: ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoveryWebMcp,
    }),
  ).annotate({
    identifier: "ScansGetResponseMetaProcessorsAgentReadinessChecksDiscovery",
  }) as any as S.Schema<ScansGetResponseMetaProcessorsAgentReadinessChecksDiscovery>;

export interface ScansGetResponseMetaProcessorsAgentReadinessChecks {
  botAccessControl: ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControl;
  commerce: ScansGetResponseMetaProcessorsAgentReadinessChecksCommerce;
  contentAccessibility: ScansGetResponseMetaProcessorsAgentReadinessChecksContentAccessibility;
  discoverability: ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoverability;
  discovery: ScansGetResponseMetaProcessorsAgentReadinessChecksDiscovery;
}
export const ScansGetResponseMetaProcessorsAgentReadinessChecks =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      botAccessControl:
        ScansGetResponseMetaProcessorsAgentReadinessChecksBotAccessControl,
      commerce: ScansGetResponseMetaProcessorsAgentReadinessChecksCommerce,
      contentAccessibility:
        ScansGetResponseMetaProcessorsAgentReadinessChecksContentAccessibility,
      discoverability:
        ScansGetResponseMetaProcessorsAgentReadinessChecksDiscoverability,
      discovery: ScansGetResponseMetaProcessorsAgentReadinessChecksDiscovery,
    }),
  ).annotate({
    identifier: "ScansGetResponseMetaProcessorsAgentReadinessChecks",
  }) as any as S.Schema<ScansGetResponseMetaProcessorsAgentReadinessChecks>;

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

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

export interface ScansGetResponseMetaProcessorsAgentReadinessNextLevelRequirementsItem {
  check: string;
  description: string;
  prompt: string;
  skillUrl: string;
  specUrls: ScansGetResponseMetaProcessorsAgentReadinessNextLevelRequirementsItemSpecUrlsList;
}
export const ScansGetResponseMetaProcessorsAgentReadinessNextLevelRequirementsItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      check: S.String,
      description: S.String,
      prompt: S.String,
      skillUrl: S.String,
      specUrls:
        ScansGetResponseMetaProcessorsAgentReadinessNextLevelRequirementsItemSpecUrlsList,
    }),
  ).annotate({
    identifier:
      "ScansGetResponseMetaProcessorsAgentReadinessNextLevelRequirementsItem",
  }) as any as S.Schema<ScansGetResponseMetaProcessorsAgentReadinessNextLevelRequirementsItem>;

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

export interface ScansGetResponseMetaProcessorsAgentReadinessNextLevel {
  name: string;
  requirements: ScansGetResponseMetaProcessorsAgentReadinessNextLevelRequirementsList;
  target: number;
}
export const ScansGetResponseMetaProcessorsAgentReadinessNextLevel =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      name: S.String,
      requirements:
        ScansGetResponseMetaProcessorsAgentReadinessNextLevelRequirementsList,
      target: S.Number,
    }),
  ).annotate({
    identifier: "ScansGetResponseMetaProcessorsAgentReadinessNextLevel",
  }) as any as S.Schema<ScansGetResponseMetaProcessorsAgentReadinessNextLevel>;

export interface ScansGetResponseMetaProcessorsAgentReadiness {
  checks: ScansGetResponseMetaProcessorsAgentReadinessChecks;
  level: number;
  levelName: string;
  commerceSignals?: ScansGetResponseMetaProcessorsAgentReadinessCommerceSignalsList | null;
  isCommerce?: boolean | null;
  nextLevel?: ScansGetResponseMetaProcessorsAgentReadinessNextLevel | null;
}
export const ScansGetResponseMetaProcessorsAgentReadiness =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      checks: ScansGetResponseMetaProcessorsAgentReadinessChecks,
      level: S.Number,
      levelName: S.String,
      commerceSignals: S.optional(
        S.NullOr(
          ScansGetResponseMetaProcessorsAgentReadinessCommerceSignalsList,
        ),
      ),
      isCommerce: S.optional(S.NullOr(S.Boolean)),
      nextLevel: S.optional(
        S.NullOr(ScansGetResponseMetaProcessorsAgentReadinessNextLevel),
      ),
    }),
  ).annotate({
    identifier: "ScansGetResponseMetaProcessorsAgentReadiness",
  }) as any as S.Schema<ScansGetResponseMetaProcessorsAgentReadiness>;

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

export interface ScansGetResponseMetaProcessorsPhishingV2 {
  data: ScansGetResponseMetaProcessorsPhishingV2DataList;
}
export const ScansGetResponseMetaProcessorsPhishingV2 = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      data: ScansGetResponseMetaProcessorsPhishingV2DataList,
    }),
).annotate({
  identifier: "ScansGetResponseMetaProcessorsPhishingV2",
}) as any as S.Schema<ScansGetResponseMetaProcessorsPhishingV2>;

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

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

export interface ScansGetResponseMetaProcessorsRobotsTxtDataItemRulesShapeContentSignal {
  aiInput?: string | null;
  aiTrain?: string | null;
  search?: string | null;
}
export const ScansGetResponseMetaProcessorsRobotsTxtDataItemRulesShapeContentSignal =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      aiInput: S.optional(S.NullOr(S.String).pipe(T.Body("ai-input"))),
      aiTrain: S.optional(S.NullOr(S.String).pipe(T.Body("ai-train"))),
      search: S.optional(S.NullOr(S.String)),
    }),
  ).annotate({
    identifier:
      "ScansGetResponseMetaProcessorsRobotsTxtDataItemRulesShapeContentSignal",
  }) as any as S.Schema<ScansGetResponseMetaProcessorsRobotsTxtDataItemRulesShapeContentSignal>;

export interface ScansGetResponseMetaProcessorsRobotsTxtDataItemRulesShape {
  allow: ScansGetResponseMetaProcessorsRobotsTxtDataItemRulesShapeAllowList;
  disallow: ScansGetResponseMetaProcessorsRobotsTxtDataItemRulesShapeDisallowList;
  contentSignal?: ScansGetResponseMetaProcessorsRobotsTxtDataItemRulesShapeContentSignal | null;
  crawlDelay?: number | null;
}
export const ScansGetResponseMetaProcessorsRobotsTxtDataItemRulesShape =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      allow: ScansGetResponseMetaProcessorsRobotsTxtDataItemRulesShapeAllowList,
      disallow:
        ScansGetResponseMetaProcessorsRobotsTxtDataItemRulesShapeDisallowList,
      contentSignal: S.optional(
        S.NullOr(
          ScansGetResponseMetaProcessorsRobotsTxtDataItemRulesShapeContentSignal,
        ),
      ),
      crawlDelay: S.optional(S.NullOr(S.Number)),
    }),
  ).annotate({
    identifier: "ScansGetResponseMetaProcessorsRobotsTxtDataItemRulesShape",
  }) as any as S.Schema<ScansGetResponseMetaProcessorsRobotsTxtDataItemRulesShape>;

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

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

export interface ScansGetResponseMetaProcessorsRobotsTxtDataItem {
  rules: ScansGetResponseMetaProcessorsRobotsTxtDataItemRules;
  sitemaps: ScansGetResponseMetaProcessorsRobotsTxtDataItemSitemapsList;
  hash?: string | null;
}
export const ScansGetResponseMetaProcessorsRobotsTxtDataItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      rules: ScansGetResponseMetaProcessorsRobotsTxtDataItemRules,
      sitemaps: ScansGetResponseMetaProcessorsRobotsTxtDataItemSitemapsList,
      hash: S.optional(S.NullOr(S.String)),
    }),
  ).annotate({
    identifier: "ScansGetResponseMetaProcessorsRobotsTxtDataItem",
  }) as any as S.Schema<ScansGetResponseMetaProcessorsRobotsTxtDataItem>;

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

export interface ScansGetResponseMetaProcessorsRobotsTxt {
  data: ScansGetResponseMetaProcessorsRobotsTxtDataList;
}
export const ScansGetResponseMetaProcessorsRobotsTxt = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      data: ScansGetResponseMetaProcessorsRobotsTxtDataList,
    }),
).annotate({
  identifier: "ScansGetResponseMetaProcessorsRobotsTxt",
}) as any as S.Schema<ScansGetResponseMetaProcessorsRobotsTxt>;

export interface ScansGetResponseMetaProcessorsUrlCategoriesDataItemContentItem {
  id: number;
  name: string;
  superCategoryId: number;
}
export const ScansGetResponseMetaProcessorsUrlCategoriesDataItemContentItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.Number,
      name: S.String,
      superCategoryId: S.Number.pipe(T.Body("super_category_id")),
    }),
  ).annotate({
    identifier:
      "ScansGetResponseMetaProcessorsUrlCategoriesDataItemContentItem",
  }) as any as S.Schema<ScansGetResponseMetaProcessorsUrlCategoriesDataItemContentItem>;

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

export type ScansGetResponseMetaProcessorsUrlCategoriesDataItemInheritedContentItem =
  ScansGetResponseMetaProcessorsUrlCategoriesDataItemContentItem;
export const ScansGetResponseMetaProcessorsUrlCategoriesDataItemInheritedContentItem =
  ScansGetResponseMetaProcessorsUrlCategoriesDataItemContentItem;

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

export type ScansGetResponseMetaProcessorsUrlCategoriesDataItemInheritedRisksItem =
  ScansGetResponseMetaProcessorsUrlCategoriesDataItemContentItem;
export const ScansGetResponseMetaProcessorsUrlCategoriesDataItemInheritedRisksItem =
  ScansGetResponseMetaProcessorsUrlCategoriesDataItemContentItem;

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

export interface ScansGetResponseMetaProcessorsUrlCategoriesDataItemInherited {
  content: ScansGetResponseMetaProcessorsUrlCategoriesDataItemInheritedContentList;
  from: string;
  risks: ScansGetResponseMetaProcessorsUrlCategoriesDataItemInheritedRisksList;
}
export const ScansGetResponseMetaProcessorsUrlCategoriesDataItemInherited =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      content:
        ScansGetResponseMetaProcessorsUrlCategoriesDataItemInheritedContentList,
      from: S.String,
      risks:
        ScansGetResponseMetaProcessorsUrlCategoriesDataItemInheritedRisksList,
    }),
  ).annotate({
    identifier: "ScansGetResponseMetaProcessorsUrlCategoriesDataItemInherited",
  }) as any as S.Schema<ScansGetResponseMetaProcessorsUrlCategoriesDataItemInherited>;

export type ScansGetResponseMetaProcessorsUrlCategoriesDataItemRisksItem =
  ScansGetResponseMetaProcessorsUrlCategoriesDataItemContentItem;
export const ScansGetResponseMetaProcessorsUrlCategoriesDataItemRisksItem =
  ScansGetResponseMetaProcessorsUrlCategoriesDataItemContentItem;

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

export interface ScansGetResponseMetaProcessorsUrlCategoriesDataItem {
  content: ScansGetResponseMetaProcessorsUrlCategoriesDataItemContentList;
  inherited: ScansGetResponseMetaProcessorsUrlCategoriesDataItemInherited;
  name: string;
  risks: ScansGetResponseMetaProcessorsUrlCategoriesDataItemRisksList;
}
export const ScansGetResponseMetaProcessorsUrlCategoriesDataItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      content: ScansGetResponseMetaProcessorsUrlCategoriesDataItemContentList,
      inherited: ScansGetResponseMetaProcessorsUrlCategoriesDataItemInherited,
      name: S.String,
      risks: ScansGetResponseMetaProcessorsUrlCategoriesDataItemRisksList,
    }),
  ).annotate({
    identifier: "ScansGetResponseMetaProcessorsUrlCategoriesDataItem",
  }) as any as S.Schema<ScansGetResponseMetaProcessorsUrlCategoriesDataItem>;

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

export interface ScansGetResponseMetaProcessorsUrlCategories {
  data: ScansGetResponseMetaProcessorsUrlCategoriesDataList;
}
export const ScansGetResponseMetaProcessorsUrlCategories =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      data: ScansGetResponseMetaProcessorsUrlCategoriesDataList,
    }),
  ).annotate({
    identifier: "ScansGetResponseMetaProcessorsUrlCategories",
  }) as any as S.Schema<ScansGetResponseMetaProcessorsUrlCategories>;

export interface ScansGetResponseMetaProcessors {
  asn: ScansGetResponseMetaProcessorsAsn;
  dns: ScansGetResponseMetaProcessorsDns;
  domainCategories: ScansGetResponseMetaProcessorsDomainCategories;
  geoip: ScansGetResponseMetaProcessorsGeoip;
  phishing: ScansGetResponseMetaProcessorsPhishing;
  radarRank: ScansGetResponseMetaProcessorsRadarRank;
  wappa: ScansGetResponseMetaProcessorsWappa;
  agentReadiness?: ScansGetResponseMetaProcessorsAgentReadiness | null;
  phishingV2?: ScansGetResponseMetaProcessorsPhishingV2 | null;
  robotsTxt?: ScansGetResponseMetaProcessorsRobotsTxt | null;
  urlCategories?: ScansGetResponseMetaProcessorsUrlCategories | null;
}
export const ScansGetResponseMetaProcessors = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    asn: ScansGetResponseMetaProcessorsAsn,
    dns: ScansGetResponseMetaProcessorsDns,
    domainCategories: ScansGetResponseMetaProcessorsDomainCategories,
    geoip: ScansGetResponseMetaProcessorsGeoip,
    phishing: ScansGetResponseMetaProcessorsPhishing,
    radarRank: ScansGetResponseMetaProcessorsRadarRank,
    wappa: ScansGetResponseMetaProcessorsWappa,
    agentReadiness: S.optional(
      S.NullOr(ScansGetResponseMetaProcessorsAgentReadiness),
    ),
    phishingV2: S.optional(
      S.NullOr(ScansGetResponseMetaProcessorsPhishingV2).pipe(
        T.Body("phishing_v2"),
      ),
    ),
    robotsTxt: S.optional(S.NullOr(ScansGetResponseMetaProcessorsRobotsTxt)),
    urlCategories: S.optional(
      S.NullOr(ScansGetResponseMetaProcessorsUrlCategories),
    ),
  }),
).annotate({
  identifier: "ScansGetResponseMetaProcessors",
}) as any as S.Schema<ScansGetResponseMetaProcessors>;

export interface ScansGetResponseMeta {
  processors: ScansGetResponseMetaProcessors;
}
export const ScansGetResponseMeta = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    processors: ScansGetResponseMetaProcessors,
  }),
).annotate({
  identifier: "ScansGetResponseMeta",
}) as any as S.Schema<ScansGetResponseMeta>;

export interface ScansGetResponsePageScreenshot {
  dhash: string;
  mm3Hash: number;
  name: string;
  phash: string;
}
export const ScansGetResponsePageScreenshot = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    dhash: S.String,
    mm3Hash: S.Number,
    name: S.String,
    phash: S.String,
  }),
).annotate({
  identifier: "ScansGetResponsePageScreenshot",
}) as any as S.Schema<ScansGetResponsePageScreenshot>;

export interface ScansGetResponsePage {
  apexDomain: string;
  asn: string;
  asnname: string;
  city: string;
  country: string;
  domain: string;
  ip: string;
  mimeType: string;
  server: string;
  status: string;
  title: string;
  tlsAgeDays: number;
  tlsIssuer: string;
  tlsValidDays: number;
  tlsValidFrom: string;
  url: string;
  screenshot?: ScansGetResponsePageScreenshot | null;
}
export const ScansGetResponsePage = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    apexDomain: S.String,
    asn: S.String,
    asnname: S.String,
    city: S.String,
    country: S.String,
    domain: S.String,
    ip: S.String,
    mimeType: S.String,
    server: S.String,
    status: S.String,
    title: S.String,
    tlsAgeDays: S.Number,
    tlsIssuer: S.String,
    tlsValidDays: S.Number,
    tlsValidFrom: S.String,
    url: S.String,
    screenshot: S.optional(S.NullOr(ScansGetResponsePageScreenshot)),
  }),
).annotate({
  identifier: "ScansGetResponsePage",
}) as any as S.Schema<ScansGetResponsePage>;

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

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

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

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

export interface ScansGetResponseStatsDomainStatsItem {
  count: number;
  countries: ScansGetResponseStatsDomainStatsItemCountriesList;
  domain: string;
  encodedSize: number;
  index: number;
  initiators: ScansGetResponseStatsDomainStatsItemInitiatorsList;
  ips: ScansGetResponseStatsDomainStatsItemIpsList;
  redirects: number;
  size: number;
}
export const ScansGetResponseStatsDomainStatsItem = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      count: S.Number,
      countries: ScansGetResponseStatsDomainStatsItemCountriesList,
      domain: S.String,
      encodedSize: S.Number,
      index: S.Number,
      initiators: ScansGetResponseStatsDomainStatsItemInitiatorsList,
      ips: ScansGetResponseStatsDomainStatsItemIpsList,
      redirects: S.Number,
      size: S.Number,
    }),
).annotate({
  identifier: "ScansGetResponseStatsDomainStatsItem",
}) as any as S.Schema<ScansGetResponseStatsDomainStatsItem>;

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

export type ScansGetResponseStatsIpStatsItemAsn =
  ScansGetResponseDataRequestsItemResponseAsn;
export const ScansGetResponseStatsIpStatsItemAsn =
  ScansGetResponseDataRequestsItemResponseAsn;

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

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

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

export interface ScansGetResponseStatsIpStatsItemGeoip {
  city: string;
  country: string;
  countryName: string;
  ll: ScansGetResponseStatsIpStatsItemGeoipLlList;
  region: string;
}
export const ScansGetResponseStatsIpStatsItemGeoip = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      city: S.String,
      country: S.String,
      countryName: S.String.pipe(T.Body("country_name")),
      ll: ScansGetResponseStatsIpStatsItemGeoipLlList,
      region: S.String,
    }),
).annotate({
  identifier: "ScansGetResponseStatsIpStatsItemGeoip",
}) as any as S.Schema<ScansGetResponseStatsIpStatsItemGeoip>;

export interface ScansGetResponseStatsIpStatsItem {
  asn: ScansGetResponseDataRequestsItemResponseAsn;
  countries: ScansGetResponseStatsIpStatsItemCountriesList;
  domains: ScansGetResponseStatsIpStatsItemDomainsList;
  encodedSize: number;
  geoip: ScansGetResponseStatsIpStatsItemGeoip;
  index: number;
  ip: string;
  ipv6: boolean;
  redirects: number;
  requests: number;
  size: number;
  count?: number | null;
}
export const ScansGetResponseStatsIpStatsItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    asn: ScansGetResponseDataRequestsItemResponseAsn,
    countries: ScansGetResponseStatsIpStatsItemCountriesList,
    domains: ScansGetResponseStatsIpStatsItemDomainsList,
    encodedSize: S.Number,
    geoip: ScansGetResponseStatsIpStatsItemGeoip,
    index: S.Number,
    ip: S.String,
    ipv6: S.Boolean,
    redirects: S.Number,
    requests: S.Number,
    size: S.Number,
    count: S.optional(S.NullOr(S.Number)),
  }),
).annotate({
  identifier: "ScansGetResponseStatsIpStatsItem",
}) as any as S.Schema<ScansGetResponseStatsIpStatsItem>;

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

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

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

export interface ScansGetResponseStatsProtocolStatsItem {
  count: number;
  countries: ScansGetResponseStatsProtocolStatsItemCountriesList;
  encodedSize: number;
  ips: ScansGetResponseStatsProtocolStatsItemIpsList;
  protocol: string;
  size: number;
}
export const ScansGetResponseStatsProtocolStatsItem = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      count: S.Number,
      countries: ScansGetResponseStatsProtocolStatsItemCountriesList,
      encodedSize: S.Number,
      ips: ScansGetResponseStatsProtocolStatsItemIpsList,
      protocol: S.String,
      size: S.Number,
    }),
).annotate({
  identifier: "ScansGetResponseStatsProtocolStatsItem",
}) as any as S.Schema<ScansGetResponseStatsProtocolStatsItem>;

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

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

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

export interface ScansGetResponseStatsResourceStatsItem {
  compression: number;
  count: number;
  countries: ScansGetResponseStatsResourceStatsItemCountriesList;
  encodedSize: number;
  ips: ScansGetResponseStatsResourceStatsItemIpsList;
  percentage: number;
  size: number;
  type: string;
}
export const ScansGetResponseStatsResourceStatsItem = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      compression: S.Number,
      count: S.Number,
      countries: ScansGetResponseStatsResourceStatsItemCountriesList,
      encodedSize: S.Number,
      ips: ScansGetResponseStatsResourceStatsItemIpsList,
      percentage: S.Number,
      size: S.Number,
      type: S.String,
    }),
).annotate({
  identifier: "ScansGetResponseStatsResourceStatsItem",
}) as any as S.Schema<ScansGetResponseStatsResourceStatsItem>;

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

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

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

export interface ScansGetResponseStatsServerStatsItem {
  count: number;
  countries: ScansGetResponseStatsServerStatsItemCountriesList;
  encodedSize: number;
  ips: ScansGetResponseStatsServerStatsItemIpsList;
  server: string;
  size: number;
}
export const ScansGetResponseStatsServerStatsItem = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      count: S.Number,
      countries: ScansGetResponseStatsServerStatsItemCountriesList,
      encodedSize: S.Number,
      ips: ScansGetResponseStatsServerStatsItemIpsList,
      server: S.String,
      size: S.Number,
    }),
).annotate({
  identifier: "ScansGetResponseStatsServerStatsItem",
}) as any as S.Schema<ScansGetResponseStatsServerStatsItem>;

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

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

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

export interface ScansGetResponseStatsTlsStatsItemProtocols {
  TLS_1_3___AES_128_GCM: number;
}
export const ScansGetResponseStatsTlsStatsItemProtocols =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      TLS_1_3___AES_128_GCM: S.Number.pipe(T.Body("TLS 1.3 / AES_128_GCM")),
    }),
  ).annotate({
    identifier: "ScansGetResponseStatsTlsStatsItemProtocols",
  }) as any as S.Schema<ScansGetResponseStatsTlsStatsItemProtocols>;

export interface ScansGetResponseStatsTlsStatsItem {
  count: number;
  countries: ScansGetResponseStatsTlsStatsItemCountriesList;
  encodedSize: number;
  ips: ScansGetResponseStatsTlsStatsItemIpsList;
  protocols: ScansGetResponseStatsTlsStatsItemProtocols;
  securityState: string;
  size: number;
}
export const ScansGetResponseStatsTlsStatsItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    count: S.Number,
    countries: ScansGetResponseStatsTlsStatsItemCountriesList,
    encodedSize: S.Number,
    ips: ScansGetResponseStatsTlsStatsItemIpsList,
    protocols: ScansGetResponseStatsTlsStatsItemProtocols,
    securityState: S.String,
    size: S.Number,
  }),
).annotate({
  identifier: "ScansGetResponseStatsTlsStatsItem",
}) as any as S.Schema<ScansGetResponseStatsTlsStatsItem>;

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

export interface ScansGetResponseStats {
  domainStats: ScansGetResponseStatsDomainStatsList;
  ipStats: ScansGetResponseStatsIpStatsList;
  iPv6Percentage: number;
  malicious: number;
  protocolStats: ScansGetResponseStatsProtocolStatsList;
  resourceStats: ScansGetResponseStatsResourceStatsList;
  securePercentage: number;
  secureRequests: number;
  serverStats: ScansGetResponseStatsServerStatsList;
  tlsStats: ScansGetResponseStatsTlsStatsList;
  totalLinks: number;
  uniqASNs: number;
  uniqCountries: number;
}
export const ScansGetResponseStats = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    domainStats: ScansGetResponseStatsDomainStatsList,
    ipStats: ScansGetResponseStatsIpStatsList,
    iPv6Percentage: S.Number.pipe(T.Body("IPv6Percentage")),
    malicious: S.Number,
    protocolStats: ScansGetResponseStatsProtocolStatsList,
    resourceStats: ScansGetResponseStatsResourceStatsList,
    securePercentage: S.Number,
    secureRequests: S.Number,
    serverStats: ScansGetResponseStatsServerStatsList,
    tlsStats: ScansGetResponseStatsTlsStatsList,
    totalLinks: S.Number,
    uniqASNs: S.Number,
    uniqCountries: S.Number,
  }),
).annotate({
  identifier: "ScansGetResponseStats",
}) as any as S.Schema<ScansGetResponseStats>;

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

export interface ScansGetResponseTaskOptions {
  /** Custom headers set. */
  customHeaders?: unknown | null;
  screenshotsResolutions?: ScansGetResponseTaskOptionsScreenshotsResolutionsList | null;
}
export const ScansGetResponseTaskOptions = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    customHeaders: S.optional(S.NullOr(S.Unknown)),
    screenshotsResolutions: S.optional(
      S.NullOr(ScansGetResponseTaskOptionsScreenshotsResolutionsList),
    ),
  }),
).annotate({
  identifier: "ScansGetResponseTaskOptions",
}) as any as S.Schema<ScansGetResponseTaskOptions>;

export interface ScansGetResponseTask {
  apexDomain: string;
  domain: string;
  domURL: string;
  method: string;
  options: ScansGetResponseTaskOptions;
  reportURL: string;
  screenshotURL: string;
  source: string;
  success: boolean;
  time: string;
  url: string;
  uuid: string;
  visibility: string;
}
export const ScansGetResponseTask = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    apexDomain: S.String,
    domain: S.String,
    domURL: S.String,
    method: S.String,
    options: ScansGetResponseTaskOptions,
    reportURL: S.String,
    screenshotURL: S.String,
    source: S.String,
    success: S.Boolean,
    time: S.String,
    url: S.String,
    uuid: S.String,
    visibility: S.String,
  }),
).annotate({
  identifier: "ScansGetResponseTask",
}) as any as S.Schema<ScansGetResponseTask>;

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

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

export interface ScansGetResponseVerdictsOverall {
  categories: ScansGetResponseVerdictsOverallCategoriesList;
  hasVerdicts: boolean;
  malicious: boolean;
  tags: ScansGetResponseVerdictsOverallTagsList;
}
export const ScansGetResponseVerdictsOverall = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    categories: ScansGetResponseVerdictsOverallCategoriesList,
    hasVerdicts: S.Boolean,
    malicious: S.Boolean,
    tags: ScansGetResponseVerdictsOverallTagsList,
  }),
).annotate({
  identifier: "ScansGetResponseVerdictsOverall",
}) as any as S.Schema<ScansGetResponseVerdictsOverall>;

export interface ScansGetResponseVerdicts {
  overall: ScansGetResponseVerdictsOverall;
}
export const ScansGetResponseVerdicts = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    overall: ScansGetResponseVerdictsOverall,
  }),
).annotate({
  identifier: "ScansGetResponseVerdicts",
}) as any as S.Schema<ScansGetResponseVerdicts>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface GetScanResponse {
  data: ScansGetResponseData;
  lists: ScansGetResponseLists;
  meta: ScansGetResponseMeta;
  page: ScansGetResponsePage;
  scanner: ScansGetResponseScanner;
  stats: ScansGetResponseStats;
  task: ScansGetResponseTask;
  verdicts: ScansGetResponseVerdicts;
}
export const GetScanResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    data: ScansGetResponseData,
    lists: ScansGetResponseLists,
    meta: ScansGetResponseMeta,
    page: ScansGetResponsePage,
    scanner: ScansGetResponseScanner,
    stats: ScansGetResponseStats,
    task: ScansGetResponseTask,
    verdicts: ScansGetResponseVerdicts,
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetScanResponse",
}) as any as S.Schema<GetScanResponse>;

export interface HarScanRequest {
  /** Account ID. */
  accountId: string;
  /** Scan UUID. */
  scanId: string;
}
export const HarScanRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    scanId: S.String.pipe(T.Label("scan_id")),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/urlscanner/v2/har/{scan_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({ identifier: "HarScanRequest" }) as any as S.Schema<HarScanRequest>;

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

export type ScansHarResponseLogEntriesItemRequestHeadersItem =
  ScansGetResponseDataRequestsItemRequestRedirectResponseSecurityHeadersItem;
export const ScansHarResponseLogEntriesItemRequestHeadersItem =
  ScansGetResponseDataRequestsItemRequestRedirectResponseSecurityHeadersItem;

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

export interface ScansHarResponseLogEntriesItemRequest {
  bodySize: number;
  headers: ScansHarResponseLogEntriesItemRequestHeadersList;
  headersSize: number;
  httpVersion: string;
  method: string;
  url: string;
}
export const ScansHarResponseLogEntriesItemRequest = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      bodySize: S.Number,
      headers: ScansHarResponseLogEntriesItemRequestHeadersList,
      headersSize: S.Number,
      httpVersion: S.String,
      method: S.String,
      url: S.String,
    }),
).annotate({
  identifier: "ScansHarResponseLogEntriesItemRequest",
}) as any as S.Schema<ScansHarResponseLogEntriesItemRequest>;

export interface ScansHarResponseLogEntriesItemResponseContent {
  mimeType: string;
  size: number;
  compression?: number | null;
}
export const ScansHarResponseLogEntriesItemResponseContent =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      mimeType: S.String,
      size: S.Number,
      compression: S.optional(S.NullOr(S.Number)),
    }),
  ).annotate({
    identifier: "ScansHarResponseLogEntriesItemResponseContent",
  }) as any as S.Schema<ScansHarResponseLogEntriesItemResponseContent>;

export type ScansHarResponseLogEntriesItemResponseHeadersItem =
  ScansGetResponseDataRequestsItemRequestRedirectResponseSecurityHeadersItem;
export const ScansHarResponseLogEntriesItemResponseHeadersItem =
  ScansGetResponseDataRequestsItemRequestRedirectResponseSecurityHeadersItem;

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

export interface ScansHarResponseLogEntriesItemResponse {
  transferSize: number;
  bodySize: number;
  content: ScansHarResponseLogEntriesItemResponseContent;
  headers: ScansHarResponseLogEntriesItemResponseHeadersList;
  headersSize: number;
  httpVersion: string;
  redirectURL: string;
  status: number;
  statusText: string;
}
export const ScansHarResponseLogEntriesItemResponse = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      transferSize: S.Number.pipe(T.Body("_transferSize")),
      bodySize: S.Number,
      content: ScansHarResponseLogEntriesItemResponseContent,
      headers: ScansHarResponseLogEntriesItemResponseHeadersList,
      headersSize: S.Number,
      httpVersion: S.String,
      redirectURL: S.String,
      status: S.Number,
      statusText: S.String,
    }),
).annotate({
  identifier: "ScansHarResponseLogEntriesItemResponse",
}) as any as S.Schema<ScansHarResponseLogEntriesItemResponse>;

export interface ScansHarResponseLogEntriesItem {
  initialPriority: string;
  initiatorType: string;
  priority: string;
  requestId: string;
  requestTime: number;
  resourceType: string;
  cache: unknown;
  connection: string;
  pageref: string;
  request: ScansHarResponseLogEntriesItemRequest;
  response: ScansHarResponseLogEntriesItemResponse;
  serverIPAddress: string;
  startedDateTime: string;
  time: number;
}
export const ScansHarResponseLogEntriesItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    initialPriority: S.String.pipe(T.Body("_initialPriority")),
    initiatorType: S.String.pipe(T.Body("_initiator_type")),
    priority: S.String.pipe(T.Body("_priority")),
    requestId: S.String.pipe(T.Body("_requestId")),
    requestTime: S.Number.pipe(T.Body("_requestTime")),
    resourceType: S.String.pipe(T.Body("_resourceType")),
    cache: S.Unknown,
    connection: S.String,
    pageref: S.String,
    request: ScansHarResponseLogEntriesItemRequest,
    response: ScansHarResponseLogEntriesItemResponse,
    serverIPAddress: S.String,
    startedDateTime: S.String,
    time: S.Number,
  }),
).annotate({
  identifier: "ScansHarResponseLogEntriesItem",
}) as any as S.Schema<ScansHarResponseLogEntriesItem>;

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

export interface ScansHarResponseLogPagesItemPageTimings {
  onContentLoad: number;
  onLoad: number;
}
export const ScansHarResponseLogPagesItemPageTimings = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      onContentLoad: S.Number,
      onLoad: S.Number,
    }),
).annotate({
  identifier: "ScansHarResponseLogPagesItemPageTimings",
}) as any as S.Schema<ScansHarResponseLogPagesItemPageTimings>;

export interface ScansHarResponseLogPagesItem {
  id: string;
  pageTimings: ScansHarResponseLogPagesItemPageTimings;
  startedDateTime: string;
  title: string;
}
export const ScansHarResponseLogPagesItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    pageTimings: ScansHarResponseLogPagesItemPageTimings,
    startedDateTime: S.String,
    title: S.String,
  }),
).annotate({
  identifier: "ScansHarResponseLogPagesItem",
}) as any as S.Schema<ScansHarResponseLogPagesItem>;

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

export interface ScansHarResponseLog {
  creator: ScansHarResponseLogCreator;
  entries: ScansHarResponseLogEntriesList;
  pages: ScansHarResponseLogPagesList;
  version: string;
}
export const ScansHarResponseLog = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    creator: ScansHarResponseLogCreator,
    entries: ScansHarResponseLogEntriesList,
    pages: ScansHarResponseLogPagesList,
    version: S.String,
  }),
).annotate({
  identifier: "ScansHarResponseLog",
}) as any as S.Schema<ScansHarResponseLog>;

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

export interface ListScansRequest {
  /** Account ID. */
  accountId: string;
  /** Filter scans */
  q?: string;
  /** Limit the number of objects in the response. */
  size?: number;
}
export const ListScansRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    q: S.optional(S.String.pipe(T.Query())),
    size: S.optional(S.Number.pipe(T.Query())),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/urlscanner/v2/search",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListScansRequest",
}) as any as S.Schema<ListScansRequest>;

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

export interface ScansListResponseResultsItemStats {
  dataLength: number;
  requests: number;
  uniqCountries: number;
  uniqIPs: number;
}
export const ScansListResponseResultsItemStats = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    dataLength: S.Number,
    requests: S.Number,
    uniqCountries: S.Number,
    uniqIPs: S.Number,
  }),
).annotate({
  identifier: "ScansListResponseResultsItemStats",
}) as any as S.Schema<ScansListResponseResultsItemStats>;

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

export interface ScansListResponseResultsItemVerdicts {
  malicious: boolean;
}
export const ScansListResponseResultsItemVerdicts = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      malicious: S.Boolean,
    }),
).annotate({
  identifier: "ScansListResponseResultsItemVerdicts",
}) as any as S.Schema<ScansListResponseResultsItemVerdicts>;

export interface ScansListResponseResultsItem {
  id: string;
  page: ScansListResponseResultsItemPage;
  result: string;
  stats: ScansListResponseResultsItemStats;
  task: ScansListResponseResultsItemTask;
  verdicts: ScansListResponseResultsItemVerdicts;
}
export const ScansListResponseResultsItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String.pipe(T.Body("_id")),
    page: ScansListResponseResultsItemPage,
    result: S.String,
    stats: ScansListResponseResultsItemStats,
    task: ScansListResponseResultsItemTask,
    verdicts: ScansListResponseResultsItemVerdicts,
  }),
).annotate({
  identifier: "ScansListResponseResultsItem",
}) as any as S.Schema<ScansListResponseResultsItem>;

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

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

export type ScansScreenshotRequestResolution = "desktop" | "mobile" | "tablet";
export const ScansScreenshotRequestResolution = /*@__PURE__*/ S.String;

export interface ScreenshotScanRequest {
  /** Account ID. */
  accountId: string;
  /** Scan UUID. */
  scanId: string;
  /** Target device type. */
  resolution?: ScansScreenshotRequestResolution | (string & {});
}
export const ScreenshotScanRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    scanId: S.String.pipe(T.Label("scan_id")),
    resolution: S.optional(ScansScreenshotRequestResolution.pipe(T.Query())),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/urlscanner/v2/screenshots/{scan_id}.png",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ScreenshotScanRequest",
}) as any as S.Schema<ScreenshotScanRequest>;

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

export type BulkCreateScansError = CloudflareOpError;
/** Submit URLs to scan. Check limits at https://developers.cloudflare.com/security-center/investigate/scan-limits/ and take into account scans submitted in bulk have lower priority and may take longer to finish. */
export const bulkCreateScans: API.OperationMethod<
  BulkCreateScansRequest,
  BulkCreateScansResponse,
  BulkCreateScansError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: BulkCreateScansRequest,
  output: BulkCreateScansResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type CreateScanError = CloudflareOpError;
/** Submit a URL to scan. Check limits at https://developers.cloudflare.com/security-center/investigate/scan-limits/. */
export const createScan: API.OperationMethod<
  CreateScanRequest,
  CreateScanResponse,
  CreateScanError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: CreateScanRequest,
  output: CreateScanResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type DomScanError = CloudflareOpError;
/** Returns a plain text response, with the scan's DOM content as rendered by Chrome. */
export const domScan: API.OperationMethod<
  DomScanRequest,
  DomScanResponse,
  DomScanError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: DomScanRequest,
  output: DomScanResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetResponsError = CloudflareOpError;
/** Returns the raw response of the network request. Find the `response_id` in the `data.requests.response.hash`. */
export const getRespons: API.OperationMethod<
  GetResponsRequest,
  GetResponsResponse,
  GetResponsError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetResponsRequest,
  output: GetResponsResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetScanError = CloudflareOpError;
/** Get URL scan by uuid */
export const getScan: API.OperationMethod<
  GetScanRequest,
  GetScanResponse,
  GetScanError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetScanRequest,
  output: GetScanResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type HarScanError = CloudflareOpError;
/** Get a URL scan's HAR file. See HAR spec at http://www.softwareishard.com/blog/har-12-spec/. */
export const harScan: API.OperationMethod<
  HarScanRequest,
  HarScanResponse,
  HarScanError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: HarScanRequest,
  output: HarScanResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type ListScansError = CloudflareOpError;
/** Use a subset of ElasticSearch Query syntax to filter scans. Some example queries:<br/> <br/>- 'path:"/bundles/jquery.js"': Searches for scans who requested resources with the given path.<br/>- 'page.asn:AS24940 AND hash:xxx': Websites hosted in AS24940 where a resource with the given hash was downloaded.<br/>- 'page.domain:microsoft* AND verdicts.malicious:true AND NOT page.domain:microsoft.com': malicious scans whose hostname starts with "microsoft".<br/>- 'apikey:me AND date:[2025-01 TO 2025-02]': my scans from 2025 January to 2025 February. */
export const listScans: API.OperationMethod<
  ListScansRequest,
  ListScansResponse,
  ListScansError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: ListScansRequest,
  output: ListScansResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type ScreenshotScanError = CloudflareOpError;
/** Get scan's screenshot by resolution (desktop/mobile/tablet). */
export const screenshotScan: API.OperationMethod<
  ScreenshotScanRequest,
  ScreenshotScanResponse,
  ScreenshotScanError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: ScreenshotScanRequest,
  output: ScreenshotScanResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));