@distilled.cloud/cloudflare 0.0.0-john

package/lib/services/intel.d.ts

@@ -0,0 +1,865 @@
+/**
+ * Cloudflare INTEL API
+ *
+ * Generated from Cloudflare TypeScript SDK.
+ * DO NOT EDIT - regenerate with: bun scripts/generate.ts --service intel
+ */
+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 GetAsnRequest {
+    /** Identifier. */
+    accountId: string;
+}
+export declare const GetAsnRequest: Schema.Schema<GetAsnRequest>;
+export type GetAsnResponse = unknown;
+export declare const GetAsnResponse: Schema.Schema<unknown>;
+export type GetAsnError = DefaultErrors;
+export declare const getAsn: API.OperationMethod<GetAsnRequest, GetAsnResponse, GetAsnError, Credentials | HttpClient.HttpClient>;
+export interface GetAsnSubnetRequest {
+    /** Identifier. */
+    accountId: 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;
+    /** 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;
+    };
+}
+export declare const ListAttackSurfaceReportIssuesResponse: Schema.Schema<ListAttackSurfaceReportIssuesResponse>;
+export type ListAttackSurfaceReportIssuesError = DefaultErrors;
+export declare const listAttackSurfaceReportIssues: API.PaginatedOperationMethod<ListAttackSurfaceReportIssuesRequest, ListAttackSurfaceReportIssuesResponse, ListAttackSurfaceReportIssuesError, Credentials | HttpClient.HttpClient> & {
+    pages: (input: ListAttackSurfaceReportIssuesRequest) => stream.Stream<ListAttackSurfaceReportIssuesResponse, ListAttackSurfaceReportIssuesError, Credentials | HttpClient.HttpClient>;
+    items: (input: ListAttackSurfaceReportIssuesRequest) => stream.Stream<{
+        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;
+    }, 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> & {
+    pages: (input: GetAttackSurfaceReportIssueTypeRequest) => stream.Stream<GetAttackSurfaceReportIssueTypeResponse, GetAttackSurfaceReportIssueTypeError, Credentials | HttpClient.HttpClient>;
+    items: (input: GetAttackSurfaceReportIssueTypeRequest) => stream.Stream<string, GetAttackSurfaceReportIssueTypeError, Credentials | HttpClient.HttpClient>;
+};
+export interface ListDnsRequest {
+    /** Path param: Identifier. */
+    accountId: string;
+    /** 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;
+    };
+}
+export declare const ListDnsResponse: Schema.Schema<ListDnsResponse>;
+export type ListDnsError = DefaultErrors;
+export declare const listDns: API.PaginatedOperationMethod<ListDnsRequest, ListDnsResponse, ListDnsError, Credentials | HttpClient.HttpClient> & {
+    pages: (input: ListDnsRequest) => stream.Stream<ListDnsResponse, ListDnsError, Credentials | HttpClient.HttpClient>;
+    items: (input: ListDnsRequest) => stream.Stream<{
+        count?: number | null;
+        page?: number | null;
+        perPage?: number | null;
+        reverseRecords?: {
+            firstSeen?: string | null;
+            hostname?: string | null;
+            lastSeen?: string | null;
+        }[] | null;
+    }, 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> & {
+    pages: (input: ListIndicatorFeedsRequest) => stream.Stream<ListIndicatorFeedsResponse, ListIndicatorFeedsError, Credentials | HttpClient.HttpClient>;
+    items: (input: ListIndicatorFeedsRequest) => stream.Stream<{
+        id?: number | null;
+        createdOn?: string | null;
+        description?: string | null;
+        isAttributable?: boolean | null;
+        isDownloadable?: boolean | null;
+        isPublic?: boolean | null;
+        modifiedOn?: string | null;
+        name?: string | null;
+    }, 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 = unknown;
+export declare const DataIndicatorFeedResponse: Schema.Schema<unknown>;
+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> & {
+    pages: (input: GetIpListRequest) => stream.Stream<GetIpListResponse, GetIpListError, Credentials | HttpClient.HttpClient>;
+    items: (input: GetIpListRequest) => stream.Stream<{
+        id?: number | null;
+        description?: string | null;
+        name?: string | null;
+    }, 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> & {
+    pages: (input: ListSinkholesRequest) => stream.Stream<ListSinkholesResponse, ListSinkholesError, Credentials | HttpClient.HttpClient>;
+    items: (input: ListSinkholesRequest) => stream.Stream<{
+        id?: number | null;
+        accountTag?: string | null;
+        createdOn?: string | null;
+        modifiedOn?: string | null;
+        name?: string | null;
+        r2Bucket?: string | null;
+        r2Id?: string | null;
+    }, 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