cloudflare/resources/zero-trust/dex/traceroute-tests.d.ts

The official TypeScript library for the Cloudflare API

import * as Core from 'cloudflare/core';
import { APIResource } from 'cloudflare/resource';
import * as TracerouteTestsAPI from 'cloudflare/resources/zero-trust/dex/traceroute-tests';
export declare class TracerouteTests extends APIResource {
    /**
     * Get test details and aggregate performance metrics for an traceroute test for a
     * given time period between 1 hour and 7 days.
     */
    get(testId: string, params: TracerouteTestGetParams, options?: Core.RequestOptions): Core.APIPromise<DigitalExperienceMonitoringTracerouteDetails>;
    /**
     * Get a breakdown of metrics by hop for individual traceroute test runs
     */
    networkPath(testId: string, params: TracerouteTestNetworkPathParams, options?: Core.RequestOptions): Core.APIPromise<DigitalExperienceMonitoringTracerouteTestNetworkPath>;
    /**
     * Get percentiles for a traceroute test for a given time period between 1 hour and
     * 7 days.
     */
    percentiles(testId: string, params: TracerouteTestPercentilesParams, options?: Core.RequestOptions): Core.APIPromise<DigitalExperienceMonitoringTracerouteDetailsPercentiles>;
}
export interface DigitalExperienceMonitoringTracerouteDetails {
    /**
     * The host of the Traceroute synthetic application test
     */
    host: string;
    /**
     * The interval at which the Traceroute synthetic application test is set to run.
     */
    interval: string;
    kind: 'traceroute';
    /**
     * The name of the Traceroute synthetic application test
     */
    name: string;
    tracerouteStats?: DigitalExperienceMonitoringTracerouteDetails.TracerouteStats | null;
    tracerouteStatsByColo?: Array<DigitalExperienceMonitoringTracerouteDetails.TracerouteStatsByColo>;
}
export declare namespace DigitalExperienceMonitoringTracerouteDetails {
    interface TracerouteStats {
        availabilityPct: TracerouteStats.AvailabilityPct;
        hopsCount: TracerouteStats.HopsCount;
        packetLossPct: TracerouteStats.PacketLossPct;
        roundTripTimeMs: TracerouteStats.RoundTripTimeMs;
        /**
         * Count of unique devices that have run this test in the given time period
         */
        uniqueDevicesTotal: number;
    }
    namespace TracerouteStats {
        interface AvailabilityPct {
            slots: Array<AvailabilityPct.Slot>;
            /**
             * average observed in the time period
             */
            avg?: number | null;
            /**
             * highest observed in the time period
             */
            max?: number | null;
            /**
             * lowest observed in the time period
             */
            min?: number | null;
        }
        namespace AvailabilityPct {
            interface Slot {
                timestamp: string;
                value: number;
            }
        }
        interface HopsCount {
            slots: Array<HopsCount.Slot>;
            /**
             * average observed in the time period
             */
            avg?: number | null;
            /**
             * highest observed in the time period
             */
            max?: number | null;
            /**
             * lowest observed in the time period
             */
            min?: number | null;
        }
        namespace HopsCount {
            interface Slot {
                timestamp: string;
                value: number;
            }
        }
        interface PacketLossPct {
            slots: Array<PacketLossPct.Slot>;
            /**
             * average observed in the time period
             */
            avg?: number | null;
            /**
             * highest observed in the time period
             */
            max?: number | null;
            /**
             * lowest observed in the time period
             */
            min?: number | null;
        }
        namespace PacketLossPct {
            interface Slot {
                timestamp: string;
                value: number;
            }
        }
        interface RoundTripTimeMs {
            slots: Array<RoundTripTimeMs.Slot>;
            /**
             * average observed in the time period
             */
            avg?: number | null;
            /**
             * highest observed in the time period
             */
            max?: number | null;
            /**
             * lowest observed in the time period
             */
            min?: number | null;
        }
        namespace RoundTripTimeMs {
            interface Slot {
                timestamp: string;
                value: number;
            }
        }
    }
    interface TracerouteStatsByColo {
        availabilityPct: TracerouteStatsByColo.AvailabilityPct;
        colo: string;
        hopsCount: TracerouteStatsByColo.HopsCount;
        packetLossPct: TracerouteStatsByColo.PacketLossPct;
        roundTripTimeMs: TracerouteStatsByColo.RoundTripTimeMs;
        /**
         * Count of unique devices that have run this test in the given time period
         */
        uniqueDevicesTotal: number;
    }
    namespace TracerouteStatsByColo {
        interface AvailabilityPct {
            slots: Array<AvailabilityPct.Slot>;
            /**
             * average observed in the time period
             */
            avg?: number | null;
            /**
             * highest observed in the time period
             */
            max?: number | null;
            /**
             * lowest observed in the time period
             */
            min?: number | null;
        }
        namespace AvailabilityPct {
            interface Slot {
                timestamp: string;
                value: number;
            }
        }
        interface HopsCount {
            slots: Array<HopsCount.Slot>;
            /**
             * average observed in the time period
             */
            avg?: number | null;
            /**
             * highest observed in the time period
             */
            max?: number | null;
            /**
             * lowest observed in the time period
             */
            min?: number | null;
        }
        namespace HopsCount {
            interface Slot {
                timestamp: string;
                value: number;
            }
        }
        interface PacketLossPct {
            slots: Array<PacketLossPct.Slot>;
            /**
             * average observed in the time period
             */
            avg?: number | null;
            /**
             * highest observed in the time period
             */
            max?: number | null;
            /**
             * lowest observed in the time period
             */
            min?: number | null;
        }
        namespace PacketLossPct {
            interface Slot {
                timestamp: string;
                value: number;
            }
        }
        interface RoundTripTimeMs {
            slots: Array<RoundTripTimeMs.Slot>;
            /**
             * average observed in the time period
             */
            avg?: number | null;
            /**
             * highest observed in the time period
             */
            max?: number | null;
            /**
             * lowest observed in the time period
             */
            min?: number | null;
        }
        namespace RoundTripTimeMs {
            interface Slot {
                timestamp: string;
                value: number;
            }
        }
    }
}
export interface DigitalExperienceMonitoringTracerouteDetailsPercentiles {
    hopsCount?: DigitalExperienceMonitoringTracerouteDetailsPercentiles.HopsCount;
    packetLossPct?: DigitalExperienceMonitoringTracerouteDetailsPercentiles.PacketLossPct;
    roundTripTimeMs?: DigitalExperienceMonitoringTracerouteDetailsPercentiles.RoundTripTimeMs;
}
export declare namespace DigitalExperienceMonitoringTracerouteDetailsPercentiles {
    interface HopsCount {
        /**
         * p50 observed in the time period
         */
        p50?: number | null;
        /**
         * p90 observed in the time period
         */
        p90?: number | null;
        /**
         * p95 observed in the time period
         */
        p95?: number | null;
        /**
         * p99 observed in the time period
         */
        p99?: number | null;
    }
    interface PacketLossPct {
        /**
         * p50 observed in the time period
         */
        p50?: number | null;
        /**
         * p90 observed in the time period
         */
        p90?: number | null;
        /**
         * p95 observed in the time period
         */
        p95?: number | null;
        /**
         * p99 observed in the time period
         */
        p99?: number | null;
    }
    interface RoundTripTimeMs {
        /**
         * p50 observed in the time period
         */
        p50?: number | null;
        /**
         * p90 observed in the time period
         */
        p90?: number | null;
        /**
         * p95 observed in the time period
         */
        p95?: number | null;
        /**
         * p99 observed in the time period
         */
        p99?: number | null;
    }
}
export interface DigitalExperienceMonitoringTracerouteTestNetworkPath {
    /**
     * API Resource UUID tag.
     */
    id: string;
    deviceName?: string;
    /**
     * The interval at which the Traceroute synthetic application test is set to run.
     */
    interval?: string;
    kind?: 'traceroute';
    name?: string;
    networkPath?: DigitalExperienceMonitoringTracerouteTestNetworkPath.NetworkPath | null;
    /**
     * The host of the Traceroute synthetic application test
     */
    url?: string;
}
export declare namespace DigitalExperienceMonitoringTracerouteTestNetworkPath {
    interface NetworkPath {
        slots: Array<NetworkPath.Slot>;
        /**
         * Specifies the sampling applied, if any, to the slots response. When sampled,
         * results shown represent the first test run to the start of each sampling
         * interval.
         */
        sampling?: NetworkPath.Sampling | null;
    }
    namespace NetworkPath {
        interface Slot {
            /**
             * API Resource UUID tag.
             */
            id: string;
            /**
             * Round trip time in ms of the client to app mile
             */
            clientToAppRttMs: number | null;
            /**
             * Round trip time in ms of the client to Cloudflare egress mile
             */
            clientToCfEgressRttMs: number | null;
            /**
             * Round trip time in ms of the client to Cloudflare ingress mile
             */
            clientToCfIngressRttMs: number | null;
            timestamp: string;
            /**
             * Round trip time in ms of the client to ISP mile
             */
            clientToIspRttMs?: number | null;
        }
        /**
         * Specifies the sampling applied, if any, to the slots response. When sampled,
         * results shown represent the first test run to the start of each sampling
         * interval.
         */
        interface Sampling {
            unit: 'hours';
            value: number;
        }
    }
}
export interface TracerouteTestGetParams {
    /**
     * Path param: Unique identifier linked to an account
     */
    account_id: string;
    /**
     * Query param: Time interval for aggregate time slots.
     */
    interval: 'minute' | 'hour';
    /**
     * Query param: End time for aggregate metrics in ISO ms
     */
    timeEnd: string;
    /**
     * Query param: Start time for aggregate metrics in ISO ms
     */
    timeStart: string;
    /**
     * Query param: Optionally filter result stats to a Cloudflare colo. Cannot be used
     * in combination with deviceId param.
     */
    colo?: string;
    /**
     * Query param: Optionally filter result stats to a specific device(s). Cannot be
     * used in combination with colo param.
     */
    deviceId?: Array<string>;
}
export interface TracerouteTestNetworkPathParams {
    /**
     * Path param: unique identifier linked to an account
     */
    account_id: string;
    /**
     * Query param: Device to filter tracroute result runs to
     */
    deviceId: string;
    /**
     * Query param: Time interval for aggregate time slots.
     */
    interval: 'minute' | 'hour';
    /**
     * Query param: End time for aggregate metrics in ISO ms
     */
    timeEnd: string;
    /**
     * Query param: Start time for aggregate metrics in ISO ms
     */
    timeStart: string;
}
export interface TracerouteTestPercentilesParams {
    /**
     * Path param: unique identifier linked to an account in the API request path.
     */
    account_id: string;
    /**
     * Query param: End time for aggregate metrics in ISO format
     */
    timeEnd: string;
    /**
     * Query param: Start time for aggregate metrics in ISO format
     */
    timeStart: string;
    /**
     * Query param: Optionally filter result stats to a Cloudflare colo. Cannot be used
     * in combination with deviceId param.
     */
    colo?: string;
    /**
     * Query param: Optionally filter result stats to a specific device(s). Cannot be
     * used in combination with colo param.
     */
    deviceId?: Array<string>;
}
export declare namespace TracerouteTests {
    export import DigitalExperienceMonitoringTracerouteDetails = TracerouteTestsAPI.DigitalExperienceMonitoringTracerouteDetails;
    export import DigitalExperienceMonitoringTracerouteDetailsPercentiles = TracerouteTestsAPI.DigitalExperienceMonitoringTracerouteDetailsPercentiles;
    export import DigitalExperienceMonitoringTracerouteTestNetworkPath = TracerouteTestsAPI.DigitalExperienceMonitoringTracerouteTestNetworkPath;
    export import TracerouteTestGetParams = TracerouteTestsAPI.TracerouteTestGetParams;
    export import TracerouteTestNetworkPathParams = TracerouteTestsAPI.TracerouteTestNetworkPathParams;
    export import TracerouteTestPercentilesParams = TracerouteTestsAPI.TracerouteTestPercentilesParams;
}
//# sourceMappingURL=traceroute-tests.d.ts.map