// 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>> = {
  accountId: "account_id",
  anniversaryDate: "anniversary_date",
  completedAfter: "completed_after",
  completedBefore: "completed_before",
  contentType: "content_type",
  createdAfter: "created_after",
  createdBefore: "created_before",
  documentationUrl: "documentation_url",
  fileType: "file_type",
  messageTokens: "message_tokens",
  perPage: "per_page",
  quarterAnniversaryDate: "quarter_anniversary_date",
  readableId: "readable_id",
  requestType: "request_type",
  sortBy: "sort_by",
  sortOrder: "sort_order",
};

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

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

export interface ThreatEventsBulkCreateRequestDataItemRaw {
  data: ThreatEventsBulkCreateRequestDataItemRawDataMap;
  source?: string;
  tlp?: string;
}
export const ThreatEventsBulkCreateRequestDataItemRaw = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      data: ThreatEventsBulkCreateRequestDataItemRawDataMap,
      source: S.optional(S.String),
      tlp: S.optional(S.String),
    }),
).annotate({
  identifier: "ThreatEventsBulkCreateRequestDataItemRaw",
}) as any as S.Schema<ThreatEventsBulkCreateRequestDataItemRaw>;

export interface ThreatEventsBulkCreateRequestDataItemIndicatorsItem {
  /** The type of indicator (e.g., DOMAIN, IP, JA3, HASH) */
  indicatorType: string;
  /** The indicator value (e.g., domain name, IP address, hash) */
  value: string;
}
export const ThreatEventsBulkCreateRequestDataItemIndicatorsItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      indicatorType: S.String,
      value: S.String,
    }),
  ).annotate({
    identifier: "ThreatEventsBulkCreateRequestDataItemIndicatorsItem",
  }) as any as S.Schema<ThreatEventsBulkCreateRequestDataItemIndicatorsItem>;

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

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

export interface ThreatEventsBulkCreateRequestDataItem {
  category: string;
  date: string;
  event: string;
  raw: ThreatEventsBulkCreateRequestDataItemRaw;
  tlp: string;
  accountId?: number;
  attacker?: string;
  attackerCountry?: string;
  datasetId?: string;
  indicator?: string;
  /** Array of indicators for this event. Supports multiple indicators per event for complex scenarios. */
  indicators?: ThreatEventsBulkCreateRequestDataItemIndicatorsList;
  indicatorType?: string;
  insight?: string;
  tags?: ThreatEventsBulkCreateRequestDataItemTagsList;
  targetCountry?: string;
  targetIndustry?: string;
}
export const ThreatEventsBulkCreateRequestDataItem = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      category: S.String,
      date: S.String,
      event: S.String,
      raw: ThreatEventsBulkCreateRequestDataItemRaw,
      tlp: S.String,
      accountId: S.optional(S.Number),
      attacker: S.optional(S.String),
      attackerCountry: S.optional(S.String),
      datasetId: S.optional(S.String),
      indicator: S.optional(S.String),
      indicators: S.optional(
        ThreatEventsBulkCreateRequestDataItemIndicatorsList,
      ),
      indicatorType: S.optional(S.String),
      insight: S.optional(S.String),
      tags: S.optional(ThreatEventsBulkCreateRequestDataItemTagsList),
      targetCountry: S.optional(S.String),
      targetIndustry: S.optional(S.String),
    }),
).annotate({
  identifier: "ThreatEventsBulkCreateRequestDataItem",
}) as any as S.Schema<ThreatEventsBulkCreateRequestDataItem>;

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

export interface BulkCreateThreatEventsRequest {
  /** Account ID. */
  accountId: string;
  data: ThreatEventsBulkCreateRequestDataList;
  datasetId: string;
  /** When true, response includes array of created event UUIDs and shard IDs. Useful for tracking which events were created and where. */
  includeCreatedEvents?: boolean;
}
export const BulkCreateThreatEventsRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    data: ThreatEventsBulkCreateRequestDataList,
    datasetId: S.String,
    includeCreatedEvents: S.optional(S.Boolean),
  })
    .pipe(
      T.Http({
        method: "POST",
        uri: "/accounts/{account_id}/cloudforce-one/events/create/bulk",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "BulkCreateThreatEventsRequest",
}) as any as S.Schema<BulkCreateThreatEventsRequest>;

export interface ThreatEventsBulkCreateResponseCreatedEventsItem {
  /** Original index in the input data array */
  eventIndex: number;
  /** Dataset ID of the shard where the event was created */
  shardId: string;
  /** UUID of the created event */
  uuid: string;
}
export const ThreatEventsBulkCreateResponseCreatedEventsItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      eventIndex: S.Number,
      shardId: S.String,
      uuid: S.String,
    }),
  ).annotate({
    identifier: "ThreatEventsBulkCreateResponseCreatedEventsItem",
  }) as any as S.Schema<ThreatEventsBulkCreateResponseCreatedEventsItem>;

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

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface BulkCreateThreatEventsResponse {
  /** Number of events created */
  createdEventsCount: number;
  /** Number of new tags created in SoT */
  createdTagsCount: number;
  /** Number of errors encountered */
  errorCount: number;
  /** Number of indicators queued for async processing */
  queuedIndicatorsCount: number;
  /** Correlation ID for async indicator processing */
  createBulkEventsRequestId?: string | null;
  /** Array of created events with UUIDs and shard locations. Only present when includeCreatedEvents=true */
  createdEvents?: ThreatEventsBulkCreateResponseCreatedEventsList | null;
}
export const BulkCreateThreatEventsResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    createdEventsCount: S.Number,
    createdTagsCount: S.Number,
    errorCount: S.Number,
    queuedIndicatorsCount: S.Number,
    createBulkEventsRequestId: S.optional(S.NullOr(S.String)),
    createdEvents: S.optional(
      S.NullOr(ThreatEventsBulkCreateResponseCreatedEventsList),
    ),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "BulkCreateThreatEventsResponse",
}) as any as S.Schema<BulkCreateThreatEventsResponse>;

export interface CreateBinaryStorageRequest {
  /** Account ID. */
  accountId: string;
}
export const CreateBinaryStorageRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
  })
    .pipe(
      T.Http({
        method: "POST",
        uri: "/accounts/{account_id}/cloudforce-one/binary",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateBinaryStorageRequest",
}) as any as S.Schema<CreateBinaryStorageRequest>;

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

export type RequestsCreateRequestTlp =
  | "clear"
  | "amber"
  | "amber-strict"
  | "green"
  | "red";
export const RequestsCreateRequestTlp = /*@__PURE__*/ S.String;

export interface CreateRequestRequest {
  /** Identifier. */
  accountId: string;
  /** Request content. */
  content?: string;
  /** Priority for analyzing the request. */
  priority?: string;
  /** Requested information from request. */
  requestType?: string;
  /** Brief description of the request. */
  summary?: string;
  /** The CISA defined Traffic Light Protocol (TLP). */
  tlp?: RequestsCreateRequestTlp | (string & {});
}
export const CreateRequestRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    content: S.optional(S.String),
    priority: S.optional(S.String),
    requestType: S.optional(S.String.pipe(T.Body("request_type"))),
    summary: S.optional(S.String),
    tlp: S.optional(RequestsCreateRequestTlp),
  })
    .pipe(
      T.Http({
        method: "POST",
        uri: "/accounts/{account_id}/cloudforce-one/requests/new",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateRequestRequest",
}) as any as S.Schema<CreateRequestRequest>;

export type RequestsCreateResponseTlp =
  | "clear"
  | "amber"
  | "amber-strict"
  | "green"
  | "red";
export const RequestsCreateResponseTlp = /*@__PURE__*/ S.String;

export type RequestsCreateResponseStatus =
  | "open"
  | "accepted"
  | "reported"
  | "approved"
  | "completed"
  | "declined";
export const RequestsCreateResponseStatus = /*@__PURE__*/ S.String;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface CreateRequestResponse {
  /** UUID. */
  id: string;
  /** Request content. */
  content: string;
  created: string;
  priority: string;
  /** Requested information from request. */
  request: string;
  /** Brief description of the request. */
  summary: string;
  /** The CISA defined Traffic Light Protocol (TLP). */
  tlp: RequestsCreateResponseTlp;
  updated: string;
  completed?: string | null;
  /** Tokens for the request messages. */
  messageTokens?: number | null;
  /** Readable Request ID. */
  readableId?: string | null;
  /** Request Status. */
  status?: RequestsCreateResponseStatus | null;
  /** Tokens for the request. */
  tokens?: number | null;
}
export const CreateRequestResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    content: S.String,
    created: S.String,
    priority: S.String,
    request: S.String,
    summary: S.String,
    tlp: RequestsCreateResponseTlp,
    updated: S.String,
    completed: S.optional(S.NullOr(S.String)),
    messageTokens: S.optional(
      S.NullOr(S.Number).pipe(T.Body("message_tokens")),
    ),
    readableId: S.optional(S.NullOr(S.String).pipe(T.Body("readable_id"))),
    status: S.optional(S.NullOr(RequestsCreateResponseStatus)),
    tokens: S.optional(S.NullOr(S.Number)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateRequestResponse",
}) as any as S.Schema<CreateRequestResponse>;

export interface CreateRequestAssetRequest {
  /** Identifier. */
  accountId: string;
  /** UUID. */
  requestId: string;
  /** Page number of results. */
  page: number;
  /** Number of results per page. */
  perPage: number;
}
export const CreateRequestAssetRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    requestId: S.String.pipe(T.Label("request_id")),
    page: S.Number,
    perPage: S.Number.pipe(T.Body("per_page")),
  })
    .pipe(
      T.Http({
        method: "POST",
        uri: "/accounts/{account_id}/cloudforce-one/requests/{request_id}/asset",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateRequestAssetRequest",
}) as any as S.Schema<CreateRequestAssetRequest>;

export interface RequestsAssetsCreateResultItem {
  /** Asset ID. */
  id: number;
  /** Asset name. */
  name: string;
  /** Defines the asset creation time. */
  created?: string | null;
  /** Asset description. */
  description?: string | null;
  /** Asset file type. */
  fileType?: string | null;
}
export const RequestsAssetsCreateResultItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.Number,
    name: S.String,
    created: S.optional(S.NullOr(S.String)),
    description: S.optional(S.NullOr(S.String)),
    fileType: S.optional(S.NullOr(S.String).pipe(T.Body("file_type"))),
  }),
).annotate({
  identifier: "RequestsAssetsCreateResultItem",
}) as any as S.Schema<RequestsAssetsCreateResultItem>;

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

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

export interface CreateRequestMessageRequest {
  /** Identifier. */
  accountId: string;
  /** UUID. */
  requestId: string;
  /** Content of message. */
  content?: string;
}
export const CreateRequestMessageRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    requestId: S.String.pipe(T.Label("request_id")),
    content: S.optional(S.String),
  })
    .pipe(
      T.Http({
        method: "POST",
        uri: "/accounts/{account_id}/cloudforce-one/requests/{request_id}/message/new",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateRequestMessageRequest",
}) as any as S.Schema<CreateRequestMessageRequest>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface CreateRequestMessageResponse {
  /** Message ID. */
  id: number;
  /** Author of message. */
  author: string;
  /** Content of message. */
  content: string;
  /** Whether the message is a follow-on request. */
  isFollowOnRequest: boolean;
  /** Defines the message last updated time. */
  updated: string;
  /** Defines the message creation time. */
  created?: string | null;
}
export const CreateRequestMessageResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.Number,
    author: S.String,
    content: S.String,
    isFollowOnRequest: S.Boolean.pipe(T.Body("is_follow_on_request")),
    updated: S.String,
    created: S.optional(S.NullOr(S.String)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateRequestMessageResponse",
}) as any as S.Schema<CreateRequestMessageResponse>;

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

export type RequestsPriorityCreateRequestTlp =
  | "clear"
  | "amber"
  | "amber-strict"
  | "green"
  | "red";
export const RequestsPriorityCreateRequestTlp = /*@__PURE__*/ S.String;

export interface CreateRequestPriorityRequest {
  /** Identifier. */
  accountId: string;
  /** List of labels. */
  labels: RequestsPriorityCreateRequestLabelsList;
  /** Priority. */
  priority: number;
  /** Requirement. */
  requirement: string;
  /** The CISA defined Traffic Light Protocol (TLP). */
  tlp: RequestsPriorityCreateRequestTlp | (string & {});
}
export const CreateRequestPriorityRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    labels: RequestsPriorityCreateRequestLabelsList,
    priority: S.Number,
    requirement: S.String,
    tlp: RequestsPriorityCreateRequestTlp,
  })
    .pipe(
      T.Http({
        method: "POST",
        uri: "/accounts/{account_id}/cloudforce-one/requests/priority/new",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateRequestPriorityRequest",
}) as any as S.Schema<CreateRequestPriorityRequest>;

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

export type RequestsPriorityCreateResponseTlp =
  | "clear"
  | "amber"
  | "amber-strict"
  | "green"
  | "red";
export const RequestsPriorityCreateResponseTlp = /*@__PURE__*/ S.String;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface CreateRequestPriorityResponse {
  /** UUID. */
  id: string;
  /** Priority creation time. */
  created: string;
  /** List of labels. */
  labels: RequestsPriorityCreateResponseLabelsList;
  /** Priority. */
  priority: number;
  /** Requirement. */
  requirement: string;
  /** The CISA defined Traffic Light Protocol (TLP). */
  tlp: RequestsPriorityCreateResponseTlp;
  /** Priority last updated time. */
  updated: string;
}
export const CreateRequestPriorityResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    created: S.String,
    labels: RequestsPriorityCreateResponseLabelsList,
    priority: S.Number,
    requirement: S.String,
    tlp: RequestsPriorityCreateResponseTlp,
    updated: S.String,
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateRequestPriorityResponse",
}) as any as S.Schema<CreateRequestPriorityResponse>;

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

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

export interface CreateScanConfigRequest {
  /** Defines the Account ID. */
  accountId: string;
  /** Defines a list of IP addresses or CIDR blocks to scan. The maximum number of total IP addresses allowed is 5000. */
  ips: ScansConfigCreateRequestIpsList;
  /** Defines the number of days between each scan (0 = One-off scan). */
  frequency?: number;
  /** Defines a list of ports to scan. Valid values are:"default", "all", or a comma-separated list of ports or range of ports (e.g. ["1-80", "443"]). "default" scans the 100 most commonly open ports. */
  ports?: ScansConfigCreateRequestPortsList;
}
export const CreateScanConfigRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    ips: ScansConfigCreateRequestIpsList,
    frequency: S.optional(S.Number),
    ports: S.optional(ScansConfigCreateRequestPortsList),
  })
    .pipe(
      T.Http({
        method: "POST",
        uri: "/accounts/{account_id}/cloudforce-one/scans/config",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateScanConfigRequest",
}) as any as S.Schema<CreateScanConfigRequest>;

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

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

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface CreateScanConfigResponse {
  /** Defines the Config ID. */
  id: string;
  accountId: string;
  /** Defines the number of days between each scan (0 = One-off scan). */
  frequency: number;
  /** Defines a list of IP addresses or CIDR blocks to scan. The maximum number of total IP addresses allowed is 5000. */
  ips: ScansConfigCreateResponseIpsList;
  /** Defines a list of ports to scan. Valid values are:"default", "all", or a comma-separated list of ports or range of ports (e.g. ["1-80", "443"]). "default" scans the 100 most commonly open ports. */
  ports: ScansConfigCreateResponsePortsList;
}
export const CreateScanConfigResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    accountId: S.String.pipe(T.Body("account_id")),
    frequency: S.Number,
    ips: ScansConfigCreateResponseIpsList,
    ports: ScansConfigCreateResponsePortsList,
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateScanConfigResponse",
}) as any as S.Schema<CreateScanConfigResponse>;

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

export interface ThreatEventsCreateRequestRaw {
  data: ThreatEventsCreateRequestRawDataMap;
  source?: string;
  tlp?: string;
}
export const ThreatEventsCreateRequestRaw = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    data: ThreatEventsCreateRequestRawDataMap,
    source: S.optional(S.String),
    tlp: S.optional(S.String),
  }),
).annotate({
  identifier: "ThreatEventsCreateRequestRaw",
}) as any as S.Schema<ThreatEventsCreateRequestRaw>;

export type ThreatEventsCreateRequestIndicatorsItem =
  ThreatEventsBulkCreateRequestDataItemIndicatorsItem;
export const ThreatEventsCreateRequestIndicatorsItem =
  ThreatEventsBulkCreateRequestDataItemIndicatorsItem;

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

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

export interface CreateThreatEventRequest {
  /** Account ID. */
  accountId: string;
  category: string;
  date: string;
  event: string;
  raw: ThreatEventsCreateRequestRaw;
  tlp: string;
  attacker?: string;
  attackerCountry?: string;
  datasetId?: string;
  indicator?: string;
  /** Array of indicators for this event. Supports multiple indicators per event for complex scenarios. */
  indicators?: ThreatEventsCreateRequestIndicatorsList;
  indicatorType?: string;
  insight?: string;
  tags?: ThreatEventsCreateRequestTagsList;
  targetCountry?: string;
  targetIndustry?: string;
}
export const CreateThreatEventRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    category: S.String,
    date: S.String,
    event: S.String,
    raw: ThreatEventsCreateRequestRaw,
    tlp: S.String,
    attacker: S.optional(S.String),
    attackerCountry: S.optional(S.String),
    datasetId: S.optional(S.String),
    indicator: S.optional(S.String),
    indicators: S.optional(ThreatEventsCreateRequestIndicatorsList),
    indicatorType: S.optional(S.String),
    insight: S.optional(S.String),
    tags: S.optional(ThreatEventsCreateRequestTagsList),
    targetCountry: S.optional(S.String),
    targetIndustry: S.optional(S.String),
  })
    .pipe(
      T.Http({
        method: "POST",
        uri: "/accounts/{account_id}/cloudforce-one/events/create",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateThreatEventRequest",
}) as any as S.Schema<CreateThreatEventRequest>;

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

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

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

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

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

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

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

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface CreateThreatEventResponse {
  attacker: string;
  attackerCountry: string;
  attackerCountryAlpha3: string;
  category: string;
  datasetId: string;
  date: string;
  event: string;
  hasChildren: boolean;
  indicator: string;
  indicatorType: string;
  indicatorTypeId: number;
  killChain: number;
  mitreAttack: ThreatEventsCreateResponseMitreAttackList;
  mitreCapec: ThreatEventsCreateResponseMitreCapecList;
  numReferenced: number;
  numReferences: number;
  rawId: string;
  referenced: ThreatEventsCreateResponseReferencedList;
  referencedIds: ThreatEventsCreateResponseReferencedIdsList;
  references: ThreatEventsCreateResponseReferencesList;
  referencesIds: ThreatEventsCreateResponseReferencesIdsList;
  tags: ThreatEventsCreateResponseTagsList;
  targetCountry: string;
  targetCountryAlpha3: string;
  targetIndustry: string;
  tlp: string;
  uuid: string;
  insight?: string | null;
  releasabilityId?: string | null;
}
export const CreateThreatEventResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    attacker: S.String,
    attackerCountry: S.String,
    attackerCountryAlpha3: S.String,
    category: S.String,
    datasetId: S.String,
    date: S.String,
    event: S.String,
    hasChildren: S.Boolean,
    indicator: S.String,
    indicatorType: S.String,
    indicatorTypeId: S.Number,
    killChain: S.Number,
    mitreAttack: ThreatEventsCreateResponseMitreAttackList,
    mitreCapec: ThreatEventsCreateResponseMitreCapecList,
    numReferenced: S.Number,
    numReferences: S.Number,
    rawId: S.String,
    referenced: ThreatEventsCreateResponseReferencedList,
    referencedIds: ThreatEventsCreateResponseReferencedIdsList,
    references: ThreatEventsCreateResponseReferencesList,
    referencesIds: ThreatEventsCreateResponseReferencesIdsList,
    tags: ThreatEventsCreateResponseTagsList,
    targetCountry: S.String,
    targetCountryAlpha3: S.String,
    targetIndustry: S.String,
    tlp: S.String,
    uuid: S.String,
    insight: S.optional(S.NullOr(S.String)),
    releasabilityId: S.optional(S.NullOr(S.String)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateThreatEventResponse",
}) as any as S.Schema<CreateThreatEventResponse>;

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

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

export interface CreateThreatEventCategoryRequest {
  /** Account ID. */
  accountId: string;
  killChain: number;
  name: string;
  mitreAttack?: ThreatEventsCategoriesCreateRequestMitreAttackList;
  mitreCapec?: ThreatEventsCategoriesCreateRequestMitreCapecList;
  shortname?: string;
}
export const CreateThreatEventCategoryRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    killChain: S.Number,
    name: S.String,
    mitreAttack: S.optional(ThreatEventsCategoriesCreateRequestMitreAttackList),
    mitreCapec: S.optional(ThreatEventsCategoriesCreateRequestMitreCapecList),
    shortname: S.optional(S.String),
  })
    .pipe(
      T.Http({
        method: "POST",
        uri: "/accounts/{account_id}/cloudforce-one/events/categories/create",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateThreatEventCategoryRequest",
}) as any as S.Schema<CreateThreatEventCategoryRequest>;

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

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

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface CreateThreatEventCategoryResponse {
  killChain: number;
  name: string;
  uuid: string;
  mitreAttack?: ThreatEventsCategoriesCreateResponseMitreAttackList | null;
  mitreCapec?: ThreatEventsCategoriesCreateResponseMitreCapecList | null;
  shortname?: string | null;
}
export const CreateThreatEventCategoryResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    killChain: S.Number,
    name: S.String,
    uuid: S.String,
    mitreAttack: S.optional(
      S.NullOr(ThreatEventsCategoriesCreateResponseMitreAttackList),
    ),
    mitreCapec: S.optional(
      S.NullOr(ThreatEventsCategoriesCreateResponseMitreCapecList),
    ),
    shortname: S.optional(S.NullOr(S.String)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateThreatEventCategoryResponse",
}) as any as S.Schema<CreateThreatEventCategoryResponse>;

export interface CreateThreatEventDatasetRequest {
  /** Account ID. */
  accountId: string;
  /** If true, then anyone can search the dataset. If false, then its limited to the account. */
  isPublic: boolean;
  /** Used to describe the dataset within the account context. */
  name: string;
}
export const CreateThreatEventDatasetRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    isPublic: S.Boolean,
    name: S.String,
  })
    .pipe(
      T.Http({
        method: "POST",
        uri: "/accounts/{account_id}/cloudforce-one/events/dataset/create",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateThreatEventDatasetRequest",
}) as any as S.Schema<CreateThreatEventDatasetRequest>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface CreateThreatEventDatasetResponse {
  isPublic: boolean;
  name: string;
  uuid: string;
  deletedAt?: string | null;
}
export const CreateThreatEventDatasetResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    isPublic: S.Boolean,
    name: S.String,
    uuid: S.String,
    deletedAt: S.optional(S.NullOr(S.String)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateThreatEventDatasetResponse",
}) as any as S.Schema<CreateThreatEventDatasetResponse>;

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

export interface CreateThreatEventEventTagRequest {
  /** Account ID. */
  accountId: string;
  /** Event UUID. */
  eventId: string;
  tags: ThreatEventsEventTagsCreateRequestTagsList;
}
export const CreateThreatEventEventTagRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    eventId: S.String.pipe(T.Label("event_id")),
    tags: ThreatEventsEventTagsCreateRequestTagsList,
  })
    .pipe(
      T.Http({
        method: "POST",
        uri: "/accounts/{account_id}/cloudforce-one/events/event_tag/{event_id}/create",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateThreatEventEventTagRequest",
}) as any as S.Schema<CreateThreatEventEventTagRequest>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface CreateThreatEventEventTagResponse {
  success: boolean;
}
export const CreateThreatEventEventTagResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    success: S.Boolean,
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateThreatEventEventTagResponse",
}) as any as S.Schema<CreateThreatEventEventTagResponse>;

export type ThreatEventsTagsCreateRequestAliasesItemTlp =
  | "red"
  | "amber"
  | "green"
  | "white";
export const ThreatEventsTagsCreateRequestAliasesItemTlp =
  /*@__PURE__*/ S.String;

export interface ThreatEventsTagsCreateRequestAliasesItem {
  value: string;
  confidence?: number;
  tlp?: ThreatEventsTagsCreateRequestAliasesItemTlp | (string & {});
}
export const ThreatEventsTagsCreateRequestAliasesItem = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      value: S.String,
      confidence: S.optional(S.Number),
      tlp: S.optional(ThreatEventsTagsCreateRequestAliasesItemTlp),
    }),
).annotate({
  identifier: "ThreatEventsTagsCreateRequestAliasesItem",
}) as any as S.Schema<ThreatEventsTagsCreateRequestAliasesItem>;

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

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

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

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

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

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

export type ThreatEventsTagsCreateRequestInternalAliasesItemTlp =
  | "red"
  | "amber"
  | "green"
  | "white";
export const ThreatEventsTagsCreateRequestInternalAliasesItemTlp =
  /*@__PURE__*/ S.String;

export interface ThreatEventsTagsCreateRequestInternalAliasesItem {
  value: string;
  confidence?: number;
  tlp?: ThreatEventsTagsCreateRequestInternalAliasesItemTlp | (string & {});
}
export const ThreatEventsTagsCreateRequestInternalAliasesItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      value: S.String,
      confidence: S.optional(S.Number),
      tlp: S.optional(ThreatEventsTagsCreateRequestInternalAliasesItemTlp),
    }),
  ).annotate({
    identifier: "ThreatEventsTagsCreateRequestInternalAliasesItem",
  }) as any as S.Schema<ThreatEventsTagsCreateRequestInternalAliasesItem>;

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

export type ThreatEventsTagsCreateRequestOriginCountryTlp =
  | "red"
  | "amber"
  | "green"
  | "white";
export const ThreatEventsTagsCreateRequestOriginCountryTlp =
  /*@__PURE__*/ S.String;

export interface CreateThreatEventTagRequest {
  /** Account ID. */
  accountId: string;
  value: string;
  activeDuration?: string;
  /** Actor variety. Allowed values: Activist, Competitor, Customer, Crime Syndicate, Former Employee, Nation State, Organized Crime, Nation State Affiliated, Terrorist, Unaffiliated. */
  actorCategory?: string;
  /** Confidence (1-10) in the actor variety (actorCategory). CFONE-only: stripped from responses to non-CFONE accounts. */
  actorCategoryConfidence?: number;
  /** Structured aliases ({ value, confidence 1-10, tlp }). CFONE-only: stripped from responses to non-CFONE accounts. */
  aliases?: ThreatEventsTagsCreateRequestAliasesList;
  aliasGroupNames?: ThreatEventsTagsCreateRequestAliasGroupNamesList;
  aliasGroupNamesInternal?: ThreatEventsTagsCreateRequestAliasGroupNamesInternalList;
  analyticPriority?: number;
  attributionConfidence?: string;
  attributionConfidenceScore?: number;
  attributionOrganization?: string;
  categoryUuid?: string;
  /** Date the actor was discovered (ISO YYYY-MM-DD). */
  dateOfDiscovery?: string;
  externalReferenceLinks?: ThreatEventsTagsCreateRequestExternalReferenceLinksList;
  /** Structured external references ({ url, description }). Public: returned to all accounts. */
  externalReferences?: ThreatEventsTagsCreateRequestExternalReferencesList;
  /** Internal structured aliases ({ value, confidence 1-10, tlp }). CFONE-only: never returned to non-CFONE accounts. */
  internalAliases?: ThreatEventsTagsCreateRequestInternalAliasesList;
  internalDescription?: string;
  /** Actor motive. Allowed values: Convenience, Fear, Fun, Financial, Grudge, Ideology, Espionage. */
  motive?: string;
  /** Confidence (1-10) in the actor motive. CFONE-only: stripped from responses to non-CFONE accounts. */
  motiveConfidence?: number;
  opsecLevel?: string;
  /** Confidence (1-10) in the origin-country attribution. CFONE-only: stripped from responses to non-CFONE accounts. */
  originCountryConfidence?: number;
  originCountryISO?: string;
  /** TLP marking for the origin-country attribution. CFONE-only: stripped from responses to non-CFONE accounts. */
  originCountryTlp?:
    | ThreatEventsTagsCreateRequestOriginCountryTlp
    | (string & {});
  priority?: number;
  sophisticationLevel?: string;
}
export const CreateThreatEventTagRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    value: S.String,
    activeDuration: S.optional(S.String),
    actorCategory: S.optional(S.String),
    actorCategoryConfidence: S.optional(S.Number),
    aliases: S.optional(ThreatEventsTagsCreateRequestAliasesList),
    aliasGroupNames: S.optional(
      ThreatEventsTagsCreateRequestAliasGroupNamesList,
    ),
    aliasGroupNamesInternal: S.optional(
      ThreatEventsTagsCreateRequestAliasGroupNamesInternalList,
    ),
    analyticPriority: S.optional(S.Number),
    attributionConfidence: S.optional(S.String),
    attributionConfidenceScore: S.optional(S.Number),
    attributionOrganization: S.optional(S.String),
    categoryUuid: S.optional(S.String),
    dateOfDiscovery: S.optional(S.String),
    externalReferenceLinks: S.optional(
      ThreatEventsTagsCreateRequestExternalReferenceLinksList,
    ),
    externalReferences: S.optional(
      ThreatEventsTagsCreateRequestExternalReferencesList,
    ),
    internalAliases: S.optional(
      ThreatEventsTagsCreateRequestInternalAliasesList,
    ),
    internalDescription: S.optional(S.String),
    motive: S.optional(S.String),
    motiveConfidence: S.optional(S.Number),
    opsecLevel: S.optional(S.String),
    originCountryConfidence: S.optional(S.Number),
    originCountryISO: S.optional(S.String),
    originCountryTlp: S.optional(ThreatEventsTagsCreateRequestOriginCountryTlp),
    priority: S.optional(S.Number),
    sophisticationLevel: S.optional(S.String),
  })
    .pipe(
      T.Http({
        method: "POST",
        uri: "/accounts/{account_id}/cloudforce-one/events/tags/create",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateThreatEventTagRequest",
}) as any as S.Schema<CreateThreatEventTagRequest>;

export type ThreatEventsTagsCreateResponseAliasesItemTlp =
  | "red"
  | "amber"
  | "green"
  | "white";
export const ThreatEventsTagsCreateResponseAliasesItemTlp =
  /*@__PURE__*/ S.String;

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

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

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

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

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

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

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

export type ThreatEventsTagsCreateResponseInternalAliasesItemTlp =
  | "red"
  | "amber"
  | "green"
  | "white";
export const ThreatEventsTagsCreateResponseInternalAliasesItemTlp =
  /*@__PURE__*/ S.String;

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

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

export type ThreatEventsTagsCreateResponseOriginCountryTlp =
  | "red"
  | "amber"
  | "green"
  | "white";
export const ThreatEventsTagsCreateResponseOriginCountryTlp =
  /*@__PURE__*/ S.String;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface CreateThreatEventTagResponse {
  uuid: string;
  value: string;
  activeDuration?: string | null;
  actorCategory?: string | null;
  /** Confidence (1-10) in the actor variety (actorCategory). CFONE-only: stripped from responses to non-CFONE accounts. */
  actorCategoryConfidence?: number | null;
  /** Structured aliases ({ value, confidence 1-10, tlp }). CFONE-only: stripped from responses to non-CFONE accounts. */
  aliases?: ThreatEventsTagsCreateResponseAliasesList | null;
  aliasGroupNames?: ThreatEventsTagsCreateResponseAliasGroupNamesList | null;
  aliasGroupNamesInternal?: ThreatEventsTagsCreateResponseAliasGroupNamesInternalList | null;
  analyticPriority?: number | null;
  attributionConfidence?: string | null;
  attributionConfidenceScore?: number | null;
  attributionOrganization?: string | null;
  categoryName?: string | null;
  categoryUuid?: string | null;
  dateOfDiscovery?: string | null;
  externalReferenceLinks?: ThreatEventsTagsCreateResponseExternalReferenceLinksList | null;
  /** Structured external references ({ url, description }). Public: returned to all accounts. */
  externalReferences?: ThreatEventsTagsCreateResponseExternalReferencesList | null;
  /** Internal structured aliases ({ value, confidence 1-10, tlp }). CFONE-only: never returned to non-CFONE accounts. */
  internalAliases?: ThreatEventsTagsCreateResponseInternalAliasesList | null;
  internalDescription?: string | null;
  motive?: string | null;
  /** Confidence (1-10) in the actor motive. CFONE-only: stripped from responses to non-CFONE accounts. */
  motiveConfidence?: number | null;
  opsecLevel?: string | null;
  /** Confidence (1-10) in the origin-country attribution. CFONE-only: stripped from responses to non-CFONE accounts. */
  originCountryConfidence?: number | null;
  originCountryISO?: string | null;
  originCountryISOAlpha3?: string | null;
  /** TLP marking for the origin-country attribution. CFONE-only: stripped from responses to non-CFONE accounts. */
  originCountryTlp?: ThreatEventsTagsCreateResponseOriginCountryTlp | null;
  priority?: number | null;
  sophisticationLevel?: string | null;
}
export const CreateThreatEventTagResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    uuid: S.String,
    value: S.String,
    activeDuration: S.optional(S.NullOr(S.String)),
    actorCategory: S.optional(S.NullOr(S.String)),
    actorCategoryConfidence: S.optional(S.NullOr(S.Number)),
    aliases: S.optional(S.NullOr(ThreatEventsTagsCreateResponseAliasesList)),
    aliasGroupNames: S.optional(
      S.NullOr(ThreatEventsTagsCreateResponseAliasGroupNamesList),
    ),
    aliasGroupNamesInternal: S.optional(
      S.NullOr(ThreatEventsTagsCreateResponseAliasGroupNamesInternalList),
    ),
    analyticPriority: S.optional(S.NullOr(S.Number)),
    attributionConfidence: S.optional(S.NullOr(S.String)),
    attributionConfidenceScore: S.optional(S.NullOr(S.Number)),
    attributionOrganization: S.optional(S.NullOr(S.String)),
    categoryName: S.optional(S.NullOr(S.String)),
    categoryUuid: S.optional(S.NullOr(S.String)),
    dateOfDiscovery: S.optional(S.NullOr(S.String)),
    externalReferenceLinks: S.optional(
      S.NullOr(ThreatEventsTagsCreateResponseExternalReferenceLinksList),
    ),
    externalReferences: S.optional(
      S.NullOr(ThreatEventsTagsCreateResponseExternalReferencesList),
    ),
    internalAliases: S.optional(
      S.NullOr(ThreatEventsTagsCreateResponseInternalAliasesList),
    ),
    internalDescription: S.optional(S.NullOr(S.String)),
    motive: S.optional(S.NullOr(S.String)),
    motiveConfidence: S.optional(S.NullOr(S.Number)),
    opsecLevel: S.optional(S.NullOr(S.String)),
    originCountryConfidence: S.optional(S.NullOr(S.Number)),
    originCountryISO: S.optional(S.NullOr(S.String)),
    originCountryISOAlpha3: S.optional(S.NullOr(S.String)),
    originCountryTlp: S.optional(
      S.NullOr(ThreatEventsTagsCreateResponseOriginCountryTlp),
    ),
    priority: S.optional(S.NullOr(S.Number)),
    sophisticationLevel: S.optional(S.NullOr(S.String)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateThreatEventTagResponse",
}) as any as S.Schema<CreateThreatEventTagResponse>;

export interface DeleteRequestRequest {
  /** Identifier. */
  accountId: string;
  /** UUID. */
  requestId: string;
}
export const DeleteRequestRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    requestId: S.String.pipe(T.Label("request_id")),
  })
    .pipe(
      T.Http({
        method: "DELETE",
        uri: "/accounts/{account_id}/cloudforce-one/requests/{request_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteRequestRequest",
}) as any as S.Schema<DeleteRequestRequest>;

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

export interface DeleteRequestAssetRequest {
  /** Identifier. */
  accountId: string;
  /** UUID. */
  requestId: string;
  /** UUID. */
  assetId: string;
}
export const DeleteRequestAssetRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    requestId: S.String.pipe(T.Label("request_id")),
    assetId: S.String.pipe(T.Label("asset_id")),
  })
    .pipe(
      T.Http({
        method: "DELETE",
        uri: "/accounts/{account_id}/cloudforce-one/requests/{request_id}/asset/{asset_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteRequestAssetRequest",
}) as any as S.Schema<DeleteRequestAssetRequest>;

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

export interface DeleteRequestMessageRequest {
  /** Identifier. */
  accountId: string;
  /** UUID. */
  requestId: string;
  messageId: number;
}
export const DeleteRequestMessageRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    requestId: S.String.pipe(T.Label("request_id")),
    messageId: S.Number.pipe(T.Label("message_id")),
  })
    .pipe(
      T.Http({
        method: "DELETE",
        uri: "/accounts/{account_id}/cloudforce-one/requests/{request_id}/message/{message_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteRequestMessageRequest",
}) as any as S.Schema<DeleteRequestMessageRequest>;

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

export interface DeleteRequestPriorityRequest {
  /** Identifier. */
  accountId: string;
  /** UUID. */
  priorityId: string;
}
export const DeleteRequestPriorityRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    priorityId: S.String.pipe(T.Label("priority_id")),
  })
    .pipe(
      T.Http({
        method: "DELETE",
        uri: "/accounts/{account_id}/cloudforce-one/requests/priority/{priority_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteRequestPriorityRequest",
}) as any as S.Schema<DeleteRequestPriorityRequest>;

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

export interface DeleteScanConfigRequest {
  /** Defines the Account ID. */
  accountId: string;
  /** Defines the Config ID. */
  configId: string;
}
export const DeleteScanConfigRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    configId: S.String.pipe(T.Label("config_id")),
  })
    .pipe(
      T.Http({
        method: "DELETE",
        uri: "/accounts/{account_id}/cloudforce-one/scans/config/{config_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteScanConfigRequest",
}) as any as S.Schema<DeleteScanConfigRequest>;

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

export interface DeleteThreatEventCategoryRequest {
  /** Account ID. */
  accountId: string;
  /** Category UUID. */
  categoryId: string;
}
export const DeleteThreatEventCategoryRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    categoryId: S.String.pipe(T.Label("category_id")),
  })
    .pipe(
      T.Http({
        method: "DELETE",
        uri: "/accounts/{account_id}/cloudforce-one/events/categories/{category_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteThreatEventCategoryRequest",
}) as any as S.Schema<DeleteThreatEventCategoryRequest>;

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

export interface DeleteThreatEventEventTagRequest {
  /** Account ID. */
  accountId: string;
  /** Event UUID. */
  eventId: string;
}
export const DeleteThreatEventEventTagRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    eventId: S.String.pipe(T.Label("event_id")),
  })
    .pipe(
      T.Http({
        method: "DELETE",
        uri: "/accounts/{account_id}/cloudforce-one/events/event_tag/{event_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteThreatEventEventTagRequest",
}) as any as S.Schema<DeleteThreatEventEventTagRequest>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface DeleteThreatEventEventTagResponse {
  success: boolean;
}
export const DeleteThreatEventEventTagResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    success: S.Boolean,
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteThreatEventEventTagResponse",
}) as any as S.Schema<DeleteThreatEventEventTagResponse>;

export interface DeleteThreatEventRelateRequest {
  /** Account ID. */
  accountId: string;
  /** Event UUID. */
  eventId: string;
}
export const DeleteThreatEventRelateRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    eventId: S.String.pipe(T.Label("event_id")),
  })
    .pipe(
      T.Http({
        method: "DELETE",
        uri: "/accounts/{account_id}/cloudforce-one/events/relate/{event_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteThreatEventRelateRequest",
}) as any as S.Schema<DeleteThreatEventRelateRequest>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface DeleteThreatEventRelateResponse {
  success: boolean;
}
export const DeleteThreatEventRelateResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    success: S.Boolean,
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteThreatEventRelateResponse",
}) as any as S.Schema<DeleteThreatEventRelateResponse>;

export interface GetBinaryStorageRequest {
  /** Account ID. */
  accountId: string;
  /** hash of the binary */
  hash: string;
}
export const GetBinaryStorageRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    hash: S.String.pipe(T.Label()),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/cloudforce-one/binary/{hash}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetBinaryStorageRequest",
}) as any as S.Schema<GetBinaryStorageRequest>;

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

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

export type RequestsGetResponseTlp =
  | "clear"
  | "amber"
  | "amber-strict"
  | "green"
  | "red";
export const RequestsGetResponseTlp = /*@__PURE__*/ S.String;

export type RequestsGetResponseStatus =
  | "open"
  | "accepted"
  | "reported"
  | "approved"
  | "completed"
  | "declined";
export const RequestsGetResponseStatus = /*@__PURE__*/ S.String;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface GetRequestResponse {
  /** UUID. */
  id: string;
  /** Request content. */
  content: string;
  created: string;
  priority: string;
  /** Requested information from request. */
  request: string;
  /** Brief description of the request. */
  summary: string;
  /** The CISA defined Traffic Light Protocol (TLP). */
  tlp: RequestsGetResponseTlp;
  updated: string;
  completed?: string | null;
  /** Tokens for the request messages. */
  messageTokens?: number | null;
  /** Readable Request ID. */
  readableId?: string | null;
  /** Request Status. */
  status?: RequestsGetResponseStatus | null;
  /** Tokens for the request. */
  tokens?: number | null;
}
export const GetRequestResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    content: S.String,
    created: S.String,
    priority: S.String,
    request: S.String,
    summary: S.String,
    tlp: RequestsGetResponseTlp,
    updated: S.String,
    completed: S.optional(S.NullOr(S.String)),
    messageTokens: S.optional(
      S.NullOr(S.Number).pipe(T.Body("message_tokens")),
    ),
    readableId: S.optional(S.NullOr(S.String).pipe(T.Body("readable_id"))),
    status: S.optional(S.NullOr(RequestsGetResponseStatus)),
    tokens: S.optional(S.NullOr(S.Number)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetRequestResponse",
}) as any as S.Schema<GetRequestResponse>;

export type RequestsMessageGetRequestSortOrder = "asc" | "desc";
export const RequestsMessageGetRequestSortOrder = /*@__PURE__*/ S.String;

export interface GetRequestMessageRequest {
  /** Identifier. */
  accountId: string;
  /** UUID. */
  requestId: string;
  /** Page number of results. */
  page: number;
  /** Number of results per page. */
  perPage: number;
  /** Retrieve mes ges created after this time. */
  after?: string;
  /** Retrieve messages created before this time. */
  before?: string;
  /** Field to sort results by. */
  sortBy?: string;
  /** Sort order (asc or desc). */
  sortOrder?: RequestsMessageGetRequestSortOrder | (string & {});
}
export const GetRequestMessageRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    requestId: S.String.pipe(T.Label("request_id")),
    page: S.Number,
    perPage: S.Number.pipe(T.Body("per_page")),
    after: S.optional(S.String),
    before: S.optional(S.String),
    sortBy: S.optional(S.String.pipe(T.Body("sort_by"))),
    sortOrder: S.optional(
      RequestsMessageGetRequestSortOrder.pipe(T.Body("sort_order")),
    ),
  })
    .pipe(
      T.Http({
        method: "POST",
        uri: "/accounts/{account_id}/cloudforce-one/requests/{request_id}/message",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetRequestMessageRequest",
}) as any as S.Schema<GetRequestMessageRequest>;

export interface RequestsMessageGetResultItem {
  /** Message ID. */
  id: number;
  /** Author of message. */
  author: string;
  /** Content of message. */
  content: string;
  /** Whether the message is a follow-on request. */
  isFollowOnRequest: boolean;
  /** Defines the message last updated time. */
  updated: string;
  /** Defines the message creation time. */
  created?: string | null;
}
export const RequestsMessageGetResultItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.Number,
    author: S.String,
    content: S.String,
    isFollowOnRequest: S.Boolean.pipe(T.Body("is_follow_on_request")),
    updated: S.String,
    created: S.optional(S.NullOr(S.String)),
  }),
).annotate({
  identifier: "RequestsMessageGetResultItem",
}) as any as S.Schema<RequestsMessageGetResultItem>;

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

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

export interface GetRequestPriorityRequest {
  /** Identifier. */
  accountId: string;
  /** UUID. */
  priorityId: string;
}
export const GetRequestPriorityRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    priorityId: S.String.pipe(T.Label("priority_id")),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/cloudforce-one/requests/priority/{priority_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetRequestPriorityRequest",
}) as any as S.Schema<GetRequestPriorityRequest>;

export type RequestsPriorityGetResponseTlp =
  | "clear"
  | "amber"
  | "amber-strict"
  | "green"
  | "red";
export const RequestsPriorityGetResponseTlp = /*@__PURE__*/ S.String;

export type RequestsPriorityGetResponseStatus =
  | "open"
  | "accepted"
  | "reported"
  | "approved"
  | "completed"
  | "declined";
export const RequestsPriorityGetResponseStatus = /*@__PURE__*/ S.String;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface GetRequestPriorityResponse {
  /** UUID. */
  id: string;
  /** Request content. */
  content: string;
  created: string;
  priority: string;
  /** Requested information from request. */
  request: string;
  /** Brief description of the request. */
  summary: string;
  /** The CISA defined Traffic Light Protocol (TLP). */
  tlp: RequestsPriorityGetResponseTlp;
  updated: string;
  completed?: string | null;
  /** Tokens for the request messages. */
  messageTokens?: number | null;
  /** Readable Request ID. */
  readableId?: string | null;
  /** Request Status. */
  status?: RequestsPriorityGetResponseStatus | null;
  /** Tokens for the request. */
  tokens?: number | null;
}
export const GetRequestPriorityResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    content: S.String,
    created: S.String,
    priority: S.String,
    request: S.String,
    summary: S.String,
    tlp: RequestsPriorityGetResponseTlp,
    updated: S.String,
    completed: S.optional(S.NullOr(S.String)),
    messageTokens: S.optional(
      S.NullOr(S.Number).pipe(T.Body("message_tokens")),
    ),
    readableId: S.optional(S.NullOr(S.String).pipe(T.Body("readable_id"))),
    status: S.optional(S.NullOr(RequestsPriorityGetResponseStatus)),
    tokens: S.optional(S.NullOr(S.Number)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetRequestPriorityResponse",
}) as any as S.Schema<GetRequestPriorityResponse>;

export interface GetRequestsAssetRequest {
  /** Identifier. */
  accountId: string;
  /** UUID. */
  requestId: string;
  /** UUID. */
  assetId: string;
}
export const GetRequestsAssetRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    requestId: S.String.pipe(T.Label("request_id")),
    assetId: S.String.pipe(T.Label("asset_id")),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/cloudforce-one/requests/{request_id}/asset/{asset_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetRequestsAssetRequest",
}) as any as S.Schema<GetRequestsAssetRequest>;

export type GetRequestsAssetResultItem = RequestsAssetsCreateResultItem;
export const GetRequestsAssetResultItem = RequestsAssetsCreateResultItem;

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

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

export interface GetScanResultRequest {
  /** Defines the Account ID. */
  accountId: string;
  /** Defines the Config ID. */
  configId: string;
}
export const GetScanResultRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    configId: S.String.pipe(T.Label("config_id")),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/cloudforce-one/scans/results/{config_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetScanResultRequest",
}) as any as S.Schema<GetScanResultRequest>;

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

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

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface GetScanResultResponse {
  "1_1_1_1": ScansResultsGetResponse1111List;
}
export const GetScanResultResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    "1_1_1_1": ScansResultsGetResponse1111List.pipe(T.Body("1.1.1.1")),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetScanResultResponse",
}) as any as S.Schema<GetScanResultResponse>;

export interface GetThreatEventRequest {
  /** Account ID. */
  accountId: string;
  /** Event UUID. */
  eventId: string;
}
export const GetThreatEventRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    eventId: S.String.pipe(T.Label("event_id")),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/cloudforce-one/events/{event_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetThreatEventRequest",
}) as any as S.Schema<GetThreatEventRequest>;

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

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

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

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

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

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

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

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface GetThreatEventResponse {
  attacker: string;
  attackerCountry: string;
  attackerCountryAlpha3: string;
  category: string;
  datasetId: string;
  date: string;
  event: string;
  hasChildren: boolean;
  indicator: string;
  indicatorType: string;
  indicatorTypeId: number;
  killChain: number;
  mitreAttack: ThreatEventsGetResponseMitreAttackList;
  mitreCapec: ThreatEventsGetResponseMitreCapecList;
  numReferenced: number;
  numReferences: number;
  rawId: string;
  referenced: ThreatEventsGetResponseReferencedList;
  referencedIds: ThreatEventsGetResponseReferencedIdsList;
  references: ThreatEventsGetResponseReferencesList;
  referencesIds: ThreatEventsGetResponseReferencesIdsList;
  tags: ThreatEventsGetResponseTagsList;
  targetCountry: string;
  targetCountryAlpha3: string;
  targetIndustry: string;
  tlp: string;
  uuid: string;
  insight?: string | null;
  releasabilityId?: string | null;
}
export const GetThreatEventResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    attacker: S.String,
    attackerCountry: S.String,
    attackerCountryAlpha3: S.String,
    category: S.String,
    datasetId: S.String,
    date: S.String,
    event: S.String,
    hasChildren: S.Boolean,
    indicator: S.String,
    indicatorType: S.String,
    indicatorTypeId: S.Number,
    killChain: S.Number,
    mitreAttack: ThreatEventsGetResponseMitreAttackList,
    mitreCapec: ThreatEventsGetResponseMitreCapecList,
    numReferenced: S.Number,
    numReferences: S.Number,
    rawId: S.String,
    referenced: ThreatEventsGetResponseReferencedList,
    referencedIds: ThreatEventsGetResponseReferencedIdsList,
    references: ThreatEventsGetResponseReferencesList,
    referencesIds: ThreatEventsGetResponseReferencesIdsList,
    tags: ThreatEventsGetResponseTagsList,
    targetCountry: S.String,
    targetCountryAlpha3: S.String,
    targetIndustry: S.String,
    tlp: S.String,
    uuid: S.String,
    insight: S.optional(S.NullOr(S.String)),
    releasabilityId: S.optional(S.NullOr(S.String)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetThreatEventResponse",
}) as any as S.Schema<GetThreatEventResponse>;

export interface GetThreatEventCategoryRequest {
  /** Account ID. */
  accountId: string;
  /** Category UUID. */
  categoryId: string;
}
export const GetThreatEventCategoryRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    categoryId: S.String.pipe(T.Label("category_id")),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/cloudforce-one/events/categories/{category_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetThreatEventCategoryRequest",
}) as any as S.Schema<GetThreatEventCategoryRequest>;

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

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

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface GetThreatEventCategoryResponse {
  killChain: number;
  name: string;
  uuid: string;
  mitreAttack?: ThreatEventsCategoriesGetResponseMitreAttackList | null;
  mitreCapec?: ThreatEventsCategoriesGetResponseMitreCapecList | null;
  shortname?: string | null;
}
export const GetThreatEventCategoryResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    killChain: S.Number,
    name: S.String,
    uuid: S.String,
    mitreAttack: S.optional(
      S.NullOr(ThreatEventsCategoriesGetResponseMitreAttackList),
    ),
    mitreCapec: S.optional(
      S.NullOr(ThreatEventsCategoriesGetResponseMitreCapecList),
    ),
    shortname: S.optional(S.NullOr(S.String)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetThreatEventCategoryResponse",
}) as any as S.Schema<GetThreatEventCategoryResponse>;

export interface GetThreatEventDatasetRequest {
  /** Account ID. */
  accountId: string;
  /** Dataset ID. */
  datasetId: string;
}
export const GetThreatEventDatasetRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    datasetId: S.String.pipe(T.Label("dataset_id")),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/cloudforce-one/events/dataset/{dataset_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetThreatEventDatasetRequest",
}) as any as S.Schema<GetThreatEventDatasetRequest>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface GetThreatEventDatasetResponse {
  isPublic: boolean;
  name: string;
  uuid: string;
  deletedAt?: string | null;
}
export const GetThreatEventDatasetResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    isPublic: S.Boolean,
    name: S.String,
    uuid: S.String,
    deletedAt: S.optional(S.NullOr(S.String)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetThreatEventDatasetResponse",
}) as any as S.Schema<GetThreatEventDatasetResponse>;

export interface GetThreatEventRawRequest {
  /** Account ID. */
  accountId: string;
  /** Event UUID. */
  eventId: string;
  /** Raw Event UUID. */
  rawId: string;
}
export const GetThreatEventRawRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    eventId: S.String.pipe(T.Label("event_id")),
    rawId: S.String.pipe(T.Label("raw_id")),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/cloudforce-one/events/{event_id}/raw/{raw_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetThreatEventRawRequest",
}) as any as S.Schema<GetThreatEventRawRequest>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface GetThreatEventRawResponse {
  id: string;
  accountId: number;
  created: string;
  data: unknown;
  source: string;
  tlp: string;
}
export const GetThreatEventRawResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    accountId: S.Number,
    created: S.String,
    data: S.Unknown,
    source: S.String,
    tlp: S.String,
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetThreatEventRawResponse",
}) as any as S.Schema<GetThreatEventRawResponse>;

export type ListRequestsRequestSortOrder = "asc" | "desc";
export const ListRequestsRequestSortOrder = /*@__PURE__*/ S.String;

export type ListRequestsRequestStatus =
  | "open"
  | "accepted"
  | "reported"
  | "approved"
  | "completed"
  | "declined";
export const ListRequestsRequestStatus = /*@__PURE__*/ S.String;

export interface ListRequestsRequest {
  /** Identifier. */
  accountId: string;
  /** Page number of results. */
  page: number;
  /** Number of results per page. */
  perPage: number;
  /** Retrieve requests completed after this time. */
  completedAfter?: string;
  /** Retrieve requests completed before this time. */
  completedBefore?: string;
  /** Retrieve requests created after this time. */
  createdAfter?: string;
  /** Retrieve requests created before this time. */
  createdBefore?: string;
  /** Requested information from request. */
  requestType?: string;
  /** Field to sort results by. */
  sortBy?: string;
  /** Sort order (asc or desc). */
  sortOrder?: ListRequestsRequestSortOrder | (string & {});
  /** Request Status. */
  status?: ListRequestsRequestStatus | (string & {});
}
export const ListRequestsRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    page: S.Number,
    perPage: S.Number.pipe(T.Body("per_page")),
    completedAfter: S.optional(S.String.pipe(T.Body("completed_after"))),
    completedBefore: S.optional(S.String.pipe(T.Body("completed_before"))),
    createdAfter: S.optional(S.String.pipe(T.Body("created_after"))),
    createdBefore: S.optional(S.String.pipe(T.Body("created_before"))),
    requestType: S.optional(S.String.pipe(T.Body("request_type"))),
    sortBy: S.optional(S.String.pipe(T.Body("sort_by"))),
    sortOrder: S.optional(
      ListRequestsRequestSortOrder.pipe(T.Body("sort_order")),
    ),
    status: S.optional(ListRequestsRequestStatus),
  })
    .pipe(
      T.Http({
        method: "POST",
        uri: "/accounts/{account_id}/cloudforce-one/requests",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListRequestsRequest",
}) as any as S.Schema<ListRequestsRequest>;

export type ListRequestsResultItemPriority = "routine" | "high" | "urgent";
export const ListRequestsResultItemPriority = /*@__PURE__*/ S.String;

export type ListRequestsResultItemTlp =
  | "clear"
  | "amber"
  | "amber-strict"
  | "green"
  | "red";
export const ListRequestsResultItemTlp = /*@__PURE__*/ S.String;

export type ListRequestsResultItemStatus =
  | "open"
  | "accepted"
  | "reported"
  | "approved"
  | "completed"
  | "declined";
export const ListRequestsResultItemStatus = /*@__PURE__*/ S.String;

export interface ListRequestsResultItem {
  /** UUID. */
  id: string;
  /** Request creation time. */
  created: string;
  priority: ListRequestsResultItemPriority;
  /** Requested information from request. */
  request: string;
  /** Brief description of the request. */
  summary: string;
  /** The CISA defined Traffic Light Protocol (TLP). */
  tlp: ListRequestsResultItemTlp;
  /** Request last updated time. */
  updated: string;
  /** Request completion time. */
  completed?: string | null;
  /** Tokens for the request messages. */
  messageTokens?: number | null;
  /** Readable Request ID. */
  readableId?: string | null;
  /** Request Status. */
  status?: ListRequestsResultItemStatus | null;
  /** Tokens for the request. */
  tokens?: number | null;
}
export const ListRequestsResultItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    created: S.String,
    priority: ListRequestsResultItemPriority,
    request: S.String,
    summary: S.String,
    tlp: ListRequestsResultItemTlp,
    updated: S.String,
    completed: S.optional(S.NullOr(S.String)),
    messageTokens: S.optional(
      S.NullOr(S.Number).pipe(T.Body("message_tokens")),
    ),
    readableId: S.optional(S.NullOr(S.String).pipe(T.Body("readable_id"))),
    status: S.optional(S.NullOr(ListRequestsResultItemStatus)),
    tokens: S.optional(S.NullOr(S.Number)),
  }),
).annotate({
  identifier: "ListRequestsResultItem",
}) as any as S.Schema<ListRequestsResultItem>;

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

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

export interface ListScanConfigsRequest {
  /** Defines the Account ID. */
  accountId: string;
}
export const ListScanConfigsRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/cloudforce-one/scans/config",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListScanConfigsRequest",
}) as any as S.Schema<ListScanConfigsRequest>;

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

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

export interface ScansConfigListResultItem {
  /** Defines the Config ID. */
  id: string;
  accountId: string;
  /** Defines the number of days between each scan (0 = One-off scan). */
  frequency: number;
  /** Defines a list of IP addresses or CIDR blocks to scan. The maximum number of total IP addresses allowed is 5000. */
  ips: ScansConfigListResultItemIpsList;
  /** Defines a list of ports to scan. Valid values are:"default", "all", or a comma-separated list of ports or range of ports (e.g. ["1-80", "443"]). "default" scans the 100 most commonly open ports. */
  ports: ScansConfigListResultItemPortsList;
}
export const ScansConfigListResultItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    accountId: S.String.pipe(T.Body("account_id")),
    frequency: S.Number,
    ips: ScansConfigListResultItemIpsList,
    ports: ScansConfigListResultItemPortsList,
  }),
).annotate({
  identifier: "ScansConfigListResultItem",
}) as any as S.Schema<ScansConfigListResultItem>;

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

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

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

export interface ListThreatEventAttackersRequest {
  /** Account ID. */
  accountId: string;
  /** Array of dataset IDs to query attackers from. If not provided, uses the default dataset. */
  datasetIds?: ThreatEventsAttackersListRequestDatasetIdsList;
}
export const ListThreatEventAttackersRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    datasetIds: S.optional(
      ThreatEventsAttackersListRequestDatasetIdsList.pipe(T.Query()),
    ),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/cloudforce-one/events/attackers",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListThreatEventAttackersRequest",
}) as any as S.Schema<ListThreatEventAttackersRequest>;

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

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

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

export interface ListThreatEventCategoriesRequest {
  /** Account ID. */
  accountId: string;
  /** Array of dataset IDs to query categories from. If not provided, uses the default dataset. */
  datasetIds?: ThreatEventsCategoriesListRequestDatasetIdsList;
}
export const ListThreatEventCategoriesRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    datasetIds: S.optional(
      ThreatEventsCategoriesListRequestDatasetIdsList.pipe(T.Query()),
    ),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/cloudforce-one/events/categories",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListThreatEventCategoriesRequest",
}) as any as S.Schema<ListThreatEventCategoriesRequest>;

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

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

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface ListThreatEventCategoriesResponse {
  killChain: number;
  name: string;
  uuid: string;
  mitreAttack?: ThreatEventsCategoriesListResponseMitreAttackList | null;
  mitreCapec?: ThreatEventsCategoriesListResponseMitreCapecList | null;
  shortname?: string | null;
}
export const ListThreatEventCategoriesResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    killChain: S.Number,
    name: S.String,
    uuid: S.String,
    mitreAttack: S.optional(
      S.NullOr(ThreatEventsCategoriesListResponseMitreAttackList),
    ),
    mitreCapec: S.optional(
      S.NullOr(ThreatEventsCategoriesListResponseMitreCapecList),
    ),
    shortname: S.optional(S.NullOr(S.String)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListThreatEventCategoriesResponse",
}) as any as S.Schema<ListThreatEventCategoriesResponse>;

export interface ListThreatEventCountriesRequest {
  /** Account ID. */
  accountId: string;
}
export const ListThreatEventCountriesRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/cloudforce-one/events/countries",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListThreatEventCountriesRequest",
}) as any as S.Schema<ListThreatEventCountriesRequest>;

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

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

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

export interface ListThreatEventDatasetsRequest {
  /** Account ID. */
  accountId: string;
  /** When true, include soft-deleted datasets in the response. Each item includes a `deletedAt` field (ISO 8601 or null). Default: false. */
  includeDeleted?: boolean;
}
export const ListThreatEventDatasetsRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    includeDeleted: S.optional(S.Boolean.pipe(T.Query())),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/cloudforce-one/events/dataset",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListThreatEventDatasetsRequest",
}) as any as S.Schema<ListThreatEventDatasetsRequest>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface ListThreatEventDatasetsResponse {
  isPublic: boolean;
  name: string;
  uuid: string;
  deletedAt?: string | null;
}
export const ListThreatEventDatasetsResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    isPublic: S.Boolean,
    name: S.String,
    uuid: S.String,
    deletedAt: S.optional(S.NullOr(S.String)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListThreatEventDatasetsResponse",
}) as any as S.Schema<ListThreatEventDatasetsResponse>;

export interface ListThreatEventIndicatorTypesRequest {
  /** Account ID. */
  accountId: string;
}
export const ListThreatEventIndicatorTypesRequest = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      accountId: S.String.pipe(T.Label("account_id")),
    })
      .pipe(
        T.Http({
          method: "GET",
          uri: "/accounts/{account_id}/cloudforce-one/events/indicatorTypes",
          code: 200,
        }),
      )
      .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListThreatEventIndicatorTypesRequest",
}) as any as S.Schema<ListThreatEventIndicatorTypesRequest>;

export type ThreatEventsIndicatorTypesListResponseItems =
  ThreatEventsAttackersListResponseItems;
export const ThreatEventsIndicatorTypesListResponseItems =
  ThreatEventsAttackersListResponseItems;

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

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

export type ThreatEventsListRequestFormat = "json" | "stix2" | "taxii";
export const ThreatEventsListRequestFormat = /*@__PURE__*/ S.String;

export type ThreatEventsListRequestOrder = "asc" | "desc";
export const ThreatEventsListRequestOrder = /*@__PURE__*/ S.String;

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

export type ThreatEventsListRequestSource = "do" | "r2catalog";
export const ThreatEventsListRequestSource = /*@__PURE__*/ S.String;

export interface ListThreatEventsRequest {
  /** Account ID. */
  accountId: string;
  /** Cursor for pagination. When provided, filters are embedded in the cursor so you only need to pass cursor and pageSize. Returned in the previous response's result_info.cursor field. Use cursor-based pagination for deep pagination (beyond 100,000 records) or for optimal performance. */
  cursor?: string;
  /** Dataset IDs to query events from (array of UUIDs), or special value 'all' or '*' to query all event datasets for the account. If not provided, uses the default dataset. */
  datasetId?: ThreatEventsListRequestDatasetIdList;
  forceRefresh?: boolean;
  format?: ThreatEventsListRequestFormat | (string & {});
  order?: ThreatEventsListRequestOrder | (string & {});
  orderBy?: string;
  /** Page number (1-indexed) for offset-based pagination. Limited to offset of 100,000 records. For deep pagination, use cursor-based pagination instead. */
  page?: number;
  /** Number of results per page. Maximum 25,000. */
  pageSize?: number;
  search?: ThreatEventsListRequestSearchList;
  /** Read backend. 'do' (default) reads Durable Object storage. 'r2catalog' reads R2 Data Catalog (admin-only, experimental; supports a subset of search fields — no 'tags'). */
  source?: ThreatEventsListRequestSource | (string & {});
}
export const ListThreatEventsRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    cursor: S.optional(S.String.pipe(T.Query())),
    datasetId: S.optional(ThreatEventsListRequestDatasetIdList.pipe(T.Query())),
    forceRefresh: S.optional(S.Boolean.pipe(T.Query())),
    format: S.optional(ThreatEventsListRequestFormat.pipe(T.Query())),
    order: S.optional(ThreatEventsListRequestOrder.pipe(T.Query())),
    orderBy: S.optional(S.String.pipe(T.Query())),
    page: S.optional(S.Number.pipe(T.Query())),
    pageSize: S.optional(S.Number.pipe(T.Query())),
    search: S.optional(ThreatEventsListRequestSearchList.pipe(T.Query())),
    source: S.optional(ThreatEventsListRequestSource.pipe(T.Query())),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/cloudforce-one/events",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListThreatEventsRequest",
}) as any as S.Schema<ListThreatEventsRequest>;

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

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

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

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

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

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

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

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface ListThreatEventsResponse {
  attacker: string;
  attackerCountry: string;
  attackerCountryAlpha3: string;
  category: string;
  datasetId: string;
  date: string;
  event: string;
  hasChildren: boolean;
  indicator: string;
  indicatorType: string;
  indicatorTypeId: number;
  killChain: number;
  mitreAttack: ThreatEventsListResponseMitreAttackList;
  mitreCapec: ThreatEventsListResponseMitreCapecList;
  numReferenced: number;
  numReferences: number;
  rawId: string;
  referenced: ThreatEventsListResponseReferencedList;
  referencedIds: ThreatEventsListResponseReferencedIdsList;
  references: ThreatEventsListResponseReferencesList;
  referencesIds: ThreatEventsListResponseReferencesIdsList;
  tags: ThreatEventsListResponseTagsList;
  targetCountry: string;
  targetCountryAlpha3: string;
  targetIndustry: string;
  tlp: string;
  uuid: string;
  insight?: string | null;
  releasabilityId?: string | null;
}
export const ListThreatEventsResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    attacker: S.String,
    attackerCountry: S.String,
    attackerCountryAlpha3: S.String,
    category: S.String,
    datasetId: S.String,
    date: S.String,
    event: S.String,
    hasChildren: S.Boolean,
    indicator: S.String,
    indicatorType: S.String,
    indicatorTypeId: S.Number,
    killChain: S.Number,
    mitreAttack: ThreatEventsListResponseMitreAttackList,
    mitreCapec: ThreatEventsListResponseMitreCapecList,
    numReferenced: S.Number,
    numReferences: S.Number,
    rawId: S.String,
    referenced: ThreatEventsListResponseReferencedList,
    referencedIds: ThreatEventsListResponseReferencedIdsList,
    references: ThreatEventsListResponseReferencesList,
    referencesIds: ThreatEventsListResponseReferencesIdsList,
    tags: ThreatEventsListResponseTagsList,
    targetCountry: S.String,
    targetCountryAlpha3: S.String,
    targetIndustry: S.String,
    tlp: S.String,
    uuid: S.String,
    insight: S.optional(S.NullOr(S.String)),
    releasabilityId: S.optional(S.NullOr(S.String)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListThreatEventsResponse",
}) as any as S.Schema<ListThreatEventsResponse>;

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

export interface ListThreatEventTargetIndustriesRequest {
  /** Account ID. */
  accountId: string;
  /** Array of dataset IDs to query target industries from. If not provided, uses the default dataset. */
  datasetIds?: ThreatEventsTargetIndustriesListRequestDatasetIdsList;
}
export const ListThreatEventTargetIndustriesRequest = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      accountId: S.String.pipe(T.Label("account_id")),
      datasetIds: S.optional(
        ThreatEventsTargetIndustriesListRequestDatasetIdsList.pipe(T.Query()),
      ),
    })
      .pipe(
        T.Http({
          method: "GET",
          uri: "/accounts/{account_id}/cloudforce-one/events/targetIndustries",
          code: 200,
        }),
      )
      .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListThreatEventTargetIndustriesRequest",
}) as any as S.Schema<ListThreatEventTargetIndustriesRequest>;

export type ThreatEventsTargetIndustriesListResponseItems =
  ThreatEventsAttackersListResponseItems;
export const ThreatEventsTargetIndustriesListResponseItems =
  ThreatEventsAttackersListResponseItems;

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

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

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

export interface PatchScanConfigRequest {
  /** Defines the Account ID. */
  accountId: string;
  /** Defines the Config ID. */
  configId: string;
  /** Defines the number of days between each scan (0 = One-off scan). */
  frequency?: number;
  /** Defines a list of IP addresses or CIDR blocks to scan. The maximum number of total IP addresses allowed is 5000. */
  ips?: ScansConfigEditRequestIpsList;
  /** Defines a list of ports to scan. Valid values are:"default", "all", or a comma-separated list of ports or range of ports (e.g. ["1-80", "443"]). "default" scans the 100 most commonly open ports. */
  ports?: ScansConfigEditRequestPortsList;
}
export const PatchScanConfigRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    configId: S.String.pipe(T.Label("config_id")),
    frequency: S.optional(S.Number),
    ips: S.optional(ScansConfigEditRequestIpsList),
    ports: S.optional(ScansConfigEditRequestPortsList),
  })
    .pipe(
      T.Http({
        method: "PATCH",
        uri: "/accounts/{account_id}/cloudforce-one/scans/config/{config_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "PatchScanConfigRequest",
}) as any as S.Schema<PatchScanConfigRequest>;

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

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

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface PatchScanConfigResponse {
  /** Defines the Config ID. */
  id: string;
  accountId: string;
  /** Defines the number of days between each scan (0 = One-off scan). */
  frequency: number;
  /** Defines a list of IP addresses or CIDR blocks to scan. The maximum number of total IP addresses allowed is 5000. */
  ips: ScansConfigEditResponseIpsList;
  /** Defines a list of ports to scan. Valid values are:"default", "all", or a comma-separated list of ports or range of ports (e.g. ["1-80", "443"]). "default" scans the 100 most commonly open ports. */
  ports: ScansConfigEditResponsePortsList;
}
export const PatchScanConfigResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    accountId: S.String.pipe(T.Body("account_id")),
    frequency: S.Number,
    ips: ScansConfigEditResponseIpsList,
    ports: ScansConfigEditResponsePortsList,
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "PatchScanConfigResponse",
}) as any as S.Schema<PatchScanConfigResponse>;

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

export interface ThreatEventsEditRequestRaw {
  data?: ThreatEventsEditRequestRawDataMap;
  source?: string;
  tlp?: string;
}
export const ThreatEventsEditRequestRaw = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    data: S.optional(ThreatEventsEditRequestRawDataMap),
    source: S.optional(S.String),
    tlp: S.optional(S.String),
  }),
).annotate({
  identifier: "ThreatEventsEditRequestRaw",
}) as any as S.Schema<ThreatEventsEditRequestRaw>;

export interface PatchThreatEventRequest {
  /** Account ID. */
  accountId: string;
  /** Event UUID. */
  eventId: string;
  /** Dataset ID containing the event to update. */
  datasetId: string;
  attacker?: string;
  attackerCountry?: string;
  category?: string;
  createdAt?: string;
  date?: string;
  event?: string;
  indicator?: string;
  indicatorType?: string;
  insight?: string;
  raw?: ThreatEventsEditRequestRaw;
  targetCountry?: string;
  targetIndustry?: string;
  tlp?: string;
}
export const PatchThreatEventRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    eventId: S.String.pipe(T.Label("event_id")),
    datasetId: S.String,
    attacker: S.optional(S.String),
    attackerCountry: S.optional(S.String),
    category: S.optional(S.String),
    createdAt: S.optional(S.String),
    date: S.optional(S.String),
    event: S.optional(S.String),
    indicator: S.optional(S.String),
    indicatorType: S.optional(S.String),
    insight: S.optional(S.String),
    raw: S.optional(ThreatEventsEditRequestRaw),
    targetCountry: S.optional(S.String),
    targetIndustry: S.optional(S.String),
    tlp: S.optional(S.String),
  })
    .pipe(
      T.Http({
        method: "PATCH",
        uri: "/accounts/{account_id}/cloudforce-one/events/{event_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "PatchThreatEventRequest",
}) as any as S.Schema<PatchThreatEventRequest>;

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

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

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

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

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

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

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

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface PatchThreatEventResponse {
  attacker: string;
  attackerCountry: string;
  attackerCountryAlpha3: string;
  category: string;
  datasetId: string;
  date: string;
  event: string;
  hasChildren: boolean;
  indicator: string;
  indicatorType: string;
  indicatorTypeId: number;
  killChain: number;
  mitreAttack: ThreatEventsEditResponseMitreAttackList;
  mitreCapec: ThreatEventsEditResponseMitreCapecList;
  numReferenced: number;
  numReferences: number;
  rawId: string;
  referenced: ThreatEventsEditResponseReferencedList;
  referencedIds: ThreatEventsEditResponseReferencedIdsList;
  references: ThreatEventsEditResponseReferencesList;
  referencesIds: ThreatEventsEditResponseReferencesIdsList;
  tags: ThreatEventsEditResponseTagsList;
  targetCountry: string;
  targetCountryAlpha3: string;
  targetIndustry: string;
  tlp: string;
  uuid: string;
  insight?: string | null;
  releasabilityId?: string | null;
}
export const PatchThreatEventResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    attacker: S.String,
    attackerCountry: S.String,
    attackerCountryAlpha3: S.String,
    category: S.String,
    datasetId: S.String,
    date: S.String,
    event: S.String,
    hasChildren: S.Boolean,
    indicator: S.String,
    indicatorType: S.String,
    indicatorTypeId: S.Number,
    killChain: S.Number,
    mitreAttack: ThreatEventsEditResponseMitreAttackList,
    mitreCapec: ThreatEventsEditResponseMitreCapecList,
    numReferenced: S.Number,
    numReferences: S.Number,
    rawId: S.String,
    referenced: ThreatEventsEditResponseReferencedList,
    referencedIds: ThreatEventsEditResponseReferencedIdsList,
    references: ThreatEventsEditResponseReferencesList,
    referencesIds: ThreatEventsEditResponseReferencesIdsList,
    tags: ThreatEventsEditResponseTagsList,
    targetCountry: S.String,
    targetCountryAlpha3: S.String,
    targetIndustry: S.String,
    tlp: S.String,
    uuid: S.String,
    insight: S.optional(S.NullOr(S.String)),
    releasabilityId: S.optional(S.NullOr(S.String)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "PatchThreatEventResponse",
}) as any as S.Schema<PatchThreatEventResponse>;

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

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

export interface PatchThreatEventCategoryRequest {
  /** Account ID. */
  accountId: string;
  /** Category UUID. */
  categoryId: string;
  killChain?: number;
  mitreAttack?: ThreatEventsCategoriesEditRequestMitreAttackList;
  mitreCapec?: ThreatEventsCategoriesEditRequestMitreCapecList;
  name?: string;
  shortname?: string;
}
export const PatchThreatEventCategoryRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    categoryId: S.String.pipe(T.Label("category_id")),
    killChain: S.optional(S.Number),
    mitreAttack: S.optional(ThreatEventsCategoriesEditRequestMitreAttackList),
    mitreCapec: S.optional(ThreatEventsCategoriesEditRequestMitreCapecList),
    name: S.optional(S.String),
    shortname: S.optional(S.String),
  })
    .pipe(
      T.Http({
        method: "PATCH",
        uri: "/accounts/{account_id}/cloudforce-one/events/categories/{category_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "PatchThreatEventCategoryRequest",
}) as any as S.Schema<PatchThreatEventCategoryRequest>;

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

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

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface PatchThreatEventCategoryResponse {
  killChain: number;
  name: string;
  uuid: string;
  mitreAttack?: ThreatEventsCategoriesEditResponseMitreAttackList | null;
  mitreCapec?: ThreatEventsCategoriesEditResponseMitreCapecList | null;
  shortname?: string | null;
}
export const PatchThreatEventCategoryResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    killChain: S.Number,
    name: S.String,
    uuid: S.String,
    mitreAttack: S.optional(
      S.NullOr(ThreatEventsCategoriesEditResponseMitreAttackList),
    ),
    mitreCapec: S.optional(
      S.NullOr(ThreatEventsCategoriesEditResponseMitreCapecList),
    ),
    shortname: S.optional(S.NullOr(S.String)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "PatchThreatEventCategoryResponse",
}) as any as S.Schema<PatchThreatEventCategoryResponse>;

export interface PatchThreatEventDatasetRequest {
  /** Account ID. */
  accountId: string;
  /** Dataset ID. */
  datasetId: string;
  /** If true, then anyone can search the dataset. If false, then its limited to the account. */
  isPublic: boolean;
  /** Used to describe the dataset within the account context. */
  name: string;
}
export const PatchThreatEventDatasetRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    datasetId: S.String.pipe(T.Label("dataset_id")),
    isPublic: S.Boolean,
    name: S.String,
  })
    .pipe(
      T.Http({
        method: "PATCH",
        uri: "/accounts/{account_id}/cloudforce-one/events/dataset/{dataset_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "PatchThreatEventDatasetRequest",
}) as any as S.Schema<PatchThreatEventDatasetRequest>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface PatchThreatEventDatasetResponse {
  isPublic: boolean;
  name: string;
  uuid: string;
  deletedAt?: string | null;
}
export const PatchThreatEventDatasetResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    isPublic: S.Boolean,
    name: S.String,
    uuid: S.String,
    deletedAt: S.optional(S.NullOr(S.String)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "PatchThreatEventDatasetResponse",
}) as any as S.Schema<PatchThreatEventDatasetResponse>;

export interface PatchThreatEventRawRequest {
  /** Account ID. */
  accountId: string;
  /** Event UUID. */
  eventId: string;
  /** Raw Event UUID. */
  rawId: string;
  data?: unknown;
  source?: string;
  tlp?: string;
}
export const PatchThreatEventRawRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    eventId: S.String.pipe(T.Label("event_id")),
    rawId: S.String.pipe(T.Label("raw_id")),
    data: S.optional(S.Unknown),
    source: S.optional(S.String),
    tlp: S.optional(S.String),
  })
    .pipe(
      T.Http({
        method: "PATCH",
        uri: "/accounts/{account_id}/cloudforce-one/events/{event_id}/raw/{raw_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "PatchThreatEventRawRequest",
}) as any as S.Schema<PatchThreatEventRawRequest>;

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

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

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface QuotaRequestPriorityResponse {
  /** Anniversary date is when annual quota limit is refreshed. */
  anniversaryDate?: string | null;
  /** Quarter anniversary date is when quota limit is refreshed each quarter. */
  quarterAnniversaryDate?: string | null;
  /** Tokens for the quarter. */
  quota?: number | null;
  /** Tokens remaining for the quarter. */
  remaining?: number | null;
}
export const QuotaRequestPriorityResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    anniversaryDate: S.optional(
      S.NullOr(S.String).pipe(T.Body("anniversary_date")),
    ),
    quarterAnniversaryDate: S.optional(
      S.NullOr(S.String).pipe(T.Body("quarter_anniversary_date")),
    ),
    quota: S.optional(S.NullOr(S.Number)),
    remaining: S.optional(S.NullOr(S.Number)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "QuotaRequestPriorityResponse",
}) as any as S.Schema<QuotaRequestPriorityResponse>;

export interface RawThreatEventDatasetRequest {
  /** Account ID. */
  accountId: string;
  /** Dataset ID. */
  datasetId: string;
  /** Event ID. */
  eventId: string;
}
export const RawThreatEventDatasetRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    datasetId: S.String.pipe(T.Label("dataset_id")),
    eventId: S.String.pipe(T.Label("event_id")),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/cloudforce-one/events/raw/{dataset_id}/{event_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "RawThreatEventDatasetRequest",
}) as any as S.Schema<RawThreatEventDatasetRequest>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface RawThreatEventDatasetResponse {
  id: number;
  accountId: number;
  created: string;
  data: string;
  source: string;
  tlp: string;
}
export const RawThreatEventDatasetResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.Number,
    accountId: S.Number,
    created: S.String,
    data: S.String,
    source: S.String,
    tlp: S.String,
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "RawThreatEventDatasetResponse",
}) as any as S.Schema<RawThreatEventDatasetResponse>;

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

export type RequestsConstantsResponsePriorityItem =
  | "routine"
  | "high"
  | "urgent";
export const RequestsConstantsResponsePriorityItem = /*@__PURE__*/ S.String;

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

export type RequestsConstantsResponseStatusItem =
  | "open"
  | "accepted"
  | "reported"
  | "approved"
  | "completed"
  | "declined";
export const RequestsConstantsResponseStatusItem = /*@__PURE__*/ S.String;

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

export type RequestsConstantsResponseTlpItem =
  | "clear"
  | "amber"
  | "amber-strict"
  | "green"
  | "red";
export const RequestsConstantsResponseTlpItem = /*@__PURE__*/ S.String;

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

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface RequestsConstantsResponse {
  priority?: RequestsConstantsResponsePriorityList | null;
  status?: RequestsConstantsResponseStatusList | null;
  tlp?: RequestsConstantsResponseTlpList | null;
}
export const RequestsConstantsResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    priority: S.optional(S.NullOr(RequestsConstantsResponsePriorityList)),
    status: S.optional(S.NullOr(RequestsConstantsResponseStatusList)),
    tlp: S.optional(S.NullOr(RequestsConstantsResponseTlpList)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "RequestsConstantsResponse",
}) as any as S.Schema<RequestsConstantsResponse>;

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

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface RequestsQuotaResponse {
  /** Anniversary date is when annual quota limit is refreshed. */
  anniversaryDate?: string | null;
  /** Quarter anniversary date is when quota limit is refreshed each quarter. */
  quarterAnniversaryDate?: string | null;
  /** Tokens for the quarter. */
  quota?: number | null;
  /** Tokens remaining for the quarter. */
  remaining?: number | null;
}
export const RequestsQuotaResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    anniversaryDate: S.optional(
      S.NullOr(S.String).pipe(T.Body("anniversary_date")),
    ),
    quarterAnniversaryDate: S.optional(
      S.NullOr(S.String).pipe(T.Body("quarter_anniversary_date")),
    ),
    quota: S.optional(S.NullOr(S.Number)),
    remaining: S.optional(S.NullOr(S.Number)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "RequestsQuotaResponse",
}) as any as S.Schema<RequestsQuotaResponse>;

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

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

export type UpdateRequestRequestTlp =
  | "clear"
  | "amber"
  | "amber-strict"
  | "green"
  | "red";
export const UpdateRequestRequestTlp = /*@__PURE__*/ S.String;

export interface UpdateRequestRequest {
  /** Identifier. */
  accountId: string;
  /** UUID. */
  requestId: string;
  /** Request content. */
  content?: string;
  /** Priority for analyzing the request. */
  priority?: string;
  /** Requested information from request. */
  requestType?: string;
  /** Brief description of the request. */
  summary?: string;
  /** The CISA defined Traffic Light Protocol (TLP). */
  tlp?: UpdateRequestRequestTlp | (string & {});
}
export const UpdateRequestRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    requestId: S.String.pipe(T.Label("request_id")),
    content: S.optional(S.String),
    priority: S.optional(S.String),
    requestType: S.optional(S.String.pipe(T.Body("request_type"))),
    summary: S.optional(S.String),
    tlp: S.optional(UpdateRequestRequestTlp),
  })
    .pipe(
      T.Http({
        method: "PUT",
        uri: "/accounts/{account_id}/cloudforce-one/requests/{request_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "UpdateRequestRequest",
}) as any as S.Schema<UpdateRequestRequest>;

export type UpdateRequestResponseTlp =
  | "clear"
  | "amber"
  | "amber-strict"
  | "green"
  | "red";
export const UpdateRequestResponseTlp = /*@__PURE__*/ S.String;

export type UpdateRequestResponseStatus =
  | "open"
  | "accepted"
  | "reported"
  | "approved"
  | "completed"
  | "declined";
export const UpdateRequestResponseStatus = /*@__PURE__*/ S.String;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface UpdateRequestResponse {
  /** UUID. */
  id: string;
  /** Request content. */
  content: string;
  created: string;
  priority: string;
  /** Requested information from request. */
  request: string;
  /** Brief description of the request. */
  summary: string;
  /** The CISA defined Traffic Light Protocol (TLP). */
  tlp: UpdateRequestResponseTlp;
  updated: string;
  completed?: string | null;
  /** Tokens for the request messages. */
  messageTokens?: number | null;
  /** Readable Request ID. */
  readableId?: string | null;
  /** Request Status. */
  status?: UpdateRequestResponseStatus | null;
  /** Tokens for the request. */
  tokens?: number | null;
}
export const UpdateRequestResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    content: S.String,
    created: S.String,
    priority: S.String,
    request: S.String,
    summary: S.String,
    tlp: UpdateRequestResponseTlp,
    updated: S.String,
    completed: S.optional(S.NullOr(S.String)),
    messageTokens: S.optional(
      S.NullOr(S.Number).pipe(T.Body("message_tokens")),
    ),
    readableId: S.optional(S.NullOr(S.String).pipe(T.Body("readable_id"))),
    status: S.optional(S.NullOr(UpdateRequestResponseStatus)),
    tokens: S.optional(S.NullOr(S.Number)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "UpdateRequestResponse",
}) as any as S.Schema<UpdateRequestResponse>;

export interface UpdateRequestAssetRequest {
  /** Identifier. */
  accountId: string;
  /** UUID. */
  requestId: string;
  /** UUID. */
  assetId: string;
  /** Asset file to upload. */
  source?: string;
}
export const UpdateRequestAssetRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    requestId: S.String.pipe(T.Label("request_id")),
    assetId: S.String.pipe(T.Label("asset_id")),
    source: S.optional(S.String),
  })
    .pipe(
      T.Http({
        method: "PUT",
        uri: "/accounts/{account_id}/cloudforce-one/requests/{request_id}/asset/{asset_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "UpdateRequestAssetRequest",
}) as any as S.Schema<UpdateRequestAssetRequest>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface UpdateRequestAssetResponse {
  /** Asset ID. */
  id: number;
  /** Asset name. */
  name: string;
  /** Defines the asset creation time. */
  created?: string | null;
  /** Asset description. */
  description?: string | null;
  /** Asset file type. */
  fileType?: string | null;
}
export const UpdateRequestAssetResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.Number,
    name: S.String,
    created: S.optional(S.NullOr(S.String)),
    description: S.optional(S.NullOr(S.String)),
    fileType: S.optional(S.NullOr(S.String).pipe(T.Body("file_type"))),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "UpdateRequestAssetResponse",
}) as any as S.Schema<UpdateRequestAssetResponse>;

export interface UpdateRequestMessageRequest {
  /** Identifier. */
  accountId: string;
  /** UUID. */
  requestId: string;
  messageId: number;
  /** Content of message. */
  content?: string;
}
export const UpdateRequestMessageRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    requestId: S.String.pipe(T.Label("request_id")),
    messageId: S.Number.pipe(T.Label("message_id")),
    content: S.optional(S.String),
  })
    .pipe(
      T.Http({
        method: "PUT",
        uri: "/accounts/{account_id}/cloudforce-one/requests/{request_id}/message/{message_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "UpdateRequestMessageRequest",
}) as any as S.Schema<UpdateRequestMessageRequest>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface UpdateRequestMessageResponse {
  /** Message ID. */
  id: number;
  /** Author of message. */
  author: string;
  /** Content of message. */
  content: string;
  /** Whether the message is a follow-on request. */
  isFollowOnRequest: boolean;
  /** Defines the message last updated time. */
  updated: string;
  /** Defines the message creation time. */
  created?: string | null;
}
export const UpdateRequestMessageResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.Number,
    author: S.String,
    content: S.String,
    isFollowOnRequest: S.Boolean.pipe(T.Body("is_follow_on_request")),
    updated: S.String,
    created: S.optional(S.NullOr(S.String)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "UpdateRequestMessageResponse",
}) as any as S.Schema<UpdateRequestMessageResponse>;

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

export type RequestsPriorityUpdateRequestTlp =
  | "clear"
  | "amber"
  | "amber-strict"
  | "green"
  | "red";
export const RequestsPriorityUpdateRequestTlp = /*@__PURE__*/ S.String;

export interface UpdateRequestPriorityRequest {
  /** Identifier. */
  accountId: string;
  /** UUID. */
  priorityId: string;
  /** List of labels. */
  labels: RequestsPriorityUpdateRequestLabelsList;
  /** Priority. */
  priority: number;
  /** Requirement. */
  requirement: string;
  /** The CISA defined Traffic Light Protocol (TLP). */
  tlp: RequestsPriorityUpdateRequestTlp | (string & {});
}
export const UpdateRequestPriorityRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    priorityId: S.String.pipe(T.Label("priority_id")),
    labels: RequestsPriorityUpdateRequestLabelsList,
    priority: S.Number,
    requirement: S.String,
    tlp: RequestsPriorityUpdateRequestTlp,
  })
    .pipe(
      T.Http({
        method: "PUT",
        uri: "/accounts/{account_id}/cloudforce-one/requests/priority/{priority_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "UpdateRequestPriorityRequest",
}) as any as S.Schema<UpdateRequestPriorityRequest>;

export type RequestsPriorityUpdateResponseTlp =
  | "clear"
  | "amber"
  | "amber-strict"
  | "green"
  | "red";
export const RequestsPriorityUpdateResponseTlp = /*@__PURE__*/ S.String;

export type RequestsPriorityUpdateResponseStatus =
  | "open"
  | "accepted"
  | "reported"
  | "approved"
  | "completed"
  | "declined";
export const RequestsPriorityUpdateResponseStatus = /*@__PURE__*/ S.String;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface UpdateRequestPriorityResponse {
  /** UUID. */
  id: string;
  /** Request content. */
  content: string;
  created: string;
  priority: string;
  /** Requested information from request. */
  request: string;
  /** Brief description of the request. */
  summary: string;
  /** The CISA defined Traffic Light Protocol (TLP). */
  tlp: RequestsPriorityUpdateResponseTlp;
  updated: string;
  completed?: string | null;
  /** Tokens for the request messages. */
  messageTokens?: number | null;
  /** Readable Request ID. */
  readableId?: string | null;
  /** Request Status. */
  status?: RequestsPriorityUpdateResponseStatus | null;
  /** Tokens for the request. */
  tokens?: number | null;
}
export const UpdateRequestPriorityResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    content: S.String,
    created: S.String,
    priority: S.String,
    request: S.String,
    summary: S.String,
    tlp: RequestsPriorityUpdateResponseTlp,
    updated: S.String,
    completed: S.optional(S.NullOr(S.String)),
    messageTokens: S.optional(
      S.NullOr(S.Number).pipe(T.Body("message_tokens")),
    ),
    readableId: S.optional(S.NullOr(S.String).pipe(T.Body("readable_id"))),
    status: S.optional(S.NullOr(RequestsPriorityUpdateResponseStatus)),
    tokens: S.optional(S.NullOr(S.Number)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "UpdateRequestPriorityResponse",
}) as any as S.Schema<UpdateRequestPriorityResponse>;

export type BulkCreateThreatEventsError = CloudflareOpError;
/** The `datasetId` parameter must be defined. To list existing datasets (and their IDs) in your account, use the [`List Datasets`](https://developers.cloudflare.com/api/resources/cloudforce_one/subresources/threat_events/subresources/datasets/methods/list/) endpoint. */
export const bulkCreateThreatEvents: API.OperationMethod<
  BulkCreateThreatEventsRequest,
  BulkCreateThreatEventsResponse,
  BulkCreateThreatEventsError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: BulkCreateThreatEventsRequest,
  output: BulkCreateThreatEventsResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type CreateBinaryStorageError = CloudflareOpError;
/** Uploads a binary file to Cloudforce One's binary database for malware analysis and threat intelligence correlation. */
export const createBinaryStorage: API.OperationMethod<
  CreateBinaryStorageRequest,
  CreateBinaryStorageResponse,
  CreateBinaryStorageError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: CreateBinaryStorageRequest,
  output: CreateBinaryStorageResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type CreateRequestError = CloudflareOpError;
/** Creating a request adds the request into the Cloudforce One queue for analysis. In addition to the content, a short title, type, priority, and releasability should be provided. If one is not provided, a default will be assigned. */
export const createRequest: API.OperationMethod<
  CreateRequestRequest,
  CreateRequestResponse,
  CreateRequestError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: CreateRequestRequest,
  output: CreateRequestResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type CreateRequestAssetError = CloudflareOpError;
/** Lists assets attached to a Cloudforce One intelligence request. */
export const createRequestAsset: API.PaginatedOperationMethod<
  CreateRequestAssetRequest,
  CreateRequestAssetResponse,
  CreateRequestAssetError,
  CloudflareOpContext,
  RequestsAssetsCreateResultItem
> = /*@__PURE__*/ API.makePaginated(
  () => ({
    input: CreateRequestAssetRequest,
    output: CreateRequestAssetResponse,
    errors: [CloudflareRateLimited, CloudflareError],
    protocol: CloudflarePaginatedProtocol,
    retry: Retry.Retry,
    pagination: { mode: "single", items: "result" } as const,
  }),
  cloudflarePaginate,
) as any;

export type CreateRequestMessageError = CloudflareOpError;
/** Adds a message to a Cloudforce One intelligence request conversation. */
export const createRequestMessage: API.OperationMethod<
  CreateRequestMessageRequest,
  CreateRequestMessageResponse,
  CreateRequestMessageError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: CreateRequestMessageRequest,
  output: CreateRequestMessageResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type CreateRequestPriorityError = CloudflareOpError;
/** Creates a new priority intelligence request in Cloudforce One. */
export const createRequestPriority: API.OperationMethod<
  CreateRequestPriorityRequest,
  CreateRequestPriorityResponse,
  CreateRequestPriorityError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: CreateRequestPriorityRequest,
  output: CreateRequestPriorityResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type CreateScanConfigError = CloudflareOpError;
/** Create a new Scan Config */
export const createScanConfig: API.OperationMethod<
  CreateScanConfigRequest,
  CreateScanConfigResponse,
  CreateScanConfigError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: CreateScanConfigRequest,
  output: CreateScanConfigResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type CreateThreatEventError = CloudflareOpError;
/** To create a dataset, see the [`Create Dataset`](https://developers.cloudflare.com/api/resources/cloudforce_one/subresources/threat_events/subresources/datasets/methods/create/) endpoint. When `datasetId` parameter is unspecified, it will be created in a default dataset named `Cloudforce One Threat Events`. */
export const createThreatEvent: API.OperationMethod<
  CreateThreatEventRequest,
  CreateThreatEventResponse,
  CreateThreatEventError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: CreateThreatEventRequest,
  output: CreateThreatEventResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type CreateThreatEventCategoryError = CloudflareOpError;
/** Creates a new category */
export const createThreatEventCategory: API.OperationMethod<
  CreateThreatEventCategoryRequest,
  CreateThreatEventCategoryResponse,
  CreateThreatEventCategoryError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: CreateThreatEventCategoryRequest,
  output: CreateThreatEventCategoryResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type CreateThreatEventDatasetError = CloudflareOpError;
/** Creates a dataset */
export const createThreatEventDataset: API.OperationMethod<
  CreateThreatEventDatasetRequest,
  CreateThreatEventDatasetResponse,
  CreateThreatEventDatasetError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: CreateThreatEventDatasetRequest,
  output: CreateThreatEventDatasetResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type CreateThreatEventEventTagError = CloudflareOpError;
/** Adds a tag to an event */
export const createThreatEventEventTag: API.OperationMethod<
  CreateThreatEventEventTagRequest,
  CreateThreatEventEventTagResponse,
  CreateThreatEventEventTagError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: CreateThreatEventEventTagRequest,
  output: CreateThreatEventEventTagResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type CreateThreatEventTagError = CloudflareOpError;
/** Creates a new tag to be used accross threat events. */
export const createThreatEventTag: API.OperationMethod<
  CreateThreatEventTagRequest,
  CreateThreatEventTagResponse,
  CreateThreatEventTagError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: CreateThreatEventTagRequest,
  output: CreateThreatEventTagResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type DeleteRequestError = CloudflareOpError;
/** Deletes a Cloudforce One intelligence request and all associated data. */
export const deleteRequest: API.OperationMethod<
  DeleteRequestRequest,
  DeleteRequestResponse,
  DeleteRequestError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: DeleteRequestRequest,
  output: DeleteRequestResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type DeleteRequestAssetError = CloudflareOpError;
/** Removes an asset from a Cloudforce One intelligence request. */
export const deleteRequestAsset: API.OperationMethod<
  DeleteRequestAssetRequest,
  DeleteRequestAssetResponse,
  DeleteRequestAssetError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: DeleteRequestAssetRequest,
  output: DeleteRequestAssetResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type DeleteRequestMessageError = CloudflareOpError;
/** Removes a message from a Cloudforce One intelligence request thread. */
export const deleteRequestMessage: API.OperationMethod<
  DeleteRequestMessageRequest,
  DeleteRequestMessageResponse,
  DeleteRequestMessageError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: DeleteRequestMessageRequest,
  output: DeleteRequestMessageResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type DeleteRequestPriorityError = CloudflareOpError;
/** Deletes a priority intelligence request from Cloudforce One. */
export const deleteRequestPriority: API.OperationMethod<
  DeleteRequestPriorityRequest,
  DeleteRequestPriorityResponse,
  DeleteRequestPriorityError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: DeleteRequestPriorityRequest,
  output: DeleteRequestPriorityResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type DeleteScanConfigError = ScanConfigNotFound | CloudflareOpError;
/** Delete a Scan Config */
export const deleteScanConfig: API.OperationMethod<
  DeleteScanConfigRequest,
  DeleteScanConfigResponse,
  DeleteScanConfigError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: DeleteScanConfigRequest,
  output: DeleteScanConfigResponse,
  errors: [ScanConfigNotFound, CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type DeleteThreatEventCategoryError = CloudflareOpError;
/** Deletes a category */
export const deleteThreatEventCategory: API.OperationMethod<
  DeleteThreatEventCategoryRequest,
  DeleteThreatEventCategoryResponse,
  DeleteThreatEventCategoryError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: DeleteThreatEventCategoryRequest,
  output: DeleteThreatEventCategoryResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type DeleteThreatEventEventTagError = CloudflareOpError;
/** Removes a tag from an event */
export const deleteThreatEventEventTag: API.OperationMethod<
  DeleteThreatEventEventTagRequest,
  DeleteThreatEventEventTagResponse,
  DeleteThreatEventEventTagError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: DeleteThreatEventEventTagRequest,
  output: DeleteThreatEventEventTagResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type DeleteThreatEventRelateError = CloudflareOpError;
/** Removes an event reference */
export const deleteThreatEventRelate: API.OperationMethod<
  DeleteThreatEventRelateRequest,
  DeleteThreatEventRelateResponse,
  DeleteThreatEventRelateError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: DeleteThreatEventRelateRequest,
  output: DeleteThreatEventRelateResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetBinaryStorageError = CloudflareOpError;
/** Retrieves a binary file from the Cloudforce One binary storage for analysis. */
export const getBinaryStorage: API.OperationMethod<
  GetBinaryStorageRequest,
  GetBinaryStorageResponse,
  GetBinaryStorageError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetBinaryStorageRequest,
  output: GetBinaryStorageResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetRequestError = CloudflareOpError;
/** Retrieves details for a specific Cloudforce One intelligence request. */
export const getRequest: API.OperationMethod<
  GetRequestRequest,
  GetRequestResponse,
  GetRequestError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetRequestRequest,
  output: GetRequestResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetRequestMessageError = CloudflareOpError;
/** Lists messages in a Cloudforce One intelligence request conversation. */
export const getRequestMessage: API.PaginatedOperationMethod<
  GetRequestMessageRequest,
  GetRequestMessageResponse,
  GetRequestMessageError,
  CloudflareOpContext,
  RequestsMessageGetResultItem
> = /*@__PURE__*/ API.makePaginated(
  () => ({
    input: GetRequestMessageRequest,
    output: GetRequestMessageResponse,
    errors: [CloudflareRateLimited, CloudflareError],
    protocol: CloudflarePaginatedProtocol,
    retry: Retry.Retry,
    pagination: { mode: "single", items: "result" } as const,
  }),
  cloudflarePaginate,
) as any;

export type GetRequestPriorityError = CloudflareOpError;
/** Retrieves a specific priority intelligence request from Cloudforce One. */
export const getRequestPriority: API.OperationMethod<
  GetRequestPriorityRequest,
  GetRequestPriorityResponse,
  GetRequestPriorityError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetRequestPriorityRequest,
  output: GetRequestPriorityResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetRequestsAssetError = CloudflareOpError;
/** Retrieves an asset attached to a Cloudforce One intelligence request. */
export const getRequestsAsset: API.OperationMethod<
  GetRequestsAssetRequest,
  GetRequestsAssetResponse,
  GetRequestsAssetError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetRequestsAssetRequest,
  output: GetRequestsAssetResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetScanResultError = CloudflareOpError;
/** Get the Latest Scan Result */
export const getScanResult: API.OperationMethod<
  GetScanResultRequest,
  GetScanResultResponse,
  GetScanResultError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetScanResultRequest,
  output: GetScanResultResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetThreatEventError = CloudflareOpError;
/** This Method is deprecated. Please use /events/dataset/:dataset_id/events/:event_id instead. */
export const getThreatEvent: API.OperationMethod<
  GetThreatEventRequest,
  GetThreatEventResponse,
  GetThreatEventError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetThreatEventRequest,
  output: GetThreatEventResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetThreatEventCategoryError = CloudflareOpError;
/** Reads a category */
export const getThreatEventCategory: API.OperationMethod<
  GetThreatEventCategoryRequest,
  GetThreatEventCategoryResponse,
  GetThreatEventCategoryError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetThreatEventCategoryRequest,
  output: GetThreatEventCategoryResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetThreatEventDatasetError = CloudflareOpError;
/** Reads a dataset */
export const getThreatEventDataset: API.OperationMethod<
  GetThreatEventDatasetRequest,
  GetThreatEventDatasetResponse,
  GetThreatEventDatasetError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetThreatEventDatasetRequest,
  output: GetThreatEventDatasetResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetThreatEventRawError = CloudflareOpError;
/** Reads data for a raw event */
export const getThreatEventRaw: API.OperationMethod<
  GetThreatEventRawRequest,
  GetThreatEventRawResponse,
  GetThreatEventRawError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetThreatEventRawRequest,
  output: GetThreatEventRawResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type ListRequestsError = CloudflareOpError;
/** Lists Cloudforce One intelligence requests with filtering and pagination. */
export const listRequests: API.OperationMethod<
  ListRequestsRequest,
  ListRequestsResponse,
  ListRequestsError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: ListRequestsRequest,
  output: ListRequestsResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type ListScanConfigsError = CloudflareOpError;
/** List Scan Configs */
export const listScanConfigs: API.PaginatedOperationMethod<
  ListScanConfigsRequest,
  ListScanConfigsResponse,
  ListScanConfigsError,
  CloudflareOpContext,
  ScansConfigListResultItem
> = /*@__PURE__*/ API.makePaginated(
  () => ({
    input: ListScanConfigsRequest,
    output: ListScanConfigsResponse,
    errors: [CloudflareRateLimited, CloudflareError],
    protocol: CloudflarePaginatedProtocol,
    retry: Retry.Retry,
    pagination: { mode: "single", items: "result" } as const,
  }),
  cloudflarePaginate,
) as any;

export type ListThreatEventAttackersError = CloudflareOpError;
/** Lists attackers across multiple datasets */
export const listThreatEventAttackers: API.OperationMethod<
  ListThreatEventAttackersRequest,
  ListThreatEventAttackersResponse,
  ListThreatEventAttackersError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: ListThreatEventAttackersRequest,
  output: ListThreatEventAttackersResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type ListThreatEventCategoriesError = CloudflareOpError;
/** Lists categories across multiple datasets */
export const listThreatEventCategories: API.OperationMethod<
  ListThreatEventCategoriesRequest,
  ListThreatEventCategoriesResponse,
  ListThreatEventCategoriesError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: ListThreatEventCategoriesRequest,
  output: ListThreatEventCategoriesResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type ListThreatEventCountriesError = CloudflareOpError;
/** Retrieves countries information for all countries */
export const listThreatEventCountries: API.OperationMethod<
  ListThreatEventCountriesRequest,
  ListThreatEventCountriesResponse,
  ListThreatEventCountriesError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: ListThreatEventCountriesRequest,
  output: ListThreatEventCountriesResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type ListThreatEventDatasetsError = CloudflareOpError;
/** Lists all datasets in an account */
export const listThreatEventDatasets: API.OperationMethod<
  ListThreatEventDatasetsRequest,
  ListThreatEventDatasetsResponse,
  ListThreatEventDatasetsError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: ListThreatEventDatasetsRequest,
  output: ListThreatEventDatasetsResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type ListThreatEventIndicatorTypesError = CloudflareOpError;
/** This Method is deprecated. Please use /events/dataset/:dataset_id/indicatorTypes instead. */
export const listThreatEventIndicatorTypes: API.OperationMethod<
  ListThreatEventIndicatorTypesRequest,
  ListThreatEventIndicatorTypesResponse,
  ListThreatEventIndicatorTypesError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: ListThreatEventIndicatorTypesRequest,
  output: ListThreatEventIndicatorTypesResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type ListThreatEventsError = CloudflareOpError;
/** Use `datasetId=all` or `datasetId=*` to query all event datasets for the account (limited to 10). When `datasetId` is unspecified, events are listed from the default Cloudforce One Threat Events dataset. To list existing datasets, use the [`List Datasets`](https://developers.cloudflare.com/api/resources/cloudforce_one/subresources/threat_events/subresources/datasets/methods/list/) endpoint. */
export const listThreatEvents: API.OperationMethod<
  ListThreatEventsRequest,
  ListThreatEventsResponse,
  ListThreatEventsError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: ListThreatEventsRequest,
  output: ListThreatEventsResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type ListThreatEventTargetIndustriesError = CloudflareOpError;
/** Lists target industries across multiple datasets */
export const listThreatEventTargetIndustries: API.OperationMethod<
  ListThreatEventTargetIndustriesRequest,
  ListThreatEventTargetIndustriesResponse,
  ListThreatEventTargetIndustriesError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: ListThreatEventTargetIndustriesRequest,
  output: ListThreatEventTargetIndustriesResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type PatchScanConfigError = ScanConfigNotFound | CloudflareOpError;
/** Update an existing Scan Config */
export const patchScanConfig: API.OperationMethod<
  PatchScanConfigRequest,
  PatchScanConfigResponse,
  PatchScanConfigError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: PatchScanConfigRequest,
  output: PatchScanConfigResponse,
  errors: [ScanConfigNotFound, CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type PatchThreatEventError = CloudflareOpError;
/** Updates an event */
export const patchThreatEvent: API.OperationMethod<
  PatchThreatEventRequest,
  PatchThreatEventResponse,
  PatchThreatEventError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: PatchThreatEventRequest,
  output: PatchThreatEventResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type PatchThreatEventCategoryError = CloudflareOpError;
/** Updates a category */
export const patchThreatEventCategory: API.OperationMethod<
  PatchThreatEventCategoryRequest,
  PatchThreatEventCategoryResponse,
  PatchThreatEventCategoryError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: PatchThreatEventCategoryRequest,
  output: PatchThreatEventCategoryResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type PatchThreatEventDatasetError = CloudflareOpError;
/** Updates an existing dataset */
export const patchThreatEventDataset: API.OperationMethod<
  PatchThreatEventDatasetRequest,
  PatchThreatEventDatasetResponse,
  PatchThreatEventDatasetError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: PatchThreatEventDatasetRequest,
  output: PatchThreatEventDatasetResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type PatchThreatEventRawError = CloudflareOpError;
/** Updates a raw event */
export const patchThreatEventRaw: API.OperationMethod<
  PatchThreatEventRawRequest,
  PatchThreatEventRawResponse,
  PatchThreatEventRawError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: PatchThreatEventRawRequest,
  output: PatchThreatEventRawResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type QuotaRequestPriorityError = CloudflareOpError;
/** Retrieves quota usage for Cloudforce One priority requests. */
export const quotaRequestPriority: API.OperationMethod<
  QuotaRequestPriorityRequest,
  QuotaRequestPriorityResponse,
  QuotaRequestPriorityError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: QuotaRequestPriorityRequest,
  output: QuotaRequestPriorityResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type RawThreatEventDatasetError = CloudflareOpError;
/** Retrieves the raw data associated with an event. Searches across all shards in the dataset. */
export const rawThreatEventDataset: API.OperationMethod<
  RawThreatEventDatasetRequest,
  RawThreatEventDatasetResponse,
  RawThreatEventDatasetError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: RawThreatEventDatasetRequest,
  output: RawThreatEventDatasetResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type RequestsConstantsError = CloudflareOpError;
/** Retrieves constant values used in Cloudforce One requests, including valid statuses and types. */
export const requestsConstants: API.OperationMethod<
  RequestsConstantsRequest,
  RequestsConstantsResponse,
  RequestsConstantsError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: RequestsConstantsRequest,
  output: RequestsConstantsResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type RequestsQuotaError = CloudflareOpError;
/** Retrieves quota usage for Cloudforce One standard requests. */
export const requestsQuota: API.OperationMethod<
  RequestsQuotaRequest,
  RequestsQuotaResponse,
  RequestsQuotaError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: RequestsQuotaRequest,
  output: RequestsQuotaResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type RequestsTypesError = CloudflareOpError;
/** Lists available request types for Cloudforce One intelligence requests. */
export const requestsTypes: API.OperationMethod<
  RequestsTypesRequest,
  RequestsTypesResponse,
  RequestsTypesError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: RequestsTypesRequest,
  output: RequestsTypesResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type UpdateRequestError = CloudflareOpError;
/** Updating a request alters the request in the Cloudforce One queue. This API may be used to update any attributes of the request after the initial submission. Only fields that you choose to update need to be add to the request body. */
export const updateRequest: API.OperationMethod<
  UpdateRequestRequest,
  UpdateRequestResponse,
  UpdateRequestError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: UpdateRequestRequest,
  output: UpdateRequestResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type UpdateRequestAssetError = CloudflareOpError;
/** Updates an asset in a Cloudforce One intelligence request. */
export const updateRequestAsset: API.OperationMethod<
  UpdateRequestAssetRequest,
  UpdateRequestAssetResponse,
  UpdateRequestAssetError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: UpdateRequestAssetRequest,
  output: UpdateRequestAssetResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type UpdateRequestMessageError = CloudflareOpError;
/** Updates a message in a Cloudforce One intelligence request thread. */
export const updateRequestMessage: API.OperationMethod<
  UpdateRequestMessageRequest,
  UpdateRequestMessageResponse,
  UpdateRequestMessageError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: UpdateRequestMessageRequest,
  output: UpdateRequestMessageResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type UpdateRequestPriorityError = CloudflareOpError;
/** Updates a priority intelligence request in Cloudforce One. */
export const updateRequestPriority: API.OperationMethod<
  UpdateRequestPriorityRequest,
  UpdateRequestPriorityResponse,
  UpdateRequestPriorityError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: UpdateRequestPriorityRequest,
  output: UpdateRequestPriorityResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));