/**
 * Cloudflare INTEL API
 *
 * Generated from Cloudflare TypeScript SDK.
 * DO NOT EDIT - regenerate with: bun scripts/generate.ts --service intel
 */
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 GetAsnRequest {
    /** Identifier. */
    accountId: string;
    asn: string;
}
export declare const GetAsnRequest: Schema.Schema<GetAsnRequest>;
export type GetAsnResponse = number;
export declare const GetAsnResponse: Schema.Schema<GetAsnResponse>;
export type GetAsnError = DefaultErrors;
export declare const getAsn: API.OperationMethod<GetAsnRequest, GetAsnResponse, GetAsnError, Credentials | HttpClient.HttpClient>;
export interface GetAsnSubnetRequest {
    /** Identifier. */
    accountId: string;
    asn: string;
}
export declare const GetAsnSubnetRequest: Schema.Schema<GetAsnSubnetRequest>;
export interface GetAsnSubnetResponse {
    asn?: number | null;
    /** Total results returned based on your search parameters. */
    count?: number | null;
    ipCountTotal?: number | null;
    /** Current page within paginated list of results. */
    page?: number | null;
    /** Number of results per page of results. */
    perPage?: number | null;
    subnets?: string[] | null;
}
export declare const GetAsnSubnetResponse: Schema.Schema<GetAsnSubnetResponse>;
export type GetAsnSubnetError = DefaultErrors;
export declare const getAsnSubnet: API.OperationMethod<GetAsnSubnetRequest, GetAsnSubnetResponse, GetAsnSubnetError, Credentials | HttpClient.HttpClient>;
export interface ListAttackSurfaceReportIssuesRequest {
    /** Path param: Identifier. */
    accountId: string;
    page?: number;
    perPage?: number;
    /** Query param: */
    dismissed?: boolean;
    /** Query param: */
    issueClass?: string[];
    /** Query param: */
    issueClassNeq?: string[];
    /** Query param: */
    issueType?: ("compliance_violation" | "email_security" | "exposed_infrastructure" | "insecure_configuration" | "weak_authentication" | "configuration_suggestion")[];
    /** Query param: */
    issueTypeNeq?: ("compliance_violation" | "email_security" | "exposed_infrastructure" | "insecure_configuration" | "weak_authentication" | "configuration_suggestion")[];
    /** Query param: */
    product?: string[];
    /** Query param: */
    productNeq?: string[];
    /** Query param: */
    severity?: ("low" | "moderate" | "critical")[];
    /** Query param: */
    severityNeq?: ("low" | "moderate" | "critical")[];
    /** Query param: */
    subject?: string[];
    /** Query param: */
    subjectNeq?: string[];
}
export declare const ListAttackSurfaceReportIssuesRequest: Schema.Schema<ListAttackSurfaceReportIssuesRequest>;
export interface ListAttackSurfaceReportIssuesResponse {
    result: {
        items?: {
            count?: number | null;
            issues?: {
                id?: string | null;
                dismissed?: boolean | null;
                issueClass?: string | null;
                issueType?: "compliance_violation" | "email_security" | "exposed_infrastructure" | "insecure_configuration" | "weak_authentication" | "configuration_suggestion" | null;
                payload?: {
                    detectionMethod?: string | null;
                    zoneTag?: string | null;
                } | null;
                resolveLink?: string | null;
                resolveText?: string | null;
                severity?: "Low" | "Moderate" | "Critical" | null;
                since?: string | null;
                subject?: string | null;
                timestamp?: string | null;
            }[] | null;
            page?: number | null;
            perPage?: number | null;
        }[] | null;
    };
    resultInfo?: {
        count?: number | null;
        page?: number | null;
        perPage?: number | null;
        totalCount?: number | null;
    } | null;
}
export declare const ListAttackSurfaceReportIssuesResponse: Schema.Schema<ListAttackSurfaceReportIssuesResponse>;
export type ListAttackSurfaceReportIssuesError = DefaultErrors;
export declare const listAttackSurfaceReportIssues: API.PaginatedOperationMethod<ListAttackSurfaceReportIssuesRequest, ListAttackSurfaceReportIssuesResponse, ListAttackSurfaceReportIssuesError, Credentials | HttpClient.HttpClient>;
export interface ClassAttackSurfaceReportIssueRequest {
    /** Path param: Identifier. */
    accountId: string;
    /** Query param: */
    dismissed?: boolean;
    /** Query param: */
    issueClass?: string[];
    /** Query param: */
    issueClassNeq?: string[];
    /** Query param: */
    issueType?: ("compliance_violation" | "email_security" | "exposed_infrastructure" | "insecure_configuration" | "weak_authentication" | "configuration_suggestion")[];
    /** Query param: */
    issueTypeNeq?: ("compliance_violation" | "email_security" | "exposed_infrastructure" | "insecure_configuration" | "weak_authentication" | "configuration_suggestion")[];
    /** Query param: */
    product?: string[];
    /** Query param: */
    productNeq?: string[];
    /** Query param: */
    severity?: ("low" | "moderate" | "critical")[];
    /** Query param: */
    severityNeq?: ("low" | "moderate" | "critical")[];
    /** Query param: */
    subject?: string[];
    /** Query param: */
    subjectNeq?: string[];
}
export declare const ClassAttackSurfaceReportIssueRequest: Schema.Schema<ClassAttackSurfaceReportIssueRequest>;
export type ClassAttackSurfaceReportIssueResponse = {
    count?: number | null;
    value?: string | null;
}[];
export declare const ClassAttackSurfaceReportIssueResponse: Schema.Schema<ClassAttackSurfaceReportIssueResponse>;
export type ClassAttackSurfaceReportIssueError = DefaultErrors;
export declare const classAttackSurfaceReportIssue: API.OperationMethod<ClassAttackSurfaceReportIssueRequest, ClassAttackSurfaceReportIssueResponse, ClassAttackSurfaceReportIssueError, Credentials | HttpClient.HttpClient>;
export interface DismissAttackSurfaceReportIssueRequest {
    issueId: string;
    /** Path param: Identifier. */
    accountId: string;
    /** Body param: */
    dismiss?: boolean;
}
export declare const DismissAttackSurfaceReportIssueRequest: Schema.Schema<DismissAttackSurfaceReportIssueRequest>;
export interface DismissAttackSurfaceReportIssueResponse {
    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 DismissAttackSurfaceReportIssueResponse: Schema.Schema<DismissAttackSurfaceReportIssueResponse>;
export type DismissAttackSurfaceReportIssueError = DefaultErrors;
export declare const dismissAttackSurfaceReportIssue: API.OperationMethod<DismissAttackSurfaceReportIssueRequest, DismissAttackSurfaceReportIssueResponse, DismissAttackSurfaceReportIssueError, Credentials | HttpClient.HttpClient>;
export interface SeverityAttackSurfaceReportIssueRequest {
    /** Path param: Identifier. */
    accountId: string;
    /** Query param: */
    dismissed?: boolean;
    /** Query param: */
    issueClass?: string[];
    /** Query param: */
    issueClassNeq?: string[];
    /** Query param: */
    issueType?: ("compliance_violation" | "email_security" | "exposed_infrastructure" | "insecure_configuration" | "weak_authentication" | "configuration_suggestion")[];
    /** Query param: */
    issueTypeNeq?: ("compliance_violation" | "email_security" | "exposed_infrastructure" | "insecure_configuration" | "weak_authentication" | "configuration_suggestion")[];
    /** Query param: */
    product?: string[];
    /** Query param: */
    productNeq?: string[];
    /** Query param: */
    severity?: ("low" | "moderate" | "critical")[];
    /** Query param: */
    severityNeq?: ("low" | "moderate" | "critical")[];
    /** Query param: */
    subject?: string[];
    /** Query param: */
    subjectNeq?: string[];
}
export declare const SeverityAttackSurfaceReportIssueRequest: Schema.Schema<SeverityAttackSurfaceReportIssueRequest>;
export type SeverityAttackSurfaceReportIssueResponse = {
    count?: number | null;
    value?: string | null;
}[];
export declare const SeverityAttackSurfaceReportIssueResponse: Schema.Schema<SeverityAttackSurfaceReportIssueResponse>;
export type SeverityAttackSurfaceReportIssueError = DefaultErrors;
export declare const severityAttackSurfaceReportIssue: API.OperationMethod<SeverityAttackSurfaceReportIssueRequest, SeverityAttackSurfaceReportIssueResponse, SeverityAttackSurfaceReportIssueError, Credentials | HttpClient.HttpClient>;
export interface TypeAttackSurfaceReportIssueRequest {
    /** Path param: Identifier. */
    accountId: string;
    /** Query param: */
    dismissed?: boolean;
    /** Query param: */
    issueClass?: string[];
    /** Query param: */
    issueClassNeq?: string[];
    /** Query param: */
    issueType?: ("compliance_violation" | "email_security" | "exposed_infrastructure" | "insecure_configuration" | "weak_authentication" | "configuration_suggestion")[];
    /** Query param: */
    issueTypeNeq?: ("compliance_violation" | "email_security" | "exposed_infrastructure" | "insecure_configuration" | "weak_authentication" | "configuration_suggestion")[];
    /** Query param: */
    product?: string[];
    /** Query param: */
    productNeq?: string[];
    /** Query param: */
    severity?: ("low" | "moderate" | "critical")[];
    /** Query param: */
    severityNeq?: ("low" | "moderate" | "critical")[];
    /** Query param: */
    subject?: string[];
    /** Query param: */
    subjectNeq?: string[];
}
export declare const TypeAttackSurfaceReportIssueRequest: Schema.Schema<TypeAttackSurfaceReportIssueRequest>;
export type TypeAttackSurfaceReportIssueResponse = {
    count?: number | null;
    value?: string | null;
}[];
export declare const TypeAttackSurfaceReportIssueResponse: Schema.Schema<TypeAttackSurfaceReportIssueResponse>;
export type TypeAttackSurfaceReportIssueError = DefaultErrors;
export declare const typeAttackSurfaceReportIssue: API.OperationMethod<TypeAttackSurfaceReportIssueRequest, TypeAttackSurfaceReportIssueResponse, TypeAttackSurfaceReportIssueError, Credentials | HttpClient.HttpClient>;
export interface GetAttackSurfaceReportIssueTypeRequest {
    /** Identifier. */
    accountId: string;
}
export declare const GetAttackSurfaceReportIssueTypeRequest: Schema.Schema<GetAttackSurfaceReportIssueTypeRequest>;
export interface GetAttackSurfaceReportIssueTypeResponse {
    result: string[];
}
export declare const GetAttackSurfaceReportIssueTypeResponse: Schema.Schema<GetAttackSurfaceReportIssueTypeResponse>;
export type GetAttackSurfaceReportIssueTypeError = DefaultErrors;
export declare const getAttackSurfaceReportIssueType: API.PaginatedOperationMethod<GetAttackSurfaceReportIssueTypeRequest, GetAttackSurfaceReportIssueTypeResponse, GetAttackSurfaceReportIssueTypeError, Credentials | HttpClient.HttpClient>;
export interface ListDnsRequest {
    /** Path param: Identifier. */
    accountId: string;
    page?: number;
    perPage?: number;
    /** Query param: */
    ipv4?: string;
    /** Query param: */
    startEndParams?: {
        end?: string;
        start?: string;
    };
}
export declare const ListDnsRequest: Schema.Schema<ListDnsRequest>;
export interface ListDnsResponse {
    result: {
        items?: {
            count?: number | null;
            page?: number | null;
            perPage?: number | null;
            reverseRecords?: {
                firstSeen?: string | null;
                hostname?: string | null;
                lastSeen?: string | null;
            }[] | null;
        }[] | null;
    };
    resultInfo?: {
        count?: number | null;
        page?: number | null;
        perPage?: number | null;
        totalCount?: number | null;
    } | null;
}
export declare const ListDnsResponse: Schema.Schema<ListDnsResponse>;
export type ListDnsError = DefaultErrors;
export declare const listDns: API.PaginatedOperationMethod<ListDnsRequest, ListDnsResponse, ListDnsError, Credentials | HttpClient.HttpClient>;
export interface GetDomainRequest {
    /** Path param: Identifier. */
    accountId: string;
    /** Query param: */
    domain?: string;
}
export declare const GetDomainRequest: Schema.Schema<GetDomainRequest>;
export interface GetDomainResponse {
    /** Additional information related to the host name. */
    additionalInformation?: {
        suspectedMalwareFamily?: string | null;
    } | null;
    /** Application that the hostname belongs to. */
    application?: {
        id?: number | null;
        name?: string | null;
    } | null;
    contentCategories?: {
        id?: number | null;
        name?: string | null;
        superCategoryId?: number | null;
    }[] | null;
    domain?: string | null;
    inheritedContentCategories?: {
        id?: number | null;
        name?: string | null;
        superCategoryId?: number | null;
    }[] | null;
    /** Domain from which `inherited_content_categories` and `inherited_risk_types` are inherited, if applicable. */
    inheritedFrom?: string | null;
    inheritedRiskTypes?: {
        id?: number | null;
        name?: string | null;
        superCategoryId?: number | null;
    }[] | null;
    /** Global Cloudflare 100k ranking for the last 30 days, if available for the hostname. The top ranked domain is 1, the lowest ranked domain is 100,000. */
    popularityRank?: number | null;
    /** Specifies a list of references to one or more IP addresses or domain names that the domain name currently resolves to. */
    resolvesToRefs?: {
        id?: string | null;
        value?: string | null;
    }[] | null;
    /** Hostname risk score, which is a value between 0 (lowest risk) to 1 (highest risk). */
    riskScore?: number | null;
    riskTypes?: {
        id?: number | null;
        name?: string | null;
        superCategoryId?: number | null;
    }[] | null;
}
export declare const GetDomainResponse: Schema.Schema<GetDomainResponse>;
export type GetDomainError = DefaultErrors;
export declare const getDomain: API.OperationMethod<GetDomainRequest, GetDomainResponse, GetDomainError, Credentials | HttpClient.HttpClient>;
export interface GetDomainBulkRequest {
    /** Path param: Identifier. */
    accountId: string;
    /** Query param: Accepts multiple values like `?domain=cloudflare.com&domain=example.com`. */
    domain?: string[];
}
export declare const GetDomainBulkRequest: Schema.Schema<GetDomainBulkRequest>;
export type GetDomainBulkResponse = {
    additionalInformation?: {
        suspectedMalwareFamily?: string | null;
    } | null;
    application?: {
        id?: number | null;
        name?: string | null;
    } | null;
    contentCategories?: {
        id?: number | null;
        name?: string | null;
        superCategoryId?: number | null;
    }[] | null;
    domain?: string | null;
    inheritedContentCategories?: {
        id?: number | null;
        name?: string | null;
        superCategoryId?: number | null;
    }[] | null;
    inheritedFrom?: string | null;
    inheritedRiskTypes?: {
        id?: number | null;
        name?: string | null;
        superCategoryId?: number | null;
    }[] | null;
    popularityRank?: number | null;
    riskScore?: number | null;
    riskTypes?: {
        id?: number | null;
        name?: string | null;
        superCategoryId?: number | null;
    }[] | null;
}[];
export declare const GetDomainBulkResponse: Schema.Schema<GetDomainBulkResponse>;
export type GetDomainBulkError = DefaultErrors;
export declare const getDomainBulk: API.OperationMethod<GetDomainBulkRequest, GetDomainBulkResponse, GetDomainBulkError, Credentials | HttpClient.HttpClient>;
export interface GetDomainHistoryRequest {
    /** Path param: Identifier. */
    accountId: string;
    /** Query param: */
    domain?: string;
}
export declare const GetDomainHistoryRequest: Schema.Schema<GetDomainHistoryRequest>;
export type GetDomainHistoryResponse = {
    categorizations?: {
        categories?: {
            id?: number | null;
            name?: string | null;
        }[] | null;
        end?: string | null;
        start?: string | null;
    }[] | null;
    domain?: string | null;
}[];
export declare const GetDomainHistoryResponse: Schema.Schema<GetDomainHistoryResponse>;
export type GetDomainHistoryError = DefaultErrors;
export declare const getDomainHistory: API.OperationMethod<GetDomainHistoryRequest, GetDomainHistoryResponse, GetDomainHistoryError, Credentials | HttpClient.HttpClient>;
export interface GetIndicatorFeedRequest {
    feedId: number;
    /** Identifier */
    accountId: string;
}
export declare const GetIndicatorFeedRequest: Schema.Schema<GetIndicatorFeedRequest>;
export interface GetIndicatorFeedResponse {
    /** The unique identifier for the indicator feed */
    id?: number | null;
    /** The date and time when the data entry was created */
    createdOn?: string | null;
    /** The description of the example test */
    description?: string | null;
    /** Whether the indicator feed can be attributed to a provider */
    isAttributable?: boolean | null;
    /** Whether the indicator feed can be downloaded */
    isDownloadable?: boolean | null;
    /** Whether the indicator feed is exposed to customers */
    isPublic?: boolean | null;
    /** Status of the latest snapshot uploaded */
    latestUploadStatus?: "Mirroring" | "Unifying" | "Loading" | "Provisioning" | "Complete" | "Error" | null;
    /** The date and time when the data entry was last modified */
    modifiedOn?: string | null;
    /** The name of the indicator feed */
    name?: string | null;
    /** The unique identifier for the provider */
    providerId?: string | null;
    /** The provider of the indicator feed */
    providerName?: string | null;
}
export declare const GetIndicatorFeedResponse: Schema.Schema<GetIndicatorFeedResponse>;
export type GetIndicatorFeedError = DefaultErrors;
export declare const getIndicatorFeed: API.OperationMethod<GetIndicatorFeedRequest, GetIndicatorFeedResponse, GetIndicatorFeedError, Credentials | HttpClient.HttpClient>;
export interface ListIndicatorFeedsRequest {
    /** Identifier */
    accountId: string;
}
export declare const ListIndicatorFeedsRequest: Schema.Schema<ListIndicatorFeedsRequest>;
export interface ListIndicatorFeedsResponse {
    result: {
        id?: number | null;
        createdOn?: string | null;
        description?: string | null;
        isAttributable?: boolean | null;
        isDownloadable?: boolean | null;
        isPublic?: boolean | null;
        modifiedOn?: string | null;
        name?: string | null;
    }[];
}
export declare const ListIndicatorFeedsResponse: Schema.Schema<ListIndicatorFeedsResponse>;
export type ListIndicatorFeedsError = DefaultErrors;
export declare const listIndicatorFeeds: API.PaginatedOperationMethod<ListIndicatorFeedsRequest, ListIndicatorFeedsResponse, ListIndicatorFeedsError, Credentials | HttpClient.HttpClient>;
export interface CreateIndicatorFeedRequest {
    /** Path param: Identifier */
    accountId: string;
    /** Body param: The description of the example test */
    description?: string;
    /** Body param: The name of the indicator feed */
    name?: string;
}
export declare const CreateIndicatorFeedRequest: Schema.Schema<CreateIndicatorFeedRequest>;
export interface CreateIndicatorFeedResponse {
    /** The unique identifier for the indicator feed */
    id?: number | null;
    /** The date and time when the data entry was created */
    createdOn?: string | null;
    /** The description of the example test */
    description?: string | null;
    /** Whether the indicator feed can be attributed to a provider */
    isAttributable?: boolean | null;
    /** Whether the indicator feed can be downloaded */
    isDownloadable?: boolean | null;
    /** Whether the indicator feed is exposed to customers */
    isPublic?: boolean | null;
    /** The date and time when the data entry was last modified */
    modifiedOn?: string | null;
    /** The name of the indicator feed */
    name?: string | null;
}
export declare const CreateIndicatorFeedResponse: Schema.Schema<CreateIndicatorFeedResponse>;
export type CreateIndicatorFeedError = DefaultErrors;
export declare const createIndicatorFeed: API.OperationMethod<CreateIndicatorFeedRequest, CreateIndicatorFeedResponse, CreateIndicatorFeedError, Credentials | HttpClient.HttpClient>;
export interface UpdateIndicatorFeedRequest {
    feedId: number;
    /** Path param: Identifier */
    accountId: string;
    /** Body param: The new description of the feed */
    description?: string;
    /** Body param: The new is_attributable value of the feed */
    isAttributable?: boolean;
    /** Body param: The new is_downloadable value of the feed */
    isDownloadable?: boolean;
    /** Body param: The new is_public value of the feed */
    isPublic?: boolean;
    /** Body param: The new name of the feed */
    name?: string;
}
export declare const UpdateIndicatorFeedRequest: Schema.Schema<UpdateIndicatorFeedRequest>;
export interface UpdateIndicatorFeedResponse {
    /** The unique identifier for the indicator feed */
    id?: number | null;
    /** The date and time when the data entry was created */
    createdOn?: string | null;
    /** The description of the example test */
    description?: string | null;
    /** Whether the indicator feed can be attributed to a provider */
    isAttributable?: boolean | null;
    /** Whether the indicator feed can be downloaded */
    isDownloadable?: boolean | null;
    /** Whether the indicator feed is exposed to customers */
    isPublic?: boolean | null;
    /** The date and time when the data entry was last modified */
    modifiedOn?: string | null;
    /** The name of the indicator feed */
    name?: string | null;
}
export declare const UpdateIndicatorFeedResponse: Schema.Schema<UpdateIndicatorFeedResponse>;
export type UpdateIndicatorFeedError = DefaultErrors;
export declare const updateIndicatorFeed: API.OperationMethod<UpdateIndicatorFeedRequest, UpdateIndicatorFeedResponse, UpdateIndicatorFeedError, Credentials | HttpClient.HttpClient>;
export interface DataIndicatorFeedRequest {
    feedId: number;
    /** Identifier */
    accountId: string;
}
export declare const DataIndicatorFeedRequest: Schema.Schema<DataIndicatorFeedRequest>;
export type DataIndicatorFeedResponse = string;
export declare const DataIndicatorFeedResponse: Schema.Schema<DataIndicatorFeedResponse>;
export type DataIndicatorFeedError = DefaultErrors;
export declare const dataIndicatorFeed: API.OperationMethod<DataIndicatorFeedRequest, DataIndicatorFeedResponse, DataIndicatorFeedError, Credentials | HttpClient.HttpClient>;
export interface ListIndicatorFeedPermissionsRequest {
    /** Identifier */
    accountId: string;
}
export declare const ListIndicatorFeedPermissionsRequest: Schema.Schema<ListIndicatorFeedPermissionsRequest>;
export type ListIndicatorFeedPermissionsResponse = {
    id?: number | null;
    description?: string | null;
    isAttributable?: boolean | null;
    isDownloadable?: boolean | null;
    isPublic?: boolean | null;
    name?: string | null;
}[];
export declare const ListIndicatorFeedPermissionsResponse: Schema.Schema<ListIndicatorFeedPermissionsResponse>;
export type ListIndicatorFeedPermissionsError = DefaultErrors;
export declare const listIndicatorFeedPermissions: API.OperationMethod<ListIndicatorFeedPermissionsRequest, ListIndicatorFeedPermissionsResponse, ListIndicatorFeedPermissionsError, Credentials | HttpClient.HttpClient>;
export interface CreateIndicatorFeedPermissionRequest {
    /** Path param: Identifier */
    accountId: string;
    /** Body param: The Cloudflare account tag of the account to change permissions on */
    accountTag?: string;
    /** Body param: The ID of the feed to add/remove permissions on */
    feedId?: number;
}
export declare const CreateIndicatorFeedPermissionRequest: Schema.Schema<CreateIndicatorFeedPermissionRequest>;
export interface CreateIndicatorFeedPermissionResponse {
    /** Whether the update succeeded or not */
    success?: boolean | null;
}
export declare const CreateIndicatorFeedPermissionResponse: Schema.Schema<CreateIndicatorFeedPermissionResponse>;
export type CreateIndicatorFeedPermissionError = DefaultErrors;
export declare const createIndicatorFeedPermission: API.OperationMethod<CreateIndicatorFeedPermissionRequest, CreateIndicatorFeedPermissionResponse, CreateIndicatorFeedPermissionError, Credentials | HttpClient.HttpClient>;
export interface DeleteIndicatorFeedPermissionRequest {
    /** Path param: Identifier */
    accountId: string;
    /** Body param: The Cloudflare account tag of the account to change permissions on */
    accountTag?: string;
    /** Body param: The ID of the feed to add/remove permissions on */
    feedId?: number;
}
export declare const DeleteIndicatorFeedPermissionRequest: Schema.Schema<DeleteIndicatorFeedPermissionRequest>;
export interface DeleteIndicatorFeedPermissionResponse {
    /** Whether the update succeeded or not */
    success?: boolean | null;
}
export declare const DeleteIndicatorFeedPermissionResponse: Schema.Schema<DeleteIndicatorFeedPermissionResponse>;
export type DeleteIndicatorFeedPermissionError = DefaultErrors;
export declare const deleteIndicatorFeedPermission: API.OperationMethod<DeleteIndicatorFeedPermissionRequest, DeleteIndicatorFeedPermissionResponse, DeleteIndicatorFeedPermissionError, Credentials | HttpClient.HttpClient>;
export interface PutIndicatorFeedSnapshotRequest {
    feedId: number;
    /** Path param: Identifier */
    accountId: string;
    /** Body param: The file to upload */
    source?: string;
}
export declare const PutIndicatorFeedSnapshotRequest: Schema.Schema<PutIndicatorFeedSnapshotRequest>;
export interface PutIndicatorFeedSnapshotResponse {
    /** Feed id */
    fileId?: number | null;
    /** Name of the file unified in our system */
    filename?: string | null;
    /** Current status of upload, should be unified */
    status?: string | null;
}
export declare const PutIndicatorFeedSnapshotResponse: Schema.Schema<PutIndicatorFeedSnapshotResponse>;
export type PutIndicatorFeedSnapshotError = DefaultErrors;
export declare const putIndicatorFeedSnapshot: API.OperationMethod<PutIndicatorFeedSnapshotRequest, PutIndicatorFeedSnapshotResponse, PutIndicatorFeedSnapshotError, Credentials | HttpClient.HttpClient>;
export interface GetIpRequest {
    /** Path param: Identifier. */
    accountId: string;
    /** Query param: */
    ipv4?: string;
    /** Query param: */
    ipv6?: string;
}
export declare const GetIpRequest: Schema.Schema<GetIpRequest>;
export type GetIpResponse = {
    belongsToRef?: {
        id?: string | null;
        country?: string | null;
        description?: string | null;
        type?: "hosting_provider" | "isp" | "organization" | null;
        value?: string | null;
    } | null;
    ip?: string | null;
    riskTypes?: {
        id?: number | null;
        name?: string | null;
        superCategoryId?: number | null;
    }[] | null;
}[];
export declare const GetIpResponse: Schema.Schema<GetIpResponse>;
export type GetIpError = DefaultErrors;
export declare const getIp: API.OperationMethod<GetIpRequest, GetIpResponse, GetIpError, Credentials | HttpClient.HttpClient>;
export interface GetIpListRequest {
    /** Identifier. */
    accountId: string;
}
export declare const GetIpListRequest: Schema.Schema<GetIpListRequest>;
export interface GetIpListResponse {
    result: {
        id?: number | null;
        description?: string | null;
        name?: string | null;
    }[];
}
export declare const GetIpListResponse: Schema.Schema<GetIpListResponse>;
export type GetIpListError = DefaultErrors;
export declare const getIpList: API.PaginatedOperationMethod<GetIpListRequest, GetIpListResponse, GetIpListError, Credentials | HttpClient.HttpClient>;
export interface CreateMiscategorizationRequest {
    /** Path param: Identifier. */
    accountId: string;
    /** Body param: Content category IDs to add. */
    contentAdds?: number[];
    /** Body param: Content category IDs to remove. */
    contentRemoves?: number[];
    /** Body param: */
    indicatorType?: "domain" | "ipv4" | "ipv6" | "url";
    /** Body param: Provide only if indicator_type is `ipv4` or `ipv6`. */
    ip?: string | null;
    /** Body param: Security category IDs to add. */
    securityAdds?: number[];
    /** Body param: Security category IDs to remove. */
    securityRemoves?: number[];
    /** Body param: Provide only if indicator_type is `domain` or `url`. Example if indicator_type is `domain`: `example.com`. Example if indicator_type is `url`: `https://example.com/news/`. */
    url?: string;
}
export declare const CreateMiscategorizationRequest: Schema.Schema<CreateMiscategorizationRequest>;
export interface CreateMiscategorizationResponse {
    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 CreateMiscategorizationResponse: Schema.Schema<CreateMiscategorizationResponse>;
export type CreateMiscategorizationError = DefaultErrors;
export declare const createMiscategorization: API.OperationMethod<CreateMiscategorizationRequest, CreateMiscategorizationResponse, CreateMiscategorizationError, Credentials | HttpClient.HttpClient>;
export interface ListSinkholesRequest {
    /** Identifier */
    accountId: string;
}
export declare const ListSinkholesRequest: Schema.Schema<ListSinkholesRequest>;
export interface ListSinkholesResponse {
    result: {
        id?: number | null;
        accountTag?: string | null;
        createdOn?: string | null;
        modifiedOn?: string | null;
        name?: string | null;
        r2Bucket?: string | null;
        r2Id?: string | null;
    }[];
}
export declare const ListSinkholesResponse: Schema.Schema<ListSinkholesResponse>;
export type ListSinkholesError = DefaultErrors;
export declare const listSinkholes: API.PaginatedOperationMethod<ListSinkholesRequest, ListSinkholesResponse, ListSinkholesError, Credentials | HttpClient.HttpClient>;
export interface GetWhoiRequest {
    /** Path param: Use to uniquely identify or reference the resource. */
    accountId: string;
    /** Query param: */
    domain?: string;
}
export declare const GetWhoiRequest: Schema.Schema<GetWhoiRequest>;
export interface GetWhoiResponse {
    dnssec: boolean;
    domain: string;
    extension: string;
    found: boolean;
    nameservers: string[];
    punycode: string;
    registrant: string;
    registrar: string;
    id?: string | null;
    administrativeCity?: string | null;
    administrativeCountry?: string | null;
    administrativeEmail?: string | null;
    administrativeFax?: string | null;
    administrativeFaxExt?: string | null;
    administrativeId?: string | null;
    administrativeName?: string | null;
    administrativeOrg?: string | null;
    administrativePhone?: string | null;
    administrativePhoneExt?: string | null;
    administrativePostalCode?: string | null;
    administrativeProvince?: string | null;
    administrativeReferralUrl?: string | null;
    administrativeStreet?: string | null;
    billingCity?: string | null;
    billingCountry?: string | null;
    billingEmail?: string | null;
    billingFax?: string | null;
    billingFaxExt?: string | null;
    billingId?: string | null;
    billingName?: string | null;
    billingOrg?: string | null;
    billingPhone?: string | null;
    billingPhoneExt?: string | null;
    billingPostalCode?: string | null;
    billingProvince?: string | null;
    billingReferralUrl?: string | null;
    billingStreet?: string | null;
    createdDate?: string | null;
    createdDateRaw?: string | null;
    expirationDate?: string | null;
    expirationDateRaw?: string | null;
    registrantCity?: string | null;
    registrantCountry?: string | null;
    registrantEmail?: string | null;
    registrantFax?: string | null;
    registrantFaxExt?: string | null;
    registrantId?: string | null;
    registrantName?: string | null;
    registrantOrg?: string | null;
    registrantPhone?: string | null;
    registrantPhoneExt?: string | null;
    registrantPostalCode?: string | null;
    registrantProvince?: string | null;
    registrantReferralUrl?: string | null;
    registrantStreet?: string | null;
    registrarCity?: string | null;
    registrarCountry?: string | null;
    registrarEmail?: string | null;
    registrarFax?: string | null;
    registrarFaxExt?: string | null;
    registrarId?: string | null;
    registrarName?: string | null;
    registrarOrg?: string | null;
    registrarPhone?: string | null;
    registrarPhoneExt?: string | null;
    registrarPostalCode?: string | null;
    registrarProvince?: string | null;
    registrarReferralUrl?: string | null;
    registrarStreet?: string | null;
    status?: string[] | null;
    technicalCity?: string | null;
    technicalCountry?: string | null;
    technicalEmail?: string | null;
    technicalFax?: string | null;
    technicalFaxExt?: string | null;
    technicalId?: string | null;
    technicalName?: string | null;
    technicalOrg?: string | null;
    technicalPhone?: string | null;
    technicalPhoneExt?: string | null;
    technicalPostalCode?: string | null;
    technicalProvince?: string | null;
    technicalReferralUrl?: string | null;
    technicalStreet?: string | null;
    updatedDate?: string | null;
    updatedDateRaw?: string | null;
    whoisServer?: string | null;
}
export declare const GetWhoiResponse: Schema.Schema<GetWhoiResponse>;
export type GetWhoiError = DefaultErrors;
export declare const getWhoi: API.OperationMethod<GetWhoiRequest, GetWhoiResponse, GetWhoiError, Credentials | HttpClient.HttpClient>;
//# sourceMappingURL=intel.d.ts.map