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

export type { CloudflareOpError, CloudflareOpContext };

/** Fallback camelCase→wire mapping for opaque content (mined from the distilled SDK). */
const KEY_DICTIONARY: Record<string, string | ReadonlyArray<string>> = {
  accountTag: "account_tag",
  additionalInformation: "additional_information",
  administrativeCity: "administrative_city",
  administrativeCountry: "administrative_country",
  administrativeEmail: "administrative_email",
  administrativeFax: "administrative_fax",
  administrativeFaxExt: "administrative_fax_ext",
  administrativeId: "administrative_id",
  administrativeName: "administrative_name",
  administrativeOrg: "administrative_org",
  administrativePhone: "administrative_phone",
  administrativePhoneExt: "administrative_phone_ext",
  administrativePostalCode: "administrative_postal_code",
  administrativeProvince: "administrative_province",
  administrativeReferralUrl: "administrative_referral_url",
  administrativeStreet: "administrative_street",
  allowlistedDomains: "allowlisted_domains",
  belongsToRef: "belongs_to_ref",
  billingCity: "billing_city",
  billingCountry: "billing_country",
  billingEmail: "billing_email",
  billingFax: "billing_fax",
  billingFaxExt: "billing_fax_ext",
  billingId: "billing_id",
  billingName: "billing_name",
  billingOrg: "billing_org",
  billingPhone: "billing_phone",
  billingPhoneExt: "billing_phone_ext",
  billingPostalCode: "billing_postal_code",
  billingProvince: "billing_province",
  billingReferralUrl: "billing_referral_url",
  billingStreet: "billing_street",
  contentAdds: "content_adds",
  contentCategories: "content_categories",
  contentRemoves: "content_removes",
  createdDate: "created_date",
  createdDateRaw: "created_date_raw",
  createdOn: "created_on",
  detectionMethod: "detection_method",
  documentationUrl: "documentation_url",
  domainsAdded: "domains_added",
  domainsRemoved: "domains_removed",
  expirationDate: "expiration_date",
  expirationDateRaw: "expiration_date_raw",
  expiredIndicators: "expired_indicators",
  feedId: "feed_id",
  fileId: "file_id",
  firstSeen: "first_seen",
  hasExtendedContext: "has_extended_context",
  indicatorType: "indicator_type",
  inheritedContentCategories: "inherited_content_categories",
  inheritedFrom: "inherited_from",
  inheritedRiskTypes: "inherited_risk_types",
  invalidIndicators: "invalid_indicators",
  ipCountTotal: "ip_count_total",
  ipsAdded: "ips_added",
  ipsRemoved: "ips_removed",
  isAttributable: "is_attributable",
  isDownloadable: "is_downloadable",
  isPublic: "is_public",
  issueClass: "issue_class",
  issueType: "issue_type",
  lastSeen: "last_seen",
  lastUploadSummary: "last_upload_summary",
  latestUploadError: "latest_upload_error",
  latestUploadStatus: "latest_upload_status",
  modifiedOn: "modified_on",
  perPage: "per_page",
  popularityRank: "popularity_rank",
  providerId: "provider_id",
  providerName: "provider_name",
  r2Bucket: "r2_bucket",
  r2Id: "r2_id",
  registrantCity: "registrant_city",
  registrantCountry: "registrant_country",
  registrantEmail: "registrant_email",
  registrantFax: "registrant_fax",
  registrantFaxExt: "registrant_fax_ext",
  registrantId: "registrant_id",
  registrantName: "registrant_name",
  registrantOrg: "registrant_org",
  registrantPhone: "registrant_phone",
  registrantPhoneExt: "registrant_phone_ext",
  registrantPostalCode: "registrant_postal_code",
  registrantProvince: "registrant_province",
  registrantReferralUrl: "registrant_referral_url",
  registrantStreet: "registrant_street",
  registrarCity: "registrar_city",
  registrarCountry: "registrar_country",
  registrarEmail: "registrar_email",
  registrarFax: "registrar_fax",
  registrarFaxExt: "registrar_fax_ext",
  registrarId: "registrar_id",
  registrarName: "registrar_name",
  registrarOrg: "registrar_org",
  registrarPhone: "registrar_phone",
  registrarPhoneExt: "registrar_phone_ext",
  registrarPostalCode: "registrar_postal_code",
  registrarProvince: "registrar_province",
  registrarReferralUrl: "registrar_referral_url",
  registrarStreet: "registrar_street",
  resolveLink: "resolve_link",
  resolveText: "resolve_text",
  resolvesToRefs: "resolves_to_refs",
  resultInfo: "result_info",
  reverseRecords: "reverse_records",
  riskScore: "risk_score",
  riskTypes: "risk_types",
  securityAdds: "security_adds",
  securityRemoves: "security_removes",
  superCategoryId: "super_category_id",
  suspectedMalwareFamily: "suspected_malware_family",
  technicalCity: "technical_city",
  technicalCountry: "technical_country",
  technicalEmail: "technical_email",
  technicalFax: "technical_fax",
  technicalFaxExt: "technical_fax_ext",
  technicalId: "technical_id",
  technicalName: "technical_name",
  technicalOrg: "technical_org",
  technicalPhone: "technical_phone",
  technicalPhoneExt: "technical_phone_ext",
  technicalPostalCode: "technical_postal_code",
  technicalProvince: "technical_province",
  technicalReferralUrl: "technical_referral_url",
  technicalStreet: "technical_street",
  totalCount: "total_count",
  updatedDate: "updated_date",
  updatedDateRaw: "updated_date_raw",
  urlsAdded: "urls_added",
  urlsRemoved: "urls_removed",
  userClassification: "user_classification",
  whoisServer: "whois_server",
  zoneTag: "zone_tag",
};

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

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

export class IndicatorFeedsNotEntitled
  extends /*@__PURE__*/ T.applyErrorMatchers(
    /*@__PURE__*/ S.TaggedError<IndicatorFeedsNotEntitled>()(
      "IndicatorFeedsNotEntitled",
      {
        code: S.Number,
        message: S.String,
      },
    ),
    [
      {
        status: 403,
        message: { includes: "does not have permission to create a feed" },
      },
    ],
  ) {}

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

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

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

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

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

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

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

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

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

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

export interface ClassAttackSurfaceReportIssueRequest {
  /** Identifier. */
  accountId: string;
  dismissed?: boolean;
  issueClass?: AttackSurfaceReportIssuesClassRequestIssueClassList;
  issueClassNeq?: AttackSurfaceReportIssuesClassRequestIssueClassNeqList;
  issueType?: AttackSurfaceReportIssuesClassRequestIssueTypeList;
  issueTypeNeq?: AttackSurfaceReportIssuesClassRequestIssueTypeNeqList;
  product?: AttackSurfaceReportIssuesClassRequestProductList;
  productNeq?: AttackSurfaceReportIssuesClassRequestProductNeqList;
  severity?: AttackSurfaceReportIssuesClassRequestSeverityList;
  severityNeq?: AttackSurfaceReportIssuesClassRequestSeverityNeqList;
  subject?: AttackSurfaceReportIssuesClassRequestSubjectList;
  subjectNeq?: AttackSurfaceReportIssuesClassRequestSubjectNeqList;
}
export const ClassAttackSurfaceReportIssueRequest = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      accountId: S.String.pipe(T.Label("account_id")),
      dismissed: S.optional(S.Boolean.pipe(T.Query())),
      issueClass: S.optional(
        AttackSurfaceReportIssuesClassRequestIssueClassList.pipe(
          T.Query("issue_class"),
        ),
      ),
      issueClassNeq: S.optional(
        AttackSurfaceReportIssuesClassRequestIssueClassNeqList.pipe(
          T.Query("issue_class~neq"),
        ),
      ),
      issueType: S.optional(
        AttackSurfaceReportIssuesClassRequestIssueTypeList.pipe(
          T.Query("issue_type"),
        ),
      ),
      issueTypeNeq: S.optional(
        AttackSurfaceReportIssuesClassRequestIssueTypeNeqList.pipe(
          T.Query("issue_type~neq"),
        ),
      ),
      product: S.optional(
        AttackSurfaceReportIssuesClassRequestProductList.pipe(T.Query()),
      ),
      productNeq: S.optional(
        AttackSurfaceReportIssuesClassRequestProductNeqList.pipe(
          T.Query("product~neq"),
        ),
      ),
      severity: S.optional(
        AttackSurfaceReportIssuesClassRequestSeverityList.pipe(T.Query()),
      ),
      severityNeq: S.optional(
        AttackSurfaceReportIssuesClassRequestSeverityNeqList.pipe(
          T.Query("severity~neq"),
        ),
      ),
      subject: S.optional(
        AttackSurfaceReportIssuesClassRequestSubjectList.pipe(T.Query()),
      ),
      subjectNeq: S.optional(
        AttackSurfaceReportIssuesClassRequestSubjectNeqList.pipe(
          T.Query("subject~neq"),
        ),
      ),
    })
      .pipe(
        T.Http({
          method: "GET",
          uri: "/accounts/{account_id}/intel/attack-surface-report/issues/class",
          code: 200,
        }),
      )
      .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ClassAttackSurfaceReportIssueRequest",
}) as any as S.Schema<ClassAttackSurfaceReportIssueRequest>;

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

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

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

export interface CreateIndicatorFeedRequest {
  /** Identifier */
  accountId: string;
  /** The description of the example test */
  description?: string;
  /** The name of the indicator feed */
  name?: string;
}
export const CreateIndicatorFeedRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    description: S.optional(S.String),
    name: S.optional(S.String),
  })
    .pipe(
      T.Http({
        method: "POST",
        uri: "/accounts/{account_id}/intel/indicator-feeds",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateIndicatorFeedRequest",
}) as any as S.Schema<CreateIndicatorFeedRequest>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface CreateIndicatorFeedResponse {
  /** The unique identifier for the indicator feed */
  id?: number | null;
  /** The date and time when the data entry was created */
  createdOn?: string | null;
  /** The description of the example test */
  description?: string | null;
  /** Whether the indicator feed can be attributed to a provider */
  isAttributable?: boolean | null;
  /** Whether the indicator feed can be downloaded */
  isDownloadable?: boolean | null;
  /** Whether the indicator feed is exposed to customers */
  isPublic?: boolean | null;
  /** The date and time when the data entry was last modified */
  modifiedOn?: string | null;
  /** The name of the indicator feed */
  name?: string | null;
}
export const CreateIndicatorFeedResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.optional(S.NullOr(S.Number)),
    createdOn: S.optional(S.NullOr(S.String).pipe(T.Body("created_on"))),
    description: S.optional(S.NullOr(S.String)),
    isAttributable: S.optional(
      S.NullOr(S.Boolean).pipe(T.Body("is_attributable")),
    ),
    isDownloadable: S.optional(
      S.NullOr(S.Boolean).pipe(T.Body("is_downloadable")),
    ),
    isPublic: S.optional(S.NullOr(S.Boolean).pipe(T.Body("is_public"))),
    modifiedOn: S.optional(S.NullOr(S.String).pipe(T.Body("modified_on"))),
    name: S.optional(S.NullOr(S.String)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateIndicatorFeedResponse",
}) as any as S.Schema<CreateIndicatorFeedResponse>;

export interface CreateIndicatorFeedPermissionRequest {
  /** Identifier */
  accountId: string;
  /** The Cloudflare account tag of the account to change permissions on */
  accountTag?: string;
  /** The ID of the feed to add/remove permissions on */
  feedId?: number;
}
export const CreateIndicatorFeedPermissionRequest = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      accountId: S.String.pipe(T.Label("account_id")),
      accountTag: S.optional(S.String.pipe(T.Body("account_tag"))),
      feedId: S.optional(S.Number.pipe(T.Body("feed_id"))),
    })
      .pipe(
        T.Http({
          method: "PUT",
          uri: "/accounts/{account_id}/intel/indicator-feeds/permissions/add",
          code: 200,
        }),
      )
      .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateIndicatorFeedPermissionRequest",
}) as any as S.Schema<CreateIndicatorFeedPermissionRequest>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface CreateIndicatorFeedPermissionResponse {
  /** Whether the update succeeded or not */
  success?: boolean | null;
}
export const CreateIndicatorFeedPermissionResponse = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      success: S.optional(S.NullOr(S.Boolean)),
    }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateIndicatorFeedPermissionResponse",
}) as any as S.Schema<CreateIndicatorFeedPermissionResponse>;

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

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

export type MiscategorizationsCreateRequestIndicatorType =
  | "domain"
  | "ipv4"
  | "ipv6"
  | "url";
export const MiscategorizationsCreateRequestIndicatorType =
  /*@__PURE__*/ S.String;

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

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

export interface CreateMiscategorizationRequest {
  /** Identifier. */
  accountId: string;
  /** Content category IDs to add. */
  contentAdds?: MiscategorizationsCreateRequestContentAddsList;
  /** Content category IDs to remove. */
  contentRemoves?: MiscategorizationsCreateRequestContentRemovesList;
  indicatorType?: MiscategorizationsCreateRequestIndicatorType | (string & {});
  /** Provide only if indicator_type is `ipv4` or `ipv6`. */
  ip?: string;
  /** Security category IDs to add. */
  securityAdds?: MiscategorizationsCreateRequestSecurityAddsList;
  /** Security category IDs to remove. */
  securityRemoves?: MiscategorizationsCreateRequestSecurityRemovesList;
  /** Provide only if indicator_type is `domain` or `url`. Example if indicator_type is `domain`: `example.com`. Example if indicator_type is `url`: `https://example.com/news/`. */
  url?: string;
}
export const CreateMiscategorizationRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    contentAdds: S.optional(
      MiscategorizationsCreateRequestContentAddsList.pipe(
        T.Body("content_adds"),
      ),
    ),
    contentRemoves: S.optional(
      MiscategorizationsCreateRequestContentRemovesList.pipe(
        T.Body("content_removes"),
      ),
    ),
    indicatorType: S.optional(
      MiscategorizationsCreateRequestIndicatorType.pipe(
        T.Body("indicator_type"),
      ),
    ),
    ip: S.optional(S.String),
    securityAdds: S.optional(
      MiscategorizationsCreateRequestSecurityAddsList.pipe(
        T.Body("security_adds"),
      ),
    ),
    securityRemoves: S.optional(
      MiscategorizationsCreateRequestSecurityRemovesList.pipe(
        T.Body("security_removes"),
      ),
    ),
    url: S.optional(S.String),
  })
    .pipe(
      T.Http({
        method: "POST",
        uri: "/accounts/{account_id}/intel/miscategorization",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateMiscategorizationRequest",
}) as any as S.Schema<CreateMiscategorizationRequest>;

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

export interface DataIndicatorFeedRequest {
  /** Identifier */
  accountId: string;
  /** Indicator feed ID */
  feedId: number;
}
export const DataIndicatorFeedRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    feedId: S.Number.pipe(T.Label("feed_id")),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/intel/indicator-feeds/{feed_id}/data",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DataIndicatorFeedRequest",
}) as any as S.Schema<DataIndicatorFeedRequest>;

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

export interface DeleteIndicatorFeedPermissionRequest {
  /** Identifier */
  accountId: string;
  /** The Cloudflare account tag of the account to change permissions on */
  accountTag?: string;
  /** The ID of the feed to add/remove permissions on */
  feedId?: number;
}
export const DeleteIndicatorFeedPermissionRequest = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      accountId: S.String.pipe(T.Label("account_id")),
      accountTag: S.optional(S.String.pipe(T.Body("account_tag"))),
      feedId: S.optional(S.Number.pipe(T.Body("feed_id"))),
    })
      .pipe(
        T.Http({
          method: "PUT",
          uri: "/accounts/{account_id}/intel/indicator-feeds/permissions/remove",
          code: 200,
        }),
      )
      .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteIndicatorFeedPermissionRequest",
}) as any as S.Schema<DeleteIndicatorFeedPermissionRequest>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface DeleteIndicatorFeedPermissionResponse {
  /** Whether the update succeeded or not */
  success?: boolean | null;
}
export const DeleteIndicatorFeedPermissionResponse = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      success: S.optional(S.NullOr(S.Boolean)),
    }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteIndicatorFeedPermissionResponse",
}) as any as S.Schema<DeleteIndicatorFeedPermissionResponse>;

export interface DismissAttackSurfaceReportIssueRequest {
  /** Identifier. */
  accountId: string;
  issueId: string;
  dismiss?: boolean;
}
export const DismissAttackSurfaceReportIssueRequest = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      accountId: S.String.pipe(T.Label("account_id")),
      issueId: S.String.pipe(T.Label("issue_id")),
      dismiss: S.optional(S.Boolean),
    })
      .pipe(
        T.Http({
          method: "PUT",
          uri: "/accounts/{account_id}/intel/attack-surface-report/{issue_id}/dismiss",
          code: 200,
        }),
      )
      .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DismissAttackSurfaceReportIssueRequest",
}) as any as S.Schema<DismissAttackSurfaceReportIssueRequest>;

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

export interface GetAsnRequest {
  /** Identifier. */
  accountId: string;
  asn: string;
}
export const GetAsnRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    asn: S.String.pipe(T.Label()),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/intel/asn/{asn}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({ identifier: "GetAsnRequest" }) as any as S.Schema<GetAsnRequest>;

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

export interface GetAsnSubnetRequest {
  /** Identifier. */
  accountId: string;
  asn: string;
}
export const GetAsnSubnetRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    asn: S.String.pipe(T.Label()),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/intel/asn/{asn}/subnets",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetAsnSubnetRequest",
}) as any as S.Schema<GetAsnSubnetRequest>;

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

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface GetAsnSubnetResponse {
  asn?: unknown | null;
  /** Total results returned based on your search parameters. */
  count?: number | null;
  ipCountTotal?: number | null;
  /** Current page within paginated list of results. */
  page?: number | null;
  /** Number of results per page of results. */
  perPage?: number | null;
  subnets?: AsnSubnetsGetResponseSubnetsList | null;
}
export const GetAsnSubnetResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    asn: S.optional(S.NullOr(S.Unknown)),
    count: S.optional(S.NullOr(S.Number)),
    ipCountTotal: S.optional(S.NullOr(S.Number).pipe(T.Body("ip_count_total"))),
    page: S.optional(S.NullOr(S.Number)),
    perPage: S.optional(S.NullOr(S.Number).pipe(T.Body("per_page"))),
    subnets: S.optional(S.NullOr(AsnSubnetsGetResponseSubnetsList)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetAsnSubnetResponse",
}) as any as S.Schema<GetAsnSubnetResponse>;

export interface GetAttackSurfaceReportIssueTypeRequest {
  /** Identifier. */
  accountId: string;
}
export const GetAttackSurfaceReportIssueTypeRequest = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      accountId: S.String.pipe(T.Label("account_id")),
    })
      .pipe(
        T.Http({
          method: "GET",
          uri: "/accounts/{account_id}/intel/attack-surface-report/issue-types",
          code: 200,
        }),
      )
      .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetAttackSurfaceReportIssueTypeRequest",
}) as any as S.Schema<GetAttackSurfaceReportIssueTypeRequest>;

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

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

export interface GetDomainRequest {
  /** Identifier. */
  accountId: string;
  domain?: string;
  /** Skip DNS resolution lookups for faster response. */
  skipDns?: boolean;
  /** Skip the domain ranking lookup for faster responses. Defaults to */
  skipRanking?: boolean;
}
export const GetDomainRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    domain: S.optional(S.String.pipe(T.Query())),
    skipDns: S.optional(S.Boolean.pipe(T.Query("skip_dns"))),
    skipRanking: S.optional(S.Boolean.pipe(T.Query("skip_ranking"))),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/intel/domain",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetDomainRequest",
}) as any as S.Schema<GetDomainRequest>;

export interface DomainsGetResponseAdditionalInformation {
  /** Suspected DGA malware family. */
  suspectedMalwareFamily?: string | null;
}
export const DomainsGetResponseAdditionalInformation = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      suspectedMalwareFamily: S.optional(
        S.NullOr(S.String).pipe(T.Body("suspected_malware_family")),
      ),
    }),
).annotate({
  identifier: "DomainsGetResponseAdditionalInformation",
}) as any as S.Schema<DomainsGetResponseAdditionalInformation>;

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

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

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

export type DomainsGetResponseInheritedContentCategoriesItem =
  DomainsGetResponseContentCategoriesItem;
export const DomainsGetResponseInheritedContentCategoriesItem =
  DomainsGetResponseContentCategoriesItem;

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

export type DomainsGetResponseInheritedRiskTypesItem =
  DomainsGetResponseContentCategoriesItem;
export const DomainsGetResponseInheritedRiskTypesItem =
  DomainsGetResponseContentCategoriesItem;

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

export interface DomainsGetResponseResolvesToRefsItem {
  /** STIX 2.1 identifier: https://docs.oasis-open.org/cti/stix/v2.1/cs02/stix-v2.1-cs02.html#_64yvzeku5a5c. */
  id?: string | null;
  /** IP address or domain name. */
  value?: string | null;
}
export const DomainsGetResponseResolvesToRefsItem = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      id: S.optional(S.NullOr(S.String)),
      value: S.optional(S.NullOr(S.String)),
    }),
).annotate({
  identifier: "DomainsGetResponseResolvesToRefsItem",
}) as any as S.Schema<DomainsGetResponseResolvesToRefsItem>;

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

export type DomainsGetResponseRiskTypesItem =
  DomainsGetResponseContentCategoriesItem;
export const DomainsGetResponseRiskTypesItem =
  DomainsGetResponseContentCategoriesItem;

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

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface GetDomainResponse {
  /** Additional information related to the host name. */
  additionalInformation?: DomainsGetResponseAdditionalInformation | null;
  /** Application that the hostname belongs to. */
  application?: DomainsGetResponseApplication | null;
  contentCategories?: DomainsGetResponseContentCategoriesList | null;
  domain?: string | null;
  inheritedContentCategories?: DomainsGetResponseInheritedContentCategoriesList | null;
  /** Domain from which `inherited_content_categories` and `inherited_risk_types` are inherited, if applicable. */
  inheritedFrom?: string | null;
  inheritedRiskTypes?: DomainsGetResponseInheritedRiskTypesList | null;
  /** Global Cloudflare 100k ranking for the last 30 days, if available for the hostname. The top ranked domain is 1, the lowest ranked domain is 100,000. */
  popularityRank?: number | null;
  /** Specifies a list of references to one or more IP addresses or domain names that the domain name currently resolves to. */
  resolvesToRefs?: DomainsGetResponseResolvesToRefsList | null;
  /** Hostname risk score, which is a value between 0 (lowest risk) to 1 (highest risk). */
  riskScore?: number | null;
  riskTypes?: DomainsGetResponseRiskTypesList | null;
}
export const GetDomainResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    additionalInformation: S.optional(
      S.NullOr(DomainsGetResponseAdditionalInformation).pipe(
        T.Body("additional_information"),
      ),
    ),
    application: S.optional(S.NullOr(DomainsGetResponseApplication)),
    contentCategories: S.optional(
      S.NullOr(DomainsGetResponseContentCategoriesList).pipe(
        T.Body("content_categories"),
      ),
    ),
    domain: S.optional(S.NullOr(S.String)),
    inheritedContentCategories: S.optional(
      S.NullOr(DomainsGetResponseInheritedContentCategoriesList).pipe(
        T.Body("inherited_content_categories"),
      ),
    ),
    inheritedFrom: S.optional(
      S.NullOr(S.String).pipe(T.Body("inherited_from")),
    ),
    inheritedRiskTypes: S.optional(
      S.NullOr(DomainsGetResponseInheritedRiskTypesList).pipe(
        T.Body("inherited_risk_types"),
      ),
    ),
    popularityRank: S.optional(
      S.NullOr(S.Number).pipe(T.Body("popularity_rank")),
    ),
    resolvesToRefs: S.optional(
      S.NullOr(DomainsGetResponseResolvesToRefsList).pipe(
        T.Body("resolves_to_refs"),
      ),
    ),
    riskScore: S.optional(S.NullOr(S.Number).pipe(T.Body("risk_score"))),
    riskTypes: S.optional(
      S.NullOr(DomainsGetResponseRiskTypesList).pipe(T.Body("risk_types")),
    ),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetDomainResponse",
}) as any as S.Schema<GetDomainResponse>;

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

export interface GetDomainBulkRequest {
  /** Identifier. */
  accountId: string;
  /** Accepts multiple values like `?domain=cloudflare.com&domain=example.com`. */
  domain?: DomainsBulksGetRequestDomainList;
  /** Whether to include domain ranking data in the response. Defaults to */
  includeRanking?: boolean;
  /** **Deprecated.** Previously controlled whether the ranking lookup */
  skipRanking?: boolean;
}
export const GetDomainBulkRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    domain: S.optional(DomainsBulksGetRequestDomainList.pipe(T.Query())),
    includeRanking: S.optional(S.Boolean.pipe(T.Query("include_ranking"))),
    skipRanking: S.optional(S.Boolean.pipe(T.Query("skip_ranking"))),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/intel/domain/bulk",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetDomainBulkRequest",
}) as any as S.Schema<GetDomainBulkRequest>;

export type DomainsBulksGetResultItemAdditionalInformation =
  DomainsGetResponseAdditionalInformation;
export const DomainsBulksGetResultItemAdditionalInformation =
  DomainsGetResponseAdditionalInformation;

export type DomainsBulksGetResultItemApplication =
  DomainsGetResponseApplication;
export const DomainsBulksGetResultItemApplication =
  DomainsGetResponseApplication;

export type DomainsBulksGetResultItemContentCategoriesItem =
  DomainsGetResponseContentCategoriesItem;
export const DomainsBulksGetResultItemContentCategoriesItem =
  DomainsGetResponseContentCategoriesItem;

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

export type DomainsBulksGetResultItemInheritedContentCategoriesItem =
  DomainsGetResponseContentCategoriesItem;
export const DomainsBulksGetResultItemInheritedContentCategoriesItem =
  DomainsGetResponseContentCategoriesItem;

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

export type DomainsBulksGetResultItemInheritedRiskTypesItem =
  DomainsGetResponseContentCategoriesItem;
export const DomainsBulksGetResultItemInheritedRiskTypesItem =
  DomainsGetResponseContentCategoriesItem;

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

export type DomainsBulksGetResultItemRiskTypesItem =
  DomainsGetResponseContentCategoriesItem;
export const DomainsBulksGetResultItemRiskTypesItem =
  DomainsGetResponseContentCategoriesItem;

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

export interface DomainsBulksGetResultItem {
  /** Additional information related to the host name. */
  additionalInformation?: DomainsGetResponseAdditionalInformation | null;
  /** Application that the hostname belongs to. */
  application?: DomainsGetResponseApplication | null;
  contentCategories?: DomainsBulksGetResultItemContentCategoriesList | null;
  domain?: string | null;
  inheritedContentCategories?: DomainsBulksGetResultItemInheritedContentCategoriesList | null;
  /** Domain from which `inherited_content_categories` and `inherited_risk_types` are inherited, if applicable. */
  inheritedFrom?: string | null;
  inheritedRiskTypes?: DomainsBulksGetResultItemInheritedRiskTypesList | null;
  /** Global Cloudflare 100k ranking for the last 30 days, if available for the hostname. The top ranked domain is 1, the lowest ranked domain is 100,000. */
  popularityRank?: number | null;
  /** Hostname risk score, which is a value between 0 (lowest risk) to 1 (highest risk). */
  riskScore?: number | null;
  riskTypes?: DomainsBulksGetResultItemRiskTypesList | null;
}
export const DomainsBulksGetResultItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    additionalInformation: S.optional(
      S.NullOr(DomainsGetResponseAdditionalInformation).pipe(
        T.Body("additional_information"),
      ),
    ),
    application: S.optional(S.NullOr(DomainsGetResponseApplication)),
    contentCategories: S.optional(
      S.NullOr(DomainsBulksGetResultItemContentCategoriesList).pipe(
        T.Body("content_categories"),
      ),
    ),
    domain: S.optional(S.NullOr(S.String)),
    inheritedContentCategories: S.optional(
      S.NullOr(DomainsBulksGetResultItemInheritedContentCategoriesList).pipe(
        T.Body("inherited_content_categories"),
      ),
    ),
    inheritedFrom: S.optional(
      S.NullOr(S.String).pipe(T.Body("inherited_from")),
    ),
    inheritedRiskTypes: S.optional(
      S.NullOr(DomainsBulksGetResultItemInheritedRiskTypesList).pipe(
        T.Body("inherited_risk_types"),
      ),
    ),
    popularityRank: S.optional(
      S.NullOr(S.Number).pipe(T.Body("popularity_rank")),
    ),
    riskScore: S.optional(S.NullOr(S.Number).pipe(T.Body("risk_score"))),
    riskTypes: S.optional(
      S.NullOr(DomainsBulksGetResultItemRiskTypesList).pipe(
        T.Body("risk_types"),
      ),
    ),
  }),
).annotate({
  identifier: "DomainsBulksGetResultItem",
}) as any as S.Schema<DomainsBulksGetResultItem>;

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

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

export interface GetDomainHistoryRequest {
  /** Identifier. */
  accountId: string;
  domain?: string;
}
export const GetDomainHistoryRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    domain: S.optional(S.String.pipe(T.Query())),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/intel/domain-history",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetDomainHistoryRequest",
}) as any as S.Schema<GetDomainHistoryRequest>;

export type DomainHistoryGetResultItemCategorizationsItemCategoriesItem =
  DomainsGetResponseApplication;
export const DomainHistoryGetResultItemCategorizationsItemCategoriesItem =
  DomainsGetResponseApplication;

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

export interface DomainHistoryGetResultItemCategorizationsItem {
  categories?: DomainHistoryGetResultItemCategorizationsItemCategoriesList | null;
  end?: string | null;
  start?: string | null;
}
export const DomainHistoryGetResultItemCategorizationsItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      categories: S.optional(
        S.NullOr(DomainHistoryGetResultItemCategorizationsItemCategoriesList),
      ),
      end: S.optional(S.NullOr(S.String)),
      start: S.optional(S.NullOr(S.String)),
    }),
  ).annotate({
    identifier: "DomainHistoryGetResultItemCategorizationsItem",
  }) as any as S.Schema<DomainHistoryGetResultItemCategorizationsItem>;

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

export interface DomainHistoryGetResultItem {
  categorizations?: DomainHistoryGetResultItemCategorizationsList | null;
  domain?: string | null;
}
export const DomainHistoryGetResultItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    categorizations: S.optional(
      S.NullOr(DomainHistoryGetResultItemCategorizationsList),
    ),
    domain: S.optional(S.NullOr(S.String)),
  }),
).annotate({
  identifier: "DomainHistoryGetResultItem",
}) as any as S.Schema<DomainHistoryGetResultItem>;

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

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

export interface GetIndicatorFeedRequest {
  /** Identifier */
  accountId: string;
  /** Indicator feed ID */
  feedId: number;
}
export const GetIndicatorFeedRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    feedId: S.Number.pipe(T.Label("feed_id")),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/intel/indicator-feeds/{feed_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetIndicatorFeedRequest",
}) as any as S.Schema<GetIndicatorFeedRequest>;

export interface IndicatorFeedsGetResponseLastUploadSummaryPersisted {
  domainsAdded?: number | null;
  domainsRemoved?: number | null;
  ipsAdded?: number | null;
  ipsRemoved?: number | null;
  urlsAdded?: number | null;
  urlsRemoved?: number | null;
}
export const IndicatorFeedsGetResponseLastUploadSummaryPersisted =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      domainsAdded: S.optional(
        S.NullOr(S.Number).pipe(T.Body("domains_added")),
      ),
      domainsRemoved: S.optional(
        S.NullOr(S.Number).pipe(T.Body("domains_removed")),
      ),
      ipsAdded: S.optional(S.NullOr(S.Number).pipe(T.Body("ips_added"))),
      ipsRemoved: S.optional(S.NullOr(S.Number).pipe(T.Body("ips_removed"))),
      urlsAdded: S.optional(S.NullOr(S.Number).pipe(T.Body("urls_added"))),
      urlsRemoved: S.optional(S.NullOr(S.Number).pipe(T.Body("urls_removed"))),
    }),
  ).annotate({
    identifier: "IndicatorFeedsGetResponseLastUploadSummaryPersisted",
  }) as any as S.Schema<IndicatorFeedsGetResponseLastUploadSummaryPersisted>;

export interface IndicatorFeedsGetResponseLastUploadSummarySkipped {
  /** Domains filtered by the global popularity allowlist at QS */
  allowlistedDomains?: number | null;
  /** Indicators in the upload whose valid_until is already in */
  expiredIndicators?: number | null;
  /** Reserved for future use. Currently always 0 — the unifier */
  invalidIndicators?: number | null;
}
export const IndicatorFeedsGetResponseLastUploadSummarySkipped =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      allowlistedDomains: S.optional(
        S.NullOr(S.Number).pipe(T.Body("allowlisted_domains")),
      ),
      expiredIndicators: S.optional(
        S.NullOr(S.Number).pipe(T.Body("expired_indicators")),
      ),
      invalidIndicators: S.optional(
        S.NullOr(S.Number).pipe(T.Body("invalid_indicators")),
      ),
    }),
  ).annotate({
    identifier: "IndicatorFeedsGetResponseLastUploadSummarySkipped",
  }) as any as S.Schema<IndicatorFeedsGetResponseLastUploadSummarySkipped>;

export interface IndicatorFeedsGetResponseLastUploadSummaryUploaded {
  /** Number of domain indicators in the upload */
  domains?: number | null;
  /** Number of IP indicators in the upload */
  ips?: number | null;
  /** Number of URL indicators in the upload */
  urls?: number | null;
}
export const IndicatorFeedsGetResponseLastUploadSummaryUploaded =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      domains: S.optional(S.NullOr(S.Number)),
      ips: S.optional(S.NullOr(S.Number)),
      urls: S.optional(S.NullOr(S.Number)),
    }),
  ).annotate({
    identifier: "IndicatorFeedsGetResponseLastUploadSummaryUploaded",
  }) as any as S.Schema<IndicatorFeedsGetResponseLastUploadSummaryUploaded>;

export interface IndicatorFeedsGetResponseLastUploadSummary {
  /** Net delta applied to feed indicators by this upload. Snapshot */
  persisted?: IndicatorFeedsGetResponseLastUploadSummaryPersisted | null;
  /** Counts of indicators that were uploaded but did not reach */
  skipped?: IndicatorFeedsGetResponseLastUploadSummarySkipped | null;
  /** Indicator counts from the unified file the loader received */
  uploaded?: IndicatorFeedsGetResponseLastUploadSummaryUploaded | null;
}
export const IndicatorFeedsGetResponseLastUploadSummary =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      persisted: S.optional(
        S.NullOr(IndicatorFeedsGetResponseLastUploadSummaryPersisted),
      ),
      skipped: S.optional(
        S.NullOr(IndicatorFeedsGetResponseLastUploadSummarySkipped),
      ),
      uploaded: S.optional(
        S.NullOr(IndicatorFeedsGetResponseLastUploadSummaryUploaded),
      ),
    }),
  ).annotate({
    identifier: "IndicatorFeedsGetResponseLastUploadSummary",
  }) as any as S.Schema<IndicatorFeedsGetResponseLastUploadSummary>;

export type IndicatorFeedsGetResponseLatestUploadStatus =
  | "Mirroring"
  | "Unifying"
  | "Loading"
  | "Provisioning"
  | "Complete"
  | "Error";
export const IndicatorFeedsGetResponseLatestUploadStatus =
  /*@__PURE__*/ S.String;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface GetIndicatorFeedResponse {
  /** The unique identifier for the indicator feed */
  id?: number | null;
  /** The date and time when the data entry was created */
  createdOn?: string | null;
  /** The description of the example test */
  description?: string | null;
  /** Whether the indicator feed can be attributed to a provider */
  isAttributable?: boolean | null;
  /** Whether the indicator feed can be downloaded */
  isDownloadable?: boolean | null;
  /** Whether the indicator feed is exposed to customers */
  isPublic?: boolean | null;
  /** Summary of indicator counts from the last successful upload to this */
  lastUploadSummary?: IndicatorFeedsGetResponseLastUploadSummary | null;
  /** Human-readable error message describing why the latest upload */
  latestUploadError?: string | null;
  /** Status of the latest snapshot uploaded */
  latestUploadStatus?: IndicatorFeedsGetResponseLatestUploadStatus | null;
  /** The date and time when the data entry was last modified */
  modifiedOn?: string | null;
  /** The name of the indicator feed */
  name?: string | null;
  /** The unique identifier for the provider */
  providerId?: number | null;
  /** The provider of the indicator feed */
  providerName?: string | null;
}
export const GetIndicatorFeedResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.optional(S.NullOr(S.Number)),
    createdOn: S.optional(S.NullOr(S.String).pipe(T.Body("created_on"))),
    description: S.optional(S.NullOr(S.String)),
    isAttributable: S.optional(
      S.NullOr(S.Boolean).pipe(T.Body("is_attributable")),
    ),
    isDownloadable: S.optional(
      S.NullOr(S.Boolean).pipe(T.Body("is_downloadable")),
    ),
    isPublic: S.optional(S.NullOr(S.Boolean).pipe(T.Body("is_public"))),
    lastUploadSummary: S.optional(
      S.NullOr(IndicatorFeedsGetResponseLastUploadSummary).pipe(
        T.Body("last_upload_summary"),
      ),
    ),
    latestUploadError: S.optional(
      S.NullOr(S.String).pipe(T.Body("latest_upload_error")),
    ),
    latestUploadStatus: S.optional(
      S.NullOr(IndicatorFeedsGetResponseLatestUploadStatus).pipe(
        T.Body("latest_upload_status"),
      ),
    ),
    modifiedOn: S.optional(S.NullOr(S.String).pipe(T.Body("modified_on"))),
    name: S.optional(S.NullOr(S.String)),
    providerId: S.optional(S.NullOr(S.Number).pipe(T.Body("provider_id"))),
    providerName: S.optional(S.NullOr(S.String).pipe(T.Body("provider_name"))),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetIndicatorFeedResponse",
}) as any as S.Schema<GetIndicatorFeedResponse>;

export interface GetIpRequest {
  /** Identifier. */
  accountId: string;
  ipv4?: string;
  ipv6?: string;
}
export const GetIpRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    ipv4: S.optional(S.String.pipe(T.Query())),
    ipv6: S.optional(S.String.pipe(T.Query())),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/intel/ip",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({ identifier: "GetIpRequest" }) as any as S.Schema<GetIpRequest>;

export type IpsGetResultItemBelongsToRefType =
  | "hosting_provider"
  | "isp"
  | "organization";
export const IpsGetResultItemBelongsToRefType = /*@__PURE__*/ S.String;

export interface IpsGetResultItemBelongsToRef {
  id?: string | null;
  country?: string | null;
  description?: string | null;
  /** Infrastructure type of this ASN. */
  type?: IpsGetResultItemBelongsToRefType | null;
  value?: string | null;
}
export const IpsGetResultItemBelongsToRef = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.optional(S.NullOr(S.String)),
    country: S.optional(S.NullOr(S.String)),
    description: S.optional(S.NullOr(S.String)),
    type: S.optional(S.NullOr(IpsGetResultItemBelongsToRefType)),
    value: S.optional(S.NullOr(S.String)),
  }),
).annotate({
  identifier: "IpsGetResultItemBelongsToRef",
}) as any as S.Schema<IpsGetResultItemBelongsToRef>;

export type IpsGetResultItemRiskTypesItem =
  DomainsGetResponseContentCategoriesItem;
export const IpsGetResultItemRiskTypesItem =
  DomainsGetResponseContentCategoriesItem;

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

export interface IpsGetResultItem {
  /** Specifies a reference to the autonomous systems (AS) that the IP address belongs to. */
  belongsToRef?: IpsGetResultItemBelongsToRef | null;
  ip?: string | null;
  riskTypes?: IpsGetResultItemRiskTypesList | null;
}
export const IpsGetResultItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    belongsToRef: S.optional(
      S.NullOr(IpsGetResultItemBelongsToRef).pipe(T.Body("belongs_to_ref")),
    ),
    ip: S.optional(S.NullOr(S.String)),
    riskTypes: S.optional(
      S.NullOr(IpsGetResultItemRiskTypesList).pipe(T.Body("risk_types")),
    ),
  }),
).annotate({
  identifier: "IpsGetResultItem",
}) as any as S.Schema<IpsGetResultItem>;

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

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

export interface GetWhoiRequest {
  /** Use to uniquely identify or reference the resource. */
  accountId: string;
  domain?: string;
}
export const GetWhoiRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    domain: S.optional(S.String.pipe(T.Query())),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/intel/whois",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({ identifier: "GetWhoiRequest" }) as any as S.Schema<GetWhoiRequest>;

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

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

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface GetWhoiResponse {
  dnssec: boolean;
  domain: string;
  extension: string;
  found: boolean;
  nameservers: WhoisGetResponseNameserversList;
  punycode: string;
  registrant: string;
  registrar: string;
  id?: string | null;
  administrativeCity?: string | null;
  administrativeCountry?: string | null;
  administrativeEmail?: string | null;
  administrativeFax?: string | null;
  administrativeFaxExt?: string | null;
  administrativeId?: string | null;
  administrativeName?: string | null;
  administrativeOrg?: string | null;
  administrativePhone?: string | null;
  administrativePhoneExt?: string | null;
  administrativePostalCode?: string | null;
  administrativeProvince?: string | null;
  administrativeReferralUrl?: string | null;
  administrativeStreet?: string | null;
  billingCity?: string | null;
  billingCountry?: string | null;
  billingEmail?: string | null;
  billingFax?: string | null;
  billingFaxExt?: string | null;
  billingId?: string | null;
  billingName?: string | null;
  billingOrg?: string | null;
  billingPhone?: string | null;
  billingPhoneExt?: string | null;
  billingPostalCode?: string | null;
  billingProvince?: string | null;
  billingReferralUrl?: string | null;
  billingStreet?: string | null;
  createdDate?: string | null;
  createdDateRaw?: string | null;
  expirationDate?: string | null;
  expirationDateRaw?: string | null;
  registrantCity?: string | null;
  registrantCountry?: string | null;
  registrantEmail?: string | null;
  registrantFax?: string | null;
  registrantFaxExt?: string | null;
  registrantId?: string | null;
  registrantName?: string | null;
  registrantOrg?: string | null;
  registrantPhone?: string | null;
  registrantPhoneExt?: string | null;
  registrantPostalCode?: string | null;
  registrantProvince?: string | null;
  registrantReferralUrl?: string | null;
  registrantStreet?: string | null;
  registrarCity?: string | null;
  registrarCountry?: string | null;
  registrarEmail?: string | null;
  registrarFax?: string | null;
  registrarFaxExt?: string | null;
  registrarId?: string | null;
  registrarName?: string | null;
  registrarOrg?: string | null;
  registrarPhone?: string | null;
  registrarPhoneExt?: string | null;
  registrarPostalCode?: string | null;
  registrarProvince?: string | null;
  registrarReferralUrl?: string | null;
  registrarStreet?: string | null;
  status?: WhoisGetResponseStatusList | null;
  technicalCity?: string | null;
  technicalCountry?: string | null;
  technicalEmail?: string | null;
  technicalFax?: string | null;
  technicalFaxExt?: string | null;
  technicalId?: string | null;
  technicalName?: string | null;
  technicalOrg?: string | null;
  technicalPhone?: string | null;
  technicalPhoneExt?: string | null;
  technicalPostalCode?: string | null;
  technicalProvince?: string | null;
  technicalReferralUrl?: string | null;
  technicalStreet?: string | null;
  updatedDate?: string | null;
  updatedDateRaw?: string | null;
  whoisServer?: string | null;
}
export const GetWhoiResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    dnssec: S.Boolean,
    domain: S.String,
    extension: S.String,
    found: S.Boolean,
    nameservers: WhoisGetResponseNameserversList,
    punycode: S.String,
    registrant: S.String,
    registrar: S.String,
    id: S.optional(S.NullOr(S.String)),
    administrativeCity: S.optional(
      S.NullOr(S.String).pipe(T.Body("administrative_city")),
    ),
    administrativeCountry: S.optional(
      S.NullOr(S.String).pipe(T.Body("administrative_country")),
    ),
    administrativeEmail: S.optional(
      S.NullOr(S.String).pipe(T.Body("administrative_email")),
    ),
    administrativeFax: S.optional(
      S.NullOr(S.String).pipe(T.Body("administrative_fax")),
    ),
    administrativeFaxExt: S.optional(
      S.NullOr(S.String).pipe(T.Body("administrative_fax_ext")),
    ),
    administrativeId: S.optional(
      S.NullOr(S.String).pipe(T.Body("administrative_id")),
    ),
    administrativeName: S.optional(
      S.NullOr(S.String).pipe(T.Body("administrative_name")),
    ),
    administrativeOrg: S.optional(
      S.NullOr(S.String).pipe(T.Body("administrative_org")),
    ),
    administrativePhone: S.optional(
      S.NullOr(S.String).pipe(T.Body("administrative_phone")),
    ),
    administrativePhoneExt: S.optional(
      S.NullOr(S.String).pipe(T.Body("administrative_phone_ext")),
    ),
    administrativePostalCode: S.optional(
      S.NullOr(S.String).pipe(T.Body("administrative_postal_code")),
    ),
    administrativeProvince: S.optional(
      S.NullOr(S.String).pipe(T.Body("administrative_province")),
    ),
    administrativeReferralUrl: S.optional(
      S.NullOr(S.String).pipe(T.Body("administrative_referral_url")),
    ),
    administrativeStreet: S.optional(
      S.NullOr(S.String).pipe(T.Body("administrative_street")),
    ),
    billingCity: S.optional(S.NullOr(S.String).pipe(T.Body("billing_city"))),
    billingCountry: S.optional(
      S.NullOr(S.String).pipe(T.Body("billing_country")),
    ),
    billingEmail: S.optional(S.NullOr(S.String).pipe(T.Body("billing_email"))),
    billingFax: S.optional(S.NullOr(S.String).pipe(T.Body("billing_fax"))),
    billingFaxExt: S.optional(
      S.NullOr(S.String).pipe(T.Body("billing_fax_ext")),
    ),
    billingId: S.optional(S.NullOr(S.String).pipe(T.Body("billing_id"))),
    billingName: S.optional(S.NullOr(S.String).pipe(T.Body("billing_name"))),
    billingOrg: S.optional(S.NullOr(S.String).pipe(T.Body("billing_org"))),
    billingPhone: S.optional(S.NullOr(S.String).pipe(T.Body("billing_phone"))),
    billingPhoneExt: S.optional(
      S.NullOr(S.String).pipe(T.Body("billing_phone_ext")),
    ),
    billingPostalCode: S.optional(
      S.NullOr(S.String).pipe(T.Body("billing_postal_code")),
    ),
    billingProvince: S.optional(
      S.NullOr(S.String).pipe(T.Body("billing_province")),
    ),
    billingReferralUrl: S.optional(
      S.NullOr(S.String).pipe(T.Body("billing_referral_url")),
    ),
    billingStreet: S.optional(
      S.NullOr(S.String).pipe(T.Body("billing_street")),
    ),
    createdDate: S.optional(S.NullOr(S.String).pipe(T.Body("created_date"))),
    createdDateRaw: S.optional(
      S.NullOr(S.String).pipe(T.Body("created_date_raw")),
    ),
    expirationDate: S.optional(
      S.NullOr(S.String).pipe(T.Body("expiration_date")),
    ),
    expirationDateRaw: S.optional(
      S.NullOr(S.String).pipe(T.Body("expiration_date_raw")),
    ),
    registrantCity: S.optional(
      S.NullOr(S.String).pipe(T.Body("registrant_city")),
    ),
    registrantCountry: S.optional(
      S.NullOr(S.String).pipe(T.Body("registrant_country")),
    ),
    registrantEmail: S.optional(
      S.NullOr(S.String).pipe(T.Body("registrant_email")),
    ),
    registrantFax: S.optional(
      S.NullOr(S.String).pipe(T.Body("registrant_fax")),
    ),
    registrantFaxExt: S.optional(
      S.NullOr(S.String).pipe(T.Body("registrant_fax_ext")),
    ),
    registrantId: S.optional(S.NullOr(S.String).pipe(T.Body("registrant_id"))),
    registrantName: S.optional(
      S.NullOr(S.String).pipe(T.Body("registrant_name")),
    ),
    registrantOrg: S.optional(
      S.NullOr(S.String).pipe(T.Body("registrant_org")),
    ),
    registrantPhone: S.optional(
      S.NullOr(S.String).pipe(T.Body("registrant_phone")),
    ),
    registrantPhoneExt: S.optional(
      S.NullOr(S.String).pipe(T.Body("registrant_phone_ext")),
    ),
    registrantPostalCode: S.optional(
      S.NullOr(S.String).pipe(T.Body("registrant_postal_code")),
    ),
    registrantProvince: S.optional(
      S.NullOr(S.String).pipe(T.Body("registrant_province")),
    ),
    registrantReferralUrl: S.optional(
      S.NullOr(S.String).pipe(T.Body("registrant_referral_url")),
    ),
    registrantStreet: S.optional(
      S.NullOr(S.String).pipe(T.Body("registrant_street")),
    ),
    registrarCity: S.optional(
      S.NullOr(S.String).pipe(T.Body("registrar_city")),
    ),
    registrarCountry: S.optional(
      S.NullOr(S.String).pipe(T.Body("registrar_country")),
    ),
    registrarEmail: S.optional(
      S.NullOr(S.String).pipe(T.Body("registrar_email")),
    ),
    registrarFax: S.optional(S.NullOr(S.String).pipe(T.Body("registrar_fax"))),
    registrarFaxExt: S.optional(
      S.NullOr(S.String).pipe(T.Body("registrar_fax_ext")),
    ),
    registrarId: S.optional(S.NullOr(S.String).pipe(T.Body("registrar_id"))),
    registrarName: S.optional(
      S.NullOr(S.String).pipe(T.Body("registrar_name")),
    ),
    registrarOrg: S.optional(S.NullOr(S.String).pipe(T.Body("registrar_org"))),
    registrarPhone: S.optional(
      S.NullOr(S.String).pipe(T.Body("registrar_phone")),
    ),
    registrarPhoneExt: S.optional(
      S.NullOr(S.String).pipe(T.Body("registrar_phone_ext")),
    ),
    registrarPostalCode: S.optional(
      S.NullOr(S.String).pipe(T.Body("registrar_postal_code")),
    ),
    registrarProvince: S.optional(
      S.NullOr(S.String).pipe(T.Body("registrar_province")),
    ),
    registrarReferralUrl: S.optional(
      S.NullOr(S.String).pipe(T.Body("registrar_referral_url")),
    ),
    registrarStreet: S.optional(
      S.NullOr(S.String).pipe(T.Body("registrar_street")),
    ),
    status: S.optional(S.NullOr(WhoisGetResponseStatusList)),
    technicalCity: S.optional(
      S.NullOr(S.String).pipe(T.Body("technical_city")),
    ),
    technicalCountry: S.optional(
      S.NullOr(S.String).pipe(T.Body("technical_country")),
    ),
    technicalEmail: S.optional(
      S.NullOr(S.String).pipe(T.Body("technical_email")),
    ),
    technicalFax: S.optional(S.NullOr(S.String).pipe(T.Body("technical_fax"))),
    technicalFaxExt: S.optional(
      S.NullOr(S.String).pipe(T.Body("technical_fax_ext")),
    ),
    technicalId: S.optional(S.NullOr(S.String).pipe(T.Body("technical_id"))),
    technicalName: S.optional(
      S.NullOr(S.String).pipe(T.Body("technical_name")),
    ),
    technicalOrg: S.optional(S.NullOr(S.String).pipe(T.Body("technical_org"))),
    technicalPhone: S.optional(
      S.NullOr(S.String).pipe(T.Body("technical_phone")),
    ),
    technicalPhoneExt: S.optional(
      S.NullOr(S.String).pipe(T.Body("technical_phone_ext")),
    ),
    technicalPostalCode: S.optional(
      S.NullOr(S.String).pipe(T.Body("technical_postal_code")),
    ),
    technicalProvince: S.optional(
      S.NullOr(S.String).pipe(T.Body("technical_province")),
    ),
    technicalReferralUrl: S.optional(
      S.NullOr(S.String).pipe(T.Body("technical_referral_url")),
    ),
    technicalStreet: S.optional(
      S.NullOr(S.String).pipe(T.Body("technical_street")),
    ),
    updatedDate: S.optional(S.NullOr(S.String).pipe(T.Body("updated_date"))),
    updatedDateRaw: S.optional(
      S.NullOr(S.String).pipe(T.Body("updated_date_raw")),
    ),
    whoisServer: S.optional(S.NullOr(S.String).pipe(T.Body("whois_server"))),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetWhoiResponse",
}) as any as S.Schema<GetWhoiResponse>;

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

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

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

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

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

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

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

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

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

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

export interface ListAttackSurfaceReportIssuesRequest {
  /** Identifier. */
  accountId: string;
  dismissed?: boolean;
  issueClass?: AttackSurfaceReportIssuesListRequestIssueClassList;
  issueClassNeq?: AttackSurfaceReportIssuesListRequestIssueClassNeqList;
  issueType?: AttackSurfaceReportIssuesListRequestIssueTypeList;
  issueTypeNeq?: AttackSurfaceReportIssuesListRequestIssueTypeNeqList;
  /** Specifies the current page within paginated list of results. */
  page?: number;
  /** Sets the number of results per page of results. */
  perPage?: number;
  product?: AttackSurfaceReportIssuesListRequestProductList;
  productNeq?: AttackSurfaceReportIssuesListRequestProductNeqList;
  severity?: AttackSurfaceReportIssuesListRequestSeverityList;
  severityNeq?: AttackSurfaceReportIssuesListRequestSeverityNeqList;
  subject?: AttackSurfaceReportIssuesListRequestSubjectList;
  subjectNeq?: AttackSurfaceReportIssuesListRequestSubjectNeqList;
}
export const ListAttackSurfaceReportIssuesRequest = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      accountId: S.String.pipe(T.Label("account_id")),
      dismissed: S.optional(S.Boolean.pipe(T.Query())),
      issueClass: S.optional(
        AttackSurfaceReportIssuesListRequestIssueClassList.pipe(
          T.Query("issue_class"),
        ),
      ),
      issueClassNeq: S.optional(
        AttackSurfaceReportIssuesListRequestIssueClassNeqList.pipe(
          T.Query("issue_class~neq"),
        ),
      ),
      issueType: S.optional(
        AttackSurfaceReportIssuesListRequestIssueTypeList.pipe(
          T.Query("issue_type"),
        ),
      ),
      issueTypeNeq: S.optional(
        AttackSurfaceReportIssuesListRequestIssueTypeNeqList.pipe(
          T.Query("issue_type~neq"),
        ),
      ),
      page: S.optional(S.Number.pipe(T.Query())),
      perPage: S.optional(S.Number.pipe(T.Query("per_page"))),
      product: S.optional(
        AttackSurfaceReportIssuesListRequestProductList.pipe(T.Query()),
      ),
      productNeq: S.optional(
        AttackSurfaceReportIssuesListRequestProductNeqList.pipe(
          T.Query("product~neq"),
        ),
      ),
      severity: S.optional(
        AttackSurfaceReportIssuesListRequestSeverityList.pipe(T.Query()),
      ),
      severityNeq: S.optional(
        AttackSurfaceReportIssuesListRequestSeverityNeqList.pipe(
          T.Query("severity~neq"),
        ),
      ),
      subject: S.optional(
        AttackSurfaceReportIssuesListRequestSubjectList.pipe(T.Query()),
      ),
      subjectNeq: S.optional(
        AttackSurfaceReportIssuesListRequestSubjectNeqList.pipe(
          T.Query("subject~neq"),
        ),
      ),
    })
      .pipe(
        T.Http({
          method: "GET",
          uri: "/accounts/{account_id}/intel/attack-surface-report/issues",
          code: 200,
        }),
      )
      .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListAttackSurfaceReportIssuesRequest",
}) as any as S.Schema<ListAttackSurfaceReportIssuesRequest>;

export type AttackSurfaceReportIssuesListResponseIssuesItemIssueType =
  | "compliance_violation"
  | "email_security"
  | "exposed_infrastructure"
  | "insecure_configuration"
  | "weak_authentication"
  | "configuration_suggestion";
export const AttackSurfaceReportIssuesListResponseIssuesItemIssueType =
  /*@__PURE__*/ S.String;

export interface AttackSurfaceReportIssuesListResponseIssuesItemPayload {
  /** Describes the method used to detect insight. */
  detectionMethod?: string | null;
  zoneTag?: string | null;
}
export const AttackSurfaceReportIssuesListResponseIssuesItemPayload =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      detectionMethod: S.optional(
        S.NullOr(S.String).pipe(T.Body("detection_method")),
      ),
      zoneTag: S.optional(S.NullOr(S.String).pipe(T.Body("zone_tag"))),
    }),
  ).annotate({
    identifier: "AttackSurfaceReportIssuesListResponseIssuesItemPayload",
  }) as any as S.Schema<AttackSurfaceReportIssuesListResponseIssuesItemPayload>;

export type AttackSurfaceReportIssuesListResponseIssuesItemSeverity =
  | "Low"
  | "Moderate"
  | "Critical";
export const AttackSurfaceReportIssuesListResponseIssuesItemSeverity =
  /*@__PURE__*/ S.String;

export type AttackSurfaceReportIssuesListResponseIssuesItemStatus =
  | "active"
  | "resolved";
export const AttackSurfaceReportIssuesListResponseIssuesItemStatus =
  /*@__PURE__*/ S.String;

export type AttackSurfaceReportIssuesListResponseIssuesItemUserClassification =
  | "false_positive"
  | "accept_risk"
  | "other";
export const AttackSurfaceReportIssuesListResponseIssuesItemUserClassification =
  /*@__PURE__*/ S.String;

export interface AttackSurfaceReportIssuesListResponseIssuesItem {
  id?: string | null;
  dismissed?: boolean | null;
  /** Indicates whether the insight has a large payload that requires fetching via the context endpoint. */
  hasExtendedContext?: boolean | null;
  issueClass?: string | null;
  issueType?: AttackSurfaceReportIssuesListResponseIssuesItemIssueType | null;
  payload?: AttackSurfaceReportIssuesListResponseIssuesItemPayload | null;
  resolveLink?: string | null;
  resolveText?: string | null;
  severity?: AttackSurfaceReportIssuesListResponseIssuesItemSeverity | null;
  since?: string | null;
  /** The current status of the insight. */
  status?: AttackSurfaceReportIssuesListResponseIssuesItemStatus | null;
  subject?: string | null;
  timestamp?: string | null;
  /** User-defined classification for the insight. Can be 'false_positive', 'accept_risk', 'other', or null. */
  userClassification?: AttackSurfaceReportIssuesListResponseIssuesItemUserClassification | null;
}
export const AttackSurfaceReportIssuesListResponseIssuesItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.optional(S.NullOr(S.String)),
      dismissed: S.optional(S.NullOr(S.Boolean)),
      hasExtendedContext: S.optional(
        S.NullOr(S.Boolean).pipe(T.Body("has_extended_context")),
      ),
      issueClass: S.optional(S.NullOr(S.String).pipe(T.Body("issue_class"))),
      issueType: S.optional(
        S.NullOr(AttackSurfaceReportIssuesListResponseIssuesItemIssueType).pipe(
          T.Body("issue_type"),
        ),
      ),
      payload: S.optional(
        S.NullOr(AttackSurfaceReportIssuesListResponseIssuesItemPayload),
      ),
      resolveLink: S.optional(S.NullOr(S.String).pipe(T.Body("resolve_link"))),
      resolveText: S.optional(S.NullOr(S.String).pipe(T.Body("resolve_text"))),
      severity: S.optional(
        S.NullOr(AttackSurfaceReportIssuesListResponseIssuesItemSeverity),
      ),
      since: S.optional(S.NullOr(S.String)),
      status: S.optional(
        S.NullOr(AttackSurfaceReportIssuesListResponseIssuesItemStatus),
      ),
      subject: S.optional(S.NullOr(S.String)),
      timestamp: S.optional(S.NullOr(S.String)),
      userClassification: S.optional(
        S.NullOr(
          AttackSurfaceReportIssuesListResponseIssuesItemUserClassification,
        ).pipe(T.Body("user_classification")),
      ),
    }),
  ).annotate({
    identifier: "AttackSurfaceReportIssuesListResponseIssuesItem",
  }) as any as S.Schema<AttackSurfaceReportIssuesListResponseIssuesItem>;

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

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface ListAttackSurfaceReportIssuesResponse {
  /** Indicates the total number of results. */
  count?: number | null;
  issues?: AttackSurfaceReportIssuesListResponseIssuesList | null;
  /** Specifies the current page within paginated list of results. */
  page?: number | null;
  /** Sets the number of results per page of results. */
  perPage?: number | null;
}
export const ListAttackSurfaceReportIssuesResponse = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      count: S.optional(S.NullOr(S.Number)),
      issues: S.optional(
        S.NullOr(AttackSurfaceReportIssuesListResponseIssuesList),
      ),
      page: S.optional(S.NullOr(S.Number)),
      perPage: S.optional(S.NullOr(S.Number).pipe(T.Body("per_page"))),
    }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListAttackSurfaceReportIssuesResponse",
}) as any as S.Schema<ListAttackSurfaceReportIssuesResponse>;

export interface DnsListRequestStartEndParams {
  /** Defaults to the current date. */
  end?: string;
  /** Defaults to 30 days before the end parameter value. */
  start?: string;
}
export const DnsListRequestStartEndParams = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    end: S.optional(S.String),
    start: S.optional(S.String),
  }),
).annotate({
  identifier: "DnsListRequestStartEndParams",
}) as any as S.Schema<DnsListRequestStartEndParams>;

export interface ListDnsRequest {
  /** Identifier. */
  accountId: string;
  ipv4?: string;
  /** Requested page within paginated list of results. */
  page?: number;
  /** Maximum number of results requested. */
  perPage?: number;
  startEndParams?: DnsListRequestStartEndParams;
}
export const ListDnsRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    ipv4: S.optional(S.String.pipe(T.Query())),
    page: S.optional(S.Number.pipe(T.Query())),
    perPage: S.optional(S.Number.pipe(T.Query("per_page"))),
    startEndParams: S.optional(
      DnsListRequestStartEndParams.pipe(
        T.Body("start_end_params"),
        T.DeepQuery("start_end_params"),
      ),
    ),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/intel/dns",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({ identifier: "ListDnsRequest" }) as any as S.Schema<ListDnsRequest>;

export interface DnsListResponseReverseRecordsItem {
  /** First seen date of the DNS record during the time period. */
  firstSeen?: string | null;
  /** Hostname that the IP was observed resolving to. */
  hostname?: string | null;
  /** Last seen date of the DNS record during the time period. */
  lastSeen?: string | null;
}
export const DnsListResponseReverseRecordsItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    firstSeen: S.optional(S.NullOr(S.String).pipe(T.Body("first_seen"))),
    hostname: S.optional(S.NullOr(S.String)),
    lastSeen: S.optional(S.NullOr(S.String).pipe(T.Body("last_seen"))),
  }),
).annotate({
  identifier: "DnsListResponseReverseRecordsItem",
}) as any as S.Schema<DnsListResponseReverseRecordsItem>;

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

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface ListDnsResponse {
  /** Total results returned based on your search parameters. */
  count?: number | null;
  /** Current page within paginated list of results. */
  page?: number | null;
  /** Number of results per page of results. */
  perPage?: number | null;
  /** Reverse DNS look-ups observed during the time period. */
  reverseRecords?: DnsListResponseReverseRecordsList | null;
}
export const ListDnsResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    count: S.optional(S.NullOr(S.Number)),
    page: S.optional(S.NullOr(S.Number)),
    perPage: S.optional(S.NullOr(S.Number).pipe(T.Body("per_page"))),
    reverseRecords: S.optional(
      S.NullOr(DnsListResponseReverseRecordsList).pipe(
        T.Body("reverse_records"),
      ),
    ),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListDnsResponse",
}) as any as S.Schema<ListDnsResponse>;

export interface ListIndicatorFeedPermissionsRequest {
  /** Identifier */
  accountId: string;
}
export const ListIndicatorFeedPermissionsRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/intel/indicator-feeds/permissions/view",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListIndicatorFeedPermissionsRequest",
}) as any as S.Schema<ListIndicatorFeedPermissionsRequest>;

export interface IndicatorFeedsPermissionsListResultItem {
  /** The unique identifier for the indicator feed */
  id?: number | null;
  /** The description of the example test */
  description?: string | null;
  /** Whether the indicator feed can be attributed to a provider */
  isAttributable?: boolean | null;
  /** Whether the indicator feed can be downloaded */
  isDownloadable?: boolean | null;
  /** Whether the indicator feed is exposed to customers */
  isPublic?: boolean | null;
  /** The name of the indicator feed */
  name?: string | null;
}
export const IndicatorFeedsPermissionsListResultItem = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      id: S.optional(S.NullOr(S.Number)),
      description: S.optional(S.NullOr(S.String)),
      isAttributable: S.optional(
        S.NullOr(S.Boolean).pipe(T.Body("is_attributable")),
      ),
      isDownloadable: S.optional(
        S.NullOr(S.Boolean).pipe(T.Body("is_downloadable")),
      ),
      isPublic: S.optional(S.NullOr(S.Boolean).pipe(T.Body("is_public"))),
      name: S.optional(S.NullOr(S.String)),
    }),
).annotate({
  identifier: "IndicatorFeedsPermissionsListResultItem",
}) as any as S.Schema<IndicatorFeedsPermissionsListResultItem>;

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

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

export interface ListIndicatorFeedsRequest {
  /** Identifier */
  accountId: string;
}
export const ListIndicatorFeedsRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/intel/indicator-feeds",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListIndicatorFeedsRequest",
}) as any as S.Schema<ListIndicatorFeedsRequest>;

export interface IndicatorFeedsListResultItem {
  /** The unique identifier for the indicator feed */
  id?: number | null;
  /** The date and time when the data entry was created */
  createdOn?: string | null;
  /** The description of the example test */
  description?: string | null;
  /** Whether the indicator feed can be attributed to a provider */
  isAttributable?: boolean | null;
  /** Whether the indicator feed can be downloaded */
  isDownloadable?: boolean | null;
  /** Whether the indicator feed is exposed to customers */
  isPublic?: boolean | null;
  /** The date and time when the data entry was last modified */
  modifiedOn?: string | null;
  /** The name of the indicator feed */
  name?: string | null;
}
export const IndicatorFeedsListResultItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.optional(S.NullOr(S.Number)),
    createdOn: S.optional(S.NullOr(S.String).pipe(T.Body("created_on"))),
    description: S.optional(S.NullOr(S.String)),
    isAttributable: S.optional(
      S.NullOr(S.Boolean).pipe(T.Body("is_attributable")),
    ),
    isDownloadable: S.optional(
      S.NullOr(S.Boolean).pipe(T.Body("is_downloadable")),
    ),
    isPublic: S.optional(S.NullOr(S.Boolean).pipe(T.Body("is_public"))),
    modifiedOn: S.optional(S.NullOr(S.String).pipe(T.Body("modified_on"))),
    name: S.optional(S.NullOr(S.String)),
  }),
).annotate({
  identifier: "IndicatorFeedsListResultItem",
}) as any as S.Schema<IndicatorFeedsListResultItem>;

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

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

export interface ListSinkholesRequest {
  /** Identifier. */
  accountId: string;
}
export const ListSinkholesRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/intel/sinkholes",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListSinkholesRequest",
}) as any as S.Schema<ListSinkholesRequest>;

export interface SinkholesListResultItem {
  /** The unique identifier for the sinkhole. */
  id?: string | null;
  /** The account tag that owns this sinkhole. */
  accountTag?: string | null;
  /** The date and time when the sinkhole was created. */
  createdOn?: string | null;
  /** The date and time when the sinkhole was last modified. */
  modifiedOn?: string | null;
  /** The name of the sinkhole. */
  name?: string | null;
  /** The name of the R2 bucket to store results. */
  r2Bucket?: string | null;
  /** The id of the R2 instance. */
  r2Id?: string | null;
}
export const SinkholesListResultItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.optional(S.NullOr(S.String)),
    accountTag: S.optional(S.NullOr(S.String).pipe(T.Body("account_tag"))),
    createdOn: S.optional(S.NullOr(S.String).pipe(T.Body("created_on"))),
    modifiedOn: S.optional(S.NullOr(S.String).pipe(T.Body("modified_on"))),
    name: S.optional(S.NullOr(S.String)),
    r2Bucket: S.optional(S.NullOr(S.String).pipe(T.Body("r2_bucket"))),
    r2Id: S.optional(S.NullOr(S.String).pipe(T.Body("r2_id"))),
  }),
).annotate({
  identifier: "SinkholesListResultItem",
}) as any as S.Schema<SinkholesListResultItem>;

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

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

export interface PutIndicatorFeedSnapshotRequest {
  /** Identifier */
  accountId: string;
  /** Indicator feed ID */
  feedId: number;
  /** The file to upload. Either a plain STIX2/CRDF body or a gzipped one (recognised by 0x1f 0x8b magic bytes or a .gz filename suffix). */
  source?: string;
}
export const PutIndicatorFeedSnapshotRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    feedId: S.Number.pipe(T.Label("feed_id")),
    source: S.optional(S.String),
  })
    .pipe(
      T.Http({
        method: "PUT",
        uri: "/accounts/{account_id}/intel/indicator-feeds/{feed_id}/snapshot",
        code: 200,
        contentType: "multipart",
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "PutIndicatorFeedSnapshotRequest",
}) as any as S.Schema<PutIndicatorFeedSnapshotRequest>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface PutIndicatorFeedSnapshotResponse {
  /** Feed id */
  fileId?: number | null;
  /** Name of the file unified in our system */
  filename?: string | null;
  /** Current status of upload, should be unified */
  status?: string | null;
}
export const PutIndicatorFeedSnapshotResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    fileId: S.optional(S.NullOr(S.Number).pipe(T.Body("file_id"))),
    filename: S.optional(S.NullOr(S.String)),
    status: S.optional(S.NullOr(S.String)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "PutIndicatorFeedSnapshotResponse",
}) as any as S.Schema<PutIndicatorFeedSnapshotResponse>;

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

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

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

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

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

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

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

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

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

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

export interface SeverityAttackSurfaceReportIssueRequest {
  /** Identifier. */
  accountId: string;
  dismissed?: boolean;
  issueClass?: AttackSurfaceReportIssuesSeverityRequestIssueClassList;
  issueClassNeq?: AttackSurfaceReportIssuesSeverityRequestIssueClassNeqList;
  issueType?: AttackSurfaceReportIssuesSeverityRequestIssueTypeList;
  issueTypeNeq?: AttackSurfaceReportIssuesSeverityRequestIssueTypeNeqList;
  product?: AttackSurfaceReportIssuesSeverityRequestProductList;
  productNeq?: AttackSurfaceReportIssuesSeverityRequestProductNeqList;
  severity?: AttackSurfaceReportIssuesSeverityRequestSeverityList;
  severityNeq?: AttackSurfaceReportIssuesSeverityRequestSeverityNeqList;
  subject?: AttackSurfaceReportIssuesSeverityRequestSubjectList;
  subjectNeq?: AttackSurfaceReportIssuesSeverityRequestSubjectNeqList;
}
export const SeverityAttackSurfaceReportIssueRequest = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      accountId: S.String.pipe(T.Label("account_id")),
      dismissed: S.optional(S.Boolean.pipe(T.Query())),
      issueClass: S.optional(
        AttackSurfaceReportIssuesSeverityRequestIssueClassList.pipe(
          T.Query("issue_class"),
        ),
      ),
      issueClassNeq: S.optional(
        AttackSurfaceReportIssuesSeverityRequestIssueClassNeqList.pipe(
          T.Query("issue_class~neq"),
        ),
      ),
      issueType: S.optional(
        AttackSurfaceReportIssuesSeverityRequestIssueTypeList.pipe(
          T.Query("issue_type"),
        ),
      ),
      issueTypeNeq: S.optional(
        AttackSurfaceReportIssuesSeverityRequestIssueTypeNeqList.pipe(
          T.Query("issue_type~neq"),
        ),
      ),
      product: S.optional(
        AttackSurfaceReportIssuesSeverityRequestProductList.pipe(T.Query()),
      ),
      productNeq: S.optional(
        AttackSurfaceReportIssuesSeverityRequestProductNeqList.pipe(
          T.Query("product~neq"),
        ),
      ),
      severity: S.optional(
        AttackSurfaceReportIssuesSeverityRequestSeverityList.pipe(T.Query()),
      ),
      severityNeq: S.optional(
        AttackSurfaceReportIssuesSeverityRequestSeverityNeqList.pipe(
          T.Query("severity~neq"),
        ),
      ),
      subject: S.optional(
        AttackSurfaceReportIssuesSeverityRequestSubjectList.pipe(T.Query()),
      ),
      subjectNeq: S.optional(
        AttackSurfaceReportIssuesSeverityRequestSubjectNeqList.pipe(
          T.Query("subject~neq"),
        ),
      ),
    })
      .pipe(
        T.Http({
          method: "GET",
          uri: "/accounts/{account_id}/intel/attack-surface-report/issues/severity",
          code: 200,
        }),
      )
      .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "SeverityAttackSurfaceReportIssueRequest",
}) as any as S.Schema<SeverityAttackSurfaceReportIssueRequest>;

export type AttackSurfaceReportIssuesSeverityResultItem =
  AttackSurfaceReportIssuesClassResultItem;
export const AttackSurfaceReportIssuesSeverityResultItem =
  AttackSurfaceReportIssuesClassResultItem;

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

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

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

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

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

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

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

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

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

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

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

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

export interface TypeAttackSurfaceReportIssueRequest {
  /** Identifier. */
  accountId: string;
  dismissed?: boolean;
  issueClass?: AttackSurfaceReportIssuesTypeRequestIssueClassList;
  issueClassNeq?: AttackSurfaceReportIssuesTypeRequestIssueClassNeqList;
  issueType?: AttackSurfaceReportIssuesTypeRequestIssueTypeList;
  issueTypeNeq?: AttackSurfaceReportIssuesTypeRequestIssueTypeNeqList;
  product?: AttackSurfaceReportIssuesTypeRequestProductList;
  productNeq?: AttackSurfaceReportIssuesTypeRequestProductNeqList;
  severity?: AttackSurfaceReportIssuesTypeRequestSeverityList;
  severityNeq?: AttackSurfaceReportIssuesTypeRequestSeverityNeqList;
  subject?: AttackSurfaceReportIssuesTypeRequestSubjectList;
  subjectNeq?: AttackSurfaceReportIssuesTypeRequestSubjectNeqList;
}
export const TypeAttackSurfaceReportIssueRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    dismissed: S.optional(S.Boolean.pipe(T.Query())),
    issueClass: S.optional(
      AttackSurfaceReportIssuesTypeRequestIssueClassList.pipe(
        T.Query("issue_class"),
      ),
    ),
    issueClassNeq: S.optional(
      AttackSurfaceReportIssuesTypeRequestIssueClassNeqList.pipe(
        T.Query("issue_class~neq"),
      ),
    ),
    issueType: S.optional(
      AttackSurfaceReportIssuesTypeRequestIssueTypeList.pipe(
        T.Query("issue_type"),
      ),
    ),
    issueTypeNeq: S.optional(
      AttackSurfaceReportIssuesTypeRequestIssueTypeNeqList.pipe(
        T.Query("issue_type~neq"),
      ),
    ),
    product: S.optional(
      AttackSurfaceReportIssuesTypeRequestProductList.pipe(T.Query()),
    ),
    productNeq: S.optional(
      AttackSurfaceReportIssuesTypeRequestProductNeqList.pipe(
        T.Query("product~neq"),
      ),
    ),
    severity: S.optional(
      AttackSurfaceReportIssuesTypeRequestSeverityList.pipe(T.Query()),
    ),
    severityNeq: S.optional(
      AttackSurfaceReportIssuesTypeRequestSeverityNeqList.pipe(
        T.Query("severity~neq"),
      ),
    ),
    subject: S.optional(
      AttackSurfaceReportIssuesTypeRequestSubjectList.pipe(T.Query()),
    ),
    subjectNeq: S.optional(
      AttackSurfaceReportIssuesTypeRequestSubjectNeqList.pipe(
        T.Query("subject~neq"),
      ),
    ),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/intel/attack-surface-report/issues/type",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "TypeAttackSurfaceReportIssueRequest",
}) as any as S.Schema<TypeAttackSurfaceReportIssueRequest>;

export type AttackSurfaceReportIssuesTypeResultItem =
  AttackSurfaceReportIssuesClassResultItem;
export const AttackSurfaceReportIssuesTypeResultItem =
  AttackSurfaceReportIssuesClassResultItem;

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

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

export interface UpdateIndicatorFeedRequest {
  /** Identifier */
  accountId: string;
  /** Indicator feed ID */
  feedId: number;
  /** The new description of the feed */
  description?: string;
  /** The new is_attributable value of the feed */
  isAttributable?: boolean;
  /** The new is_downloadable value of the feed */
  isDownloadable?: boolean;
  /** The new is_public value of the feed */
  isPublic?: boolean;
  /** The new name of the feed */
  name?: string;
}
export const UpdateIndicatorFeedRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    feedId: S.Number.pipe(T.Label("feed_id")),
    description: S.optional(S.String),
    isAttributable: S.optional(S.Boolean.pipe(T.Body("is_attributable"))),
    isDownloadable: S.optional(S.Boolean.pipe(T.Body("is_downloadable"))),
    isPublic: S.optional(S.Boolean.pipe(T.Body("is_public"))),
    name: S.optional(S.String),
  })
    .pipe(
      T.Http({
        method: "PUT",
        uri: "/accounts/{account_id}/intel/indicator-feeds/{feed_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "UpdateIndicatorFeedRequest",
}) as any as S.Schema<UpdateIndicatorFeedRequest>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface UpdateIndicatorFeedResponse {
  /** The unique identifier for the indicator feed */
  id?: number | null;
  /** The date and time when the data entry was created */
  createdOn?: string | null;
  /** The description of the example test */
  description?: string | null;
  /** Whether the indicator feed can be attributed to a provider */
  isAttributable?: boolean | null;
  /** Whether the indicator feed can be downloaded */
  isDownloadable?: boolean | null;
  /** Whether the indicator feed is exposed to customers */
  isPublic?: boolean | null;
  /** The date and time when the data entry was last modified */
  modifiedOn?: string | null;
  /** The name of the indicator feed */
  name?: string | null;
}
export const UpdateIndicatorFeedResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.optional(S.NullOr(S.Number)),
    createdOn: S.optional(S.NullOr(S.String).pipe(T.Body("created_on"))),
    description: S.optional(S.NullOr(S.String)),
    isAttributable: S.optional(
      S.NullOr(S.Boolean).pipe(T.Body("is_attributable")),
    ),
    isDownloadable: S.optional(
      S.NullOr(S.Boolean).pipe(T.Body("is_downloadable")),
    ),
    isPublic: S.optional(S.NullOr(S.Boolean).pipe(T.Body("is_public"))),
    modifiedOn: S.optional(S.NullOr(S.String).pipe(T.Body("modified_on"))),
    name: S.optional(S.NullOr(S.String)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "UpdateIndicatorFeedResponse",
}) as any as S.Schema<UpdateIndicatorFeedResponse>;

export type ClassAttackSurfaceReportIssueError = CloudflareOpError;
/** Retrieves Security Center issue counts aggregated by classification class. */
export const classAttackSurfaceReportIssue: API.OperationMethod<
  ClassAttackSurfaceReportIssueRequest,
  ClassAttackSurfaceReportIssueResponse,
  ClassAttackSurfaceReportIssueError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: ClassAttackSurfaceReportIssueRequest,
  output: ClassAttackSurfaceReportIssueResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type CreateIndicatorFeedError =
  | IndicatorFeedsNotEntitled
  | Forbidden
  | CloudflareOpError;
/** Creates a new custom threat indicator feed for sharing threat intelligence data. */
export const createIndicatorFeed: API.OperationMethod<
  CreateIndicatorFeedRequest,
  CreateIndicatorFeedResponse,
  CreateIndicatorFeedError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: CreateIndicatorFeedRequest,
  output: CreateIndicatorFeedResponse,
  errors: [
    IndicatorFeedsNotEntitled,
    Forbidden,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type CreateIndicatorFeedPermissionError =
  | IndicatorFeedNotFound
  | Forbidden
  | CloudflareOpError;
/** Grants access permissions for a custom threat indicator feed to other accounts. */
export const createIndicatorFeedPermission: API.OperationMethod<
  CreateIndicatorFeedPermissionRequest,
  CreateIndicatorFeedPermissionResponse,
  CreateIndicatorFeedPermissionError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: CreateIndicatorFeedPermissionRequest,
  output: CreateIndicatorFeedPermissionResponse,
  errors: [
    IndicatorFeedNotFound,
    Forbidden,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type CreateMiscategorizationError = CloudflareOpError;
/** Allows you to submit requests to change a domain’s category. Requests that include category `169` (New Domains) or category `177` (Newly Seen) in any of `content_adds`, `content_removes`, `security_adds`, or `security_removes` will be rejected with a `400 Bad Request`. These categories are automatically managed and fall off 30 days after they are applied. */
export const createMiscategorization: API.OperationMethod<
  CreateMiscategorizationRequest,
  CreateMiscategorizationResponse,
  CreateMiscategorizationError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: CreateMiscategorizationRequest,
  output: CreateMiscategorizationResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type DataIndicatorFeedError = CloudflareOpError;
/** Retrieves the raw data entries in a custom threat indicator feed. */
export const dataIndicatorFeed: API.OperationMethod<
  DataIndicatorFeedRequest,
  DataIndicatorFeedResponse,
  DataIndicatorFeedError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: DataIndicatorFeedRequest,
  output: DataIndicatorFeedResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type DeleteIndicatorFeedPermissionError =
  | IndicatorFeedNotFound
  | Forbidden
  | CloudflareOpError;
/** Revokes access permissions for a custom threat indicator feed. */
export const deleteIndicatorFeedPermission: API.OperationMethod<
  DeleteIndicatorFeedPermissionRequest,
  DeleteIndicatorFeedPermissionResponse,
  DeleteIndicatorFeedPermissionError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: DeleteIndicatorFeedPermissionRequest,
  output: DeleteIndicatorFeedPermissionResponse,
  errors: [
    IndicatorFeedNotFound,
    Forbidden,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type DismissAttackSurfaceReportIssueError = CloudflareOpError;
/** Deprecated endpoint for archiving Security Center insights. Use the newer archive-security-center-insight endpoint instead. */
export const dismissAttackSurfaceReportIssue: API.OperationMethod<
  DismissAttackSurfaceReportIssueRequest,
  DismissAttackSurfaceReportIssueResponse,
  DismissAttackSurfaceReportIssueError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: DismissAttackSurfaceReportIssueRequest,
  output: DismissAttackSurfaceReportIssueResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetAsnError = CloudflareOpError;
/** Gets an overview of the Autonomous System Number (ASN) and a list of subnets for it. */
export const getAsn: API.OperationMethod<
  GetAsnRequest,
  GetAsnResponse,
  GetAsnError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetAsnRequest,
  output: GetAsnResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetAsnSubnetError = CloudflareOpError;
/** Get ASN Subnets. */
export const getAsnSubnet: API.OperationMethod<
  GetAsnSubnetRequest,
  GetAsnSubnetResponse,
  GetAsnSubnetError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetAsnSubnetRequest,
  output: GetAsnSubnetResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetAttackSurfaceReportIssueTypeError = CloudflareOpError;
/** Lists all available issue types in Security Center, describing categories of security issues. */
export const getAttackSurfaceReportIssueType: API.PaginatedOperationMethod<
  GetAttackSurfaceReportIssueTypeRequest,
  GetAttackSurfaceReportIssueTypeResponse,
  GetAttackSurfaceReportIssueTypeError,
  CloudflareOpContext,
  string
> = /*@__PURE__*/ API.makePaginated(
  () => ({
    input: GetAttackSurfaceReportIssueTypeRequest,
    output: GetAttackSurfaceReportIssueTypeResponse,
    errors: [CloudflareRateLimited, CloudflareError],
    protocol: CloudflarePaginatedProtocol,
    retry: Retry.Retry,
    pagination: { mode: "single", items: "result" } as const,
  }),
  cloudflarePaginate,
) as any;

export type GetDomainError = CloudflareOpError;
/** Gets security details and statistics about a domain. */
export const getDomain: API.OperationMethod<
  GetDomainRequest,
  GetDomainResponse,
  GetDomainError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetDomainRequest,
  output: GetDomainResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetDomainBulkError = CloudflareOpError;
/** Returns security details and statistics about multiple domains in a single request. **Behavior change — domain ranking is becoming opt-in.** This endpoint previously included domain ranking data in every response and accepted a `skip_ranking=true` query parameter to opt out. That parameter is being deprecated and ranking will no longer be returned by default. Callers that want ranking data must pass `include_ranking=true`. The `skip_ranking` parameter will be silently ignored once the change ships. */
export const getDomainBulk: API.OperationMethod<
  GetDomainBulkRequest,
  GetDomainBulkResponse,
  GetDomainBulkError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetDomainBulkRequest,
  output: GetDomainBulkResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetDomainHistoryError = CloudflareOpError;
/** Gets historical security threat and content categories currently and previously assigned to a domain. */
export const getDomainHistory: API.OperationMethod<
  GetDomainHistoryRequest,
  GetDomainHistoryResponse,
  GetDomainHistoryError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetDomainHistoryRequest,
  output: GetDomainHistoryResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetIndicatorFeedError =
  | IndicatorFeedNotFound
  | Forbidden
  | CloudflareOpError;
/** Retrieves details for a specific custom threat indicator feed. */
export const getIndicatorFeed: API.OperationMethod<
  GetIndicatorFeedRequest,
  GetIndicatorFeedResponse,
  GetIndicatorFeedError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetIndicatorFeedRequest,
  output: GetIndicatorFeedResponse,
  errors: [
    IndicatorFeedNotFound,
    Forbidden,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetIpError = CloudflareOpError;
/** Gets the geolocation, ASN, infrastructure type of the ASN, and any security threat categories of an IP address. **Must provide ip query parameters.** For example, `/intel/ip?ipv4=1.1.1.1` or `/intel/ip?ipv6=2001:db8::1`. */
export const getIp: API.OperationMethod<
  GetIpRequest,
  GetIpResponse,
  GetIpError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetIpRequest,
  output: GetIpResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetWhoiError = CloudflareOpError;
/** Retrieves WHOIS registration data for a domain, including registrant and nameserver information. */
export const getWhoi: API.OperationMethod<
  GetWhoiRequest,
  GetWhoiResponse,
  GetWhoiError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetWhoiRequest,
  output: GetWhoiResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type ListAttackSurfaceReportIssuesError = CloudflareOpError;
/** Lists all Security Center issues for the account, showing active security problems requiring attention. */
export const listAttackSurfaceReportIssues: API.OperationMethod<
  ListAttackSurfaceReportIssuesRequest,
  ListAttackSurfaceReportIssuesResponse,
  ListAttackSurfaceReportIssuesError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: ListAttackSurfaceReportIssuesRequest,
  output: ListAttackSurfaceReportIssuesResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type ListDnsError = CloudflareOpError;
/** Gets a list of all the domains that have resolved to a specific IP address. */
export const listDns: API.OperationMethod<
  ListDnsRequest,
  ListDnsResponse,
  ListDnsError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: ListDnsRequest,
  output: ListDnsResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type ListIndicatorFeedPermissionsError = Forbidden | CloudflareOpError;
/** Lists current access permissions for custom threat indicator feeds. */
export const listIndicatorFeedPermissions: API.OperationMethod<
  ListIndicatorFeedPermissionsRequest,
  ListIndicatorFeedPermissionsResponse,
  ListIndicatorFeedPermissionsError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: ListIndicatorFeedPermissionsRequest,
  output: ListIndicatorFeedPermissionsResponse,
  errors: [Forbidden, CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type ListIndicatorFeedsError = Forbidden | CloudflareOpError;
/** Retrieves details for all accessible custom threat indicator feeds. */
export const listIndicatorFeeds: API.PaginatedOperationMethod<
  ListIndicatorFeedsRequest,
  ListIndicatorFeedsResponse,
  ListIndicatorFeedsError,
  CloudflareOpContext,
  IndicatorFeedsListResultItem
> = /*@__PURE__*/ API.makePaginated(
  () => ({
    input: ListIndicatorFeedsRequest,
    output: ListIndicatorFeedsResponse,
    errors: [Forbidden, CloudflareRateLimited, CloudflareError],
    protocol: CloudflarePaginatedProtocol,
    retry: Retry.Retry,
    pagination: { mode: "single", items: "result" } as const,
  }),
  cloudflarePaginate,
) as any;

export type ListSinkholesError = CloudflareOpError;
/** Lists sinkholes owned by the account for redirecting malicious traffic. */
export const listSinkholes: API.PaginatedOperationMethod<
  ListSinkholesRequest,
  ListSinkholesResponse,
  ListSinkholesError,
  CloudflareOpContext,
  SinkholesListResultItem
> = /*@__PURE__*/ API.makePaginated(
  () => ({
    input: ListSinkholesRequest,
    output: ListSinkholesResponse,
    errors: [CloudflareRateLimited, CloudflareError],
    protocol: CloudflarePaginatedProtocol,
    retry: Retry.Retry,
    pagination: { mode: "single", items: "result" } as const,
  }),
  cloudflarePaginate,
) as any;

export type PutIndicatorFeedSnapshotError =
  | IndicatorFeedNotFound
  | Forbidden
  | CloudflareOpError;
/** Revises the raw data entries in a custom threat indicator feed. Accepts both plain and gzipped STIX2/CRDF bodies. Gzip is detected by RFC 1952 magic bytes (`0x1f 0x8b`) and/or a `.gz` filename suffix (case-insensitive) — either signal alone is sufficient to trigger the gzip path; if the body is not valid gzip, the upload fails fast. Customers are encouraged to gzip larger uploads — the api-gateway 500 MB body cap applies to the on-the-wire (compressed) size, so gzip lets a single upload carry several GiB of decompressed STIX. */
export const putIndicatorFeedSnapshot: API.OperationMethod<
  PutIndicatorFeedSnapshotRequest,
  PutIndicatorFeedSnapshotResponse,
  PutIndicatorFeedSnapshotError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: PutIndicatorFeedSnapshotRequest,
  output: PutIndicatorFeedSnapshotResponse,
  errors: [
    IndicatorFeedNotFound,
    Forbidden,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type SeverityAttackSurfaceReportIssueError = CloudflareOpError;
/** Retrieves Security Center issue counts aggregated by severity level. */
export const severityAttackSurfaceReportIssue: API.OperationMethod<
  SeverityAttackSurfaceReportIssueRequest,
  SeverityAttackSurfaceReportIssueResponse,
  SeverityAttackSurfaceReportIssueError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: SeverityAttackSurfaceReportIssueRequest,
  output: SeverityAttackSurfaceReportIssueResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type TypeAttackSurfaceReportIssueError = CloudflareOpError;
/** Retrieves Security Center issue counts aggregated by issue type. */
export const typeAttackSurfaceReportIssue: API.OperationMethod<
  TypeAttackSurfaceReportIssueRequest,
  TypeAttackSurfaceReportIssueResponse,
  TypeAttackSurfaceReportIssueError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: TypeAttackSurfaceReportIssueRequest,
  output: TypeAttackSurfaceReportIssueResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type UpdateIndicatorFeedError =
  | IndicatorFeedNotFound
  | Forbidden
  | CloudflareOpError;
/** Revises details for a specific custom threat indicator feed. */
export const updateIndicatorFeed: API.OperationMethod<
  UpdateIndicatorFeedRequest,
  UpdateIndicatorFeedResponse,
  UpdateIndicatorFeedError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: UpdateIndicatorFeedRequest,
  output: UpdateIndicatorFeedResponse,
  errors: [
    IndicatorFeedNotFound,
    Forbidden,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));