import * as S from "@distilled.cloud/core/schema";
import * as API from "@distilled.cloud/core/api";
import { type CloudflareOpError, type CloudflareOpContext } from "../protocol.ts";
export type { CloudflareOpError, CloudflareOpContext };
export interface CacheReserveClearClearRequest {
    /** Identifier. */
    zoneId: string;
}
export declare const CacheReserveClearClearRequest: S.Schema<CacheReserveClearClearRequest>;
export type CacheReserveClearClearResponseId = "cache_reserve_clear";
export declare const CacheReserveClearClearResponseId: any;
export type CacheReserveClearClearResponseState = "In-progress" | "Completed";
export declare const CacheReserveClearClearResponseState: any;
/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface CacheReserveClearClearResponse {
    /** ID of the zone setting. */
    id: CacheReserveClearClearResponseId;
    /** The time that the latest Cache Reserve Clear operation started. */
    startTs: string;
    /** The current state of the Cache Reserve Clear operation. */
    state: CacheReserveClearClearResponseState;
    /** The time that the latest Cache Reserve Clear operation completed. */
    endTs?: string | null;
    /** Last time this setting was modified. */
    modifiedOn?: string | null;
}
export declare const CacheReserveClearClearResponse: S.Schema<CacheReserveClearClearResponse>;
export interface CacheReserveClearStatusRequest {
    /** Identifier. */
    zoneId: string;
}
export declare const CacheReserveClearStatusRequest: S.Schema<CacheReserveClearStatusRequest>;
export type CacheReserveClearStatusResponseId = "cache_reserve_clear";
export declare const CacheReserveClearStatusResponseId: any;
export type CacheReserveClearStatusResponseState = "In-progress" | "Completed";
export declare const CacheReserveClearStatusResponseState: any;
/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface CacheReserveClearStatusResponse {
    /** ID of the zone setting. */
    id: CacheReserveClearStatusResponseId;
    /** The time that the latest Cache Reserve Clear operation started. */
    startTs: string;
    /** The current state of the Cache Reserve Clear operation. */
    state: CacheReserveClearStatusResponseState;
    /** The time that the latest Cache Reserve Clear operation completed. */
    endTs?: string | null;
    /** Last time this setting was modified. */
    modifiedOn?: string | null;
}
export declare const CacheReserveClearStatusResponse: S.Schema<CacheReserveClearStatusResponse>;
export interface GetRequest {
    /** Identifier. */
    zoneId: string;
}
export declare const GetRequest: S.Schema<GetRequest>;
export type GetResponseCacheReserveValue = "on" | "off";
export declare const GetResponseCacheReserveValue: any;
export interface GetResponseCacheReserve {
    /** The id of the Cache Reserve setting. */
    id?: string | null;
    /** Whether the setting is editable. */
    editable?: boolean | null;
    /** Specifies the enablement value of Cache Reserve. */
    value?: GetResponseCacheReserveValue | null;
}
export declare const GetResponseCacheReserve: S.Schema<GetResponseCacheReserve>;
export type GetResponseRegionalTieredCacheValue = "on" | "off";
export declare const GetResponseRegionalTieredCacheValue: any;
export interface GetResponseRegionalTieredCache {
    /** The id of the Regional Tiered Cache setting. */
    id?: string | null;
    /** Whether the setting is editable. */
    editable?: boolean | null;
    /** Specifies the enablement value of Cache Reserve. */
    value?: GetResponseRegionalTieredCacheValue | null;
}
export declare const GetResponseRegionalTieredCache: S.Schema<GetResponseRegionalTieredCache>;
export type GetResponseSmartRoutingValue = "on" | "off";
export declare const GetResponseSmartRoutingValue: any;
export interface GetResponseSmartRouting {
    /** The id of the Smart Routing setting. */
    id?: string | null;
    /** Whether the setting is editable. */
    editable?: boolean | null;
    /** Specifies the enablement value of Argo Smart Routing. */
    value?: GetResponseSmartRoutingValue | null;
}
export declare const GetResponseSmartRouting: S.Schema<GetResponseSmartRouting>;
export type GetResponseSmartTieredCacheValue = "on" | "off";
export declare const GetResponseSmartTieredCacheValue: any;
export interface GetResponseSmartTieredCache {
    /** The id of the Smart Tiered Cache setting. */
    id?: string | null;
    /** Whether the setting is editable. */
    editable?: boolean | null;
    /** The last time the setting was modified. */
    modifiedOn?: string | null;
    /** Specifies the enablement value of Tiered Cache. */
    value?: GetResponseSmartTieredCacheValue | null;
}
export declare const GetResponseSmartTieredCache: S.Schema<GetResponseSmartTieredCache>;
/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface GetResponse {
    cacheReserve: GetResponseCacheReserve;
    /** The total number of health checks associated with the zone. */
    healthchecksCount: number;
    regionalTieredCache: GetResponseRegionalTieredCache;
    smartRouting: GetResponseSmartRouting;
    smartTieredCache: GetResponseSmartTieredCache;
}
export declare const GetResponse: S.Schema<GetResponse>;
export type HealthChecksCreateRequestCheckRegionsItem = "WNAM" | "ENAM" | "WEU" | "EEU" | "NSAM" | "SSAM" | "OC" | "ME" | "NAF" | "SAF" | "IN" | "SEAS" | "NEAS" | "ALL_REGIONS";
export declare const HealthChecksCreateRequestCheckRegionsItem: any;
export type HealthChecksCreateRequestCheckRegionsList = Array<HealthChecksCreateRequestCheckRegionsItem | (string & {})>;
export declare const HealthChecksCreateRequestCheckRegionsList: S.Schema<HealthChecksCreateRequestCheckRegionsList>;
export type HealthChecksCreateRequestHttpConfigExpectedCodesList = Array<string>;
export declare const HealthChecksCreateRequestHttpConfigExpectedCodesList: S.Schema<HealthChecksCreateRequestHttpConfigExpectedCodesList>;
export type HealthChecksCreateRequestHttpConfigHeaderValueList = Array<string>;
export declare const HealthChecksCreateRequestHttpConfigHeaderValueList: S.Schema<HealthChecksCreateRequestHttpConfigHeaderValueList>;
export type HealthChecksCreateRequestHttpConfigHeaderMap = {
    [key: string]: HealthChecksCreateRequestHttpConfigHeaderValueList | undefined;
};
export declare const HealthChecksCreateRequestHttpConfigHeaderMap: S.Schema<HealthChecksCreateRequestHttpConfigHeaderMap>;
export type HealthChecksCreateRequestHttpConfigMethod = "GET" | "HEAD";
export declare const HealthChecksCreateRequestHttpConfigMethod: any;
export interface HealthChecksCreateRequestHttpConfig {
    /** Do not validate the certificate when the health check uses HTTPS. */
    allowInsecure?: boolean;
    /** A case-insensitive sub-string to look for in the response body. If this string is not found, the origin will be marked as unhealthy. */
    expectedBody?: string;
    /** The expected HTTP response codes (e.g. "200") or code ranges (e.g. "2xx" for all codes starting with 2) of the health check. */
    expectedCodes?: HealthChecksCreateRequestHttpConfigExpectedCodesList;
    /** Follow redirects if the origin returns a 3xx status code. */
    followRedirects?: boolean;
    /** The HTTP request headers to send in the health check. It is recommended you set a Host header by default. The User-Agent header cannot be overridden. */
    header?: HealthChecksCreateRequestHttpConfigHeaderMap;
    /** The HTTP method to use for the health check. */
    method?: HealthChecksCreateRequestHttpConfigMethod | (string & {});
    /** The endpoint path to health check against. */
    path?: string;
    /** Port number to connect to for the health check. Defaults to 80 if type is HTTP or 443 if type is HTTPS. */
    port?: number;
}
export declare const HealthChecksCreateRequestHttpConfig: S.Schema<HealthChecksCreateRequestHttpConfig>;
export type HealthChecksCreateRequestTcpConfigMethod = "connection_established";
export declare const HealthChecksCreateRequestTcpConfigMethod: any;
export interface HealthChecksCreateRequestTcpConfig {
    /** The TCP connection method to use for the health check. */
    method?: HealthChecksCreateRequestTcpConfigMethod | (string & {});
    /** Port number to connect to for the health check. Defaults to 80. */
    port?: number;
}
export declare const HealthChecksCreateRequestTcpConfig: S.Schema<HealthChecksCreateRequestTcpConfig>;
export interface HealthChecksCreateRequest {
    /** Identifier. */
    zoneId: string;
    /** The hostname or IP address of the origin server to run health checks on. */
    address: string;
    /** A short name to identify the health check. Only alphanumeric characters, hyphens and underscores are allowed. */
    name: string;
    /** A list of regions from which to run health checks. Null means Cloudflare will pick a default region. */
    checkRegions?: HealthChecksCreateRequestCheckRegionsList;
    /** The number of consecutive fails required from a health check before changing the health to unhealthy. */
    consecutiveFails?: number;
    /** The number of consecutive successes required from a health check before changing the health to healthy. */
    consecutiveSuccesses?: number;
    /** A human-readable description of the health check. */
    description?: string;
    /** Parameters specific to an HTTP or HTTPS health check. */
    httpConfig?: HealthChecksCreateRequestHttpConfig;
    /** The interval between each health check. Shorter intervals may give quicker notifications if the origin status changes, but will increase load on the origin as we check from multiple locations. */
    interval?: number;
    /** The number of retries to attempt in case of a timeout before marking the origin as unhealthy. Retries are attempted immediately. */
    retries?: number;
    /** If suspended, no health checks are sent to the origin. */
    suspended?: boolean;
    /** Parameters specific to TCP health check. */
    tcpConfig?: HealthChecksCreateRequestTcpConfig;
    /** The timeout (in seconds) before marking the health check as failed. */
    timeout?: number;
    /** The protocol to use for the health check. Currently supported protocols are 'HTTP', 'HTTPS' and 'TCP'. */
    type?: string;
}
export declare const HealthChecksCreateRequest: S.Schema<HealthChecksCreateRequest>;
export type HealthChecksCreateResponseCheckRegionsItem = "WNAM" | "ENAM" | "WEU" | "EEU" | "NSAM" | "SSAM" | "OC" | "ME" | "NAF" | "SAF" | "IN" | "SEAS" | "NEAS" | "ALL_REGIONS";
export declare const HealthChecksCreateResponseCheckRegionsItem: any;
export type HealthChecksCreateResponseCheckRegionsList = Array<HealthChecksCreateResponseCheckRegionsItem>;
export declare const HealthChecksCreateResponseCheckRegionsList: S.Schema<HealthChecksCreateResponseCheckRegionsList>;
export type HealthChecksCreateResponseHttpConfigExpectedCodesList = Array<string>;
export declare const HealthChecksCreateResponseHttpConfigExpectedCodesList: S.Schema<HealthChecksCreateResponseHttpConfigExpectedCodesList>;
export type HealthChecksCreateResponseHttpConfigHeaderValueList = Array<string>;
export declare const HealthChecksCreateResponseHttpConfigHeaderValueList: S.Schema<HealthChecksCreateResponseHttpConfigHeaderValueList>;
export type HealthChecksCreateResponseHttpConfigHeaderMap = {
    [key: string]: HealthChecksCreateResponseHttpConfigHeaderValueList | undefined;
};
export declare const HealthChecksCreateResponseHttpConfigHeaderMap: S.Schema<HealthChecksCreateResponseHttpConfigHeaderMap>;
export type HealthChecksCreateResponseHttpConfigMethod = "GET" | "HEAD";
export declare const HealthChecksCreateResponseHttpConfigMethod: any;
export interface HealthChecksCreateResponseHttpConfig {
    /** Do not validate the certificate when the health check uses HTTPS. */
    allowInsecure?: boolean | null;
    /** A case-insensitive sub-string to look for in the response body. If this string is not found, the origin will be marked as unhealthy. */
    expectedBody?: string | null;
    /** The expected HTTP response codes (e.g. "200") or code ranges (e.g. "2xx" for all codes starting with 2) of the health check. */
    expectedCodes?: HealthChecksCreateResponseHttpConfigExpectedCodesList | null;
    /** Follow redirects if the origin returns a 3xx status code. */
    followRedirects?: boolean | null;
    /** The HTTP request headers to send in the health check. It is recommended you set a Host header by default. The User-Agent header cannot be overridden. */
    header?: HealthChecksCreateResponseHttpConfigHeaderMap | null;
    /** The HTTP method to use for the health check. */
    method?: HealthChecksCreateResponseHttpConfigMethod | null;
    /** The endpoint path to health check against. */
    path?: string | null;
    /** Port number to connect to for the health check. Defaults to 80 if type is HTTP or 443 if type is HTTPS. */
    port?: number | null;
}
export declare const HealthChecksCreateResponseHttpConfig: S.Schema<HealthChecksCreateResponseHttpConfig>;
export type HealthChecksCreateResponseStatus = "unknown" | "healthy" | "unhealthy" | "suspended";
export declare const HealthChecksCreateResponseStatus: any;
export type HealthChecksCreateResponseTcpConfigMethod = "connection_established";
export declare const HealthChecksCreateResponseTcpConfigMethod: any;
export interface HealthChecksCreateResponseTcpConfig {
    /** The TCP connection method to use for the health check. */
    method?: HealthChecksCreateResponseTcpConfigMethod | null;
    /** Port number to connect to for the health check. Defaults to 80. */
    port?: number | null;
}
export declare const HealthChecksCreateResponseTcpConfig: S.Schema<HealthChecksCreateResponseTcpConfig>;
/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface HealthChecksCreateResponse {
    /** Identifier. */
    id?: string | null;
    /** The hostname or IP address of the origin server to run health checks on. */
    address?: string | null;
    /** A list of regions from which to run health checks. Null means Cloudflare will pick a default region. */
    checkRegions?: HealthChecksCreateResponseCheckRegionsList | null;
    /** The number of consecutive fails required from a health check before changing the health to unhealthy. */
    consecutiveFails?: number | null;
    /** The number of consecutive successes required from a health check before changing the health to healthy. */
    consecutiveSuccesses?: number | null;
    createdOn?: string | null;
    /** A human-readable description of the health check. */
    description?: string | null;
    /** The current failure reason if status is unhealthy. */
    failureReason?: string | null;
    /** Parameters specific to an HTTP or HTTPS health check. */
    httpConfig?: HealthChecksCreateResponseHttpConfig | null;
    /** The interval between each health check. Shorter intervals may give quicker notifications if the origin status changes, but will increase load on the origin as we check from multiple locations. */
    interval?: number | null;
    modifiedOn?: string | null;
    /** A short name to identify the health check. Only alphanumeric characters, hyphens and underscores are allowed. */
    name?: string | null;
    /** The number of retries to attempt in case of a timeout before marking the origin as unhealthy. Retries are attempted immediately. */
    retries?: number | null;
    /** The current status of the origin server according to the health check. */
    status?: HealthChecksCreateResponseStatus | null;
    /** If suspended, no health checks are sent to the origin. */
    suspended?: boolean | null;
    /** Parameters specific to TCP health check. */
    tcpConfig?: HealthChecksCreateResponseTcpConfig | null;
    /** The timeout (in seconds) before marking the health check as failed. */
    timeout?: number | null;
    /** The protocol to use for the health check. Currently supported protocols are 'HTTP', 'HTTPS' and 'TCP'. */
    type?: string | null;
}
export declare const HealthChecksCreateResponse: S.Schema<HealthChecksCreateResponse>;
export interface HealthChecksDeleteRequest {
    /** Identifier. */
    zoneId: string;
    /** Identifier. */
    healthcheckId: string;
}
export declare const HealthChecksDeleteRequest: S.Schema<HealthChecksDeleteRequest>;
/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface HealthChecksDeleteResponse {
    /** Identifier. */
    id?: string | null;
}
export declare const HealthChecksDeleteResponse: S.Schema<HealthChecksDeleteResponse>;
export type HealthChecksEditRequestCheckRegionsItem = "WNAM" | "ENAM" | "WEU" | "EEU" | "NSAM" | "SSAM" | "OC" | "ME" | "NAF" | "SAF" | "IN" | "SEAS" | "NEAS" | "ALL_REGIONS";
export declare const HealthChecksEditRequestCheckRegionsItem: any;
export type HealthChecksEditRequestCheckRegionsList = Array<HealthChecksEditRequestCheckRegionsItem | (string & {})>;
export declare const HealthChecksEditRequestCheckRegionsList: S.Schema<HealthChecksEditRequestCheckRegionsList>;
export type HealthChecksEditRequestHttpConfigExpectedCodesList = Array<string>;
export declare const HealthChecksEditRequestHttpConfigExpectedCodesList: S.Schema<HealthChecksEditRequestHttpConfigExpectedCodesList>;
export type HealthChecksEditRequestHttpConfigHeaderValueList = Array<string>;
export declare const HealthChecksEditRequestHttpConfigHeaderValueList: S.Schema<HealthChecksEditRequestHttpConfigHeaderValueList>;
export type HealthChecksEditRequestHttpConfigHeaderMap = {
    [key: string]: HealthChecksEditRequestHttpConfigHeaderValueList | undefined;
};
export declare const HealthChecksEditRequestHttpConfigHeaderMap: S.Schema<HealthChecksEditRequestHttpConfigHeaderMap>;
export type HealthChecksEditRequestHttpConfigMethod = "GET" | "HEAD";
export declare const HealthChecksEditRequestHttpConfigMethod: any;
export interface HealthChecksEditRequestHttpConfig {
    /** Do not validate the certificate when the health check uses HTTPS. */
    allowInsecure?: boolean;
    /** A case-insensitive sub-string to look for in the response body. If this string is not found, the origin will be marked as unhealthy. */
    expectedBody?: string;
    /** The expected HTTP response codes (e.g. "200") or code ranges (e.g. "2xx" for all codes starting with 2) of the health check. */
    expectedCodes?: HealthChecksEditRequestHttpConfigExpectedCodesList;
    /** Follow redirects if the origin returns a 3xx status code. */
    followRedirects?: boolean;
    /** The HTTP request headers to send in the health check. It is recommended you set a Host header by default. The User-Agent header cannot be overridden. */
    header?: HealthChecksEditRequestHttpConfigHeaderMap;
    /** The HTTP method to use for the health check. */
    method?: HealthChecksEditRequestHttpConfigMethod | (string & {});
    /** The endpoint path to health check against. */
    path?: string;
    /** Port number to connect to for the health check. Defaults to 80 if type is HTTP or 443 if type is HTTPS. */
    port?: number;
}
export declare const HealthChecksEditRequestHttpConfig: S.Schema<HealthChecksEditRequestHttpConfig>;
export type HealthChecksEditRequestTcpConfigMethod = "connection_established";
export declare const HealthChecksEditRequestTcpConfigMethod: any;
export interface HealthChecksEditRequestTcpConfig {
    /** The TCP connection method to use for the health check. */
    method?: HealthChecksEditRequestTcpConfigMethod | (string & {});
    /** Port number to connect to for the health check. Defaults to 80. */
    port?: number;
}
export declare const HealthChecksEditRequestTcpConfig: S.Schema<HealthChecksEditRequestTcpConfig>;
export interface HealthChecksEditRequest {
    /** Identifier. */
    zoneId: string;
    /** Identifier. */
    healthcheckId: string;
    /** The hostname or IP address of the origin server to run health checks on. */
    address: string;
    /** A short name to identify the health check. Only alphanumeric characters, hyphens and underscores are allowed. */
    name: string;
    /** A list of regions from which to run health checks. Null means Cloudflare will pick a default region. */
    checkRegions?: HealthChecksEditRequestCheckRegionsList;
    /** The number of consecutive fails required from a health check before changing the health to unhealthy. */
    consecutiveFails?: number;
    /** The number of consecutive successes required from a health check before changing the health to healthy. */
    consecutiveSuccesses?: number;
    /** A human-readable description of the health check. */
    description?: string;
    /** Parameters specific to an HTTP or HTTPS health check. */
    httpConfig?: HealthChecksEditRequestHttpConfig;
    /** The interval between each health check. Shorter intervals may give quicker notifications if the origin status changes, but will increase load on the origin as we check from multiple locations. */
    interval?: number;
    /** The number of retries to attempt in case of a timeout before marking the origin as unhealthy. Retries are attempted immediately. */
    retries?: number;
    /** If suspended, no health checks are sent to the origin. */
    suspended?: boolean;
    /** Parameters specific to TCP health check. */
    tcpConfig?: HealthChecksEditRequestTcpConfig;
    /** The timeout (in seconds) before marking the health check as failed. */
    timeout?: number;
    /** The protocol to use for the health check. Currently supported protocols are 'HTTP', 'HTTPS' and 'TCP'. */
    type?: string;
}
export declare const HealthChecksEditRequest: S.Schema<HealthChecksEditRequest>;
export type HealthChecksEditResponseCheckRegionsItem = "WNAM" | "ENAM" | "WEU" | "EEU" | "NSAM" | "SSAM" | "OC" | "ME" | "NAF" | "SAF" | "IN" | "SEAS" | "NEAS" | "ALL_REGIONS";
export declare const HealthChecksEditResponseCheckRegionsItem: any;
export type HealthChecksEditResponseCheckRegionsList = Array<HealthChecksEditResponseCheckRegionsItem>;
export declare const HealthChecksEditResponseCheckRegionsList: S.Schema<HealthChecksEditResponseCheckRegionsList>;
export type HealthChecksEditResponseHttpConfigExpectedCodesList = Array<string>;
export declare const HealthChecksEditResponseHttpConfigExpectedCodesList: S.Schema<HealthChecksEditResponseHttpConfigExpectedCodesList>;
export type HealthChecksEditResponseHttpConfigHeaderValueList = Array<string>;
export declare const HealthChecksEditResponseHttpConfigHeaderValueList: S.Schema<HealthChecksEditResponseHttpConfigHeaderValueList>;
export type HealthChecksEditResponseHttpConfigHeaderMap = {
    [key: string]: HealthChecksEditResponseHttpConfigHeaderValueList | undefined;
};
export declare const HealthChecksEditResponseHttpConfigHeaderMap: S.Schema<HealthChecksEditResponseHttpConfigHeaderMap>;
export type HealthChecksEditResponseHttpConfigMethod = "GET" | "HEAD";
export declare const HealthChecksEditResponseHttpConfigMethod: any;
export interface HealthChecksEditResponseHttpConfig {
    /** Do not validate the certificate when the health check uses HTTPS. */
    allowInsecure?: boolean | null;
    /** A case-insensitive sub-string to look for in the response body. If this string is not found, the origin will be marked as unhealthy. */
    expectedBody?: string | null;
    /** The expected HTTP response codes (e.g. "200") or code ranges (e.g. "2xx" for all codes starting with 2) of the health check. */
    expectedCodes?: HealthChecksEditResponseHttpConfigExpectedCodesList | null;
    /** Follow redirects if the origin returns a 3xx status code. */
    followRedirects?: boolean | null;
    /** The HTTP request headers to send in the health check. It is recommended you set a Host header by default. The User-Agent header cannot be overridden. */
    header?: HealthChecksEditResponseHttpConfigHeaderMap | null;
    /** The HTTP method to use for the health check. */
    method?: HealthChecksEditResponseHttpConfigMethod | null;
    /** The endpoint path to health check against. */
    path?: string | null;
    /** Port number to connect to for the health check. Defaults to 80 if type is HTTP or 443 if type is HTTPS. */
    port?: number | null;
}
export declare const HealthChecksEditResponseHttpConfig: S.Schema<HealthChecksEditResponseHttpConfig>;
export type HealthChecksEditResponseStatus = "unknown" | "healthy" | "unhealthy" | "suspended";
export declare const HealthChecksEditResponseStatus: any;
export type HealthChecksEditResponseTcpConfigMethod = "connection_established";
export declare const HealthChecksEditResponseTcpConfigMethod: any;
export interface HealthChecksEditResponseTcpConfig {
    /** The TCP connection method to use for the health check. */
    method?: HealthChecksEditResponseTcpConfigMethod | null;
    /** Port number to connect to for the health check. Defaults to 80. */
    port?: number | null;
}
export declare const HealthChecksEditResponseTcpConfig: S.Schema<HealthChecksEditResponseTcpConfig>;
/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface HealthChecksEditResponse {
    /** Identifier. */
    id?: string | null;
    /** The hostname or IP address of the origin server to run health checks on. */
    address?: string | null;
    /** A list of regions from which to run health checks. Null means Cloudflare will pick a default region. */
    checkRegions?: HealthChecksEditResponseCheckRegionsList | null;
    /** The number of consecutive fails required from a health check before changing the health to unhealthy. */
    consecutiveFails?: number | null;
    /** The number of consecutive successes required from a health check before changing the health to healthy. */
    consecutiveSuccesses?: number | null;
    createdOn?: string | null;
    /** A human-readable description of the health check. */
    description?: string | null;
    /** The current failure reason if status is unhealthy. */
    failureReason?: string | null;
    /** Parameters specific to an HTTP or HTTPS health check. */
    httpConfig?: HealthChecksEditResponseHttpConfig | null;
    /** The interval between each health check. Shorter intervals may give quicker notifications if the origin status changes, but will increase load on the origin as we check from multiple locations. */
    interval?: number | null;
    modifiedOn?: string | null;
    /** A short name to identify the health check. Only alphanumeric characters, hyphens and underscores are allowed. */
    name?: string | null;
    /** The number of retries to attempt in case of a timeout before marking the origin as unhealthy. Retries are attempted immediately. */
    retries?: number | null;
    /** The current status of the origin server according to the health check. */
    status?: HealthChecksEditResponseStatus | null;
    /** If suspended, no health checks are sent to the origin. */
    suspended?: boolean | null;
    /** Parameters specific to TCP health check. */
    tcpConfig?: HealthChecksEditResponseTcpConfig | null;
    /** The timeout (in seconds) before marking the health check as failed. */
    timeout?: number | null;
    /** The protocol to use for the health check. Currently supported protocols are 'HTTP', 'HTTPS' and 'TCP'. */
    type?: string | null;
}
export declare const HealthChecksEditResponse: S.Schema<HealthChecksEditResponse>;
export interface HealthChecksGetRequest {
    /** Identifier. */
    zoneId: string;
    /** Identifier. */
    healthcheckId: string;
}
export declare const HealthChecksGetRequest: S.Schema<HealthChecksGetRequest>;
export type HealthChecksGetResponseCheckRegionsItem = "WNAM" | "ENAM" | "WEU" | "EEU" | "NSAM" | "SSAM" | "OC" | "ME" | "NAF" | "SAF" | "IN" | "SEAS" | "NEAS" | "ALL_REGIONS";
export declare const HealthChecksGetResponseCheckRegionsItem: any;
export type HealthChecksGetResponseCheckRegionsList = Array<HealthChecksGetResponseCheckRegionsItem>;
export declare const HealthChecksGetResponseCheckRegionsList: S.Schema<HealthChecksGetResponseCheckRegionsList>;
export type HealthChecksGetResponseHttpConfigExpectedCodesList = Array<string>;
export declare const HealthChecksGetResponseHttpConfigExpectedCodesList: S.Schema<HealthChecksGetResponseHttpConfigExpectedCodesList>;
export type HealthChecksGetResponseHttpConfigHeaderValueList = Array<string>;
export declare const HealthChecksGetResponseHttpConfigHeaderValueList: S.Schema<HealthChecksGetResponseHttpConfigHeaderValueList>;
export type HealthChecksGetResponseHttpConfigHeaderMap = {
    [key: string]: HealthChecksGetResponseHttpConfigHeaderValueList | undefined;
};
export declare const HealthChecksGetResponseHttpConfigHeaderMap: S.Schema<HealthChecksGetResponseHttpConfigHeaderMap>;
export type HealthChecksGetResponseHttpConfigMethod = "GET" | "HEAD";
export declare const HealthChecksGetResponseHttpConfigMethod: any;
export interface HealthChecksGetResponseHttpConfig {
    /** Do not validate the certificate when the health check uses HTTPS. */
    allowInsecure?: boolean | null;
    /** A case-insensitive sub-string to look for in the response body. If this string is not found, the origin will be marked as unhealthy. */
    expectedBody?: string | null;
    /** The expected HTTP response codes (e.g. "200") or code ranges (e.g. "2xx" for all codes starting with 2) of the health check. */
    expectedCodes?: HealthChecksGetResponseHttpConfigExpectedCodesList | null;
    /** Follow redirects if the origin returns a 3xx status code. */
    followRedirects?: boolean | null;
    /** The HTTP request headers to send in the health check. It is recommended you set a Host header by default. The User-Agent header cannot be overridden. */
    header?: HealthChecksGetResponseHttpConfigHeaderMap | null;
    /** The HTTP method to use for the health check. */
    method?: HealthChecksGetResponseHttpConfigMethod | null;
    /** The endpoint path to health check against. */
    path?: string | null;
    /** Port number to connect to for the health check. Defaults to 80 if type is HTTP or 443 if type is HTTPS. */
    port?: number | null;
}
export declare const HealthChecksGetResponseHttpConfig: S.Schema<HealthChecksGetResponseHttpConfig>;
export type HealthChecksGetResponseStatus = "unknown" | "healthy" | "unhealthy" | "suspended";
export declare const HealthChecksGetResponseStatus: any;
export type HealthChecksGetResponseTcpConfigMethod = "connection_established";
export declare const HealthChecksGetResponseTcpConfigMethod: any;
export interface HealthChecksGetResponseTcpConfig {
    /** The TCP connection method to use for the health check. */
    method?: HealthChecksGetResponseTcpConfigMethod | null;
    /** Port number to connect to for the health check. Defaults to 80. */
    port?: number | null;
}
export declare const HealthChecksGetResponseTcpConfig: S.Schema<HealthChecksGetResponseTcpConfig>;
/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface HealthChecksGetResponse {
    /** Identifier. */
    id?: string | null;
    /** The hostname or IP address of the origin server to run health checks on. */
    address?: string | null;
    /** A list of regions from which to run health checks. Null means Cloudflare will pick a default region. */
    checkRegions?: HealthChecksGetResponseCheckRegionsList | null;
    /** The number of consecutive fails required from a health check before changing the health to unhealthy. */
    consecutiveFails?: number | null;
    /** The number of consecutive successes required from a health check before changing the health to healthy. */
    consecutiveSuccesses?: number | null;
    createdOn?: string | null;
    /** A human-readable description of the health check. */
    description?: string | null;
    /** The current failure reason if status is unhealthy. */
    failureReason?: string | null;
    /** Parameters specific to an HTTP or HTTPS health check. */
    httpConfig?: HealthChecksGetResponseHttpConfig | null;
    /** The interval between each health check. Shorter intervals may give quicker notifications if the origin status changes, but will increase load on the origin as we check from multiple locations. */
    interval?: number | null;
    modifiedOn?: string | null;
    /** A short name to identify the health check. Only alphanumeric characters, hyphens and underscores are allowed. */
    name?: string | null;
    /** The number of retries to attempt in case of a timeout before marking the origin as unhealthy. Retries are attempted immediately. */
    retries?: number | null;
    /** The current status of the origin server according to the health check. */
    status?: HealthChecksGetResponseStatus | null;
    /** If suspended, no health checks are sent to the origin. */
    suspended?: boolean | null;
    /** Parameters specific to TCP health check. */
    tcpConfig?: HealthChecksGetResponseTcpConfig | null;
    /** The timeout (in seconds) before marking the health check as failed. */
    timeout?: number | null;
    /** The protocol to use for the health check. Currently supported protocols are 'HTTP', 'HTTPS' and 'TCP'. */
    type?: string | null;
}
export declare const HealthChecksGetResponse: S.Schema<HealthChecksGetResponse>;
export interface HealthChecksListRequest {
    /** Identifier. */
    zoneId: string;
    /** Page number of paginated results. */
    page?: number;
    /** Maximum number of results per page. Must be a multiple of 5. */
    perPage?: number;
}
export declare const HealthChecksListRequest: S.Schema<HealthChecksListRequest>;
export type HealthChecksListResultItemCheckRegionsItem = "WNAM" | "ENAM" | "WEU" | "EEU" | "NSAM" | "SSAM" | "OC" | "ME" | "NAF" | "SAF" | "IN" | "SEAS" | "NEAS" | "ALL_REGIONS";
export declare const HealthChecksListResultItemCheckRegionsItem: any;
export type HealthChecksListResultItemCheckRegionsList = Array<HealthChecksListResultItemCheckRegionsItem>;
export declare const HealthChecksListResultItemCheckRegionsList: S.Schema<HealthChecksListResultItemCheckRegionsList>;
export type HealthChecksListResultItemHttpConfigExpectedCodesList = Array<string>;
export declare const HealthChecksListResultItemHttpConfigExpectedCodesList: S.Schema<HealthChecksListResultItemHttpConfigExpectedCodesList>;
export type HealthChecksListResultItemHttpConfigHeaderValueList = Array<string>;
export declare const HealthChecksListResultItemHttpConfigHeaderValueList: S.Schema<HealthChecksListResultItemHttpConfigHeaderValueList>;
export type HealthChecksListResultItemHttpConfigHeaderMap = {
    [key: string]: HealthChecksListResultItemHttpConfigHeaderValueList | undefined;
};
export declare const HealthChecksListResultItemHttpConfigHeaderMap: S.Schema<HealthChecksListResultItemHttpConfigHeaderMap>;
export type HealthChecksListResultItemHttpConfigMethod = "GET" | "HEAD";
export declare const HealthChecksListResultItemHttpConfigMethod: any;
export interface HealthChecksListResultItemHttpConfig {
    /** Do not validate the certificate when the health check uses HTTPS. */
    allowInsecure?: boolean | null;
    /** A case-insensitive sub-string to look for in the response body. If this string is not found, the origin will be marked as unhealthy. */
    expectedBody?: string | null;
    /** The expected HTTP response codes (e.g. "200") or code ranges (e.g. "2xx" for all codes starting with 2) of the health check. */
    expectedCodes?: HealthChecksListResultItemHttpConfigExpectedCodesList | null;
    /** Follow redirects if the origin returns a 3xx status code. */
    followRedirects?: boolean | null;
    /** The HTTP request headers to send in the health check. It is recommended you set a Host header by default. The User-Agent header cannot be overridden. */
    header?: HealthChecksListResultItemHttpConfigHeaderMap | null;
    /** The HTTP method to use for the health check. */
    method?: HealthChecksListResultItemHttpConfigMethod | null;
    /** The endpoint path to health check against. */
    path?: string | null;
    /** Port number to connect to for the health check. Defaults to 80 if type is HTTP or 443 if type is HTTPS. */
    port?: number | null;
}
export declare const HealthChecksListResultItemHttpConfig: S.Schema<HealthChecksListResultItemHttpConfig>;
export type HealthChecksListResultItemStatus = "unknown" | "healthy" | "unhealthy" | "suspended";
export declare const HealthChecksListResultItemStatus: any;
export type HealthChecksListResultItemTcpConfigMethod = "connection_established";
export declare const HealthChecksListResultItemTcpConfigMethod: any;
export interface HealthChecksListResultItemTcpConfig {
    /** The TCP connection method to use for the health check. */
    method?: HealthChecksListResultItemTcpConfigMethod | null;
    /** Port number to connect to for the health check. Defaults to 80. */
    port?: number | null;
}
export declare const HealthChecksListResultItemTcpConfig: S.Schema<HealthChecksListResultItemTcpConfig>;
export interface HealthChecksListResultItem {
    /** Identifier. */
    id?: string | null;
    /** The hostname or IP address of the origin server to run health checks on. */
    address?: string | null;
    /** A list of regions from which to run health checks. Null means Cloudflare will pick a default region. */
    checkRegions?: HealthChecksListResultItemCheckRegionsList | null;
    /** The number of consecutive fails required from a health check before changing the health to unhealthy. */
    consecutiveFails?: number | null;
    /** The number of consecutive successes required from a health check before changing the health to healthy. */
    consecutiveSuccesses?: number | null;
    createdOn?: string | null;
    /** A human-readable description of the health check. */
    description?: string | null;
    /** The current failure reason if status is unhealthy. */
    failureReason?: string | null;
    /** Parameters specific to an HTTP or HTTPS health check. */
    httpConfig?: HealthChecksListResultItemHttpConfig | null;
    /** The interval between each health check. Shorter intervals may give quicker notifications if the origin status changes, but will increase load on the origin as we check from multiple locations. */
    interval?: number | null;
    modifiedOn?: string | null;
    /** A short name to identify the health check. Only alphanumeric characters, hyphens and underscores are allowed. */
    name?: string | null;
    /** The number of retries to attempt in case of a timeout before marking the origin as unhealthy. Retries are attempted immediately. */
    retries?: number | null;
    /** The current status of the origin server according to the health check. */
    status?: HealthChecksListResultItemStatus | null;
    /** If suspended, no health checks are sent to the origin. */
    suspended?: boolean | null;
    /** Parameters specific to TCP health check. */
    tcpConfig?: HealthChecksListResultItemTcpConfig | null;
    /** The timeout (in seconds) before marking the health check as failed. */
    timeout?: number | null;
    /** The protocol to use for the health check. Currently supported protocols are 'HTTP', 'HTTPS' and 'TCP'. */
    type?: string | null;
}
export declare const HealthChecksListResultItem: S.Schema<HealthChecksListResultItem>;
export type HealthChecksListResultList = Array<HealthChecksListResultItem>;
export declare const HealthChecksListResultList: S.Schema<HealthChecksListResultList>;
export type HealthChecksListResponse = HealthChecksListResultList;
export declare const HealthChecksListResponse: S.Schema<HealthChecksListResponse>;
export interface HealthChecksUpdateRequestErrorsItemSource {
    pointer?: string;
}
export declare const HealthChecksUpdateRequestErrorsItemSource: S.Schema<HealthChecksUpdateRequestErrorsItemSource>;
export interface HealthChecksUpdateRequestErrorsItem {
    code: number;
    message: string;
    documentationUrl?: string;
    source?: HealthChecksUpdateRequestErrorsItemSource;
}
export declare const HealthChecksUpdateRequestErrorsItem: S.Schema<HealthChecksUpdateRequestErrorsItem>;
export type HealthChecksUpdateRequestErrorsList = Array<HealthChecksUpdateRequestErrorsItem>;
export declare const HealthChecksUpdateRequestErrorsList: S.Schema<HealthChecksUpdateRequestErrorsList>;
export interface HealthChecksUpdateRequestMessagesItem {
    code: number;
    message: string;
    documentationUrl?: string;
    source?: unknown;
}
export declare const HealthChecksUpdateRequestMessagesItem: S.Schema<HealthChecksUpdateRequestMessagesItem>;
export type HealthChecksUpdateRequestMessagesList = Array<HealthChecksUpdateRequestMessagesItem>;
export declare const HealthChecksUpdateRequestMessagesList: S.Schema<HealthChecksUpdateRequestMessagesList>;
export type HealthChecksUpdateRequestResultCheckRegionsItem = "WNAM" | "ENAM" | "WEU" | "EEU" | "NSAM" | "SSAM" | "OC" | "ME" | "NAF" | "SAF" | "IN" | "SEAS" | "NEAS" | "ALL_REGIONS";
export declare const HealthChecksUpdateRequestResultCheckRegionsItem: any;
export type HealthChecksUpdateRequestResultCheckRegionsList = Array<HealthChecksUpdateRequestResultCheckRegionsItem | (string & {})>;
export declare const HealthChecksUpdateRequestResultCheckRegionsList: S.Schema<HealthChecksUpdateRequestResultCheckRegionsList>;
export type HealthChecksUpdateRequestResultHttpConfigExpectedCodesList = Array<string>;
export declare const HealthChecksUpdateRequestResultHttpConfigExpectedCodesList: S.Schema<HealthChecksUpdateRequestResultHttpConfigExpectedCodesList>;
export type HealthChecksUpdateRequestResultHttpConfigHeaderValueList = Array<string>;
export declare const HealthChecksUpdateRequestResultHttpConfigHeaderValueList: S.Schema<HealthChecksUpdateRequestResultHttpConfigHeaderValueList>;
export type HealthChecksUpdateRequestResultHttpConfigHeaderMap = {
    [key: string]: HealthChecksUpdateRequestResultHttpConfigHeaderValueList | undefined;
};
export declare const HealthChecksUpdateRequestResultHttpConfigHeaderMap: S.Schema<HealthChecksUpdateRequestResultHttpConfigHeaderMap>;
export type HealthChecksUpdateRequestResultHttpConfigMethod = "GET" | "HEAD";
export declare const HealthChecksUpdateRequestResultHttpConfigMethod: any;
export interface HealthChecksUpdateRequestResultHttpConfig {
    /** Do not validate the certificate when the health check uses HTTPS. */
    allowInsecure?: boolean;
    /** A case-insensitive sub-string to look for in the response body. If this string is not found, the origin will be marked as unhealthy. */
    expectedBody?: string;
    /** The expected HTTP response codes (e.g. "200") or code ranges (e.g. "2xx" for all codes starting with 2) of the health check. */
    expectedCodes?: HealthChecksUpdateRequestResultHttpConfigExpectedCodesList;
    /** Follow redirects if the origin returns a 3xx status code. */
    followRedirects?: boolean;
    /** The HTTP request headers to send in the health check. It is recommended you set a Host header by default. The User-Agent header cannot be overridden. */
    header?: HealthChecksUpdateRequestResultHttpConfigHeaderMap;
    /** The HTTP method to use for the health check. */
    method?: HealthChecksUpdateRequestResultHttpConfigMethod | (string & {});
    /** The endpoint path to health check against. */
    path?: string;
    /** Port number to connect to for the health check. Defaults to 80 if type is HTTP or 443 if type is HTTPS. */
    port?: number;
}
export declare const HealthChecksUpdateRequestResultHttpConfig: S.Schema<HealthChecksUpdateRequestResultHttpConfig>;
export type HealthChecksUpdateRequestResultStatus = "unknown" | "healthy" | "unhealthy" | "suspended";
export declare const HealthChecksUpdateRequestResultStatus: any;
export type HealthChecksUpdateRequestResultTcpConfigMethod = "connection_established";
export declare const HealthChecksUpdateRequestResultTcpConfigMethod: any;
export interface HealthChecksUpdateRequestResultTcpConfig {
    /** The TCP connection method to use for the health check. */
    method?: HealthChecksUpdateRequestResultTcpConfigMethod | (string & {});
    /** Port number to connect to for the health check. Defaults to 80. */
    port?: number;
}
export declare const HealthChecksUpdateRequestResultTcpConfig: S.Schema<HealthChecksUpdateRequestResultTcpConfig>;
export interface HealthChecksUpdateRequestResult {
    /** Identifier. */
    id?: string;
    /** The hostname or IP address of the origin server to run health checks on. */
    address?: string;
    /** A list of regions from which to run health checks. Null means Cloudflare will pick a default region. */
    checkRegions?: HealthChecksUpdateRequestResultCheckRegionsList;
    /** The number of consecutive fails required from a health check before changing the health to unhealthy. */
    consecutiveFails?: number;
    /** The number of consecutive successes required from a health check before changing the health to healthy. */
    consecutiveSuccesses?: number;
    createdOn?: string;
    /** A human-readable description of the health check. */
    description?: string;
    /** The current failure reason if status is unhealthy. */
    failureReason?: string;
    /** Parameters specific to an HTTP or HTTPS health check. */
    httpConfig?: HealthChecksUpdateRequestResultHttpConfig;
    /** The interval between each health check. Shorter intervals may give quicker notifications if the origin status changes, but will increase load on the origin as we check from multiple locations. */
    interval?: number;
    modifiedOn?: string;
    /** A short name to identify the health check. Only alphanumeric characters, hyphens and underscores are allowed. */
    name?: string;
    /** The number of retries to attempt in case of a timeout before marking the origin as unhealthy. Retries are attempted immediately. */
    retries?: number;
    /** The current status of the origin server according to the health check. */
    status?: HealthChecksUpdateRequestResultStatus | (string & {});
    /** If suspended, no health checks are sent to the origin. */
    suspended?: boolean;
    /** Parameters specific to TCP health check. */
    tcpConfig?: HealthChecksUpdateRequestResultTcpConfig;
    /** The timeout (in seconds) before marking the health check as failed. */
    timeout?: number;
    /** The protocol to use for the health check. Currently supported protocols are 'HTTP', 'HTTPS' and 'TCP'. */
    type?: string;
}
export declare const HealthChecksUpdateRequestResult: S.Schema<HealthChecksUpdateRequestResult>;
export interface HealthChecksUpdateRequest {
    /** Identifier. */
    zoneId: string;
    /** Identifier. */
    healthcheckId: string;
    errors: HealthChecksUpdateRequestErrorsList;
    messages: HealthChecksUpdateRequestMessagesList;
    result: HealthChecksUpdateRequestResult;
    /** Whether the API call was successful. */
    success: boolean;
}
export declare const HealthChecksUpdateRequest: S.Schema<HealthChecksUpdateRequest>;
export type HealthChecksUpdateResponseCheckRegionsItem = "WNAM" | "ENAM" | "WEU" | "EEU" | "NSAM" | "SSAM" | "OC" | "ME" | "NAF" | "SAF" | "IN" | "SEAS" | "NEAS" | "ALL_REGIONS";
export declare const HealthChecksUpdateResponseCheckRegionsItem: any;
export type HealthChecksUpdateResponseCheckRegionsList = Array<HealthChecksUpdateResponseCheckRegionsItem>;
export declare const HealthChecksUpdateResponseCheckRegionsList: S.Schema<HealthChecksUpdateResponseCheckRegionsList>;
export type HealthChecksUpdateResponseHttpConfigExpectedCodesList = Array<string>;
export declare const HealthChecksUpdateResponseHttpConfigExpectedCodesList: S.Schema<HealthChecksUpdateResponseHttpConfigExpectedCodesList>;
export type HealthChecksUpdateResponseHttpConfigHeaderValueList = Array<string>;
export declare const HealthChecksUpdateResponseHttpConfigHeaderValueList: S.Schema<HealthChecksUpdateResponseHttpConfigHeaderValueList>;
export type HealthChecksUpdateResponseHttpConfigHeaderMap = {
    [key: string]: HealthChecksUpdateResponseHttpConfigHeaderValueList | undefined;
};
export declare const HealthChecksUpdateResponseHttpConfigHeaderMap: S.Schema<HealthChecksUpdateResponseHttpConfigHeaderMap>;
export type HealthChecksUpdateResponseHttpConfigMethod = "GET" | "HEAD";
export declare const HealthChecksUpdateResponseHttpConfigMethod: any;
export interface HealthChecksUpdateResponseHttpConfig {
    /** Do not validate the certificate when the health check uses HTTPS. */
    allowInsecure?: boolean | null;
    /** A case-insensitive sub-string to look for in the response body. If this string is not found, the origin will be marked as unhealthy. */
    expectedBody?: string | null;
    /** The expected HTTP response codes (e.g. "200") or code ranges (e.g. "2xx" for all codes starting with 2) of the health check. */
    expectedCodes?: HealthChecksUpdateResponseHttpConfigExpectedCodesList | null;
    /** Follow redirects if the origin returns a 3xx status code. */
    followRedirects?: boolean | null;
    /** The HTTP request headers to send in the health check. It is recommended you set a Host header by default. The User-Agent header cannot be overridden. */
    header?: HealthChecksUpdateResponseHttpConfigHeaderMap | null;
    /** The HTTP method to use for the health check. */
    method?: HealthChecksUpdateResponseHttpConfigMethod | null;
    /** The endpoint path to health check against. */
    path?: string | null;
    /** Port number to connect to for the health check. Defaults to 80 if type is HTTP or 443 if type is HTTPS. */
    port?: number | null;
}
export declare const HealthChecksUpdateResponseHttpConfig: S.Schema<HealthChecksUpdateResponseHttpConfig>;
export type HealthChecksUpdateResponseStatus = "unknown" | "healthy" | "unhealthy" | "suspended";
export declare const HealthChecksUpdateResponseStatus: any;
export type HealthChecksUpdateResponseTcpConfigMethod = "connection_established";
export declare const HealthChecksUpdateResponseTcpConfigMethod: any;
export interface HealthChecksUpdateResponseTcpConfig {
    /** The TCP connection method to use for the health check. */
    method?: HealthChecksUpdateResponseTcpConfigMethod | null;
    /** Port number to connect to for the health check. Defaults to 80. */
    port?: number | null;
}
export declare const HealthChecksUpdateResponseTcpConfig: S.Schema<HealthChecksUpdateResponseTcpConfig>;
/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface HealthChecksUpdateResponse {
    /** Identifier. */
    id?: string | null;
    /** The hostname or IP address of the origin server to run health checks on. */
    address?: string | null;
    /** A list of regions from which to run health checks. Null means Cloudflare will pick a default region. */
    checkRegions?: HealthChecksUpdateResponseCheckRegionsList | null;
    /** The number of consecutive fails required from a health check before changing the health to unhealthy. */
    consecutiveFails?: number | null;
    /** The number of consecutive successes required from a health check before changing the health to healthy. */
    consecutiveSuccesses?: number | null;
    createdOn?: string | null;
    /** A human-readable description of the health check. */
    description?: string | null;
    /** The current failure reason if status is unhealthy. */
    failureReason?: string | null;
    /** Parameters specific to an HTTP or HTTPS health check. */
    httpConfig?: HealthChecksUpdateResponseHttpConfig | null;
    /** The interval between each health check. Shorter intervals may give quicker notifications if the origin status changes, but will increase load on the origin as we check from multiple locations. */
    interval?: number | null;
    modifiedOn?: string | null;
    /** A short name to identify the health check. Only alphanumeric characters, hyphens and underscores are allowed. */
    name?: string | null;
    /** The number of retries to attempt in case of a timeout before marking the origin as unhealthy. Retries are attempted immediately. */
    retries?: number | null;
    /** The current status of the origin server according to the health check. */
    status?: HealthChecksUpdateResponseStatus | null;
    /** If suspended, no health checks are sent to the origin. */
    suspended?: boolean | null;
    /** Parameters specific to TCP health check. */
    tcpConfig?: HealthChecksUpdateResponseTcpConfig | null;
    /** The timeout (in seconds) before marking the health check as failed. */
    timeout?: number | null;
    /** The protocol to use for the health check. Currently supported protocols are 'HTTP', 'HTTPS' and 'TCP'. */
    type?: string | null;
}
export declare const HealthChecksUpdateResponse: S.Schema<HealthChecksUpdateResponse>;
export type UpdateRequestCacheReserveValue = "on" | "off";
export declare const UpdateRequestCacheReserveValue: any;
export interface UpdateRequestCacheReserve {
    /** Specifies the enablement value of Cache Reserve. */
    value?: UpdateRequestCacheReserveValue | (string & {});
}
export declare const UpdateRequestCacheReserve: S.Schema<UpdateRequestCacheReserve>;
export type UpdateRequestRegionalTieredCacheValue = "on" | "off";
export declare const UpdateRequestRegionalTieredCacheValue: any;
export interface UpdateRequestRegionalTieredCache {
    /** Specifies the enablement value of Regional Tiered Cache. */
    value?: UpdateRequestRegionalTieredCacheValue | (string & {});
}
export declare const UpdateRequestRegionalTieredCache: S.Schema<UpdateRequestRegionalTieredCache>;
export type UpdateRequestSmartRoutingValue = "on" | "off";
export declare const UpdateRequestSmartRoutingValue: any;
export interface UpdateRequestSmartRouting {
    /** Specifies the enablement value of Smart Routing. */
    value?: UpdateRequestSmartRoutingValue | (string & {});
}
export declare const UpdateRequestSmartRouting: S.Schema<UpdateRequestSmartRouting>;
export type UpdateRequestSmartTieredCacheValue = "on" | "off";
export declare const UpdateRequestSmartTieredCacheValue: any;
export interface UpdateRequestSmartTieredCache {
    /** Specifies the enablement value of Smart Tiered Cache. */
    value?: UpdateRequestSmartTieredCacheValue | (string & {});
}
export declare const UpdateRequestSmartTieredCache: S.Schema<UpdateRequestSmartTieredCache>;
export interface UpdateRequest {
    /** Identifier. */
    zoneId: string;
    cacheReserve?: UpdateRequestCacheReserve;
    regionalTieredCache?: UpdateRequestRegionalTieredCache;
    smartRouting?: UpdateRequestSmartRouting;
    smartTieredCache?: UpdateRequestSmartTieredCache;
}
export declare const UpdateRequest: S.Schema<UpdateRequest>;
export type UpdateResponseSmartTieredCacheValue = "on" | "off";
export declare const UpdateResponseSmartTieredCacheValue: any;
export interface UpdateResponseSmartTieredCache {
    /** The id of the Smart Tiered Cache setting. */
    id?: string | null;
    /** Whether the setting is editable. */
    editable?: boolean | null;
    /** The last time the setting was modified. */
    modifiedOn?: string | null;
    /** Specifies the enablement value of Tiered Cache. */
    value?: UpdateResponseSmartTieredCacheValue | null;
}
export declare const UpdateResponseSmartTieredCache: S.Schema<UpdateResponseSmartTieredCache>;
/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface UpdateResponse {
    smartTieredCache: UpdateResponseSmartTieredCache;
}
export declare const UpdateResponse: S.Schema<UpdateResponse>;
export type CacheReserveClearClearError = CloudflareOpError;
/** You can use Cache Reserve Clear to clear your Cache Reserve, but you must first disable Cache Reserve. In most cases, this will be accomplished within 24 hours. You cannot re-enable Cache Reserve while this process is ongoing. Keep in mind that you cannot undo or cancel this operation. */
export declare const cacheReserveClearClear: API.OperationMethod<CacheReserveClearClearRequest, CacheReserveClearClearResponse, CacheReserveClearClearError, CloudflareOpContext>;
export type CacheReserveClearStatusError = CloudflareOpError;
/** You can use Cache Reserve Clear to clear your Cache Reserve, but you must first disable Cache Reserve. In most cases, this will be accomplished within 24 hours. You cannot re-enable Cache Reserve while this process is ongoing. Keep in mind that you cannot undo or cancel this operation. */
export declare const cacheReserveClearStatus: API.OperationMethod<CacheReserveClearStatusRequest, CacheReserveClearStatusResponse, CacheReserveClearStatusError, CloudflareOpContext>;
export type GetError = CloudflareOpError;
/** Retrieve Smart Shield Settings. */
export declare const get: API.OperationMethod<GetRequest, GetResponse, GetError, CloudflareOpContext>;
export type HealthChecksCreateError = CloudflareOpError;
/** Create a new health check. */
export declare const healthChecksCreate: API.OperationMethod<HealthChecksCreateRequest, HealthChecksCreateResponse, HealthChecksCreateError, CloudflareOpContext>;
export type HealthChecksDeleteError = CloudflareOpError;
/** Delete a health check. */
export declare const healthChecksDelete: API.OperationMethod<HealthChecksDeleteRequest, HealthChecksDeleteResponse, HealthChecksDeleteError, CloudflareOpContext>;
export type HealthChecksEditError = CloudflareOpError;
/** Patch a configured health check. */
export declare const healthChecksEdit: API.OperationMethod<HealthChecksEditRequest, HealthChecksEditResponse, HealthChecksEditError, CloudflareOpContext>;
export type HealthChecksGetError = CloudflareOpError;
/** Fetch a single configured health check. */
export declare const healthChecksGet: API.OperationMethod<HealthChecksGetRequest, HealthChecksGetResponse, HealthChecksGetError, CloudflareOpContext>;
export type HealthChecksListError = CloudflareOpError;
/** List configured health checks. */
export declare const healthChecksList: API.OperationMethod<HealthChecksListRequest, HealthChecksListResponse, HealthChecksListError, CloudflareOpContext>;
export type HealthChecksUpdateError = CloudflareOpError;
/** Update a configured health check. */
export declare const healthChecksUpdate: API.OperationMethod<HealthChecksUpdateRequest, HealthChecksUpdateResponse, HealthChecksUpdateError, CloudflareOpContext>;
export type UpdateError = CloudflareOpError;
/** Set Smart Shield Settings. */
export declare const update: API.OperationMethod<UpdateRequest, UpdateResponse, UpdateError, CloudflareOpContext>;
//# sourceMappingURL=smart_shield.d.ts.map