/**
 * Cloudflare CLOUDFORCE-ONE API
 *
 * Generated from Cloudflare TypeScript SDK.
 * DO NOT EDIT - regenerate with: bun scripts/generate.ts --service cloudforce-one
 */
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<GetBinaryStorageResponse>;
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>;
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>;
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>;
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>;
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>;
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 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: "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 GetRequestPriorityResponse: Schema.Schema<GetRequestPriorityResponse>;
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 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: "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 UpdateRequestPriorityResponse: Schema.Schema<UpdateRequestPriorityResponse>;
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 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 declare const QuotaRequestPriorityResponse: Schema.Schema<QuotaRequestPriorityResponse>;
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>;
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<DeleteScanConfigResponse>;
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