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

The official TypeScript library for the Cloudflare API

import * as Core from 'cloudflare/core';
import { APIResource } from 'cloudflare/resource';
import * as TestsAPI from 'cloudflare/resources/zero-trust/dex/tests/tests';
import * as UniqueDevicesAPI from 'cloudflare/resources/zero-trust/dex/tests/unique-devices';
import { V4PagePagination, type V4PagePaginationParams } from 'cloudflare/pagination';
export declare class Tests extends APIResource {
    uniqueDevices: UniqueDevicesAPI.UniqueDevices;
    /**
     * List DEX tests
     */
    list(params: TestListParams, options?: Core.RequestOptions): Core.PagePromise<TestListResponsesV4PagePagination, TestListResponse>;
}
export declare class TestListResponsesV4PagePagination extends V4PagePagination<TestListResponse> {
}
export interface DigitalExperienceMonitoringTests {
    overviewMetrics: DigitalExperienceMonitoringTests.OverviewMetrics;
    /**
     * array of test results objects.
     */
    tests: Array<DigitalExperienceMonitoringTests.Test>;
}
export declare namespace DigitalExperienceMonitoringTests {
    interface OverviewMetrics {
        /**
         * number of tests.
         */
        testsTotal: number;
        /**
         * percentage availability for all traceroutes results in response
         */
        avgTracerouteAvailabilityPct?: number | null;
    }
    interface Test {
        /**
         * API Resource UUID tag.
         */
        id: string;
        /**
         * date the test was created.
         */
        created: string;
        /**
         * the test description defined during configuration
         */
        description: string;
        /**
         * if true, then the test will run on targeted devices. Else, the test will not
         * run.
         */
        enabled: boolean;
        host: string;
        /**
         * The interval at which the synthetic application test is set to run.
         */
        interval: string;
        /**
         * test type, http or traceroute
         */
        kind: 'http' | 'traceroute';
        /**
         * name given to this test
         */
        name: string;
        updated: string;
        httpResults?: Test.HTTPResults | null;
        httpResultsByColo?: Array<Test.HTTPResultsByColo>;
        /**
         * for HTTP, the method to use when running the test
         */
        method?: string;
        tracerouteResults?: Test.TracerouteResults | null;
        tracerouteResultsByColo?: Array<Test.TracerouteResultsByColo>;
    }
    namespace Test {
        interface HTTPResults {
            resourceFetchTime: HTTPResults.ResourceFetchTime;
        }
        namespace HTTPResults {
            interface ResourceFetchTime {
                history: Array<ResourceFetchTime.History>;
                avgMs?: number | null;
                overTime?: ResourceFetchTime.OverTime | null;
            }
            namespace ResourceFetchTime {
                interface History {
                    timePeriod: History.TimePeriod;
                    avgMs?: number | null;
                    deltaPct?: number | null;
                }
                namespace History {
                    interface TimePeriod {
                        units: 'hours' | 'days' | 'testRuns';
                        value: number;
                    }
                }
                interface OverTime {
                    timePeriod: OverTime.TimePeriod;
                    values: Array<OverTime.Value>;
                }
                namespace OverTime {
                    interface TimePeriod {
                        units: 'hours' | 'days' | 'testRuns';
                        value: number;
                    }
                    interface Value {
                        avgMs: number;
                        timestamp: string;
                    }
                }
            }
        }
        interface HTTPResultsByColo {
            /**
             * Cloudflare colo
             */
            colo: string;
            resourceFetchTime: HTTPResultsByColo.ResourceFetchTime;
        }
        namespace HTTPResultsByColo {
            interface ResourceFetchTime {
                history: Array<ResourceFetchTime.History>;
                avgMs?: number | null;
                overTime?: ResourceFetchTime.OverTime | null;
            }
            namespace ResourceFetchTime {
                interface History {
                    timePeriod: History.TimePeriod;
                    avgMs?: number | null;
                    deltaPct?: number | null;
                }
                namespace History {
                    interface TimePeriod {
                        units: 'hours' | 'days' | 'testRuns';
                        value: number;
                    }
                }
                interface OverTime {
                    timePeriod: OverTime.TimePeriod;
                    values: Array<OverTime.Value>;
                }
                namespace OverTime {
                    interface TimePeriod {
                        units: 'hours' | 'days' | 'testRuns';
                        value: number;
                    }
                    interface Value {
                        avgMs: number;
                        timestamp: string;
                    }
                }
            }
        }
        interface TracerouteResults {
            roundTripTime: TracerouteResults.RoundTripTime;
        }
        namespace TracerouteResults {
            interface RoundTripTime {
                history: Array<RoundTripTime.History>;
                avgMs?: number | null;
                overTime?: RoundTripTime.OverTime | null;
            }
            namespace RoundTripTime {
                interface History {
                    timePeriod: History.TimePeriod;
                    avgMs?: number | null;
                    deltaPct?: number | null;
                }
                namespace History {
                    interface TimePeriod {
                        units: 'hours' | 'days' | 'testRuns';
                        value: number;
                    }
                }
                interface OverTime {
                    timePeriod: OverTime.TimePeriod;
                    values: Array<OverTime.Value>;
                }
                namespace OverTime {
                    interface TimePeriod {
                        units: 'hours' | 'days' | 'testRuns';
                        value: number;
                    }
                    interface Value {
                        avgMs: number;
                        timestamp: string;
                    }
                }
            }
        }
        interface TracerouteResultsByColo {
            /**
             * Cloudflare colo
             */
            colo: string;
            roundTripTime: TracerouteResultsByColo.RoundTripTime;
        }
        namespace TracerouteResultsByColo {
            interface RoundTripTime {
                history: Array<RoundTripTime.History>;
                avgMs?: number | null;
                overTime?: RoundTripTime.OverTime | null;
            }
            namespace RoundTripTime {
                interface History {
                    timePeriod: History.TimePeriod;
                    avgMs?: number | null;
                    deltaPct?: number | null;
                }
                namespace History {
                    interface TimePeriod {
                        units: 'hours' | 'days' | 'testRuns';
                        value: number;
                    }
                }
                interface OverTime {
                    timePeriod: OverTime.TimePeriod;
                    values: Array<OverTime.Value>;
                }
                namespace OverTime {
                    interface TimePeriod {
                        units: 'hours' | 'days' | 'testRuns';
                        value: number;
                    }
                    interface Value {
                        avgMs: number;
                        timestamp: string;
                    }
                }
            }
        }
    }
}
export interface TestListResponse {
    errors: Array<TestListResponse.Error>;
    messages: Array<TestListResponse.Message>;
    result: DigitalExperienceMonitoringTests;
    /**
     * Whether the API call was successful
     */
    success: true;
    result_info?: TestListResponse.ResultInfo;
}
export declare namespace TestListResponse {
    interface Error {
        code: number;
        message: string;
    }
    interface Message {
        code: number;
        message: string;
    }
    interface ResultInfo {
        /**
         * Total number of results for the requested service
         */
        count?: number;
        /**
         * Current page within paginated list of results
         */
        page?: number;
        /**
         * Number of results per page of results
         */
        per_page?: number;
        /**
         * Total results available without any search parameters
         */
        total_count?: number;
    }
}
export interface TestListParams extends V4PagePaginationParams {
    /**
     * Path param: unique identifier linked to an account in the API request path.
     */
    account_id: 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>;
    /**
     * Query param: Optionally filter results by test name
     */
    testName?: string;
}
export declare namespace Tests {
    export import DigitalExperienceMonitoringTests = TestsAPI.DigitalExperienceMonitoringTests;
    export import TestListResponse = TestsAPI.TestListResponse;
    export import TestListResponsesV4PagePagination = TestsAPI.TestListResponsesV4PagePagination;
    export import TestListParams = TestsAPI.TestListParams;
    export import UniqueDevices = UniqueDevicesAPI.UniqueDevices;
    export import DigitalExperienceMonitoringUniqueDevices = UniqueDevicesAPI.DigitalExperienceMonitoringUniqueDevices;
    export import UniqueDeviceListParams = UniqueDevicesAPI.UniqueDeviceListParams;
}
//# sourceMappingURL=tests.d.ts.map