cloudflare/resources/pcaps/pcaps.d.ts

The official TypeScript library for the Cloudflare API

import * as Core from 'cloudflare/core';
import { APIResource } from 'cloudflare/resource';
import * as PCAPsAPI from 'cloudflare/resources/pcaps/pcaps';
import * as DownloadAPI from 'cloudflare/resources/pcaps/download';
import * as OwnershipAPI from 'cloudflare/resources/pcaps/ownership';
import { SinglePage } from 'cloudflare/pagination';
export declare class PCAPs extends APIResource {
    ownership: OwnershipAPI.Ownership;
    download: DownloadAPI.Download;
    /**
     * Create new PCAP request for account.
     */
    create(params: PCAPCreateParams, options?: Core.RequestOptions): Core.APIPromise<PCAPCreateResponse>;
    /**
     * Lists all packet capture requests for an account.
     */
    list(params: PCAPListParams, options?: Core.RequestOptions): Core.PagePromise<PCAPListResponsesSinglePage, PCAPListResponse>;
    /**
     * Get information for a PCAP request by id.
     */
    get(pcapId: string, params: PCAPGetParams, options?: Core.RequestOptions): Core.APIPromise<PCAPGetResponse>;
}
export declare class PCAPListResponsesSinglePage extends SinglePage<PCAPListResponse> {
}
export type PCAPCreateResponse = PCAPCreateResponse.MagicVisibilityPCAPsResponseSimple | PCAPCreateResponse.MagicVisibilityPCAPsResponseFull;
export declare namespace PCAPCreateResponse {
    interface MagicVisibilityPCAPsResponseSimple {
        /**
         * The ID for the packet capture.
         */
        id?: string;
        /**
         * The packet capture filter. When this field is empty, all packets are captured.
         */
        filter_v1?: MagicVisibilityPCAPsResponseSimple.FilterV1;
        /**
         * The status of the packet capture request.
         */
        status?: 'unknown' | 'success' | 'pending' | 'running' | 'conversion_pending' | 'conversion_running' | 'complete' | 'failed';
        /**
         * The RFC 3339 timestamp when the packet capture was created.
         */
        submitted?: string;
        /**
         * The system used to collect packet captures.
         */
        system?: 'magic-transit';
        /**
         * The packet capture duration in seconds.
         */
        time_limit?: number;
        /**
         * The type of packet capture. `Simple` captures sampled packets, and `full`
         * captures entire payloads and non-sampled packets.
         */
        type?: 'simple' | 'full';
    }
    namespace MagicVisibilityPCAPsResponseSimple {
        /**
         * The packet capture filter. When this field is empty, all packets are captured.
         */
        interface FilterV1 {
            /**
             * The destination IP address of the packet.
             */
            destination_address?: string;
            /**
             * The destination port of the packet.
             */
            destination_port?: number;
            /**
             * The protocol number of the packet.
             */
            protocol?: number;
            /**
             * The source IP address of the packet.
             */
            source_address?: string;
            /**
             * The source port of the packet.
             */
            source_port?: number;
        }
    }
    interface MagicVisibilityPCAPsResponseFull {
        /**
         * The ID for the packet capture.
         */
        id?: string;
        /**
         * The maximum number of bytes to capture. This field only applies to `full` packet
         * captures.
         */
        byte_limit?: number;
        /**
         * The name of the data center used for the packet capture. This can be a specific
         * colo (ord02) or a multi-colo name (ORD). This field only applies to `full`
         * packet captures.
         */
        colo_name?: string;
        /**
         * The full URI for the bucket. This field only applies to `full` packet captures.
         */
        destination_conf?: string;
        /**
         * An error message that describes why the packet capture failed. This field only
         * applies to `full` packet captures.
         */
        error_message?: string;
        /**
         * The packet capture filter. When this field is empty, all packets are captured.
         */
        filter_v1?: MagicVisibilityPCAPsResponseFull.FilterV1;
        /**
         * The status of the packet capture request.
         */
        status?: 'unknown' | 'success' | 'pending' | 'running' | 'conversion_pending' | 'conversion_running' | 'complete' | 'failed';
        /**
         * The RFC 3339 timestamp when the packet capture was created.
         */
        submitted?: string;
        /**
         * The system used to collect packet captures.
         */
        system?: 'magic-transit';
        /**
         * The packet capture duration in seconds.
         */
        time_limit?: number;
        /**
         * The type of packet capture. `Simple` captures sampled packets, and `full`
         * captures entire payloads and non-sampled packets.
         */
        type?: 'simple' | 'full';
    }
    namespace MagicVisibilityPCAPsResponseFull {
        /**
         * The packet capture filter. When this field is empty, all packets are captured.
         */
        interface FilterV1 {
            /**
             * The destination IP address of the packet.
             */
            destination_address?: string;
            /**
             * The destination port of the packet.
             */
            destination_port?: number;
            /**
             * The protocol number of the packet.
             */
            protocol?: number;
            /**
             * The source IP address of the packet.
             */
            source_address?: string;
            /**
             * The source port of the packet.
             */
            source_port?: number;
        }
    }
}
export type PCAPListResponse = PCAPListResponse.MagicVisibilityPCAPsResponseSimple | PCAPListResponse.MagicVisibilityPCAPsResponseFull;
export declare namespace PCAPListResponse {
    interface MagicVisibilityPCAPsResponseSimple {
        /**
         * The ID for the packet capture.
         */
        id?: string;
        /**
         * The packet capture filter. When this field is empty, all packets are captured.
         */
        filter_v1?: MagicVisibilityPCAPsResponseSimple.FilterV1;
        /**
         * The status of the packet capture request.
         */
        status?: 'unknown' | 'success' | 'pending' | 'running' | 'conversion_pending' | 'conversion_running' | 'complete' | 'failed';
        /**
         * The RFC 3339 timestamp when the packet capture was created.
         */
        submitted?: string;
        /**
         * The system used to collect packet captures.
         */
        system?: 'magic-transit';
        /**
         * The packet capture duration in seconds.
         */
        time_limit?: number;
        /**
         * The type of packet capture. `Simple` captures sampled packets, and `full`
         * captures entire payloads and non-sampled packets.
         */
        type?: 'simple' | 'full';
    }
    namespace MagicVisibilityPCAPsResponseSimple {
        /**
         * The packet capture filter. When this field is empty, all packets are captured.
         */
        interface FilterV1 {
            /**
             * The destination IP address of the packet.
             */
            destination_address?: string;
            /**
             * The destination port of the packet.
             */
            destination_port?: number;
            /**
             * The protocol number of the packet.
             */
            protocol?: number;
            /**
             * The source IP address of the packet.
             */
            source_address?: string;
            /**
             * The source port of the packet.
             */
            source_port?: number;
        }
    }
    interface MagicVisibilityPCAPsResponseFull {
        /**
         * The ID for the packet capture.
         */
        id?: string;
        /**
         * The maximum number of bytes to capture. This field only applies to `full` packet
         * captures.
         */
        byte_limit?: number;
        /**
         * The name of the data center used for the packet capture. This can be a specific
         * colo (ord02) or a multi-colo name (ORD). This field only applies to `full`
         * packet captures.
         */
        colo_name?: string;
        /**
         * The full URI for the bucket. This field only applies to `full` packet captures.
         */
        destination_conf?: string;
        /**
         * An error message that describes why the packet capture failed. This field only
         * applies to `full` packet captures.
         */
        error_message?: string;
        /**
         * The packet capture filter. When this field is empty, all packets are captured.
         */
        filter_v1?: MagicVisibilityPCAPsResponseFull.FilterV1;
        /**
         * The status of the packet capture request.
         */
        status?: 'unknown' | 'success' | 'pending' | 'running' | 'conversion_pending' | 'conversion_running' | 'complete' | 'failed';
        /**
         * The RFC 3339 timestamp when the packet capture was created.
         */
        submitted?: string;
        /**
         * The system used to collect packet captures.
         */
        system?: 'magic-transit';
        /**
         * The packet capture duration in seconds.
         */
        time_limit?: number;
        /**
         * The type of packet capture. `Simple` captures sampled packets, and `full`
         * captures entire payloads and non-sampled packets.
         */
        type?: 'simple' | 'full';
    }
    namespace MagicVisibilityPCAPsResponseFull {
        /**
         * The packet capture filter. When this field is empty, all packets are captured.
         */
        interface FilterV1 {
            /**
             * The destination IP address of the packet.
             */
            destination_address?: string;
            /**
             * The destination port of the packet.
             */
            destination_port?: number;
            /**
             * The protocol number of the packet.
             */
            protocol?: number;
            /**
             * The source IP address of the packet.
             */
            source_address?: string;
            /**
             * The source port of the packet.
             */
            source_port?: number;
        }
    }
}
export type PCAPGetResponse = PCAPGetResponse.MagicVisibilityPCAPsResponseSimple | PCAPGetResponse.MagicVisibilityPCAPsResponseFull;
export declare namespace PCAPGetResponse {
    interface MagicVisibilityPCAPsResponseSimple {
        /**
         * The ID for the packet capture.
         */
        id?: string;
        /**
         * The packet capture filter. When this field is empty, all packets are captured.
         */
        filter_v1?: MagicVisibilityPCAPsResponseSimple.FilterV1;
        /**
         * The status of the packet capture request.
         */
        status?: 'unknown' | 'success' | 'pending' | 'running' | 'conversion_pending' | 'conversion_running' | 'complete' | 'failed';
        /**
         * The RFC 3339 timestamp when the packet capture was created.
         */
        submitted?: string;
        /**
         * The system used to collect packet captures.
         */
        system?: 'magic-transit';
        /**
         * The packet capture duration in seconds.
         */
        time_limit?: number;
        /**
         * The type of packet capture. `Simple` captures sampled packets, and `full`
         * captures entire payloads and non-sampled packets.
         */
        type?: 'simple' | 'full';
    }
    namespace MagicVisibilityPCAPsResponseSimple {
        /**
         * The packet capture filter. When this field is empty, all packets are captured.
         */
        interface FilterV1 {
            /**
             * The destination IP address of the packet.
             */
            destination_address?: string;
            /**
             * The destination port of the packet.
             */
            destination_port?: number;
            /**
             * The protocol number of the packet.
             */
            protocol?: number;
            /**
             * The source IP address of the packet.
             */
            source_address?: string;
            /**
             * The source port of the packet.
             */
            source_port?: number;
        }
    }
    interface MagicVisibilityPCAPsResponseFull {
        /**
         * The ID for the packet capture.
         */
        id?: string;
        /**
         * The maximum number of bytes to capture. This field only applies to `full` packet
         * captures.
         */
        byte_limit?: number;
        /**
         * The name of the data center used for the packet capture. This can be a specific
         * colo (ord02) or a multi-colo name (ORD). This field only applies to `full`
         * packet captures.
         */
        colo_name?: string;
        /**
         * The full URI for the bucket. This field only applies to `full` packet captures.
         */
        destination_conf?: string;
        /**
         * An error message that describes why the packet capture failed. This field only
         * applies to `full` packet captures.
         */
        error_message?: string;
        /**
         * The packet capture filter. When this field is empty, all packets are captured.
         */
        filter_v1?: MagicVisibilityPCAPsResponseFull.FilterV1;
        /**
         * The status of the packet capture request.
         */
        status?: 'unknown' | 'success' | 'pending' | 'running' | 'conversion_pending' | 'conversion_running' | 'complete' | 'failed';
        /**
         * The RFC 3339 timestamp when the packet capture was created.
         */
        submitted?: string;
        /**
         * The system used to collect packet captures.
         */
        system?: 'magic-transit';
        /**
         * The packet capture duration in seconds.
         */
        time_limit?: number;
        /**
         * The type of packet capture. `Simple` captures sampled packets, and `full`
         * captures entire payloads and non-sampled packets.
         */
        type?: 'simple' | 'full';
    }
    namespace MagicVisibilityPCAPsResponseFull {
        /**
         * The packet capture filter. When this field is empty, all packets are captured.
         */
        interface FilterV1 {
            /**
             * The destination IP address of the packet.
             */
            destination_address?: string;
            /**
             * The destination port of the packet.
             */
            destination_port?: number;
            /**
             * The protocol number of the packet.
             */
            protocol?: number;
            /**
             * The source IP address of the packet.
             */
            source_address?: string;
            /**
             * The source port of the packet.
             */
            source_port?: number;
        }
    }
}
export type PCAPCreateParams = PCAPCreateParams.MagicVisibilityPCAPsRequestSimple | PCAPCreateParams.MagicVisibilityPCAPsRequestFull;
export declare namespace PCAPCreateParams {
    interface MagicVisibilityPCAPsRequestSimple {
        /**
         * Path param: Identifier
         */
        account_id: string;
        /**
         * Body param: The limit of packets contained in a packet capture.
         */
        packet_limit: number;
        /**
         * Body param: The system used to collect packet captures.
         */
        system: 'magic-transit';
        /**
         * Body param: The packet capture duration in seconds.
         */
        time_limit: number;
        /**
         * Body param: The type of packet capture. `Simple` captures sampled packets, and
         * `full` captures entire payloads and non-sampled packets.
         */
        type: 'simple' | 'full';
        /**
         * Body param: The packet capture filter. When this field is empty, all packets are
         * captured.
         */
        filter_v1?: PCAPCreateParams.MagicVisibilityPCAPsRequestSimple.FilterV1;
    }
    namespace MagicVisibilityPCAPsRequestSimple {
        /**
         * The packet capture filter. When this field is empty, all packets are captured.
         */
        interface FilterV1 {
            /**
             * The destination IP address of the packet.
             */
            destination_address?: string;
            /**
             * The destination port of the packet.
             */
            destination_port?: number;
            /**
             * The protocol number of the packet.
             */
            protocol?: number;
            /**
             * The source IP address of the packet.
             */
            source_address?: string;
            /**
             * The source port of the packet.
             */
            source_port?: number;
        }
    }
    interface MagicVisibilityPCAPsRequestFull {
        /**
         * Path param: Identifier
         */
        account_id: string;
        /**
         * Body param: The name of the data center used for the packet capture. This can be
         * a specific colo (ord02) or a multi-colo name (ORD). This field only applies to
         * `full` packet captures.
         */
        colo_name: string;
        /**
         * Body param: The full URI for the bucket. This field only applies to `full`
         * packet captures.
         */
        destination_conf: string;
        /**
         * Body param: The system used to collect packet captures.
         */
        system: 'magic-transit';
        /**
         * Body param: The packet capture duration in seconds.
         */
        time_limit: number;
        /**
         * Body param: The type of packet capture. `Simple` captures sampled packets, and
         * `full` captures entire payloads and non-sampled packets.
         */
        type: 'simple' | 'full';
        /**
         * Body param: The maximum number of bytes to capture. This field only applies to
         * `full` packet captures.
         */
        byte_limit?: number;
        /**
         * Body param: The packet capture filter. When this field is empty, all packets are
         * captured.
         */
        filter_v1?: PCAPCreateParams.MagicVisibilityPCAPsRequestFull.FilterV1;
        /**
         * Body param: The limit of packets contained in a packet capture.
         */
        packet_limit?: number;
    }
    namespace MagicVisibilityPCAPsRequestFull {
        /**
         * The packet capture filter. When this field is empty, all packets are captured.
         */
        interface FilterV1 {
            /**
             * The destination IP address of the packet.
             */
            destination_address?: string;
            /**
             * The destination port of the packet.
             */
            destination_port?: number;
            /**
             * The protocol number of the packet.
             */
            protocol?: number;
            /**
             * The source IP address of the packet.
             */
            source_address?: string;
            /**
             * The source port of the packet.
             */
            source_port?: number;
        }
    }
}
export interface PCAPListParams {
    /**
     * Identifier
     */
    account_id: string;
}
export interface PCAPGetParams {
    /**
     * Identifier
     */
    account_id: string;
}
export declare namespace PCAPs {
    export import PCAPCreateResponse = PCAPsAPI.PCAPCreateResponse;
    export import PCAPListResponse = PCAPsAPI.PCAPListResponse;
    export import PCAPGetResponse = PCAPsAPI.PCAPGetResponse;
    export import PCAPListResponsesSinglePage = PCAPsAPI.PCAPListResponsesSinglePage;
    export import PCAPCreateParams = PCAPsAPI.PCAPCreateParams;
    export import PCAPListParams = PCAPsAPI.PCAPListParams;
    export import PCAPGetParams = PCAPsAPI.PCAPGetParams;
    export import Ownership = OwnershipAPI.Ownership;
    export import MagicVisibilityPCAPsOwnership = OwnershipAPI.MagicVisibilityPCAPsOwnership;
    export import OwnershipGetResponse = OwnershipAPI.OwnershipGetResponse;
    export import OwnershipCreateParams = OwnershipAPI.OwnershipCreateParams;
    export import OwnershipDeleteParams = OwnershipAPI.OwnershipDeleteParams;
    export import OwnershipGetParams = OwnershipAPI.OwnershipGetParams;
    export import OwnershipValidateParams = OwnershipAPI.OwnershipValidateParams;
    export import Download = DownloadAPI.Download;
    export import DownloadGetParams = DownloadAPI.DownloadGetParams;
}
//# sourceMappingURL=pcaps.d.ts.map