@distilled.cloud/cloudflare 0.0.0-john

package/lib/services/cloudforce-one.d.ts

@@ -0,0 +1,1387 @@
+/**
+ * Cloudflare CLOUDFORCE-ONE API
+ *
+ * Generated from Cloudflare TypeScript SDK.
+ * DO NOT EDIT - regenerate with: bun scripts/generate.ts --service cloudforce-one
+ */
+import * as stream from "effect/Stream";
+import * as Schema from "effect/Schema";
+import type * as HttpClient from "effect/unstable/http/HttpClient";
+import * as API from "../client/api.ts";
+import type { Credentials } from "../credentials.ts";
+import { type DefaultErrors } from "../errors.ts";
+export interface GetBinaryStorageRequest {
+    hash: string;
+    /** Account ID. */
+    accountId: string;
+}
+export declare const GetBinaryStorageRequest: Schema.Schema<GetBinaryStorageRequest>;
+export type GetBinaryStorageResponse = unknown;
+export declare const GetBinaryStorageResponse: Schema.Schema<unknown>;
+export type GetBinaryStorageError = DefaultErrors;
+export declare const getBinaryStorage: API.OperationMethod<GetBinaryStorageRequest, GetBinaryStorageResponse, GetBinaryStorageError, Credentials | HttpClient.HttpClient>;
+export interface CreateBinaryStorageRequest {
+    /** Path param: Account ID. */
+    accountId: string;
+    /** Body param: The binary file content to upload. */
+    file: File | Blob;
+}
+export declare const CreateBinaryStorageRequest: Schema.Schema<CreateBinaryStorageRequest>;
+export interface CreateBinaryStorageResponse {
+    contentType: string;
+    md5: string;
+    sha1: string;
+    sha256: string;
+}
+export declare const CreateBinaryStorageResponse: Schema.Schema<CreateBinaryStorageResponse>;
+export type CreateBinaryStorageError = DefaultErrors;
+export declare const createBinaryStorage: API.OperationMethod<CreateBinaryStorageRequest, CreateBinaryStorageResponse, CreateBinaryStorageError, Credentials | HttpClient.HttpClient>;
+export interface GetRequestRequest {
+    requestId: string;
+    /** Identifier. */
+    accountId: string;
+}
+export declare const GetRequestRequest: Schema.Schema<GetRequestRequest>;
+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: "clear" | "amber" | "amber-strict" | "green" | "red";
+    updated: string;
+    completed?: string | null;
+    /** Tokens for the request messages. */
+    messageTokens?: number | null;
+    /** Readable Request ID. */
+    readableId?: string | null;
+    /** Request Status. */
+    status?: "open" | "accepted" | "reported" | "approved" | "completed" | "declined" | null;
+    /** Tokens for the request. */
+    tokens?: number | null;
+}
+export declare const GetRequestResponse: Schema.Schema<GetRequestResponse>;
+export type GetRequestError = DefaultErrors;
+export declare const getRequest: API.OperationMethod<GetRequestRequest, GetRequestResponse, GetRequestError, Credentials | HttpClient.HttpClient>;
+export interface ListRequestsRequest {
+    /** Path param: Identifier. */
+    accountId: string;
+    /** Body param: Page number of results. */
+    page: number;
+    /** Body param: Number of results per page. */
+    perPage: number;
+    /** Body param: Retrieve requests completed after this time. */
+    completedAfter?: string;
+    /** Body param: Retrieve requests completed before this time. */
+    completedBefore?: string;
+    /** Body param: Retrieve requests created after this time. */
+    createdAfter?: string;
+    /** Body param: Retrieve requests created before this time. */
+    createdBefore?: string;
+    /** Body param: Requested information from request. */
+    requestType?: string;
+    /** Body param: Field to sort results by. */
+    sortBy?: string;
+    /** Body param: Sort order (asc or desc). */
+    sortOrder?: "asc" | "desc";
+    /** Body param: Request Status. */
+    status?: "open" | "accepted" | "reported" | "approved" | "completed" | "declined";
+}
+export declare const ListRequestsRequest: Schema.Schema<ListRequestsRequest>;
+export interface ListRequestsResponse {
+    result: {
+        id: string;
+        created: string;
+        priority: "routine" | "high" | "urgent";
+        request: string;
+        summary: string;
+        tlp: "clear" | "amber" | "amber-strict" | "green" | "red";
+        updated: string;
+        completed?: string | null;
+        messageTokens?: number | null;
+        readableId?: string | null;
+        status?: "open" | "accepted" | "reported" | "approved" | "completed" | "declined" | null;
+        tokens?: number | null;
+    }[];
+}
+export declare const ListRequestsResponse: Schema.Schema<ListRequestsResponse>;
+export type ListRequestsError = DefaultErrors;
+export declare const listRequests: API.PaginatedOperationMethod<ListRequestsRequest, ListRequestsResponse, ListRequestsError, Credentials | HttpClient.HttpClient> & {
+    pages: (input: ListRequestsRequest) => stream.Stream<ListRequestsResponse, ListRequestsError, Credentials | HttpClient.HttpClient>;
+    items: (input: ListRequestsRequest) => stream.Stream<{
+        id: string;
+        created: string;
+        priority: "routine" | "high" | "urgent";
+        request: string;
+        summary: string;
+        tlp: "clear" | "amber" | "amber-strict" | "green" | "red";
+        updated: string;
+        completed?: string | null;
+        messageTokens?: number | null;
+        readableId?: string | null;
+        status?: "open" | "accepted" | "reported" | "approved" | "completed" | "declined" | null;
+        tokens?: number | null;
+    }, ListRequestsError, Credentials | HttpClient.HttpClient>;
+};
+export interface CreateRequestRequest {
+    /** Path param: Identifier. */
+    accountId: string;
+    /** Body param: Request content. */
+    content?: string;
+    /** Body param: Priority for analyzing the request. */
+    priority?: string;
+    /** Body param: Requested information from request. */
+    requestType?: string;
+    /** Body param: Brief description of the request. */
+    summary?: string;
+    /** Body param: The CISA defined Traffic Light Protocol (TLP). */
+    tlp?: "clear" | "amber" | "amber-strict" | "green" | "red";
+}
+export declare const CreateRequestRequest: Schema.Schema<CreateRequestRequest>;
+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: "clear" | "amber" | "amber-strict" | "green" | "red";
+    updated: string;
+    completed?: string | null;
+    /** Tokens for the request messages. */
+    messageTokens?: number | null;
+    /** Readable Request ID. */
+    readableId?: string | null;
+    /** Request Status. */
+    status?: "open" | "accepted" | "reported" | "approved" | "completed" | "declined" | null;
+    /** Tokens for the request. */
+    tokens?: number | null;
+}
+export declare const CreateRequestResponse: Schema.Schema<CreateRequestResponse>;
+export type CreateRequestError = DefaultErrors;
+export declare const createRequest: API.OperationMethod<CreateRequestRequest, CreateRequestResponse, CreateRequestError, Credentials | HttpClient.HttpClient>;
+export interface UpdateRequestRequest {
+    requestId: string;
+    /** Path param: Identifier. */
+    accountId: string;
+    /** Body param: Request content. */
+    content?: string;
+    /** Body param: Priority for analyzing the request. */
+    priority?: string;
+    /** Body param: Requested information from request. */
+    requestType?: string;
+    /** Body param: Brief description of the request. */
+    summary?: string;
+    /** Body param: The CISA defined Traffic Light Protocol (TLP). */
+    tlp?: "clear" | "amber" | "amber-strict" | "green" | "red";
+}
+export declare const UpdateRequestRequest: Schema.Schema<UpdateRequestRequest>;
+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: "clear" | "amber" | "amber-strict" | "green" | "red";
+    updated: string;
+    completed?: string | null;
+    /** Tokens for the request messages. */
+    messageTokens?: number | null;
+    /** Readable Request ID. */
+    readableId?: string | null;
+    /** Request Status. */
+    status?: "open" | "accepted" | "reported" | "approved" | "completed" | "declined" | null;
+    /** Tokens for the request. */
+    tokens?: number | null;
+}
+export declare const UpdateRequestResponse: Schema.Schema<UpdateRequestResponse>;
+export type UpdateRequestError = DefaultErrors;
+export declare const updateRequest: API.OperationMethod<UpdateRequestRequest, UpdateRequestResponse, UpdateRequestError, Credentials | HttpClient.HttpClient>;
+export interface DeleteRequestRequest {
+    requestId: string;
+    /** Identifier. */
+    accountId: string;
+}
+export declare const DeleteRequestRequest: Schema.Schema<DeleteRequestRequest>;
+export interface DeleteRequestResponse {
+    errors: {
+        code: number;
+        message: string;
+        documentationUrl?: string | null;
+        source?: {
+            pointer?: string | null;
+        } | null;
+    }[];
+    messages: {
+        code: number;
+        message: string;
+        documentationUrl?: string | null;
+        source?: {
+            pointer?: string | null;
+        } | null;
+    }[];
+    /** Whether the API call was successful. */
+    success: true;
+}
+export declare const DeleteRequestResponse: Schema.Schema<DeleteRequestResponse>;
+export type DeleteRequestError = DefaultErrors;
+export declare const deleteRequest: API.OperationMethod<DeleteRequestRequest, DeleteRequestResponse, DeleteRequestError, Credentials | HttpClient.HttpClient>;
+export interface ConstantsRequestRequest {
+    /** Identifier. */
+    accountId: string;
+}
+export declare const ConstantsRequestRequest: Schema.Schema<ConstantsRequestRequest>;
+export interface ConstantsRequestResponse {
+    priority?: ("routine" | "high" | "urgent")[] | null;
+    status?: ("open" | "accepted" | "reported" | "approved" | "completed" | "declined")[] | null;
+    tlp?: ("clear" | "amber" | "amber-strict" | "green" | "red")[] | null;
+}
+export declare const ConstantsRequestResponse: Schema.Schema<ConstantsRequestResponse>;
+export type ConstantsRequestError = DefaultErrors;
+export declare const constantsRequest: API.OperationMethod<ConstantsRequestRequest, ConstantsRequestResponse, ConstantsRequestError, Credentials | HttpClient.HttpClient>;
+export interface QuotaRequestRequest {
+    /** Identifier. */
+    accountId: string;
+}
+export declare const QuotaRequestRequest: Schema.Schema<QuotaRequestRequest>;
+export interface QuotaRequestResponse {
+    /** 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 declare const QuotaRequestResponse: Schema.Schema<QuotaRequestResponse>;
+export type QuotaRequestError = DefaultErrors;
+export declare const quotaRequest: API.OperationMethod<QuotaRequestRequest, QuotaRequestResponse, QuotaRequestError, Credentials | HttpClient.HttpClient>;
+export interface TypesRequestRequest {
+    /** Identifier. */
+    accountId: string;
+}
+export declare const TypesRequestRequest: Schema.Schema<TypesRequestRequest>;
+export interface TypesRequestResponse {
+    result: string[];
+}
+export declare const TypesRequestResponse: Schema.Schema<TypesRequestResponse>;
+export type TypesRequestError = DefaultErrors;
+export declare const typesRequest: API.PaginatedOperationMethod<TypesRequestRequest, TypesRequestResponse, TypesRequestError, Credentials | HttpClient.HttpClient> & {
+    pages: (input: TypesRequestRequest) => stream.Stream<TypesRequestResponse, TypesRequestError, Credentials | HttpClient.HttpClient>;
+    items: (input: TypesRequestRequest) => stream.Stream<string, TypesRequestError, Credentials | HttpClient.HttpClient>;
+};
+export interface GetRequestAssetRequest {
+    requestId: string;
+    assetId: string;
+    /** Identifier. */
+    accountId: string;
+}
+export declare const GetRequestAssetRequest: Schema.Schema<GetRequestAssetRequest>;
+export interface GetRequestAssetResponse {
+    result: {
+        id: number;
+        name: string;
+        created?: string | null;
+        description?: string | null;
+        fileType?: string | null;
+    }[];
+}
+export declare const GetRequestAssetResponse: Schema.Schema<GetRequestAssetResponse>;
+export type GetRequestAssetError = DefaultErrors;
+export declare const getRequestAsset: API.PaginatedOperationMethod<GetRequestAssetRequest, GetRequestAssetResponse, GetRequestAssetError, Credentials | HttpClient.HttpClient> & {
+    pages: (input: GetRequestAssetRequest) => stream.Stream<GetRequestAssetResponse, GetRequestAssetError, Credentials | HttpClient.HttpClient>;
+    items: (input: GetRequestAssetRequest) => stream.Stream<{
+        id: number;
+        name: string;
+        created?: string | null;
+        description?: string | null;
+        fileType?: string | null;
+    }, GetRequestAssetError, Credentials | HttpClient.HttpClient>;
+};
+export interface CreateRequestAssetRequest {
+    requestId: string;
+    /** Path param: Identifier. */
+    accountId: string;
+    /** Body param: Page number of results. */
+    page: number;
+    /** Body param: Number of results per page. */
+    perPage: number;
+}
+export declare const CreateRequestAssetRequest: Schema.Schema<CreateRequestAssetRequest>;
+export interface CreateRequestAssetResponse {
+    result: {
+        id: number;
+        name: string;
+        created?: string | null;
+        description?: string | null;
+        fileType?: string | null;
+    }[];
+}
+export declare const CreateRequestAssetResponse: Schema.Schema<CreateRequestAssetResponse>;
+export type CreateRequestAssetError = DefaultErrors;
+export declare const createRequestAsset: API.PaginatedOperationMethod<CreateRequestAssetRequest, CreateRequestAssetResponse, CreateRequestAssetError, Credentials | HttpClient.HttpClient> & {
+    pages: (input: CreateRequestAssetRequest) => stream.Stream<CreateRequestAssetResponse, CreateRequestAssetError, Credentials | HttpClient.HttpClient>;
+    items: (input: CreateRequestAssetRequest) => stream.Stream<{
+        id: number;
+        name: string;
+        created?: string | null;
+        description?: string | null;
+        fileType?: string | null;
+    }, CreateRequestAssetError, Credentials | HttpClient.HttpClient>;
+};
+export interface UpdateRequestAssetRequest {
+    requestId: string;
+    assetId: string;
+    /** Path param: Identifier. */
+    accountId: string;
+    /** Body param: Asset file to upload. */
+    source?: string;
+}
+export declare const UpdateRequestAssetRequest: Schema.Schema<UpdateRequestAssetRequest>;
+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 declare const UpdateRequestAssetResponse: Schema.Schema<UpdateRequestAssetResponse>;
+export type UpdateRequestAssetError = DefaultErrors;
+export declare const updateRequestAsset: API.OperationMethod<UpdateRequestAssetRequest, UpdateRequestAssetResponse, UpdateRequestAssetError, Credentials | HttpClient.HttpClient>;
+export interface DeleteRequestAssetRequest {
+    requestId: string;
+    assetId: string;
+    /** Identifier. */
+    accountId: string;
+}
+export declare const DeleteRequestAssetRequest: Schema.Schema<DeleteRequestAssetRequest>;
+export interface DeleteRequestAssetResponse {
+    errors: {
+        code: number;
+        message: string;
+        documentationUrl?: string | null;
+        source?: {
+            pointer?: string | null;
+        } | null;
+    }[];
+    messages: {
+        code: number;
+        message: string;
+        documentationUrl?: string | null;
+        source?: {
+            pointer?: string | null;
+        } | null;
+    }[];
+    /** Whether the API call was successful. */
+    success: true;
+}
+export declare const DeleteRequestAssetResponse: Schema.Schema<DeleteRequestAssetResponse>;
+export type DeleteRequestAssetError = DefaultErrors;
+export declare const deleteRequestAsset: API.OperationMethod<DeleteRequestAssetRequest, DeleteRequestAssetResponse, DeleteRequestAssetError, Credentials | HttpClient.HttpClient>;
+export interface GetRequestMessageRequest {
+    requestId: string;
+    /** Path param: Identifier. */
+    accountId: string;
+    /** Body param: Page number of results. */
+    page: number;
+    /** Body param: Number of results per page. */
+    perPage: number;
+    /** Body param: Retrieve mes ges created after this time. */
+    after?: string;
+    /** Body param: Retrieve messages created before this time. */
+    before?: string;
+    /** Body param: Field to sort results by. */
+    sortBy?: string;
+    /** Body param: Sort order (asc or desc). */
+    sortOrder?: "asc" | "desc";
+}
+export declare const GetRequestMessageRequest: Schema.Schema<GetRequestMessageRequest>;
+export interface GetRequestMessageResponse {
+    result: {
+        code: number;
+        message: string;
+        documentationUrl?: string | null;
+        source?: {
+            pointer?: string | null;
+        } | null;
+    }[];
+}
+export declare const GetRequestMessageResponse: Schema.Schema<GetRequestMessageResponse>;
+export type GetRequestMessageError = DefaultErrors;
+export declare const getRequestMessage: API.PaginatedOperationMethod<GetRequestMessageRequest, GetRequestMessageResponse, GetRequestMessageError, Credentials | HttpClient.HttpClient> & {
+    pages: (input: GetRequestMessageRequest) => stream.Stream<GetRequestMessageResponse, GetRequestMessageError, Credentials | HttpClient.HttpClient>;
+    items: (input: GetRequestMessageRequest) => stream.Stream<{
+        code: number;
+        message: string;
+        documentationUrl?: string | null;
+        source?: {
+            pointer?: string | null;
+        } | null;
+    }, GetRequestMessageError, Credentials | HttpClient.HttpClient>;
+};
+export interface CreateRequestMessageRequest {
+    requestId: string;
+    /** Path param: Identifier. */
+    accountId: string;
+    /** Body param: Content of message. */
+    content?: string;
+}
+export declare const CreateRequestMessageRequest: Schema.Schema<CreateRequestMessageRequest>;
+export interface CreateRequestMessageResponse {
+    code: number;
+    message: string;
+    documentationUrl?: string | null;
+    source?: {
+        pointer?: string | null;
+    } | null;
+}
+export declare const CreateRequestMessageResponse: Schema.Schema<CreateRequestMessageResponse>;
+export type CreateRequestMessageError = DefaultErrors;
+export declare const createRequestMessage: API.OperationMethod<CreateRequestMessageRequest, CreateRequestMessageResponse, CreateRequestMessageError, Credentials | HttpClient.HttpClient>;
+export interface UpdateRequestMessageRequest {
+    requestId: string;
+    messageId: number;
+    /** Path param: Identifier. */
+    accountId: string;
+    /** Body param: Content of message. */
+    content?: string;
+}
+export declare const UpdateRequestMessageRequest: Schema.Schema<UpdateRequestMessageRequest>;
+export interface UpdateRequestMessageResponse {
+    code: number;
+    message: string;
+    documentationUrl?: string | null;
+    source?: {
+        pointer?: string | null;
+    } | null;
+}
+export declare const UpdateRequestMessageResponse: Schema.Schema<UpdateRequestMessageResponse>;
+export type UpdateRequestMessageError = DefaultErrors;
+export declare const updateRequestMessage: API.OperationMethod<UpdateRequestMessageRequest, UpdateRequestMessageResponse, UpdateRequestMessageError, Credentials | HttpClient.HttpClient>;
+export interface DeleteRequestMessageRequest {
+    requestId: string;
+    messageId: number;
+    /** Identifier. */
+    accountId: string;
+}
+export declare const DeleteRequestMessageRequest: Schema.Schema<DeleteRequestMessageRequest>;
+export interface DeleteRequestMessageResponse {
+    errors: {
+        code: number;
+        message: string;
+        documentationUrl?: string | null;
+        source?: {
+            pointer?: string | null;
+        } | null;
+    }[];
+    messages: {
+        code: number;
+        message: string;
+        documentationUrl?: string | null;
+        source?: {
+            pointer?: string | null;
+        } | null;
+    }[];
+    /** Whether the API call was successful. */
+    success: true;
+}
+export declare const DeleteRequestMessageResponse: Schema.Schema<DeleteRequestMessageResponse>;
+export type DeleteRequestMessageError = DefaultErrors;
+export declare const deleteRequestMessage: API.OperationMethod<DeleteRequestMessageRequest, DeleteRequestMessageResponse, DeleteRequestMessageError, Credentials | HttpClient.HttpClient>;
+export interface GetRequestPriorityRequest {
+    priorityId: string;
+    /** Identifier. */
+    accountId: string;
+}
+export declare const GetRequestPriorityRequest: Schema.Schema<GetRequestPriorityRequest>;
+export type GetRequestPriorityResponse = unknown;
+export declare const GetRequestPriorityResponse: Schema.Schema<unknown>;
+export type GetRequestPriorityError = DefaultErrors;
+export declare const getRequestPriority: API.OperationMethod<GetRequestPriorityRequest, GetRequestPriorityResponse, GetRequestPriorityError, Credentials | HttpClient.HttpClient>;
+export interface CreateRequestPriorityRequest {
+    /** Path param: Identifier. */
+    accountId: string;
+    /** Body param: List of labels. */
+    labels: string[];
+    /** Body param: Priority. */
+    priority: number;
+    /** Body param: Requirement. */
+    requirement: string;
+    /** Body param: The CISA defined Traffic Light Protocol (TLP). */
+    tlp: "clear" | "amber" | "amber-strict" | "green" | "red";
+}
+export declare const CreateRequestPriorityRequest: Schema.Schema<CreateRequestPriorityRequest>;
+export interface CreateRequestPriorityResponse {
+    /** UUID. */
+    id: string;
+    /** Priority creation time. */
+    created: string;
+    /** List of labels. */
+    labels: string[];
+    /** Priority. */
+    priority: number;
+    /** Requirement. */
+    requirement: string;
+    /** The CISA defined Traffic Light Protocol (TLP). */
+    tlp: "clear" | "amber" | "amber-strict" | "green" | "red";
+    /** Priority last updated time. */
+    updated: string;
+}
+export declare const CreateRequestPriorityResponse: Schema.Schema<CreateRequestPriorityResponse>;
+export type CreateRequestPriorityError = DefaultErrors;
+export declare const createRequestPriority: API.OperationMethod<CreateRequestPriorityRequest, CreateRequestPriorityResponse, CreateRequestPriorityError, Credentials | HttpClient.HttpClient>;
+export interface UpdateRequestPriorityRequest {
+    priorityId: string;
+    /** Path param: Identifier. */
+    accountId: string;
+    /** Body param: List of labels. */
+    labels: string[];
+    /** Body param: Priority. */
+    priority: number;
+    /** Body param: Requirement. */
+    requirement: string;
+    /** Body param: The CISA defined Traffic Light Protocol (TLP). */
+    tlp: "clear" | "amber" | "amber-strict" | "green" | "red";
+}
+export declare const UpdateRequestPriorityRequest: Schema.Schema<UpdateRequestPriorityRequest>;
+export type UpdateRequestPriorityResponse = unknown;
+export declare const UpdateRequestPriorityResponse: Schema.Schema<unknown>;
+export type UpdateRequestPriorityError = DefaultErrors;
+export declare const updateRequestPriority: API.OperationMethod<UpdateRequestPriorityRequest, UpdateRequestPriorityResponse, UpdateRequestPriorityError, Credentials | HttpClient.HttpClient>;
+export interface DeleteRequestPriorityRequest {
+    priorityId: string;
+    /** Identifier. */
+    accountId: string;
+}
+export declare const DeleteRequestPriorityRequest: Schema.Schema<DeleteRequestPriorityRequest>;
+export interface DeleteRequestPriorityResponse {
+    errors: {
+        code: number;
+        message: string;
+        documentationUrl?: string | null;
+        source?: {
+            pointer?: string | null;
+        } | null;
+    }[];
+    messages: {
+        code: number;
+        message: string;
+        documentationUrl?: string | null;
+        source?: {
+            pointer?: string | null;
+        } | null;
+    }[];
+    /** Whether the API call was successful. */
+    success: true;
+}
+export declare const DeleteRequestPriorityResponse: Schema.Schema<DeleteRequestPriorityResponse>;
+export type DeleteRequestPriorityError = DefaultErrors;
+export declare const deleteRequestPriority: API.OperationMethod<DeleteRequestPriorityRequest, DeleteRequestPriorityResponse, DeleteRequestPriorityError, Credentials | HttpClient.HttpClient>;
+export interface QuotaRequestPriorityRequest {
+    /** Identifier. */
+    accountId: string;
+}
+export declare const QuotaRequestPriorityRequest: Schema.Schema<QuotaRequestPriorityRequest>;
+export type QuotaRequestPriorityResponse = unknown;
+export declare const QuotaRequestPriorityResponse: Schema.Schema<unknown>;
+export type QuotaRequestPriorityError = DefaultErrors;
+export declare const quotaRequestPriority: API.OperationMethod<QuotaRequestPriorityRequest, QuotaRequestPriorityResponse, QuotaRequestPriorityError, Credentials | HttpClient.HttpClient>;
+export interface ListScanConfigsRequest {
+    /** Defines the Account ID. */
+    accountId: string;
+}
+export declare const ListScanConfigsRequest: Schema.Schema<ListScanConfigsRequest>;
+export interface ListScanConfigsResponse {
+    result: {
+        id: string;
+        accountId: string;
+        frequency: number;
+        ips: string[];
+        ports: string[];
+    }[];
+}
+export declare const ListScanConfigsResponse: Schema.Schema<ListScanConfigsResponse>;
+export type ListScanConfigsError = DefaultErrors;
+export declare const listScanConfigs: API.PaginatedOperationMethod<ListScanConfigsRequest, ListScanConfigsResponse, ListScanConfigsError, Credentials | HttpClient.HttpClient> & {
+    pages: (input: ListScanConfigsRequest) => stream.Stream<ListScanConfigsResponse, ListScanConfigsError, Credentials | HttpClient.HttpClient>;
+    items: (input: ListScanConfigsRequest) => stream.Stream<{
+        id: string;
+        accountId: string;
+        frequency: number;
+        ips: string[];
+        ports: string[];
+    }, ListScanConfigsError, Credentials | HttpClient.HttpClient>;
+};
+export interface CreateScanConfigRequest {
+    /** Path param: Defines the Account ID. */
+    accountId: string;
+    /** Body param: Defines a list of IP addresses or CIDR blocks to scan. The maximum number of total IP addresses allowed is 5000. */
+    ips: string[];
+    /** Body param: Defines the number of days between each scan (0 = One-off scan). */
+    frequency?: number;
+    /** Body param: 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?: string[];
+}
+export declare const CreateScanConfigRequest: Schema.Schema<CreateScanConfigRequest>;
+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: string[];
+    /** 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: string[];
+}
+export declare const CreateScanConfigResponse: Schema.Schema<CreateScanConfigResponse>;
+export type CreateScanConfigError = DefaultErrors;
+export declare const createScanConfig: API.OperationMethod<CreateScanConfigRequest, CreateScanConfigResponse, CreateScanConfigError, Credentials | HttpClient.HttpClient>;
+export interface PatchScanConfigRequest {
+    configId: string;
+    /** Path param: Defines the Account ID. */
+    accountId: string;
+    /** Body param: Defines the number of days between each scan (0 = One-off scan). */
+    frequency?: number;
+    /** Body param: Defines a list of IP addresses or CIDR blocks to scan. The maximum number of total IP addresses allowed is 5000. */
+    ips?: string[];
+    /** Body param: 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?: string[];
+}
+export declare const PatchScanConfigRequest: Schema.Schema<PatchScanConfigRequest>;
+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: string[];
+    /** 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: string[];
+}
+export declare const PatchScanConfigResponse: Schema.Schema<PatchScanConfigResponse>;
+export type PatchScanConfigError = DefaultErrors;
+export declare const patchScanConfig: API.OperationMethod<PatchScanConfigRequest, PatchScanConfigResponse, PatchScanConfigError, Credentials | HttpClient.HttpClient>;
+export interface DeleteScanConfigRequest {
+    configId: string;
+    /** Defines the Account ID. */
+    accountId: string;
+}
+export declare const DeleteScanConfigRequest: Schema.Schema<DeleteScanConfigRequest>;
+export type DeleteScanConfigResponse = unknown;
+export declare const DeleteScanConfigResponse: Schema.Schema<unknown>;
+export type DeleteScanConfigError = DefaultErrors;
+export declare const deleteScanConfig: API.OperationMethod<DeleteScanConfigRequest, DeleteScanConfigResponse, DeleteScanConfigError, Credentials | HttpClient.HttpClient>;
+export interface GetScanResultRequest {
+    configId: string;
+    /** Defines the Account ID. */
+    accountId: string;
+}
+export declare const GetScanResultRequest: Schema.Schema<GetScanResultRequest>;
+export interface GetScanResultResponse {
+    "1.1.1.1": {
+        number?: number | null;
+        proto?: string | null;
+        status?: string | null;
+    }[];
+}
+export declare const GetScanResultResponse: Schema.Schema<GetScanResultResponse>;
+export type GetScanResultError = DefaultErrors;
+export declare const getScanResult: API.OperationMethod<GetScanResultRequest, GetScanResultResponse, GetScanResultError, Credentials | HttpClient.HttpClient>;
+export interface GetThreatEventRequest {
+    eventId: string;
+    /** Account ID. */
+    accountId: string;
+}
+export declare const GetThreatEventRequest: Schema.Schema<GetThreatEventRequest>;
+export interface GetThreatEventResponse {
+    attacker: string;
+    attackerCountry: string;
+    category: string;
+    date: string;
+    event: string;
+    hasChildren: boolean;
+    indicator: string;
+    indicatorType: string;
+    indicatorTypeId: number;
+    killChain: number;
+    mitreAttack: string[];
+    numReferenced: number;
+    numReferences: number;
+    rawId: string;
+    referenced: string[];
+    referencedIds: number[];
+    references: string[];
+    referencesIds: number[];
+    tags: string[];
+    targetCountry: string;
+    targetIndustry: string;
+    tlp: string;
+    uuid: string;
+    insight?: string | null;
+    releasabilityId?: string | null;
+}
+export declare const GetThreatEventResponse: Schema.Schema<GetThreatEventResponse>;
+export type GetThreatEventError = DefaultErrors;
+export declare const getThreatEvent: API.OperationMethod<GetThreatEventRequest, GetThreatEventResponse, GetThreatEventError, Credentials | HttpClient.HttpClient>;
+export interface ListThreatEventsRequest {
+    /** Path param: Account ID. */
+    accountId: string;
+    /** Query param: */
+    datasetId?: string[];
+    /** Query param: */
+    forceRefresh?: boolean;
+    /** Query param: */
+    format?: "json" | "stix2";
+    /** Query param: */
+    order?: "asc" | "desc";
+    /** Query param: */
+    orderBy?: string;
+    /** Query param: */
+    page?: number;
+    /** Query param: */
+    pageSize?: number;
+    /** Query param: */
+    search?: {
+        field?: string;
+        op?: "equals" | "not" | "gt" | "gte" | "lt" | "lte" | "like" | "contains" | "startsWith" | "endsWith" | "in" | "find";
+        value?: string | number | (string | number)[];
+    }[];
+}
+export declare const ListThreatEventsRequest: Schema.Schema<ListThreatEventsRequest>;
+export type ListThreatEventsResponse = {
+    attacker: string;
+    attackerCountry: string;
+    category: string;
+    date: string;
+    event: string;
+    hasChildren: boolean;
+    indicator: string;
+    indicatorType: string;
+    indicatorTypeId: number;
+    killChain: number;
+    mitreAttack: string[];
+    numReferenced: number;
+    numReferences: number;
+    rawId: string;
+    referenced: string[];
+    referencedIds: number[];
+    references: string[];
+    referencesIds: number[];
+    tags: string[];
+    targetCountry: string;
+    targetIndustry: string;
+    tlp: string;
+    uuid: string;
+    insight?: string | null;
+    releasabilityId?: string | null;
+}[];
+export declare const ListThreatEventsResponse: Schema.Schema<ListThreatEventsResponse>;
+export type ListThreatEventsError = DefaultErrors;
+export declare const listThreatEvents: API.OperationMethod<ListThreatEventsRequest, ListThreatEventsResponse, ListThreatEventsError, Credentials | HttpClient.HttpClient>;
+export interface CreateThreatEventRequest {
+    /** Path param: Account ID. */
+    accountId: string;
+    /** Body param: */
+    category: string;
+    /** Body param: */
+    date: string;
+    /** Body param: */
+    event: string;
+    /** Body param: */
+    raw: {
+        data: Record<string, unknown> | null;
+        source?: string;
+        tlp?: string;
+    };
+    /** Body param: */
+    tlp: string;
+    /** Body param: */
+    attacker?: string | null;
+    /** Body param: */
+    attackerCountry?: string;
+    /** Body param: */
+    datasetId?: string;
+    /** Body param: */
+    indicator?: string;
+    /** Body param: Array of indicators for this event. Supports multiple indicators per event for complex scenarios. */
+    indicators?: {
+        indicatorType: string;
+        value: string;
+    }[];
+    /** Body param: */
+    indicatorType?: string;
+    /** Body param: */
+    insight?: string;
+    /** Body param: */
+    tags?: string[];
+    /** Body param: */
+    targetCountry?: string;
+    /** Body param: */
+    targetIndustry?: string;
+    /** Body param: Optional UUID for the event. Only used when preserveUuid=true in bulk create. Must be a valid UUID format. */
+    uuid?: string;
+}
+export declare const CreateThreatEventRequest: Schema.Schema<CreateThreatEventRequest>;
+export interface CreateThreatEventResponse {
+    attacker: string;
+    attackerCountry: string;
+    category: string;
+    date: string;
+    event: string;
+    hasChildren: boolean;
+    indicator: string;
+    indicatorType: string;
+    indicatorTypeId: number;
+    killChain: number;
+    mitreAttack: string[];
+    numReferenced: number;
+    numReferences: number;
+    rawId: string;
+    referenced: string[];
+    referencedIds: number[];
+    references: string[];
+    referencesIds: number[];
+    tags: string[];
+    targetCountry: string;
+    targetIndustry: string;
+    tlp: string;
+    uuid: string;
+    insight?: string | null;
+    releasabilityId?: string | null;
+}
+export declare const CreateThreatEventResponse: Schema.Schema<CreateThreatEventResponse>;
+export type CreateThreatEventError = DefaultErrors;
+export declare const createThreatEvent: API.OperationMethod<CreateThreatEventRequest, CreateThreatEventResponse, CreateThreatEventError, Credentials | HttpClient.HttpClient>;
+export interface PatchThreatEventRequest {
+    eventId: string;
+    /** Path param: Account ID. */
+    accountId: string;
+    /** Body param: */
+    attacker?: string | null;
+    /** Body param: */
+    attackerCountry?: string;
+    /** Body param: */
+    category?: string;
+    /** Body param: */
+    createdAt?: string;
+    /** Body param: */
+    datasetId?: string;
+    /** Body param: */
+    date?: string;
+    /** Body param: */
+    event?: string;
+    /** Body param: */
+    indicator?: string;
+    /** Body param: */
+    indicatorType?: string;
+    /** Body param: */
+    insight?: string;
+    /** Body param: */
+    raw?: {
+        data?: Record<string, unknown> | null;
+        source?: string;
+        tlp?: string;
+    };
+    /** Body param: */
+    targetCountry?: string;
+    /** Body param: */
+    targetIndustry?: string;
+    /** Body param: */
+    tlp?: string;
+}
+export declare const PatchThreatEventRequest: Schema.Schema<PatchThreatEventRequest>;
+export interface PatchThreatEventResponse {
+    attacker: string;
+    attackerCountry: string;
+    category: string;
+    date: string;
+    event: string;
+    hasChildren: boolean;
+    indicator: string;
+    indicatorType: string;
+    indicatorTypeId: number;
+    killChain: number;
+    mitreAttack: string[];
+    numReferenced: number;
+    numReferences: number;
+    rawId: string;
+    referenced: string[];
+    referencedIds: number[];
+    references: string[];
+    referencesIds: number[];
+    tags: string[];
+    targetCountry: string;
+    targetIndustry: string;
+    tlp: string;
+    uuid: string;
+    insight?: string | null;
+    releasabilityId?: string | null;
+}
+export declare const PatchThreatEventResponse: Schema.Schema<PatchThreatEventResponse>;
+export type PatchThreatEventError = DefaultErrors;
+export declare const patchThreatEvent: API.OperationMethod<PatchThreatEventRequest, PatchThreatEventResponse, PatchThreatEventError, Credentials | HttpClient.HttpClient>;
+export interface DeleteThreatEventRequest {
+    eventId: string;
+    /** Account ID. */
+    accountId: string;
+}
+export declare const DeleteThreatEventRequest: Schema.Schema<DeleteThreatEventRequest>;
+export interface DeleteThreatEventResponse {
+    uuid: string;
+}
+export declare const DeleteThreatEventResponse: Schema.Schema<DeleteThreatEventResponse>;
+export type DeleteThreatEventError = DefaultErrors;
+export declare const deleteThreatEvent: API.OperationMethod<DeleteThreatEventRequest, DeleteThreatEventResponse, DeleteThreatEventError, Credentials | HttpClient.HttpClient>;
+export interface BulkCreateThreatEventsRequest {
+    /** Path param: Account ID. */
+    accountId: string;
+    /** Body param: */
+    data: {
+        category: string;
+        date: string;
+        event: string;
+        raw: {
+            data: Record<string, unknown> | null;
+            source?: string;
+            tlp?: string;
+        };
+        tlp: string;
+        accountId?: number;
+        attacker?: string | null;
+        attackerCountry?: string;
+        datasetId?: string;
+        indicator?: string;
+        indicators?: {
+            indicatorType: string;
+            value: string;
+        }[];
+        indicatorType?: string;
+        insight?: string;
+        tags?: string[];
+        targetCountry?: string;
+        targetIndustry?: string;
+        uuid?: string;
+    }[];
+    /** Body param: */
+    datasetId: string;
+    /** Body param: When true, use provided UUIDs from event data instead of generating new ones. Used for migration scenarios where original UUIDs must be preserved. Duplicate UUIDs will be skipped. */
+    preserveUuid?: boolean;
+}
+export declare const BulkCreateThreatEventsRequest: Schema.Schema<BulkCreateThreatEventsRequest>;
+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;
+    /** Number of events skipped due to duplicate UUID (only when preserveUuid=true) */
+    skippedEventsCount: number;
+    /** Correlation ID for async indicator processing */
+    createBulkEventsRequestId?: string | null;
+    /** Array of error details */
+    errors?: {
+        error: string;
+        eventIndex: number;
+    }[] | null;
+}
+export declare const BulkCreateThreatEventsResponse: Schema.Schema<BulkCreateThreatEventsResponse>;
+export type BulkCreateThreatEventsError = DefaultErrors;
+export declare const bulkCreateThreatEvents: API.OperationMethod<BulkCreateThreatEventsRequest, BulkCreateThreatEventsResponse, BulkCreateThreatEventsError, Credentials | HttpClient.HttpClient>;
+export interface ListThreatEventAttackersRequest {
+    /** Path param: Account ID. */
+    accountId: string;
+    /** Query param: Array of dataset IDs to query attackers from. If not provided, uses the default dataset. */
+    datasetIds?: string[];
+}
+export declare const ListThreatEventAttackersRequest: Schema.Schema<ListThreatEventAttackersRequest>;
+export interface ListThreatEventAttackersResponse {
+    items: {
+        type: string;
+    };
+    type: string;
+}
+export declare const ListThreatEventAttackersResponse: Schema.Schema<ListThreatEventAttackersResponse>;
+export type ListThreatEventAttackersError = DefaultErrors;
+export declare const listThreatEventAttackers: API.OperationMethod<ListThreatEventAttackersRequest, ListThreatEventAttackersResponse, ListThreatEventAttackersError, Credentials | HttpClient.HttpClient>;
+export interface GetThreatEventCategoryRequest {
+    categoryId: string;
+    /** Account ID. */
+    accountId: string;
+}
+export declare const GetThreatEventCategoryRequest: Schema.Schema<GetThreatEventCategoryRequest>;
+export interface GetThreatEventCategoryResponse {
+    killChain: number;
+    name: string;
+    uuid: string;
+    mitreAttack?: string[] | null;
+    shortname?: string | null;
+}
+export declare const GetThreatEventCategoryResponse: Schema.Schema<GetThreatEventCategoryResponse>;
+export type GetThreatEventCategoryError = DefaultErrors;
+export declare const getThreatEventCategory: API.OperationMethod<GetThreatEventCategoryRequest, GetThreatEventCategoryResponse, GetThreatEventCategoryError, Credentials | HttpClient.HttpClient>;
+export interface ListThreatEventCategoriesRequest {
+    /** Path param: Account ID. */
+    accountId: string;
+    /** Query param: Array of dataset IDs to query categories from. If not provided, uses the default dataset. */
+    datasetIds?: string[];
+}
+export declare const ListThreatEventCategoriesRequest: Schema.Schema<ListThreatEventCategoriesRequest>;
+export type ListThreatEventCategoriesResponse = {
+    killChain: number;
+    name: string;
+    uuid: string;
+    mitreAttack?: string[] | null;
+    shortname?: string | null;
+}[];
+export declare const ListThreatEventCategoriesResponse: Schema.Schema<ListThreatEventCategoriesResponse>;
+export type ListThreatEventCategoriesError = DefaultErrors;
+export declare const listThreatEventCategories: API.OperationMethod<ListThreatEventCategoriesRequest, ListThreatEventCategoriesResponse, ListThreatEventCategoriesError, Credentials | HttpClient.HttpClient>;
+export interface CreateThreatEventCategoryRequest {
+    /** Path param: Account ID. */
+    accountId: string;
+    /** Body param: */
+    killChain: number;
+    /** Body param: */
+    name: string;
+    /** Body param: */
+    mitreAttack?: string[];
+    /** Body param: */
+    shortname?: string;
+}
+export declare const CreateThreatEventCategoryRequest: Schema.Schema<CreateThreatEventCategoryRequest>;
+export interface CreateThreatEventCategoryResponse {
+    killChain: number;
+    name: string;
+    uuid: string;
+    mitreAttack?: string[] | null;
+    shortname?: string | null;
+}
+export declare const CreateThreatEventCategoryResponse: Schema.Schema<CreateThreatEventCategoryResponse>;
+export type CreateThreatEventCategoryError = DefaultErrors;
+export declare const createThreatEventCategory: API.OperationMethod<CreateThreatEventCategoryRequest, CreateThreatEventCategoryResponse, CreateThreatEventCategoryError, Credentials | HttpClient.HttpClient>;
+export interface PatchThreatEventCategoryRequest {
+    categoryId: string;
+    /** Path param: Account ID. */
+    accountId: string;
+    /** Body param: */
+    killChain?: number;
+    /** Body param: */
+    mitreAttack?: string[];
+    /** Body param: */
+    name?: string;
+    /** Body param: */
+    shortname?: string;
+}
+export declare const PatchThreatEventCategoryRequest: Schema.Schema<PatchThreatEventCategoryRequest>;
+export interface PatchThreatEventCategoryResponse {
+    killChain: number;
+    name: string;
+    uuid: string;
+    mitreAttack?: string[] | null;
+    shortname?: string | null;
+}
+export declare const PatchThreatEventCategoryResponse: Schema.Schema<PatchThreatEventCategoryResponse>;
+export type PatchThreatEventCategoryError = DefaultErrors;
+export declare const patchThreatEventCategory: API.OperationMethod<PatchThreatEventCategoryRequest, PatchThreatEventCategoryResponse, PatchThreatEventCategoryError, Credentials | HttpClient.HttpClient>;
+export interface DeleteThreatEventCategoryRequest {
+    categoryId: string;
+    /** Account ID. */
+    accountId: string;
+}
+export declare const DeleteThreatEventCategoryRequest: Schema.Schema<DeleteThreatEventCategoryRequest>;
+export interface DeleteThreatEventCategoryResponse {
+    uuid: string;
+}
+export declare const DeleteThreatEventCategoryResponse: Schema.Schema<DeleteThreatEventCategoryResponse>;
+export type DeleteThreatEventCategoryError = DefaultErrors;
+export declare const deleteThreatEventCategory: API.OperationMethod<DeleteThreatEventCategoryRequest, DeleteThreatEventCategoryResponse, DeleteThreatEventCategoryError, Credentials | HttpClient.HttpClient>;
+export interface ListThreatEventCountriesRequest {
+    /** Account ID. */
+    accountId: string;
+}
+export declare const ListThreatEventCountriesRequest: Schema.Schema<ListThreatEventCountriesRequest>;
+export type ListThreatEventCountriesResponse = {
+    result: {
+        alpha3: string;
+        name: string;
+    }[];
+    success: string;
+}[];
+export declare const ListThreatEventCountriesResponse: Schema.Schema<ListThreatEventCountriesResponse>;
+export type ListThreatEventCountriesError = DefaultErrors;
+export declare const listThreatEventCountries: API.OperationMethod<ListThreatEventCountriesRequest, ListThreatEventCountriesResponse, ListThreatEventCountriesError, Credentials | HttpClient.HttpClient>;
+export interface GetThreatEventDatasetRequest {
+    datasetId: string;
+    /** Account ID. */
+    accountId: string;
+}
+export declare const GetThreatEventDatasetRequest: Schema.Schema<GetThreatEventDatasetRequest>;
+export interface GetThreatEventDatasetResponse {
+    isPublic: boolean;
+    name: string;
+    uuid: string;
+}
+export declare const GetThreatEventDatasetResponse: Schema.Schema<GetThreatEventDatasetResponse>;
+export type GetThreatEventDatasetError = DefaultErrors;
+export declare const getThreatEventDataset: API.OperationMethod<GetThreatEventDatasetRequest, GetThreatEventDatasetResponse, GetThreatEventDatasetError, Credentials | HttpClient.HttpClient>;
+export interface ListThreatEventDatasetsRequest {
+    /** Account ID. */
+    accountId: string;
+}
+export declare const ListThreatEventDatasetsRequest: Schema.Schema<ListThreatEventDatasetsRequest>;
+export type ListThreatEventDatasetsResponse = {
+    isPublic: boolean;
+    name: string;
+    uuid: string;
+}[];
+export declare const ListThreatEventDatasetsResponse: Schema.Schema<ListThreatEventDatasetsResponse>;
+export type ListThreatEventDatasetsError = DefaultErrors;
+export declare const listThreatEventDatasets: API.OperationMethod<ListThreatEventDatasetsRequest, ListThreatEventDatasetsResponse, ListThreatEventDatasetsError, Credentials | HttpClient.HttpClient>;
+export interface CreateThreatEventDatasetRequest {
+    /** Path param: Account ID. */
+    accountId: string;
+    /** Body param: If true, then anyone can search the dataset. If false, then its limited to the account. */
+    isPublic: boolean;
+    /** Body param: Used to describe the dataset within the account context. */
+    name: string;
+}
+export declare const CreateThreatEventDatasetRequest: Schema.Schema<CreateThreatEventDatasetRequest>;
+export interface CreateThreatEventDatasetResponse {
+    isPublic: boolean;
+    name: string;
+    uuid: string;
+}
+export declare const CreateThreatEventDatasetResponse: Schema.Schema<CreateThreatEventDatasetResponse>;
+export type CreateThreatEventDatasetError = DefaultErrors;
+export declare const createThreatEventDataset: API.OperationMethod<CreateThreatEventDatasetRequest, CreateThreatEventDatasetResponse, CreateThreatEventDatasetError, Credentials | HttpClient.HttpClient>;
+export interface PatchThreatEventDatasetRequest {
+    datasetId: string;
+    /** Path param: Account ID. */
+    accountId: string;
+    /** Body param: If true, then anyone can search the dataset. If false, then its limited to the account. */
+    isPublic: boolean;
+    /** Body param: Used to describe the dataset within the account context. */
+    name: string;
+}
+export declare const PatchThreatEventDatasetRequest: Schema.Schema<PatchThreatEventDatasetRequest>;
+export interface PatchThreatEventDatasetResponse {
+    isPublic: boolean;
+    name: string;
+    uuid: string;
+}
+export declare const PatchThreatEventDatasetResponse: Schema.Schema<PatchThreatEventDatasetResponse>;
+export type PatchThreatEventDatasetError = DefaultErrors;
+export declare const patchThreatEventDataset: API.OperationMethod<PatchThreatEventDatasetRequest, PatchThreatEventDatasetResponse, PatchThreatEventDatasetError, Credentials | HttpClient.HttpClient>;
+export interface RawThreatEventDatasetRequest {
+    datasetId: string;
+    eventId: string;
+    /** Account ID. */
+    accountId: string;
+}
+export declare const RawThreatEventDatasetRequest: Schema.Schema<RawThreatEventDatasetRequest>;
+export interface RawThreatEventDatasetResponse {
+    id: string;
+    accountId: number;
+    created: string;
+    data: unknown;
+    source: string;
+    tlp: string;
+}
+export declare const RawThreatEventDatasetResponse: Schema.Schema<RawThreatEventDatasetResponse>;
+export type RawThreatEventDatasetError = DefaultErrors;
+export declare const rawThreatEventDataset: API.OperationMethod<RawThreatEventDatasetRequest, RawThreatEventDatasetResponse, RawThreatEventDatasetError, Credentials | HttpClient.HttpClient>;
+export interface CreateThreatEventEventTagRequest {
+    eventId: string;
+    /** Path param: Account ID. */
+    accountId: string;
+    /** Body param: */
+    tags: string[];
+}
+export declare const CreateThreatEventEventTagRequest: Schema.Schema<CreateThreatEventEventTagRequest>;
+export interface CreateThreatEventEventTagResponse {
+    success: boolean;
+}
+export declare const CreateThreatEventEventTagResponse: Schema.Schema<CreateThreatEventEventTagResponse>;
+export type CreateThreatEventEventTagError = DefaultErrors;
+export declare const createThreatEventEventTag: API.OperationMethod<CreateThreatEventEventTagRequest, CreateThreatEventEventTagResponse, CreateThreatEventEventTagError, Credentials | HttpClient.HttpClient>;
+export interface DeleteThreatEventEventTagRequest {
+    eventId: string;
+    /** Account ID. */
+    accountId: string;
+}
+export declare const DeleteThreatEventEventTagRequest: Schema.Schema<DeleteThreatEventEventTagRequest>;
+export interface DeleteThreatEventEventTagResponse {
+    success: boolean;
+}
+export declare const DeleteThreatEventEventTagResponse: Schema.Schema<DeleteThreatEventEventTagResponse>;
+export type DeleteThreatEventEventTagError = DefaultErrors;
+export declare const deleteThreatEventEventTag: API.OperationMethod<DeleteThreatEventEventTagRequest, DeleteThreatEventEventTagResponse, DeleteThreatEventEventTagError, Credentials | HttpClient.HttpClient>;
+export interface ListThreatEventIndicatorTypesRequest {
+    /** Account ID. */
+    accountId: string;
+}
+export declare const ListThreatEventIndicatorTypesRequest: Schema.Schema<ListThreatEventIndicatorTypesRequest>;
+export interface ListThreatEventIndicatorTypesResponse {
+    items: {
+        type: string;
+    };
+    type: string;
+}
+export declare const ListThreatEventIndicatorTypesResponse: Schema.Schema<ListThreatEventIndicatorTypesResponse>;
+export type ListThreatEventIndicatorTypesError = DefaultErrors;
+export declare const listThreatEventIndicatorTypes: API.OperationMethod<ListThreatEventIndicatorTypesRequest, ListThreatEventIndicatorTypesResponse, ListThreatEventIndicatorTypesError, Credentials | HttpClient.HttpClient>;
+export interface GetThreatEventRawRequest {
+    eventId: string;
+    rawId: string;
+    /** Account ID. */
+    accountId: string;
+}
+export declare const GetThreatEventRawRequest: Schema.Schema<GetThreatEventRawRequest>;
+export interface GetThreatEventRawResponse {
+    id: string;
+    accountId: number;
+    created: string;
+    data: unknown;
+    source: string;
+    tlp: string;
+}
+export declare const GetThreatEventRawResponse: Schema.Schema<GetThreatEventRawResponse>;
+export type GetThreatEventRawError = DefaultErrors;
+export declare const getThreatEventRaw: API.OperationMethod<GetThreatEventRawRequest, GetThreatEventRawResponse, GetThreatEventRawError, Credentials | HttpClient.HttpClient>;
+export interface PatchThreatEventRawRequest {
+    eventId: string;
+    rawId: string;
+    /** Path param: Account ID. */
+    accountId: string;
+    /** Body param: */
+    data?: unknown;
+    /** Body param: */
+    source?: string;
+    /** Body param: */
+    tlp?: string;
+}
+export declare const PatchThreatEventRawRequest: Schema.Schema<PatchThreatEventRawRequest>;
+export interface PatchThreatEventRawResponse {
+    id: string;
+    data: unknown;
+}
+export declare const PatchThreatEventRawResponse: Schema.Schema<PatchThreatEventRawResponse>;
+export type PatchThreatEventRawError = DefaultErrors;
+export declare const patchThreatEventRaw: API.OperationMethod<PatchThreatEventRawRequest, PatchThreatEventRawResponse, PatchThreatEventRawError, Credentials | HttpClient.HttpClient>;
+export interface DeleteThreatEventRelateRequest {
+    eventId: string;
+    /** Account ID. */
+    accountId: string;
+}
+export declare const DeleteThreatEventRelateRequest: Schema.Schema<DeleteThreatEventRelateRequest>;
+export interface DeleteThreatEventRelateResponse {
+    success: boolean;
+}
+export declare const DeleteThreatEventRelateResponse: Schema.Schema<DeleteThreatEventRelateResponse>;
+export type DeleteThreatEventRelateError = DefaultErrors;
+export declare const deleteThreatEventRelate: API.OperationMethod<DeleteThreatEventRelateRequest, DeleteThreatEventRelateResponse, DeleteThreatEventRelateError, Credentials | HttpClient.HttpClient>;
+export interface CreateThreatEventTagRequest {
+    /** Path param: Account ID. */
+    accountId: string;
+    /** Body param: */
+    value: string;
+    /** Body param: */
+    activeDuration?: string;
+    /** Body param: */
+    actorCategory?: string;
+    /** Body param: */
+    aliasGroupNames?: string[];
+    /** Body param: */
+    aliasGroupNamesInternal?: string[];
+    /** Body param: */
+    analyticPriority?: number;
+    /** Body param: */
+    attributionConfidence?: string;
+    /** Body param: */
+    attributionOrganization?: string;
+    /** Body param: */
+    categoryUuid?: string;
+    /** Body param: */
+    externalReferenceLinks?: string[];
+    /** Body param: */
+    internalDescription?: string;
+    /** Body param: */
+    motive?: string;
+    /** Body param: */
+    opsecLevel?: string;
+    /** Body param: */
+    originCountryISO?: string;
+    /** Body param: */
+    priority?: number;
+    /** Body param: */
+    sophisticationLevel?: string;
+}
+export declare const CreateThreatEventTagRequest: Schema.Schema<CreateThreatEventTagRequest>;
+export interface CreateThreatEventTagResponse {
+    uuid: string;
+    value: string;
+    activeDuration?: string | null;
+    actorCategory?: string | null;
+    aliasGroupNames?: string[] | null;
+    aliasGroupNamesInternal?: string[] | null;
+    analyticPriority?: number | null;
+    attributionConfidence?: string | null;
+    attributionOrganization?: string | null;
+    categoryName?: string | null;
+    categoryUuid?: string | null;
+    externalReferenceLinks?: string[] | null;
+    internalDescription?: string | null;
+    motive?: string | null;
+    opsecLevel?: string | null;
+    originCountryISO?: string | null;
+    priority?: number | null;
+    sophisticationLevel?: string | null;
+}
+export declare const CreateThreatEventTagResponse: Schema.Schema<CreateThreatEventTagResponse>;
+export type CreateThreatEventTagError = DefaultErrors;
+export declare const createThreatEventTag: API.OperationMethod<CreateThreatEventTagRequest, CreateThreatEventTagResponse, CreateThreatEventTagError, Credentials | HttpClient.HttpClient>;
+export interface ListThreatEventTargetIndustriesRequest {
+    /** Path param: Account ID. */
+    accountId: string;
+    /** Query param: Array of dataset IDs to query target industries from. If not provided, uses the default dataset. */
+    datasetIds?: string[];
+}
+export declare const ListThreatEventTargetIndustriesRequest: Schema.Schema<ListThreatEventTargetIndustriesRequest>;
+export interface ListThreatEventTargetIndustriesResponse {
+    items: {
+        type: string;
+    };
+    type: string;
+}
+export declare const ListThreatEventTargetIndustriesResponse: Schema.Schema<ListThreatEventTargetIndustriesResponse>;
+export type ListThreatEventTargetIndustriesError = DefaultErrors;
+export declare const listThreatEventTargetIndustries: API.OperationMethod<ListThreatEventTargetIndustriesRequest, ListThreatEventTargetIndustriesResponse, ListThreatEventTargetIndustriesError, Credentials | HttpClient.HttpClient>;
+//# sourceMappingURL=cloudforce-one.d.ts.map