cribl-control-plane 0.5.0-rc.8 → 0.5.0-rc.9

package/dist/commonjs/models/healthcheckcollectorconf.d.ts

@@ -2,10 +2,30 @@ import * as z from "zod/v3";
 import { OpenEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export type HealthCheckAuthenticationOauthSecretAuthRequestParam = {
+    /**
+     * Parameter name.
+     */
+    name: string;
+    /**
+     * JavaScript expression to compute the parameter's value, normally enclosed in backticks (e.g., `${earliest}`). If a constant, use single quotes (e.g., 'earliest'). Values without delimiters (e.g., earliest) are evaluated as strings.
+     */
+    value: string;
+};
+export type HealthCheckAuthenticationOauthSecretAuthRequestHeader = {
+    /**
+     * Header name.
+     */
+    name: string;
+    /**
+     * JavaScript expression to compute the header's value, normally enclosed in backticks (e.g., `${earliest}`). If a constant, use single quotes (e.g., 'earliest'). Values without delimiters (e.g., earliest) are evaluated as strings.
+     */
+    value: string;
+};
 /**
  * Defines how task discovery will be performed. Use None to skip the discovery. Use HTTP Request to make a REST call to discover tasks. Use Item List to enumerate items for collect to retrieve. Use JSON Response to manually define discover tasks as a JSON array of objects. Each entry returned by the discover operation will result in a collect task.
  */
-export declare const HealthCheckCollectorConfDiscoverType: {
+export declare const HealthCheckAuthenticationOauthSecretDiscoverType: {
     /**
      * HTTP Request
      */
@@ -26,17 +46,17 @@ export declare const HealthCheckCollectorConfDiscoverType: {
 /**
  * Defines how task discovery will be performed. Use None to skip the discovery. Use HTTP Request to make a REST call to discover tasks. Use Item List to enumerate items for collect to retrieve. Use JSON Response to manually define discover tasks as a JSON array of objects. Each entry returned by the discover operation will result in a collect task.
  */
-export type HealthCheckCollectorConfDiscoverType = OpenEnum<typeof HealthCheckCollectorConfDiscoverType>;
-export type HealthCheckCollectorConfDiscovery = {
+export type HealthCheckAuthenticationOauthSecretDiscoverType = OpenEnum<typeof HealthCheckAuthenticationOauthSecretDiscoverType>;
+export type HealthCheckAuthenticationOauthSecretDiscovery = {
     /**
      * Defines how task discovery will be performed. Use None to skip the discovery. Use HTTP Request to make a REST call to discover tasks. Use Item List to enumerate items for collect to retrieve. Use JSON Response to manually define discover tasks as a JSON array of objects. Each entry returned by the discover operation will result in a collect task.
      */
-    discoverType?: HealthCheckCollectorConfDiscoverType | undefined;
+    discoverType?: HealthCheckAuthenticationOauthSecretDiscoverType | undefined;
 };
 /**
  * Health check HTTP method.
  */
-export declare const HealthCheckMethod: {
+export declare const HealthCheckAuthenticationOauthSecretHealthCheckMethod: {
     /**
      * GET
      */
@@ -53,8 +73,8 @@ export declare const HealthCheckMethod: {
 /**
  * Health check HTTP method.
  */
-export type HealthCheckMethod = OpenEnum<typeof HealthCheckMethod>;
-export type HealthCheckCollectorConfCollectRequestHeader = {
+export type HealthCheckAuthenticationOauthSecretHealthCheckMethod = OpenEnum<typeof HealthCheckAuthenticationOauthSecretHealthCheckMethod>;
+export type HealthCheckAuthenticationOauthSecretCollectRequestHeader = {
     /**
      * Header Name
      */
@@ -64,30 +84,14 @@ export type HealthCheckCollectorConfCollectRequestHeader = {
      */
     value: string;
 };
-/**
- * Authentication method for Discover and Collect REST calls. You can specify API Key–based authentication by adding the appropriate Collect headers.
- */
-export declare const HealthCheckCollectorConfAuthentication: {
-    readonly None: "none";
-    readonly Basic: "basic";
-    readonly BasicSecret: "basicSecret";
-    readonly Login: "login";
-    readonly LoginSecret: "loginSecret";
-    readonly Oauth: "oauth";
-    readonly OauthSecret: "oauthSecret";
-};
-/**
- * Authentication method for Discover and Collect REST calls. You can specify API Key–based authentication by adding the appropriate Collect headers.
- */
-export type HealthCheckCollectorConfAuthentication = OpenEnum<typeof HealthCheckCollectorConfAuthentication>;
-export declare const HealthCheckCollectorConfHiddenDefaultBreakers: {
+export declare const HealthCheckAuthenticationOauthSecretHiddenDefaultBreakers: {
     readonly Cribl: "Cribl";
 };
-export type HealthCheckCollectorConfHiddenDefaultBreakers = OpenEnum<typeof HealthCheckCollectorConfHiddenDefaultBreakers>;
+export type HealthCheckAuthenticationOauthSecretHiddenDefaultBreakers = OpenEnum<typeof HealthCheckAuthenticationOauthSecretHiddenDefaultBreakers>;
 /**
  * The algorithm to use when performing HTTP retries
  */
-export declare const HealthCheckCollectorConfRetryType: {
+export declare const HealthCheckAuthenticationOauthSecretRetryType: {
     /**
      * Disabled
      */
@@ -104,20 +108,52 @@ export declare const HealthCheckCollectorConfRetryType: {
 /**
  * The algorithm to use when performing HTTP retries
  */
-export type HealthCheckCollectorConfRetryType = OpenEnum<typeof HealthCheckCollectorConfRetryType>;
-export type HealthCheckCollectorConfRetryRules = {
+export type HealthCheckAuthenticationOauthSecretRetryType = OpenEnum<typeof HealthCheckAuthenticationOauthSecretRetryType>;
+export type HealthCheckAuthenticationOauthSecretRetryRules = {
     /**
      * The algorithm to use when performing HTTP retries
      */
-    type?: HealthCheckCollectorConfRetryType | undefined;
+    type?: HealthCheckAuthenticationOauthSecretRetryType | undefined;
     interval?: any | undefined;
     limit?: any | undefined;
     multiplier?: any | undefined;
     codes?: any | undefined;
     enableHeader?: any | undefined;
 };
-export type HealthCheckCollectorConf = {
-    discovery?: HealthCheckCollectorConfDiscovery | undefined;
+export type HealthCheckAuthenticationOauthSecret = {
+    /**
+     * Authentication method for Discover and Collect REST calls. You can specify API Key–based authentication by adding the appropriate Collect headers.
+     */
+    authentication: "oauthSecret";
+    /**
+     * URL to use for the OAuth API call. This call is expected to be a POST.
+     */
+    loginUrl?: string | undefined;
+    /**
+     * Path to token attribute in login response body. Nested attributes are OK. Leave blank if the response content type is text/plain; the entire response body will be used to derive the authorization header.
+     */
+    tokenRespAttribute?: string | undefined;
+    /**
+     * JavaScript expression to compute the Authorization header to pass in discover and collect calls. The value ${token} is used to reference the token obtained from login.
+     */
+    authHeaderExpr?: string | undefined;
+    /**
+     * Parameter name that contains client secret. Defaults to 'client_secret', and is automatically added to request parameters.
+     */
+    clientSecretParamName?: string | undefined;
+    /**
+     * Select or create a text secret that contains the client secret's value.
+     */
+    textSecret: string;
+    /**
+     * OAuth request parameters added to the POST body. The Content-Type header will automatically be set to application/x-www-form-urlencoded.
+     */
+    authRequestParams?: Array<HealthCheckAuthenticationOauthSecretAuthRequestParam> | undefined;
+    /**
+     * Optional authentication request headers.
+     */
+    authRequestHeaders?: Array<HealthCheckAuthenticationOauthSecretAuthRequestHeader> | undefined;
+    discovery?: HealthCheckAuthenticationOauthSecretDiscovery | undefined;
     /**
      * Expression to derive URL to use for the health check operation (can be a constant).
      */
@@ -125,21 +161,17 @@ export type HealthCheckCollectorConf = {
     /**
      * Health check HTTP method.
      */
-    collectMethod?: HealthCheckMethod | undefined;
+    collectMethod?: HealthCheckAuthenticationOauthSecretHealthCheckMethod | undefined;
     collectRequestParams?: any | undefined;
     collectBody?: any | undefined;
     /**
      * Optional health check request headers.
      */
-    collectRequestHeaders?: Array<HealthCheckCollectorConfCollectRequestHeader> | undefined;
+    collectRequestHeaders?: Array<HealthCheckAuthenticationOauthSecretCollectRequestHeader> | undefined;
     /**
      * Enable to make auth health check call.
      */
     authenticateCollect?: boolean | undefined;
-    /**
-     * Authentication method for Discover and Collect REST calls. You can specify API Key–based authentication by adding the appropriate Collect headers.
-     */
-    authentication?: HealthCheckCollectorConfAuthentication | undefined;
     /**
      * HTTP request inactivity timeout, use 0 to disable
      */
@@ -148,87 +180,2279 @@ export type HealthCheckCollectorConf = {
      * Whether to reject certificates that cannot be verified against a valid CA (e.g., self-signed certificates).
      */
     rejectUnauthorized?: boolean | undefined;
-    defaultBreakers?: HealthCheckCollectorConfHiddenDefaultBreakers | undefined;
+    defaultBreakers?: HealthCheckAuthenticationOauthSecretHiddenDefaultBreakers | undefined;
     /**
      * List of headers that are safe to log in plain text.
      */
     safeHeaders?: Array<string> | undefined;
-    retryRules?: HealthCheckCollectorConfRetryRules | undefined;
+    retryRules?: HealthCheckAuthenticationOauthSecretRetryRules | undefined;
 };
-/** @internal */
-export declare const HealthCheckCollectorConfDiscoverType$inboundSchema: z.ZodType<HealthCheckCollectorConfDiscoverType, z.ZodTypeDef, unknown>;
-/** @internal */
-export declare const HealthCheckCollectorConfDiscoverType$outboundSchema: z.ZodType<string, z.ZodTypeDef, HealthCheckCollectorConfDiscoverType>;
-/** @internal */
-export declare const HealthCheckCollectorConfDiscovery$inboundSchema: z.ZodType<HealthCheckCollectorConfDiscovery, z.ZodTypeDef, unknown>;
-/** @internal */
-export type HealthCheckCollectorConfDiscovery$Outbound = {
-    discoverType: string;
+export type HealthCheckAuthenticationOauthAuthRequestParam = {
+    /**
+     * Parameter name.
+     */
+    name: string;
+    /**
+     * JavaScript expression to compute the parameter's value, normally enclosed in backticks (e.g., `${earliest}`). If a constant, use single quotes (e.g., 'earliest'). Values without delimiters (e.g., earliest) are evaluated as strings.
+     */
+    value: string;
 };
-/** @internal */
-export declare const HealthCheckCollectorConfDiscovery$outboundSchema: z.ZodType<HealthCheckCollectorConfDiscovery$Outbound, z.ZodTypeDef, HealthCheckCollectorConfDiscovery>;
-export declare function healthCheckCollectorConfDiscoveryToJSON(healthCheckCollectorConfDiscovery: HealthCheckCollectorConfDiscovery): string;
-export declare function healthCheckCollectorConfDiscoveryFromJSON(jsonString: string): SafeParseResult<HealthCheckCollectorConfDiscovery, SDKValidationError>;
-/** @internal */
-export declare const HealthCheckMethod$inboundSchema: z.ZodType<HealthCheckMethod, z.ZodTypeDef, unknown>;
-/** @internal */
-export declare const HealthCheckMethod$outboundSchema: z.ZodType<string, z.ZodTypeDef, HealthCheckMethod>;
-/** @internal */
-export declare const HealthCheckCollectorConfCollectRequestHeader$inboundSchema: z.ZodType<HealthCheckCollectorConfCollectRequestHeader, z.ZodTypeDef, unknown>;
-/** @internal */
-export type HealthCheckCollectorConfCollectRequestHeader$Outbound = {
+export type HealthCheckAuthenticationOauthAuthRequestHeader = {
+    /**
+     * Header name.
+     */
     name: string;
+    /**
+     * JavaScript expression to compute the header's value, normally enclosed in backticks (e.g., `${earliest}`). If a constant, use single quotes (e.g., 'earliest'). Values without delimiters (e.g., earliest) are evaluated as strings.
+     */
     value: string;
 };
-/** @internal */
-export declare const HealthCheckCollectorConfCollectRequestHeader$outboundSchema: z.ZodType<HealthCheckCollectorConfCollectRequestHeader$Outbound, z.ZodTypeDef, HealthCheckCollectorConfCollectRequestHeader>;
-export declare function healthCheckCollectorConfCollectRequestHeaderToJSON(healthCheckCollectorConfCollectRequestHeader: HealthCheckCollectorConfCollectRequestHeader): string;
-export declare function healthCheckCollectorConfCollectRequestHeaderFromJSON(jsonString: string): SafeParseResult<HealthCheckCollectorConfCollectRequestHeader, SDKValidationError>;
-/** @internal */
-export declare const HealthCheckCollectorConfAuthentication$inboundSchema: z.ZodType<HealthCheckCollectorConfAuthentication, z.ZodTypeDef, unknown>;
-/** @internal */
-export declare const HealthCheckCollectorConfAuthentication$outboundSchema: z.ZodType<string, z.ZodTypeDef, HealthCheckCollectorConfAuthentication>;
-/** @internal */
-export declare const HealthCheckCollectorConfHiddenDefaultBreakers$inboundSchema: z.ZodType<HealthCheckCollectorConfHiddenDefaultBreakers, z.ZodTypeDef, unknown>;
-/** @internal */
-export declare const HealthCheckCollectorConfHiddenDefaultBreakers$outboundSchema: z.ZodType<string, z.ZodTypeDef, HealthCheckCollectorConfHiddenDefaultBreakers>;
-/** @internal */
-export declare const HealthCheckCollectorConfRetryType$inboundSchema: z.ZodType<HealthCheckCollectorConfRetryType, z.ZodTypeDef, unknown>;
-/** @internal */
-export declare const HealthCheckCollectorConfRetryType$outboundSchema: z.ZodType<string, z.ZodTypeDef, HealthCheckCollectorConfRetryType>;
-/** @internal */
-export declare const HealthCheckCollectorConfRetryRules$inboundSchema: z.ZodType<HealthCheckCollectorConfRetryRules, z.ZodTypeDef, unknown>;
-/** @internal */
-export type HealthCheckCollectorConfRetryRules$Outbound = {
-    type: string;
+/**
+ * Defines how task discovery will be performed. Use None to skip the discovery. Use HTTP Request to make a REST call to discover tasks. Use Item List to enumerate items for collect to retrieve. Use JSON Response to manually define discover tasks as a JSON array of objects. Each entry returned by the discover operation will result in a collect task.
+ */
+export declare const HealthCheckAuthenticationOauthDiscoverType: {
+    /**
+     * HTTP Request
+     */
+    readonly Http: "http";
+    /**
+     * JSON Response
+     */
+    readonly Json: "json";
+    /**
+     * Item List
+     */
+    readonly List: "list";
+    /**
+     * None
+     */
+    readonly None: "none";
+};
+/**
+ * Defines how task discovery will be performed. Use None to skip the discovery. Use HTTP Request to make a REST call to discover tasks. Use Item List to enumerate items for collect to retrieve. Use JSON Response to manually define discover tasks as a JSON array of objects. Each entry returned by the discover operation will result in a collect task.
+ */
+export type HealthCheckAuthenticationOauthDiscoverType = OpenEnum<typeof HealthCheckAuthenticationOauthDiscoverType>;
+export type HealthCheckAuthenticationOauthDiscovery = {
+    /**
+     * Defines how task discovery will be performed. Use None to skip the discovery. Use HTTP Request to make a REST call to discover tasks. Use Item List to enumerate items for collect to retrieve. Use JSON Response to manually define discover tasks as a JSON array of objects. Each entry returned by the discover operation will result in a collect task.
+     */
+    discoverType?: HealthCheckAuthenticationOauthDiscoverType | undefined;
+};
+/**
+ * Health check HTTP method.
+ */
+export declare const HealthCheckAuthenticationOauthHealthCheckMethod: {
+    /**
+     * GET
+     */
+    readonly Get: "get";
+    /**
+     * POST
+     */
+    readonly Post: "post";
+    /**
+     * POST with Body
+     */
+    readonly PostWithBody: "post_with_body";
+};
+/**
+ * Health check HTTP method.
+ */
+export type HealthCheckAuthenticationOauthHealthCheckMethod = OpenEnum<typeof HealthCheckAuthenticationOauthHealthCheckMethod>;
+export type HealthCheckAuthenticationOauthCollectRequestHeader = {
+    /**
+     * Header Name
+     */
+    name: string;
+    /**
+     * JavaScript expression to compute the header value (can be a constant).
+     */
+    value: string;
+};
+export declare const HealthCheckAuthenticationOauthHiddenDefaultBreakers: {
+    readonly Cribl: "Cribl";
+};
+export type HealthCheckAuthenticationOauthHiddenDefaultBreakers = OpenEnum<typeof HealthCheckAuthenticationOauthHiddenDefaultBreakers>;
+/**
+ * The algorithm to use when performing HTTP retries
+ */
+export declare const HealthCheckAuthenticationOauthRetryType: {
+    /**
+     * Disabled
+     */
+    readonly None: "none";
+    /**
+     * Backoff
+     */
+    readonly Backoff: "backoff";
+    /**
+     * Static
+     */
+    readonly Static: "static";
+};
+/**
+ * The algorithm to use when performing HTTP retries
+ */
+export type HealthCheckAuthenticationOauthRetryType = OpenEnum<typeof HealthCheckAuthenticationOauthRetryType>;
+export type HealthCheckAuthenticationOauthRetryRules = {
+    /**
+     * The algorithm to use when performing HTTP retries
+     */
+    type?: HealthCheckAuthenticationOauthRetryType | undefined;
     interval?: any | undefined;
     limit?: any | undefined;
     multiplier?: any | undefined;
     codes?: any | undefined;
     enableHeader?: any | undefined;
 };
-/** @internal */
-export declare const HealthCheckCollectorConfRetryRules$outboundSchema: z.ZodType<HealthCheckCollectorConfRetryRules$Outbound, z.ZodTypeDef, HealthCheckCollectorConfRetryRules>;
-export declare function healthCheckCollectorConfRetryRulesToJSON(healthCheckCollectorConfRetryRules: HealthCheckCollectorConfRetryRules): string;
-export declare function healthCheckCollectorConfRetryRulesFromJSON(jsonString: string): SafeParseResult<HealthCheckCollectorConfRetryRules, SDKValidationError>;
-/** @internal */
-export declare const HealthCheckCollectorConf$inboundSchema: z.ZodType<HealthCheckCollectorConf, z.ZodTypeDef, unknown>;
-/** @internal */
-export type HealthCheckCollectorConf$Outbound = {
-    discovery?: HealthCheckCollectorConfDiscovery$Outbound | undefined;
+export type HealthCheckAuthenticationOauth = {
+    /**
+     * Authentication method for Discover and Collect REST calls. You can specify API Key–based authentication by adding the appropriate Collect headers.
+     */
+    authentication: "oauth";
+    /**
+     * URL to use for the OAuth API call. This call is expected to be a POST.
+     */
+    loginUrl?: string | undefined;
+    /**
+     * Path to token attribute in login response body. Nested attributes are OK. Leave blank if the response content type is text/plain; the entire response body will be used to derive the authorization header.
+     */
+    tokenRespAttribute?: string | undefined;
+    /**
+     * JavaScript expression to compute the Authorization header to pass in discover and collect calls. The value ${token} is used to reference the token obtained from login.
+     */
+    authHeaderExpr?: string | undefined;
+    /**
+     * Parameter name that contains client secret. Defaults to 'client_secret', and is automatically added to request parameters.
+     */
+    clientSecretParamName?: string | undefined;
+    /**
+     * Secret value to add to HTTP requests as the 'client secret' parameter. Stored on disk encrypted, and is automatically added to request parameters
+     */
+    clientSecretParamValue: string;
+    /**
+     * OAuth request parameters added to the POST body. The Content-Type header will automatically be set to application/x-www-form-urlencoded.
+     */
+    authRequestParams?: Array<HealthCheckAuthenticationOauthAuthRequestParam> | undefined;
+    /**
+     * Optional authentication request headers.
+     */
+    authRequestHeaders?: Array<HealthCheckAuthenticationOauthAuthRequestHeader> | undefined;
+    discovery?: HealthCheckAuthenticationOauthDiscovery | undefined;
+    /**
+     * Expression to derive URL to use for the health check operation (can be a constant).
+     */
     collectUrl: string;
-    collectMethod: string;
+    /**
+     * Health check HTTP method.
+     */
+    collectMethod?: HealthCheckAuthenticationOauthHealthCheckMethod | undefined;
     collectRequestParams?: any | undefined;
     collectBody?: any | undefined;
-    collectRequestHeaders?: Array<HealthCheckCollectorConfCollectRequestHeader$Outbound> | undefined;
-    authenticateCollect: boolean;
-    authentication: string;
-    timeout: number;
-    rejectUnauthorized: boolean;
-    defaultBreakers?: string | undefined;
+    /**
+     * Optional health check request headers.
+     */
+    collectRequestHeaders?: Array<HealthCheckAuthenticationOauthCollectRequestHeader> | undefined;
+    /**
+     * Enable to make auth health check call.
+     */
+    authenticateCollect?: boolean | undefined;
+    /**
+     * HTTP request inactivity timeout, use 0 to disable
+     */
+    timeout?: number | undefined;
+    /**
+     * Whether to reject certificates that cannot be verified against a valid CA (e.g., self-signed certificates).
+     */
+    rejectUnauthorized?: boolean | undefined;
+    defaultBreakers?: HealthCheckAuthenticationOauthHiddenDefaultBreakers | undefined;
+    /**
+     * List of headers that are safe to log in plain text.
+     */
     safeHeaders?: Array<string> | undefined;
-    retryRules?: HealthCheckCollectorConfRetryRules$Outbound | undefined;
+    retryRules?: HealthCheckAuthenticationOauthRetryRules | undefined;
+};
+export type HealthCheckAuthenticationLoginSecretAuthRequestHeader = {
+    /**
+     * Header name.
+     */
+    name: string;
+    /**
+     * JavaScript expression to compute the header value (can be a constant).
+     */
+    value: string;
+};
+/**
+ * Defines how task discovery will be performed. Use None to skip the discovery. Use HTTP Request to make a REST call to discover tasks. Use Item List to enumerate items for collect to retrieve. Use JSON Response to manually define discover tasks as a JSON array of objects. Each entry returned by the discover operation will result in a collect task.
+ */
+export declare const HealthCheckAuthenticationLoginSecretDiscoverType: {
+    /**
+     * HTTP Request
+     */
+    readonly Http: "http";
+    /**
+     * JSON Response
+     */
+    readonly Json: "json";
+    /**
+     * Item List
+     */
+    readonly List: "list";
+    /**
+     * None
+     */
+    readonly None: "none";
+};
+/**
+ * Defines how task discovery will be performed. Use None to skip the discovery. Use HTTP Request to make a REST call to discover tasks. Use Item List to enumerate items for collect to retrieve. Use JSON Response to manually define discover tasks as a JSON array of objects. Each entry returned by the discover operation will result in a collect task.
+ */
+export type HealthCheckAuthenticationLoginSecretDiscoverType = OpenEnum<typeof HealthCheckAuthenticationLoginSecretDiscoverType>;
+export type HealthCheckAuthenticationLoginSecretDiscovery = {
+    /**
+     * Defines how task discovery will be performed. Use None to skip the discovery. Use HTTP Request to make a REST call to discover tasks. Use Item List to enumerate items for collect to retrieve. Use JSON Response to manually define discover tasks as a JSON array of objects. Each entry returned by the discover operation will result in a collect task.
+     */
+    discoverType?: HealthCheckAuthenticationLoginSecretDiscoverType | undefined;
 };
+/**
+ * Health check HTTP method.
+ */
+export declare const HealthCheckAuthenticationLoginSecretHealthCheckMethod: {
+    /**
+     * GET
+     */
+    readonly Get: "get";
+    /**
+     * POST
+     */
+    readonly Post: "post";
+    /**
+     * POST with Body
+     */
+    readonly PostWithBody: "post_with_body";
+};
+/**
+ * Health check HTTP method.
+ */
+export type HealthCheckAuthenticationLoginSecretHealthCheckMethod = OpenEnum<typeof HealthCheckAuthenticationLoginSecretHealthCheckMethod>;
+export type HealthCheckAuthenticationLoginSecretCollectRequestHeader = {
+    /**
+     * Header Name
+     */
+    name: string;
+    /**
+     * JavaScript expression to compute the header value (can be a constant).
+     */
+    value: string;
+};
+export declare const HealthCheckAuthenticationLoginSecretHiddenDefaultBreakers: {
+    readonly Cribl: "Cribl";
+};
+export type HealthCheckAuthenticationLoginSecretHiddenDefaultBreakers = OpenEnum<typeof HealthCheckAuthenticationLoginSecretHiddenDefaultBreakers>;
+/**
+ * The algorithm to use when performing HTTP retries
+ */
+export declare const HealthCheckAuthenticationLoginSecretRetryType: {
+    /**
+     * Disabled
+     */
+    readonly None: "none";
+    /**
+     * Backoff
+     */
+    readonly Backoff: "backoff";
+    /**
+     * Static
+     */
+    readonly Static: "static";
+};
+/**
+ * The algorithm to use when performing HTTP retries
+ */
+export type HealthCheckAuthenticationLoginSecretRetryType = OpenEnum<typeof HealthCheckAuthenticationLoginSecretRetryType>;
+export type HealthCheckAuthenticationLoginSecretRetryRules = {
+    /**
+     * The algorithm to use when performing HTTP retries
+     */
+    type?: HealthCheckAuthenticationLoginSecretRetryType | undefined;
+    interval?: any | undefined;
+    limit?: any | undefined;
+    multiplier?: any | undefined;
+    codes?: any | undefined;
+    enableHeader?: any | undefined;
+};
+export type HealthCheckAuthenticationLoginSecret = {
+    /**
+     * Authentication method for Discover and Collect REST calls. You can specify API Key–based authentication by adding the appropriate Collect headers.
+     */
+    authentication: "loginSecret";
+    /**
+     * URL to use for login API call, this call is expected to be a POST.
+     */
+    loginUrl?: string | undefined;
+    /**
+     * Select or create a stored secret that references your login credentials
+     */
+    credentialsSecret: string;
+    /**
+     * Template for POST body to send with login request, ${username} and ${password} are used to specify location of these attributes in the message
+     */
+    loginBody?: string | undefined;
+    /**
+     * Path to token attribute in login response body. Nested attributes are OK. If left blank, the entire response body will be used to derive the authorization header.
+     */
+    tokenRespAttribute?: string | undefined;
+    /**
+     * JavaScript expression to compute the Authorization header to pass in discover and collect calls. The value ${token} is used to reference the token obtained from login.
+     */
+    authHeaderExpr?: string | undefined;
+    /**
+     * Optional authentication request headers.
+     */
+    authRequestHeaders?: Array<HealthCheckAuthenticationLoginSecretAuthRequestHeader> | undefined;
+    discovery?: HealthCheckAuthenticationLoginSecretDiscovery | undefined;
+    /**
+     * Expression to derive URL to use for the health check operation (can be a constant).
+     */
+    collectUrl: string;
+    /**
+     * Health check HTTP method.
+     */
+    collectMethod?: HealthCheckAuthenticationLoginSecretHealthCheckMethod | undefined;
+    collectRequestParams?: any | undefined;
+    collectBody?: any | undefined;
+    /**
+     * Optional health check request headers.
+     */
+    collectRequestHeaders?: Array<HealthCheckAuthenticationLoginSecretCollectRequestHeader> | undefined;
+    /**
+     * Enable to make auth health check call.
+     */
+    authenticateCollect?: boolean | undefined;
+    /**
+     * HTTP request inactivity timeout, use 0 to disable
+     */
+    timeout?: number | undefined;
+    /**
+     * Whether to reject certificates that cannot be verified against a valid CA (e.g., self-signed certificates).
+     */
+    rejectUnauthorized?: boolean | undefined;
+    defaultBreakers?: HealthCheckAuthenticationLoginSecretHiddenDefaultBreakers | undefined;
+    /**
+     * List of headers that are safe to log in plain text.
+     */
+    safeHeaders?: Array<string> | undefined;
+    retryRules?: HealthCheckAuthenticationLoginSecretRetryRules | undefined;
+};
+export type HealthCheckAuthenticationLoginAuthRequestHeader = {
+    /**
+     * Header name.
+     */
+    name: string;
+    /**
+     * JavaScript expression to compute the header value (can be a constant).
+     */
+    value: string;
+};
+/**
+ * Defines how task discovery will be performed. Use None to skip the discovery. Use HTTP Request to make a REST call to discover tasks. Use Item List to enumerate items for collect to retrieve. Use JSON Response to manually define discover tasks as a JSON array of objects. Each entry returned by the discover operation will result in a collect task.
+ */
+export declare const HealthCheckAuthenticationLoginDiscoverType: {
+    /**
+     * HTTP Request
+     */
+    readonly Http: "http";
+    /**
+     * JSON Response
+     */
+    readonly Json: "json";
+    /**
+     * Item List
+     */
+    readonly List: "list";
+    /**
+     * None
+     */
+    readonly None: "none";
+};
+/**
+ * Defines how task discovery will be performed. Use None to skip the discovery. Use HTTP Request to make a REST call to discover tasks. Use Item List to enumerate items for collect to retrieve. Use JSON Response to manually define discover tasks as a JSON array of objects. Each entry returned by the discover operation will result in a collect task.
+ */
+export type HealthCheckAuthenticationLoginDiscoverType = OpenEnum<typeof HealthCheckAuthenticationLoginDiscoverType>;
+export type HealthCheckAuthenticationLoginDiscovery = {
+    /**
+     * Defines how task discovery will be performed. Use None to skip the discovery. Use HTTP Request to make a REST call to discover tasks. Use Item List to enumerate items for collect to retrieve. Use JSON Response to manually define discover tasks as a JSON array of objects. Each entry returned by the discover operation will result in a collect task.
+     */
+    discoverType?: HealthCheckAuthenticationLoginDiscoverType | undefined;
+};
+/**
+ * Health check HTTP method.
+ */
+export declare const HealthCheckAuthenticationLoginHealthCheckMethod: {
+    /**
+     * GET
+     */
+    readonly Get: "get";
+    /**
+     * POST
+     */
+    readonly Post: "post";
+    /**
+     * POST with Body
+     */
+    readonly PostWithBody: "post_with_body";
+};
+/**
+ * Health check HTTP method.
+ */
+export type HealthCheckAuthenticationLoginHealthCheckMethod = OpenEnum<typeof HealthCheckAuthenticationLoginHealthCheckMethod>;
+export type HealthCheckAuthenticationLoginCollectRequestHeader = {
+    /**
+     * Header Name
+     */
+    name: string;
+    /**
+     * JavaScript expression to compute the header value (can be a constant).
+     */
+    value: string;
+};
+export declare const HealthCheckAuthenticationLoginHiddenDefaultBreakers: {
+    readonly Cribl: "Cribl";
+};
+export type HealthCheckAuthenticationLoginHiddenDefaultBreakers = OpenEnum<typeof HealthCheckAuthenticationLoginHiddenDefaultBreakers>;
+/**
+ * The algorithm to use when performing HTTP retries
+ */
+export declare const HealthCheckAuthenticationLoginRetryType: {
+    /**
+     * Disabled
+     */
+    readonly None: "none";
+    /**
+     * Backoff
+     */
+    readonly Backoff: "backoff";
+    /**
+     * Static
+     */
+    readonly Static: "static";
+};
+/**
+ * The algorithm to use when performing HTTP retries
+ */
+export type HealthCheckAuthenticationLoginRetryType = OpenEnum<typeof HealthCheckAuthenticationLoginRetryType>;
+export type HealthCheckAuthenticationLoginRetryRules = {
+    /**
+     * The algorithm to use when performing HTTP retries
+     */
+    type?: HealthCheckAuthenticationLoginRetryType | undefined;
+    interval?: any | undefined;
+    limit?: any | undefined;
+    multiplier?: any | undefined;
+    codes?: any | undefined;
+    enableHeader?: any | undefined;
+};
+export type HealthCheckAuthenticationLogin = {
+    /**
+     * Authentication method for Discover and Collect REST calls. You can specify API Key–based authentication by adding the appropriate Collect headers.
+     */
+    authentication: "login";
+    /**
+     * URL to use for login API call. This call is expected to be a POST.
+     */
+    loginUrl?: string | undefined;
+    /**
+     * Login username
+     */
+    username: string;
+    /**
+     * Login password
+     */
+    password: string;
+    /**
+     * Template for POST body to send with login request, ${username} and ${password} are used to specify location of these attributes in the message
+     */
+    loginBody?: string | undefined;
+    /**
+     * Path to token attribute in login response body. Nested attributes are OK. Leave blank if the response content type is text/plain; the entire response body will be used to derive the authorization header.
+     */
+    tokenRespAttribute?: string | undefined;
+    /**
+     * JavaScript expression to compute the Authorization header to pass in discover and collect calls. The value ${token} is used to reference the token obtained from login.
+     */
+    authHeaderExpr?: string | undefined;
+    /**
+     * Optional authentication request headers.
+     */
+    authRequestHeaders?: Array<HealthCheckAuthenticationLoginAuthRequestHeader> | undefined;
+    discovery?: HealthCheckAuthenticationLoginDiscovery | undefined;
+    /**
+     * Expression to derive URL to use for the health check operation (can be a constant).
+     */
+    collectUrl: string;
+    /**
+     * Health check HTTP method.
+     */
+    collectMethod?: HealthCheckAuthenticationLoginHealthCheckMethod | undefined;
+    collectRequestParams?: any | undefined;
+    collectBody?: any | undefined;
+    /**
+     * Optional health check request headers.
+     */
+    collectRequestHeaders?: Array<HealthCheckAuthenticationLoginCollectRequestHeader> | undefined;
+    /**
+     * Enable to make auth health check call.
+     */
+    authenticateCollect?: boolean | undefined;
+    /**
+     * HTTP request inactivity timeout, use 0 to disable
+     */
+    timeout?: number | undefined;
+    /**
+     * Whether to reject certificates that cannot be verified against a valid CA (e.g., self-signed certificates).
+     */
+    rejectUnauthorized?: boolean | undefined;
+    defaultBreakers?: HealthCheckAuthenticationLoginHiddenDefaultBreakers | undefined;
+    /**
+     * List of headers that are safe to log in plain text.
+     */
+    safeHeaders?: Array<string> | undefined;
+    retryRules?: HealthCheckAuthenticationLoginRetryRules | undefined;
+};
+/**
+ * Defines how task discovery will be performed. Use None to skip the discovery. Use HTTP Request to make a REST call to discover tasks. Use Item List to enumerate items for collect to retrieve. Use JSON Response to manually define discover tasks as a JSON array of objects. Each entry returned by the discover operation will result in a collect task.
+ */
+export declare const HealthCheckAuthenticationBasicSecretDiscoverType: {
+    /**
+     * HTTP Request
+     */
+    readonly Http: "http";
+    /**
+     * JSON Response
+     */
+    readonly Json: "json";
+    /**
+     * Item List
+     */
+    readonly List: "list";
+    /**
+     * None
+     */
+    readonly None: "none";
+};
+/**
+ * Defines how task discovery will be performed. Use None to skip the discovery. Use HTTP Request to make a REST call to discover tasks. Use Item List to enumerate items for collect to retrieve. Use JSON Response to manually define discover tasks as a JSON array of objects. Each entry returned by the discover operation will result in a collect task.
+ */
+export type HealthCheckAuthenticationBasicSecretDiscoverType = OpenEnum<typeof HealthCheckAuthenticationBasicSecretDiscoverType>;
+export type HealthCheckAuthenticationBasicSecretDiscovery = {
+    /**
+     * Defines how task discovery will be performed. Use None to skip the discovery. Use HTTP Request to make a REST call to discover tasks. Use Item List to enumerate items for collect to retrieve. Use JSON Response to manually define discover tasks as a JSON array of objects. Each entry returned by the discover operation will result in a collect task.
+     */
+    discoverType?: HealthCheckAuthenticationBasicSecretDiscoverType | undefined;
+};
+/**
+ * Health check HTTP method.
+ */
+export declare const HealthCheckAuthenticationBasicSecretHealthCheckMethod: {
+    /**
+     * GET
+     */
+    readonly Get: "get";
+    /**
+     * POST
+     */
+    readonly Post: "post";
+    /**
+     * POST with Body
+     */
+    readonly PostWithBody: "post_with_body";
+};
+/**
+ * Health check HTTP method.
+ */
+export type HealthCheckAuthenticationBasicSecretHealthCheckMethod = OpenEnum<typeof HealthCheckAuthenticationBasicSecretHealthCheckMethod>;
+export type HealthCheckAuthenticationBasicSecretCollectRequestHeader = {
+    /**
+     * Header Name
+     */
+    name: string;
+    /**
+     * JavaScript expression to compute the header value (can be a constant).
+     */
+    value: string;
+};
+export declare const HealthCheckAuthenticationBasicSecretHiddenDefaultBreakers: {
+    readonly Cribl: "Cribl";
+};
+export type HealthCheckAuthenticationBasicSecretHiddenDefaultBreakers = OpenEnum<typeof HealthCheckAuthenticationBasicSecretHiddenDefaultBreakers>;
+/**
+ * The algorithm to use when performing HTTP retries
+ */
+export declare const HealthCheckAuthenticationBasicSecretRetryType: {
+    /**
+     * Disabled
+     */
+    readonly None: "none";
+    /**
+     * Backoff
+     */
+    readonly Backoff: "backoff";
+    /**
+     * Static
+     */
+    readonly Static: "static";
+};
+/**
+ * The algorithm to use when performing HTTP retries
+ */
+export type HealthCheckAuthenticationBasicSecretRetryType = OpenEnum<typeof HealthCheckAuthenticationBasicSecretRetryType>;
+export type HealthCheckAuthenticationBasicSecretRetryRules = {
+    /**
+     * The algorithm to use when performing HTTP retries
+     */
+    type?: HealthCheckAuthenticationBasicSecretRetryType | undefined;
+    interval?: any | undefined;
+    limit?: any | undefined;
+    multiplier?: any | undefined;
+    codes?: any | undefined;
+    enableHeader?: any | undefined;
+};
+export type HealthCheckAuthenticationBasicSecret = {
+    /**
+     * Authentication method for Discover and Collect REST calls. You can specify API Key–based authentication by adding the appropriate Collect headers.
+     */
+    authentication: "basicSecret";
+    /**
+     * Select or create a stored secret that references your credentials
+     */
+    credentialsSecret: string;
+    discovery?: HealthCheckAuthenticationBasicSecretDiscovery | undefined;
+    /**
+     * Expression to derive URL to use for the health check operation (can be a constant).
+     */
+    collectUrl: string;
+    /**
+     * Health check HTTP method.
+     */
+    collectMethod?: HealthCheckAuthenticationBasicSecretHealthCheckMethod | undefined;
+    collectRequestParams?: any | undefined;
+    collectBody?: any | undefined;
+    /**
+     * Optional health check request headers.
+     */
+    collectRequestHeaders?: Array<HealthCheckAuthenticationBasicSecretCollectRequestHeader> | undefined;
+    /**
+     * Enable to make auth health check call.
+     */
+    authenticateCollect?: boolean | undefined;
+    /**
+     * HTTP request inactivity timeout, use 0 to disable
+     */
+    timeout?: number | undefined;
+    /**
+     * Whether to reject certificates that cannot be verified against a valid CA (e.g., self-signed certificates).
+     */
+    rejectUnauthorized?: boolean | undefined;
+    defaultBreakers?: HealthCheckAuthenticationBasicSecretHiddenDefaultBreakers | undefined;
+    /**
+     * List of headers that are safe to log in plain text.
+     */
+    safeHeaders?: Array<string> | undefined;
+    retryRules?: HealthCheckAuthenticationBasicSecretRetryRules | undefined;
+};
+/**
+ * Defines how task discovery will be performed. Use None to skip the discovery. Use HTTP Request to make a REST call to discover tasks. Use Item List to enumerate items for collect to retrieve. Use JSON Response to manually define discover tasks as a JSON array of objects. Each entry returned by the discover operation will result in a collect task.
+ */
+export declare const HealthCheckAuthenticationBasicDiscoverType: {
+    /**
+     * HTTP Request
+     */
+    readonly Http: "http";
+    /**
+     * JSON Response
+     */
+    readonly Json: "json";
+    /**
+     * Item List
+     */
+    readonly List: "list";
+    /**
+     * None
+     */
+    readonly None: "none";
+};
+/**
+ * Defines how task discovery will be performed. Use None to skip the discovery. Use HTTP Request to make a REST call to discover tasks. Use Item List to enumerate items for collect to retrieve. Use JSON Response to manually define discover tasks as a JSON array of objects. Each entry returned by the discover operation will result in a collect task.
+ */
+export type HealthCheckAuthenticationBasicDiscoverType = OpenEnum<typeof HealthCheckAuthenticationBasicDiscoverType>;
+export type HealthCheckAuthenticationBasicDiscovery = {
+    /**
+     * Defines how task discovery will be performed. Use None to skip the discovery. Use HTTP Request to make a REST call to discover tasks. Use Item List to enumerate items for collect to retrieve. Use JSON Response to manually define discover tasks as a JSON array of objects. Each entry returned by the discover operation will result in a collect task.
+     */
+    discoverType?: HealthCheckAuthenticationBasicDiscoverType | undefined;
+};
+/**
+ * Health check HTTP method.
+ */
+export declare const HealthCheckAuthenticationBasicHealthCheckMethod: {
+    /**
+     * GET
+     */
+    readonly Get: "get";
+    /**
+     * POST
+     */
+    readonly Post: "post";
+    /**
+     * POST with Body
+     */
+    readonly PostWithBody: "post_with_body";
+};
+/**
+ * Health check HTTP method.
+ */
+export type HealthCheckAuthenticationBasicHealthCheckMethod = OpenEnum<typeof HealthCheckAuthenticationBasicHealthCheckMethod>;
+export type HealthCheckAuthenticationBasicCollectRequestHeader = {
+    /**
+     * Header Name
+     */
+    name: string;
+    /**
+     * JavaScript expression to compute the header value (can be a constant).
+     */
+    value: string;
+};
+export declare const HealthCheckAuthenticationBasicHiddenDefaultBreakers: {
+    readonly Cribl: "Cribl";
+};
+export type HealthCheckAuthenticationBasicHiddenDefaultBreakers = OpenEnum<typeof HealthCheckAuthenticationBasicHiddenDefaultBreakers>;
+/**
+ * The algorithm to use when performing HTTP retries
+ */
+export declare const HealthCheckAuthenticationBasicRetryType: {
+    /**
+     * Disabled
+     */
+    readonly None: "none";
+    /**
+     * Backoff
+     */
+    readonly Backoff: "backoff";
+    /**
+     * Static
+     */
+    readonly Static: "static";
+};
+/**
+ * The algorithm to use when performing HTTP retries
+ */
+export type HealthCheckAuthenticationBasicRetryType = OpenEnum<typeof HealthCheckAuthenticationBasicRetryType>;
+export type HealthCheckAuthenticationBasicRetryRules = {
+    /**
+     * The algorithm to use when performing HTTP retries
+     */
+    type?: HealthCheckAuthenticationBasicRetryType | undefined;
+    interval?: any | undefined;
+    limit?: any | undefined;
+    multiplier?: any | undefined;
+    codes?: any | undefined;
+    enableHeader?: any | undefined;
+};
+export type HealthCheckAuthenticationBasic = {
+    /**
+     * Authentication method for Discover and Collect REST calls. You can specify API Key–based authentication by adding the appropriate Collect headers.
+     */
+    authentication: "basic";
+    /**
+     * Basic authentication username
+     */
+    username: string;
+    /**
+     * Basic authentication password
+     */
+    password: string;
+    discovery?: HealthCheckAuthenticationBasicDiscovery | undefined;
+    /**
+     * Expression to derive URL to use for the health check operation (can be a constant).
+     */
+    collectUrl: string;
+    /**
+     * Health check HTTP method.
+     */
+    collectMethod?: HealthCheckAuthenticationBasicHealthCheckMethod | undefined;
+    collectRequestParams?: any | undefined;
+    collectBody?: any | undefined;
+    /**
+     * Optional health check request headers.
+     */
+    collectRequestHeaders?: Array<HealthCheckAuthenticationBasicCollectRequestHeader> | undefined;
+    /**
+     * Enable to make auth health check call.
+     */
+    authenticateCollect?: boolean | undefined;
+    /**
+     * HTTP request inactivity timeout, use 0 to disable
+     */
+    timeout?: number | undefined;
+    /**
+     * Whether to reject certificates that cannot be verified against a valid CA (e.g., self-signed certificates).
+     */
+    rejectUnauthorized?: boolean | undefined;
+    defaultBreakers?: HealthCheckAuthenticationBasicHiddenDefaultBreakers | undefined;
+    /**
+     * List of headers that are safe to log in plain text.
+     */
+    safeHeaders?: Array<string> | undefined;
+    retryRules?: HealthCheckAuthenticationBasicRetryRules | undefined;
+};
+/**
+ * Defines how task discovery will be performed. Use None to skip the discovery. Use HTTP Request to make a REST call to discover tasks. Use Item List to enumerate items for collect to retrieve. Use JSON Response to manually define discover tasks as a JSON array of objects. Each entry returned by the discover operation will result in a collect task.
+ */
+export declare const HealthCheckAuthenticationNoneDiscoverType: {
+    /**
+     * HTTP Request
+     */
+    readonly Http: "http";
+    /**
+     * JSON Response
+     */
+    readonly Json: "json";
+    /**
+     * Item List
+     */
+    readonly List: "list";
+    /**
+     * None
+     */
+    readonly None: "none";
+};
+/**
+ * Defines how task discovery will be performed. Use None to skip the discovery. Use HTTP Request to make a REST call to discover tasks. Use Item List to enumerate items for collect to retrieve. Use JSON Response to manually define discover tasks as a JSON array of objects. Each entry returned by the discover operation will result in a collect task.
+ */
+export type HealthCheckAuthenticationNoneDiscoverType = OpenEnum<typeof HealthCheckAuthenticationNoneDiscoverType>;
+export type HealthCheckAuthenticationNoneDiscovery = {
+    /**
+     * Defines how task discovery will be performed. Use None to skip the discovery. Use HTTP Request to make a REST call to discover tasks. Use Item List to enumerate items for collect to retrieve. Use JSON Response to manually define discover tasks as a JSON array of objects. Each entry returned by the discover operation will result in a collect task.
+     */
+    discoverType?: HealthCheckAuthenticationNoneDiscoverType | undefined;
+};
+/**
+ * Health check HTTP method.
+ */
+export declare const HealthCheckAuthenticationNoneHealthCheckMethod: {
+    /**
+     * GET
+     */
+    readonly Get: "get";
+    /**
+     * POST
+     */
+    readonly Post: "post";
+    /**
+     * POST with Body
+     */
+    readonly PostWithBody: "post_with_body";
+};
+/**
+ * Health check HTTP method.
+ */
+export type HealthCheckAuthenticationNoneHealthCheckMethod = OpenEnum<typeof HealthCheckAuthenticationNoneHealthCheckMethod>;
+export type HealthCheckAuthenticationNoneCollectRequestHeader = {
+    /**
+     * Header Name
+     */
+    name: string;
+    /**
+     * JavaScript expression to compute the header value (can be a constant).
+     */
+    value: string;
+};
+export declare const HealthCheckAuthenticationNoneHiddenDefaultBreakers: {
+    readonly Cribl: "Cribl";
+};
+export type HealthCheckAuthenticationNoneHiddenDefaultBreakers = OpenEnum<typeof HealthCheckAuthenticationNoneHiddenDefaultBreakers>;
+/**
+ * The algorithm to use when performing HTTP retries
+ */
+export declare const HealthCheckAuthenticationNoneRetryType: {
+    /**
+     * Disabled
+     */
+    readonly None: "none";
+    /**
+     * Backoff
+     */
+    readonly Backoff: "backoff";
+    /**
+     * Static
+     */
+    readonly Static: "static";
+};
+/**
+ * The algorithm to use when performing HTTP retries
+ */
+export type HealthCheckAuthenticationNoneRetryType = OpenEnum<typeof HealthCheckAuthenticationNoneRetryType>;
+export type HealthCheckAuthenticationNoneRetryRules = {
+    /**
+     * The algorithm to use when performing HTTP retries
+     */
+    type?: HealthCheckAuthenticationNoneRetryType | undefined;
+    interval?: any | undefined;
+    limit?: any | undefined;
+    multiplier?: any | undefined;
+    codes?: any | undefined;
+    enableHeader?: any | undefined;
+};
+export type HealthCheckAuthenticationNone = {
+    /**
+     * Authentication method for Discover and Collect REST calls. You can specify API Key–based authentication by adding the appropriate Collect headers.
+     */
+    authentication: "none";
+    discovery?: HealthCheckAuthenticationNoneDiscovery | undefined;
+    /**
+     * Expression to derive URL to use for the health check operation (can be a constant).
+     */
+    collectUrl: string;
+    /**
+     * Health check HTTP method.
+     */
+    collectMethod?: HealthCheckAuthenticationNoneHealthCheckMethod | undefined;
+    collectRequestParams?: any | undefined;
+    collectBody?: any | undefined;
+    /**
+     * Optional health check request headers.
+     */
+    collectRequestHeaders?: Array<HealthCheckAuthenticationNoneCollectRequestHeader> | undefined;
+    /**
+     * Enable to make auth health check call.
+     */
+    authenticateCollect?: boolean | undefined;
+    /**
+     * HTTP request inactivity timeout, use 0 to disable
+     */
+    timeout?: number | undefined;
+    /**
+     * Whether to reject certificates that cannot be verified against a valid CA (e.g., self-signed certificates).
+     */
+    rejectUnauthorized?: boolean | undefined;
+    defaultBreakers?: HealthCheckAuthenticationNoneHiddenDefaultBreakers | undefined;
+    /**
+     * List of headers that are safe to log in plain text.
+     */
+    safeHeaders?: Array<string> | undefined;
+    retryRules?: HealthCheckAuthenticationNoneRetryRules | undefined;
+};
+/**
+ * Health check HTTP method.
+ */
+export declare const HealthCheckCollectMethodPostWithBodyHealthCheckMethod: {
+    /**
+     * GET
+     */
+    readonly Get: "get";
+    /**
+     * POST
+     */
+    readonly Post: "post";
+    /**
+     * POST with Body
+     */
+    readonly PostWithBody: "post_with_body";
+};
+/**
+ * Health check HTTP method.
+ */
+export type HealthCheckCollectMethodPostWithBodyHealthCheckMethod = OpenEnum<typeof HealthCheckCollectMethodPostWithBodyHealthCheckMethod>;
+/**
+ * Defines how task discovery will be performed. Use None to skip the discovery. Use HTTP Request to make a REST call to discover tasks. Use Item List to enumerate items for collect to retrieve. Use JSON Response to manually define discover tasks as a JSON array of objects. Each entry returned by the discover operation will result in a collect task.
+ */
+export declare const HealthCheckCollectMethodPostWithBodyDiscoverType: {
+    /**
+     * HTTP Request
+     */
+    readonly Http: "http";
+    /**
+     * JSON Response
+     */
+    readonly Json: "json";
+    /**
+     * Item List
+     */
+    readonly List: "list";
+    /**
+     * None
+     */
+    readonly None: "none";
+};
+/**
+ * Defines how task discovery will be performed. Use None to skip the discovery. Use HTTP Request to make a REST call to discover tasks. Use Item List to enumerate items for collect to retrieve. Use JSON Response to manually define discover tasks as a JSON array of objects. Each entry returned by the discover operation will result in a collect task.
+ */
+export type HealthCheckCollectMethodPostWithBodyDiscoverType = OpenEnum<typeof HealthCheckCollectMethodPostWithBodyDiscoverType>;
+export type HealthCheckCollectMethodPostWithBodyDiscovery = {
+    /**
+     * Defines how task discovery will be performed. Use None to skip the discovery. Use HTTP Request to make a REST call to discover tasks. Use Item List to enumerate items for collect to retrieve. Use JSON Response to manually define discover tasks as a JSON array of objects. Each entry returned by the discover operation will result in a collect task.
+     */
+    discoverType?: HealthCheckCollectMethodPostWithBodyDiscoverType | undefined;
+};
+export type HealthCheckCollectMethodPostWithBodyCollectRequestHeader = {
+    /**
+     * Header Name
+     */
+    name: string;
+    /**
+     * JavaScript expression to compute the header value (can be a constant).
+     */
+    value: string;
+};
+/**
+ * Authentication method for Discover and Collect REST calls. You can specify API Key–based authentication by adding the appropriate Collect headers.
+ */
+export declare const HealthCheckCollectMethodPostWithBodyAuthentication: {
+    readonly None: "none";
+    readonly Basic: "basic";
+    readonly BasicSecret: "basicSecret";
+    readonly Login: "login";
+    readonly LoginSecret: "loginSecret";
+    readonly Oauth: "oauth";
+    readonly OauthSecret: "oauthSecret";
+};
+/**
+ * Authentication method for Discover and Collect REST calls. You can specify API Key–based authentication by adding the appropriate Collect headers.
+ */
+export type HealthCheckCollectMethodPostWithBodyAuthentication = OpenEnum<typeof HealthCheckCollectMethodPostWithBodyAuthentication>;
+export declare const HealthCheckCollectMethodPostWithBodyHiddenDefaultBreakers: {
+    readonly Cribl: "Cribl";
+};
+export type HealthCheckCollectMethodPostWithBodyHiddenDefaultBreakers = OpenEnum<typeof HealthCheckCollectMethodPostWithBodyHiddenDefaultBreakers>;
+/**
+ * The algorithm to use when performing HTTP retries
+ */
+export declare const HealthCheckCollectMethodPostWithBodyRetryType: {
+    /**
+     * Disabled
+     */
+    readonly None: "none";
+    /**
+     * Backoff
+     */
+    readonly Backoff: "backoff";
+    /**
+     * Static
+     */
+    readonly Static: "static";
+};
+/**
+ * The algorithm to use when performing HTTP retries
+ */
+export type HealthCheckCollectMethodPostWithBodyRetryType = OpenEnum<typeof HealthCheckCollectMethodPostWithBodyRetryType>;
+export type HealthCheckCollectMethodPostWithBodyRetryRules = {
+    /**
+     * The algorithm to use when performing HTTP retries
+     */
+    type?: HealthCheckCollectMethodPostWithBodyRetryType | undefined;
+    interval?: any | undefined;
+    limit?: any | undefined;
+    multiplier?: any | undefined;
+    codes?: any | undefined;
+    enableHeader?: any | undefined;
+};
+export type HealthCheckCollectMethodPostWithBody = {
+    /**
+     * Health check HTTP method.
+     */
+    collectMethod?: HealthCheckCollectMethodPostWithBodyHealthCheckMethod | undefined;
+    collectBody?: any | undefined;
+    discovery?: HealthCheckCollectMethodPostWithBodyDiscovery | undefined;
+    /**
+     * Expression to derive URL to use for the health check operation (can be a constant).
+     */
+    collectUrl: string;
+    collectRequestParams?: any | undefined;
+    /**
+     * Optional health check request headers.
+     */
+    collectRequestHeaders?: Array<HealthCheckCollectMethodPostWithBodyCollectRequestHeader> | undefined;
+    /**
+     * Enable to make auth health check call.
+     */
+    authenticateCollect?: boolean | undefined;
+    /**
+     * Authentication method for Discover and Collect REST calls. You can specify API Key–based authentication by adding the appropriate Collect headers.
+     */
+    authentication?: HealthCheckCollectMethodPostWithBodyAuthentication | undefined;
+    /**
+     * HTTP request inactivity timeout, use 0 to disable
+     */
+    timeout?: number | undefined;
+    /**
+     * Whether to reject certificates that cannot be verified against a valid CA (e.g., self-signed certificates).
+     */
+    rejectUnauthorized?: boolean | undefined;
+    defaultBreakers?: HealthCheckCollectMethodPostWithBodyHiddenDefaultBreakers | undefined;
+    /**
+     * List of headers that are safe to log in plain text.
+     */
+    safeHeaders?: Array<string> | undefined;
+    retryRules?: HealthCheckCollectMethodPostWithBodyRetryRules | undefined;
+};
+/**
+ * Health check HTTP method.
+ */
+export declare const HealthCheckCollectMethodPostHealthCheckMethod: {
+    /**
+     * GET
+     */
+    readonly Get: "get";
+    /**
+     * POST
+     */
+    readonly Post: "post";
+    /**
+     * POST with Body
+     */
+    readonly PostWithBody: "post_with_body";
+};
+/**
+ * Health check HTTP method.
+ */
+export type HealthCheckCollectMethodPostHealthCheckMethod = OpenEnum<typeof HealthCheckCollectMethodPostHealthCheckMethod>;
+/**
+ * Defines how task discovery will be performed. Use None to skip the discovery. Use HTTP Request to make a REST call to discover tasks. Use Item List to enumerate items for collect to retrieve. Use JSON Response to manually define discover tasks as a JSON array of objects. Each entry returned by the discover operation will result in a collect task.
+ */
+export declare const HealthCheckCollectMethodPostDiscoverType: {
+    /**
+     * HTTP Request
+     */
+    readonly Http: "http";
+    /**
+     * JSON Response
+     */
+    readonly Json: "json";
+    /**
+     * Item List
+     */
+    readonly List: "list";
+    /**
+     * None
+     */
+    readonly None: "none";
+};
+/**
+ * Defines how task discovery will be performed. Use None to skip the discovery. Use HTTP Request to make a REST call to discover tasks. Use Item List to enumerate items for collect to retrieve. Use JSON Response to manually define discover tasks as a JSON array of objects. Each entry returned by the discover operation will result in a collect task.
+ */
+export type HealthCheckCollectMethodPostDiscoverType = OpenEnum<typeof HealthCheckCollectMethodPostDiscoverType>;
+export type HealthCheckCollectMethodPostDiscovery = {
+    /**
+     * Defines how task discovery will be performed. Use None to skip the discovery. Use HTTP Request to make a REST call to discover tasks. Use Item List to enumerate items for collect to retrieve. Use JSON Response to manually define discover tasks as a JSON array of objects. Each entry returned by the discover operation will result in a collect task.
+     */
+    discoverType?: HealthCheckCollectMethodPostDiscoverType | undefined;
+};
+export type HealthCheckCollectMethodPostCollectRequestHeader = {
+    /**
+     * Header Name
+     */
+    name: string;
+    /**
+     * JavaScript expression to compute the header value (can be a constant).
+     */
+    value: string;
+};
+/**
+ * Authentication method for Discover and Collect REST calls. You can specify API Key–based authentication by adding the appropriate Collect headers.
+ */
+export declare const HealthCheckCollectMethodPostAuthentication: {
+    readonly None: "none";
+    readonly Basic: "basic";
+    readonly BasicSecret: "basicSecret";
+    readonly Login: "login";
+    readonly LoginSecret: "loginSecret";
+    readonly Oauth: "oauth";
+    readonly OauthSecret: "oauthSecret";
+};
+/**
+ * Authentication method for Discover and Collect REST calls. You can specify API Key–based authentication by adding the appropriate Collect headers.
+ */
+export type HealthCheckCollectMethodPostAuthentication = OpenEnum<typeof HealthCheckCollectMethodPostAuthentication>;
+export declare const HealthCheckCollectMethodPostHiddenDefaultBreakers: {
+    readonly Cribl: "Cribl";
+};
+export type HealthCheckCollectMethodPostHiddenDefaultBreakers = OpenEnum<typeof HealthCheckCollectMethodPostHiddenDefaultBreakers>;
+/**
+ * The algorithm to use when performing HTTP retries
+ */
+export declare const HealthCheckCollectMethodPostRetryType: {
+    /**
+     * Disabled
+     */
+    readonly None: "none";
+    /**
+     * Backoff
+     */
+    readonly Backoff: "backoff";
+    /**
+     * Static
+     */
+    readonly Static: "static";
+};
+/**
+ * The algorithm to use when performing HTTP retries
+ */
+export type HealthCheckCollectMethodPostRetryType = OpenEnum<typeof HealthCheckCollectMethodPostRetryType>;
+export type HealthCheckCollectMethodPostRetryRules = {
+    /**
+     * The algorithm to use when performing HTTP retries
+     */
+    type?: HealthCheckCollectMethodPostRetryType | undefined;
+    interval?: any | undefined;
+    limit?: any | undefined;
+    multiplier?: any | undefined;
+    codes?: any | undefined;
+    enableHeader?: any | undefined;
+};
+export type HealthCheckCollectMethodPost = {
+    /**
+     * Health check HTTP method.
+     */
+    collectMethod?: HealthCheckCollectMethodPostHealthCheckMethod | undefined;
+    collectRequestParams?: any | undefined;
+    discovery?: HealthCheckCollectMethodPostDiscovery | undefined;
+    /**
+     * Expression to derive URL to use for the health check operation (can be a constant).
+     */
+    collectUrl: string;
+    collectBody?: any | undefined;
+    /**
+     * Optional health check request headers.
+     */
+    collectRequestHeaders?: Array<HealthCheckCollectMethodPostCollectRequestHeader> | undefined;
+    /**
+     * Enable to make auth health check call.
+     */
+    authenticateCollect?: boolean | undefined;
+    /**
+     * Authentication method for Discover and Collect REST calls. You can specify API Key–based authentication by adding the appropriate Collect headers.
+     */
+    authentication?: HealthCheckCollectMethodPostAuthentication | undefined;
+    /**
+     * HTTP request inactivity timeout, use 0 to disable
+     */
+    timeout?: number | undefined;
+    /**
+     * Whether to reject certificates that cannot be verified against a valid CA (e.g., self-signed certificates).
+     */
+    rejectUnauthorized?: boolean | undefined;
+    defaultBreakers?: HealthCheckCollectMethodPostHiddenDefaultBreakers | undefined;
+    /**
+     * List of headers that are safe to log in plain text.
+     */
+    safeHeaders?: Array<string> | undefined;
+    retryRules?: HealthCheckCollectMethodPostRetryRules | undefined;
+};
+/**
+ * Health check HTTP method.
+ */
+export declare const HealthCheckCollectMethodGetHealthCheckMethod: {
+    /**
+     * GET
+     */
+    readonly Get: "get";
+    /**
+     * POST
+     */
+    readonly Post: "post";
+    /**
+     * POST with Body
+     */
+    readonly PostWithBody: "post_with_body";
+};
+/**
+ * Health check HTTP method.
+ */
+export type HealthCheckCollectMethodGetHealthCheckMethod = OpenEnum<typeof HealthCheckCollectMethodGetHealthCheckMethod>;
+/**
+ * Defines how task discovery will be performed. Use None to skip the discovery. Use HTTP Request to make a REST call to discover tasks. Use Item List to enumerate items for collect to retrieve. Use JSON Response to manually define discover tasks as a JSON array of objects. Each entry returned by the discover operation will result in a collect task.
+ */
+export declare const HealthCheckCollectMethodGetDiscoverType: {
+    /**
+     * HTTP Request
+     */
+    readonly Http: "http";
+    /**
+     * JSON Response
+     */
+    readonly Json: "json";
+    /**
+     * Item List
+     */
+    readonly List: "list";
+    /**
+     * None
+     */
+    readonly None: "none";
+};
+/**
+ * Defines how task discovery will be performed. Use None to skip the discovery. Use HTTP Request to make a REST call to discover tasks. Use Item List to enumerate items for collect to retrieve. Use JSON Response to manually define discover tasks as a JSON array of objects. Each entry returned by the discover operation will result in a collect task.
+ */
+export type HealthCheckCollectMethodGetDiscoverType = OpenEnum<typeof HealthCheckCollectMethodGetDiscoverType>;
+export type HealthCheckCollectMethodGetDiscovery = {
+    /**
+     * Defines how task discovery will be performed. Use None to skip the discovery. Use HTTP Request to make a REST call to discover tasks. Use Item List to enumerate items for collect to retrieve. Use JSON Response to manually define discover tasks as a JSON array of objects. Each entry returned by the discover operation will result in a collect task.
+     */
+    discoverType?: HealthCheckCollectMethodGetDiscoverType | undefined;
+};
+export type HealthCheckCollectMethodGetCollectRequestHeader = {
+    /**
+     * Header Name
+     */
+    name: string;
+    /**
+     * JavaScript expression to compute the header value (can be a constant).
+     */
+    value: string;
+};
+/**
+ * Authentication method for Discover and Collect REST calls. You can specify API Key–based authentication by adding the appropriate Collect headers.
+ */
+export declare const HealthCheckCollectMethodGetAuthentication: {
+    readonly None: "none";
+    readonly Basic: "basic";
+    readonly BasicSecret: "basicSecret";
+    readonly Login: "login";
+    readonly LoginSecret: "loginSecret";
+    readonly Oauth: "oauth";
+    readonly OauthSecret: "oauthSecret";
+};
+/**
+ * Authentication method for Discover and Collect REST calls. You can specify API Key–based authentication by adding the appropriate Collect headers.
+ */
+export type HealthCheckCollectMethodGetAuthentication = OpenEnum<typeof HealthCheckCollectMethodGetAuthentication>;
+export declare const HealthCheckCollectMethodGetHiddenDefaultBreakers: {
+    readonly Cribl: "Cribl";
+};
+export type HealthCheckCollectMethodGetHiddenDefaultBreakers = OpenEnum<typeof HealthCheckCollectMethodGetHiddenDefaultBreakers>;
+/**
+ * The algorithm to use when performing HTTP retries
+ */
+export declare const HealthCheckCollectMethodGetRetryType: {
+    /**
+     * Disabled
+     */
+    readonly None: "none";
+    /**
+     * Backoff
+     */
+    readonly Backoff: "backoff";
+    /**
+     * Static
+     */
+    readonly Static: "static";
+};
+/**
+ * The algorithm to use when performing HTTP retries
+ */
+export type HealthCheckCollectMethodGetRetryType = OpenEnum<typeof HealthCheckCollectMethodGetRetryType>;
+export type HealthCheckCollectMethodGetRetryRules = {
+    /**
+     * The algorithm to use when performing HTTP retries
+     */
+    type?: HealthCheckCollectMethodGetRetryType | undefined;
+    interval?: any | undefined;
+    limit?: any | undefined;
+    multiplier?: any | undefined;
+    codes?: any | undefined;
+    enableHeader?: any | undefined;
+};
+export type HealthCheckCollectMethodGet = {
+    /**
+     * Health check HTTP method.
+     */
+    collectMethod?: HealthCheckCollectMethodGetHealthCheckMethod | undefined;
+    collectRequestParams?: any | undefined;
+    discovery?: HealthCheckCollectMethodGetDiscovery | undefined;
+    /**
+     * Expression to derive URL to use for the health check operation (can be a constant).
+     */
+    collectUrl: string;
+    collectBody?: any | undefined;
+    /**
+     * Optional health check request headers.
+     */
+    collectRequestHeaders?: Array<HealthCheckCollectMethodGetCollectRequestHeader> | undefined;
+    /**
+     * Enable to make auth health check call.
+     */
+    authenticateCollect?: boolean | undefined;
+    /**
+     * Authentication method for Discover and Collect REST calls. You can specify API Key–based authentication by adding the appropriate Collect headers.
+     */
+    authentication?: HealthCheckCollectMethodGetAuthentication | undefined;
+    /**
+     * HTTP request inactivity timeout, use 0 to disable
+     */
+    timeout?: number | undefined;
+    /**
+     * Whether to reject certificates that cannot be verified against a valid CA (e.g., self-signed certificates).
+     */
+    rejectUnauthorized?: boolean | undefined;
+    defaultBreakers?: HealthCheckCollectMethodGetHiddenDefaultBreakers | undefined;
+    /**
+     * List of headers that are safe to log in plain text.
+     */
+    safeHeaders?: Array<string> | undefined;
+    retryRules?: HealthCheckCollectMethodGetRetryRules | undefined;
+};
+export type HealthCheckCollectorConf = HealthCheckAuthenticationNone | HealthCheckAuthenticationBasic | HealthCheckAuthenticationBasicSecret | HealthCheckAuthenticationLogin | HealthCheckAuthenticationLoginSecret | HealthCheckAuthenticationOauth | HealthCheckAuthenticationOauthSecret;
+/** @internal */
+export declare const HealthCheckAuthenticationOauthSecretAuthRequestParam$inboundSchema: z.ZodType<HealthCheckAuthenticationOauthSecretAuthRequestParam, z.ZodTypeDef, unknown>;
+/** @internal */
+export type HealthCheckAuthenticationOauthSecretAuthRequestParam$Outbound = {
+    name: string;
+    value: string;
+};
+/** @internal */
+export declare const HealthCheckAuthenticationOauthSecretAuthRequestParam$outboundSchema: z.ZodType<HealthCheckAuthenticationOauthSecretAuthRequestParam$Outbound, z.ZodTypeDef, HealthCheckAuthenticationOauthSecretAuthRequestParam>;
+export declare function healthCheckAuthenticationOauthSecretAuthRequestParamToJSON(healthCheckAuthenticationOauthSecretAuthRequestParam: HealthCheckAuthenticationOauthSecretAuthRequestParam): string;
+export declare function healthCheckAuthenticationOauthSecretAuthRequestParamFromJSON(jsonString: string): SafeParseResult<HealthCheckAuthenticationOauthSecretAuthRequestParam, SDKValidationError>;
+/** @internal */
+export declare const HealthCheckAuthenticationOauthSecretAuthRequestHeader$inboundSchema: z.ZodType<HealthCheckAuthenticationOauthSecretAuthRequestHeader, z.ZodTypeDef, unknown>;
+/** @internal */
+export type HealthCheckAuthenticationOauthSecretAuthRequestHeader$Outbound = {
+    name: string;
+    value: string;
+};
+/** @internal */
+export declare const HealthCheckAuthenticationOauthSecretAuthRequestHeader$outboundSchema: z.ZodType<HealthCheckAuthenticationOauthSecretAuthRequestHeader$Outbound, z.ZodTypeDef, HealthCheckAuthenticationOauthSecretAuthRequestHeader>;
+export declare function healthCheckAuthenticationOauthSecretAuthRequestHeaderToJSON(healthCheckAuthenticationOauthSecretAuthRequestHeader: HealthCheckAuthenticationOauthSecretAuthRequestHeader): string;
+export declare function healthCheckAuthenticationOauthSecretAuthRequestHeaderFromJSON(jsonString: string): SafeParseResult<HealthCheckAuthenticationOauthSecretAuthRequestHeader, SDKValidationError>;
+/** @internal */
+export declare const HealthCheckAuthenticationOauthSecretDiscoverType$inboundSchema: z.ZodType<HealthCheckAuthenticationOauthSecretDiscoverType, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const HealthCheckAuthenticationOauthSecretDiscoverType$outboundSchema: z.ZodType<string, z.ZodTypeDef, HealthCheckAuthenticationOauthSecretDiscoverType>;
+/** @internal */
+export declare const HealthCheckAuthenticationOauthSecretDiscovery$inboundSchema: z.ZodType<HealthCheckAuthenticationOauthSecretDiscovery, z.ZodTypeDef, unknown>;
+/** @internal */
+export type HealthCheckAuthenticationOauthSecretDiscovery$Outbound = {
+    discoverType: string;
+};
+/** @internal */
+export declare const HealthCheckAuthenticationOauthSecretDiscovery$outboundSchema: z.ZodType<HealthCheckAuthenticationOauthSecretDiscovery$Outbound, z.ZodTypeDef, HealthCheckAuthenticationOauthSecretDiscovery>;
+export declare function healthCheckAuthenticationOauthSecretDiscoveryToJSON(healthCheckAuthenticationOauthSecretDiscovery: HealthCheckAuthenticationOauthSecretDiscovery): string;
+export declare function healthCheckAuthenticationOauthSecretDiscoveryFromJSON(jsonString: string): SafeParseResult<HealthCheckAuthenticationOauthSecretDiscovery, SDKValidationError>;
+/** @internal */
+export declare const HealthCheckAuthenticationOauthSecretHealthCheckMethod$inboundSchema: z.ZodType<HealthCheckAuthenticationOauthSecretHealthCheckMethod, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const HealthCheckAuthenticationOauthSecretHealthCheckMethod$outboundSchema: z.ZodType<string, z.ZodTypeDef, HealthCheckAuthenticationOauthSecretHealthCheckMethod>;
+/** @internal */
+export declare const HealthCheckAuthenticationOauthSecretCollectRequestHeader$inboundSchema: z.ZodType<HealthCheckAuthenticationOauthSecretCollectRequestHeader, z.ZodTypeDef, unknown>;
+/** @internal */
+export type HealthCheckAuthenticationOauthSecretCollectRequestHeader$Outbound = {
+    name: string;
+    value: string;
+};
+/** @internal */
+export declare const HealthCheckAuthenticationOauthSecretCollectRequestHeader$outboundSchema: z.ZodType<HealthCheckAuthenticationOauthSecretCollectRequestHeader$Outbound, z.ZodTypeDef, HealthCheckAuthenticationOauthSecretCollectRequestHeader>;
+export declare function healthCheckAuthenticationOauthSecretCollectRequestHeaderToJSON(healthCheckAuthenticationOauthSecretCollectRequestHeader: HealthCheckAuthenticationOauthSecretCollectRequestHeader): string;
+export declare function healthCheckAuthenticationOauthSecretCollectRequestHeaderFromJSON(jsonString: string): SafeParseResult<HealthCheckAuthenticationOauthSecretCollectRequestHeader, SDKValidationError>;
+/** @internal */
+export declare const HealthCheckAuthenticationOauthSecretHiddenDefaultBreakers$inboundSchema: z.ZodType<HealthCheckAuthenticationOauthSecretHiddenDefaultBreakers, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const HealthCheckAuthenticationOauthSecretHiddenDefaultBreakers$outboundSchema: z.ZodType<string, z.ZodTypeDef, HealthCheckAuthenticationOauthSecretHiddenDefaultBreakers>;
+/** @internal */
+export declare const HealthCheckAuthenticationOauthSecretRetryType$inboundSchema: z.ZodType<HealthCheckAuthenticationOauthSecretRetryType, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const HealthCheckAuthenticationOauthSecretRetryType$outboundSchema: z.ZodType<string, z.ZodTypeDef, HealthCheckAuthenticationOauthSecretRetryType>;
+/** @internal */
+export declare const HealthCheckAuthenticationOauthSecretRetryRules$inboundSchema: z.ZodType<HealthCheckAuthenticationOauthSecretRetryRules, z.ZodTypeDef, unknown>;
+/** @internal */
+export type HealthCheckAuthenticationOauthSecretRetryRules$Outbound = {
+    type: string;
+    interval?: any | undefined;
+    limit?: any | undefined;
+    multiplier?: any | undefined;
+    codes?: any | undefined;
+    enableHeader?: any | undefined;
+};
+/** @internal */
+export declare const HealthCheckAuthenticationOauthSecretRetryRules$outboundSchema: z.ZodType<HealthCheckAuthenticationOauthSecretRetryRules$Outbound, z.ZodTypeDef, HealthCheckAuthenticationOauthSecretRetryRules>;
+export declare function healthCheckAuthenticationOauthSecretRetryRulesToJSON(healthCheckAuthenticationOauthSecretRetryRules: HealthCheckAuthenticationOauthSecretRetryRules): string;
+export declare function healthCheckAuthenticationOauthSecretRetryRulesFromJSON(jsonString: string): SafeParseResult<HealthCheckAuthenticationOauthSecretRetryRules, SDKValidationError>;
+/** @internal */
+export declare const HealthCheckAuthenticationOauthSecret$inboundSchema: z.ZodType<HealthCheckAuthenticationOauthSecret, z.ZodTypeDef, unknown>;
+/** @internal */
+export type HealthCheckAuthenticationOauthSecret$Outbound = {
+    authentication: "oauthSecret";
+    loginUrl: string;
+    tokenRespAttribute?: string | undefined;
+    authHeaderExpr: string;
+    clientSecretParamName: string;
+    textSecret: string;
+    authRequestParams?: Array<HealthCheckAuthenticationOauthSecretAuthRequestParam$Outbound> | undefined;
+    authRequestHeaders?: Array<HealthCheckAuthenticationOauthSecretAuthRequestHeader$Outbound> | undefined;
+    discovery?: HealthCheckAuthenticationOauthSecretDiscovery$Outbound | undefined;
+    collectUrl: string;
+    collectMethod: string;
+    collectRequestParams?: any | undefined;
+    collectBody?: any | undefined;
+    collectRequestHeaders?: Array<HealthCheckAuthenticationOauthSecretCollectRequestHeader$Outbound> | undefined;
+    authenticateCollect: boolean;
+    timeout: number;
+    rejectUnauthorized: boolean;
+    defaultBreakers?: string | undefined;
+    safeHeaders?: Array<string> | undefined;
+    retryRules?: HealthCheckAuthenticationOauthSecretRetryRules$Outbound | undefined;
+};
+/** @internal */
+export declare const HealthCheckAuthenticationOauthSecret$outboundSchema: z.ZodType<HealthCheckAuthenticationOauthSecret$Outbound, z.ZodTypeDef, HealthCheckAuthenticationOauthSecret>;
+export declare function healthCheckAuthenticationOauthSecretToJSON(healthCheckAuthenticationOauthSecret: HealthCheckAuthenticationOauthSecret): string;
+export declare function healthCheckAuthenticationOauthSecretFromJSON(jsonString: string): SafeParseResult<HealthCheckAuthenticationOauthSecret, SDKValidationError>;
+/** @internal */
+export declare const HealthCheckAuthenticationOauthAuthRequestParam$inboundSchema: z.ZodType<HealthCheckAuthenticationOauthAuthRequestParam, z.ZodTypeDef, unknown>;
+/** @internal */
+export type HealthCheckAuthenticationOauthAuthRequestParam$Outbound = {
+    name: string;
+    value: string;
+};
+/** @internal */
+export declare const HealthCheckAuthenticationOauthAuthRequestParam$outboundSchema: z.ZodType<HealthCheckAuthenticationOauthAuthRequestParam$Outbound, z.ZodTypeDef, HealthCheckAuthenticationOauthAuthRequestParam>;
+export declare function healthCheckAuthenticationOauthAuthRequestParamToJSON(healthCheckAuthenticationOauthAuthRequestParam: HealthCheckAuthenticationOauthAuthRequestParam): string;
+export declare function healthCheckAuthenticationOauthAuthRequestParamFromJSON(jsonString: string): SafeParseResult<HealthCheckAuthenticationOauthAuthRequestParam, SDKValidationError>;
+/** @internal */
+export declare const HealthCheckAuthenticationOauthAuthRequestHeader$inboundSchema: z.ZodType<HealthCheckAuthenticationOauthAuthRequestHeader, z.ZodTypeDef, unknown>;
+/** @internal */
+export type HealthCheckAuthenticationOauthAuthRequestHeader$Outbound = {
+    name: string;
+    value: string;
+};
+/** @internal */
+export declare const HealthCheckAuthenticationOauthAuthRequestHeader$outboundSchema: z.ZodType<HealthCheckAuthenticationOauthAuthRequestHeader$Outbound, z.ZodTypeDef, HealthCheckAuthenticationOauthAuthRequestHeader>;
+export declare function healthCheckAuthenticationOauthAuthRequestHeaderToJSON(healthCheckAuthenticationOauthAuthRequestHeader: HealthCheckAuthenticationOauthAuthRequestHeader): string;
+export declare function healthCheckAuthenticationOauthAuthRequestHeaderFromJSON(jsonString: string): SafeParseResult<HealthCheckAuthenticationOauthAuthRequestHeader, SDKValidationError>;
+/** @internal */
+export declare const HealthCheckAuthenticationOauthDiscoverType$inboundSchema: z.ZodType<HealthCheckAuthenticationOauthDiscoverType, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const HealthCheckAuthenticationOauthDiscoverType$outboundSchema: z.ZodType<string, z.ZodTypeDef, HealthCheckAuthenticationOauthDiscoverType>;
+/** @internal */
+export declare const HealthCheckAuthenticationOauthDiscovery$inboundSchema: z.ZodType<HealthCheckAuthenticationOauthDiscovery, z.ZodTypeDef, unknown>;
+/** @internal */
+export type HealthCheckAuthenticationOauthDiscovery$Outbound = {
+    discoverType: string;
+};
+/** @internal */
+export declare const HealthCheckAuthenticationOauthDiscovery$outboundSchema: z.ZodType<HealthCheckAuthenticationOauthDiscovery$Outbound, z.ZodTypeDef, HealthCheckAuthenticationOauthDiscovery>;
+export declare function healthCheckAuthenticationOauthDiscoveryToJSON(healthCheckAuthenticationOauthDiscovery: HealthCheckAuthenticationOauthDiscovery): string;
+export declare function healthCheckAuthenticationOauthDiscoveryFromJSON(jsonString: string): SafeParseResult<HealthCheckAuthenticationOauthDiscovery, SDKValidationError>;
+/** @internal */
+export declare const HealthCheckAuthenticationOauthHealthCheckMethod$inboundSchema: z.ZodType<HealthCheckAuthenticationOauthHealthCheckMethod, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const HealthCheckAuthenticationOauthHealthCheckMethod$outboundSchema: z.ZodType<string, z.ZodTypeDef, HealthCheckAuthenticationOauthHealthCheckMethod>;
+/** @internal */
+export declare const HealthCheckAuthenticationOauthCollectRequestHeader$inboundSchema: z.ZodType<HealthCheckAuthenticationOauthCollectRequestHeader, z.ZodTypeDef, unknown>;
+/** @internal */
+export type HealthCheckAuthenticationOauthCollectRequestHeader$Outbound = {
+    name: string;
+    value: string;
+};
+/** @internal */
+export declare const HealthCheckAuthenticationOauthCollectRequestHeader$outboundSchema: z.ZodType<HealthCheckAuthenticationOauthCollectRequestHeader$Outbound, z.ZodTypeDef, HealthCheckAuthenticationOauthCollectRequestHeader>;
+export declare function healthCheckAuthenticationOauthCollectRequestHeaderToJSON(healthCheckAuthenticationOauthCollectRequestHeader: HealthCheckAuthenticationOauthCollectRequestHeader): string;
+export declare function healthCheckAuthenticationOauthCollectRequestHeaderFromJSON(jsonString: string): SafeParseResult<HealthCheckAuthenticationOauthCollectRequestHeader, SDKValidationError>;
+/** @internal */
+export declare const HealthCheckAuthenticationOauthHiddenDefaultBreakers$inboundSchema: z.ZodType<HealthCheckAuthenticationOauthHiddenDefaultBreakers, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const HealthCheckAuthenticationOauthHiddenDefaultBreakers$outboundSchema: z.ZodType<string, z.ZodTypeDef, HealthCheckAuthenticationOauthHiddenDefaultBreakers>;
+/** @internal */
+export declare const HealthCheckAuthenticationOauthRetryType$inboundSchema: z.ZodType<HealthCheckAuthenticationOauthRetryType, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const HealthCheckAuthenticationOauthRetryType$outboundSchema: z.ZodType<string, z.ZodTypeDef, HealthCheckAuthenticationOauthRetryType>;
+/** @internal */
+export declare const HealthCheckAuthenticationOauthRetryRules$inboundSchema: z.ZodType<HealthCheckAuthenticationOauthRetryRules, z.ZodTypeDef, unknown>;
+/** @internal */
+export type HealthCheckAuthenticationOauthRetryRules$Outbound = {
+    type: string;
+    interval?: any | undefined;
+    limit?: any | undefined;
+    multiplier?: any | undefined;
+    codes?: any | undefined;
+    enableHeader?: any | undefined;
+};
+/** @internal */
+export declare const HealthCheckAuthenticationOauthRetryRules$outboundSchema: z.ZodType<HealthCheckAuthenticationOauthRetryRules$Outbound, z.ZodTypeDef, HealthCheckAuthenticationOauthRetryRules>;
+export declare function healthCheckAuthenticationOauthRetryRulesToJSON(healthCheckAuthenticationOauthRetryRules: HealthCheckAuthenticationOauthRetryRules): string;
+export declare function healthCheckAuthenticationOauthRetryRulesFromJSON(jsonString: string): SafeParseResult<HealthCheckAuthenticationOauthRetryRules, SDKValidationError>;
+/** @internal */
+export declare const HealthCheckAuthenticationOauth$inboundSchema: z.ZodType<HealthCheckAuthenticationOauth, z.ZodTypeDef, unknown>;
+/** @internal */
+export type HealthCheckAuthenticationOauth$Outbound = {
+    authentication: "oauth";
+    loginUrl: string;
+    tokenRespAttribute?: string | undefined;
+    authHeaderExpr: string;
+    clientSecretParamName: string;
+    clientSecretParamValue: string;
+    authRequestParams?: Array<HealthCheckAuthenticationOauthAuthRequestParam$Outbound> | undefined;
+    authRequestHeaders?: Array<HealthCheckAuthenticationOauthAuthRequestHeader$Outbound> | undefined;
+    discovery?: HealthCheckAuthenticationOauthDiscovery$Outbound | undefined;
+    collectUrl: string;
+    collectMethod: string;
+    collectRequestParams?: any | undefined;
+    collectBody?: any | undefined;
+    collectRequestHeaders?: Array<HealthCheckAuthenticationOauthCollectRequestHeader$Outbound> | undefined;
+    authenticateCollect: boolean;
+    timeout: number;
+    rejectUnauthorized: boolean;
+    defaultBreakers?: string | undefined;
+    safeHeaders?: Array<string> | undefined;
+    retryRules?: HealthCheckAuthenticationOauthRetryRules$Outbound | undefined;
+};
+/** @internal */
+export declare const HealthCheckAuthenticationOauth$outboundSchema: z.ZodType<HealthCheckAuthenticationOauth$Outbound, z.ZodTypeDef, HealthCheckAuthenticationOauth>;
+export declare function healthCheckAuthenticationOauthToJSON(healthCheckAuthenticationOauth: HealthCheckAuthenticationOauth): string;
+export declare function healthCheckAuthenticationOauthFromJSON(jsonString: string): SafeParseResult<HealthCheckAuthenticationOauth, SDKValidationError>;
+/** @internal */
+export declare const HealthCheckAuthenticationLoginSecretAuthRequestHeader$inboundSchema: z.ZodType<HealthCheckAuthenticationLoginSecretAuthRequestHeader, z.ZodTypeDef, unknown>;
+/** @internal */
+export type HealthCheckAuthenticationLoginSecretAuthRequestHeader$Outbound = {
+    name: string;
+    value: string;
+};
+/** @internal */
+export declare const HealthCheckAuthenticationLoginSecretAuthRequestHeader$outboundSchema: z.ZodType<HealthCheckAuthenticationLoginSecretAuthRequestHeader$Outbound, z.ZodTypeDef, HealthCheckAuthenticationLoginSecretAuthRequestHeader>;
+export declare function healthCheckAuthenticationLoginSecretAuthRequestHeaderToJSON(healthCheckAuthenticationLoginSecretAuthRequestHeader: HealthCheckAuthenticationLoginSecretAuthRequestHeader): string;
+export declare function healthCheckAuthenticationLoginSecretAuthRequestHeaderFromJSON(jsonString: string): SafeParseResult<HealthCheckAuthenticationLoginSecretAuthRequestHeader, SDKValidationError>;
+/** @internal */
+export declare const HealthCheckAuthenticationLoginSecretDiscoverType$inboundSchema: z.ZodType<HealthCheckAuthenticationLoginSecretDiscoverType, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const HealthCheckAuthenticationLoginSecretDiscoverType$outboundSchema: z.ZodType<string, z.ZodTypeDef, HealthCheckAuthenticationLoginSecretDiscoverType>;
+/** @internal */
+export declare const HealthCheckAuthenticationLoginSecretDiscovery$inboundSchema: z.ZodType<HealthCheckAuthenticationLoginSecretDiscovery, z.ZodTypeDef, unknown>;
+/** @internal */
+export type HealthCheckAuthenticationLoginSecretDiscovery$Outbound = {
+    discoverType: string;
+};
+/** @internal */
+export declare const HealthCheckAuthenticationLoginSecretDiscovery$outboundSchema: z.ZodType<HealthCheckAuthenticationLoginSecretDiscovery$Outbound, z.ZodTypeDef, HealthCheckAuthenticationLoginSecretDiscovery>;
+export declare function healthCheckAuthenticationLoginSecretDiscoveryToJSON(healthCheckAuthenticationLoginSecretDiscovery: HealthCheckAuthenticationLoginSecretDiscovery): string;
+export declare function healthCheckAuthenticationLoginSecretDiscoveryFromJSON(jsonString: string): SafeParseResult<HealthCheckAuthenticationLoginSecretDiscovery, SDKValidationError>;
+/** @internal */
+export declare const HealthCheckAuthenticationLoginSecretHealthCheckMethod$inboundSchema: z.ZodType<HealthCheckAuthenticationLoginSecretHealthCheckMethod, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const HealthCheckAuthenticationLoginSecretHealthCheckMethod$outboundSchema: z.ZodType<string, z.ZodTypeDef, HealthCheckAuthenticationLoginSecretHealthCheckMethod>;
+/** @internal */
+export declare const HealthCheckAuthenticationLoginSecretCollectRequestHeader$inboundSchema: z.ZodType<HealthCheckAuthenticationLoginSecretCollectRequestHeader, z.ZodTypeDef, unknown>;
+/** @internal */
+export type HealthCheckAuthenticationLoginSecretCollectRequestHeader$Outbound = {
+    name: string;
+    value: string;
+};
+/** @internal */
+export declare const HealthCheckAuthenticationLoginSecretCollectRequestHeader$outboundSchema: z.ZodType<HealthCheckAuthenticationLoginSecretCollectRequestHeader$Outbound, z.ZodTypeDef, HealthCheckAuthenticationLoginSecretCollectRequestHeader>;
+export declare function healthCheckAuthenticationLoginSecretCollectRequestHeaderToJSON(healthCheckAuthenticationLoginSecretCollectRequestHeader: HealthCheckAuthenticationLoginSecretCollectRequestHeader): string;
+export declare function healthCheckAuthenticationLoginSecretCollectRequestHeaderFromJSON(jsonString: string): SafeParseResult<HealthCheckAuthenticationLoginSecretCollectRequestHeader, SDKValidationError>;
+/** @internal */
+export declare const HealthCheckAuthenticationLoginSecretHiddenDefaultBreakers$inboundSchema: z.ZodType<HealthCheckAuthenticationLoginSecretHiddenDefaultBreakers, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const HealthCheckAuthenticationLoginSecretHiddenDefaultBreakers$outboundSchema: z.ZodType<string, z.ZodTypeDef, HealthCheckAuthenticationLoginSecretHiddenDefaultBreakers>;
+/** @internal */
+export declare const HealthCheckAuthenticationLoginSecretRetryType$inboundSchema: z.ZodType<HealthCheckAuthenticationLoginSecretRetryType, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const HealthCheckAuthenticationLoginSecretRetryType$outboundSchema: z.ZodType<string, z.ZodTypeDef, HealthCheckAuthenticationLoginSecretRetryType>;
+/** @internal */
+export declare const HealthCheckAuthenticationLoginSecretRetryRules$inboundSchema: z.ZodType<HealthCheckAuthenticationLoginSecretRetryRules, z.ZodTypeDef, unknown>;
+/** @internal */
+export type HealthCheckAuthenticationLoginSecretRetryRules$Outbound = {
+    type: string;
+    interval?: any | undefined;
+    limit?: any | undefined;
+    multiplier?: any | undefined;
+    codes?: any | undefined;
+    enableHeader?: any | undefined;
+};
+/** @internal */
+export declare const HealthCheckAuthenticationLoginSecretRetryRules$outboundSchema: z.ZodType<HealthCheckAuthenticationLoginSecretRetryRules$Outbound, z.ZodTypeDef, HealthCheckAuthenticationLoginSecretRetryRules>;
+export declare function healthCheckAuthenticationLoginSecretRetryRulesToJSON(healthCheckAuthenticationLoginSecretRetryRules: HealthCheckAuthenticationLoginSecretRetryRules): string;
+export declare function healthCheckAuthenticationLoginSecretRetryRulesFromJSON(jsonString: string): SafeParseResult<HealthCheckAuthenticationLoginSecretRetryRules, SDKValidationError>;
+/** @internal */
+export declare const HealthCheckAuthenticationLoginSecret$inboundSchema: z.ZodType<HealthCheckAuthenticationLoginSecret, z.ZodTypeDef, unknown>;
+/** @internal */
+export type HealthCheckAuthenticationLoginSecret$Outbound = {
+    authentication: "loginSecret";
+    loginUrl: string;
+    credentialsSecret: string;
+    loginBody: string;
+    tokenRespAttribute?: string | undefined;
+    authHeaderExpr: string;
+    authRequestHeaders?: Array<HealthCheckAuthenticationLoginSecretAuthRequestHeader$Outbound> | undefined;
+    discovery?: HealthCheckAuthenticationLoginSecretDiscovery$Outbound | undefined;
+    collectUrl: string;
+    collectMethod: string;
+    collectRequestParams?: any | undefined;
+    collectBody?: any | undefined;
+    collectRequestHeaders?: Array<HealthCheckAuthenticationLoginSecretCollectRequestHeader$Outbound> | undefined;
+    authenticateCollect: boolean;
+    timeout: number;
+    rejectUnauthorized: boolean;
+    defaultBreakers?: string | undefined;
+    safeHeaders?: Array<string> | undefined;
+    retryRules?: HealthCheckAuthenticationLoginSecretRetryRules$Outbound | undefined;
+};
+/** @internal */
+export declare const HealthCheckAuthenticationLoginSecret$outboundSchema: z.ZodType<HealthCheckAuthenticationLoginSecret$Outbound, z.ZodTypeDef, HealthCheckAuthenticationLoginSecret>;
+export declare function healthCheckAuthenticationLoginSecretToJSON(healthCheckAuthenticationLoginSecret: HealthCheckAuthenticationLoginSecret): string;
+export declare function healthCheckAuthenticationLoginSecretFromJSON(jsonString: string): SafeParseResult<HealthCheckAuthenticationLoginSecret, SDKValidationError>;
+/** @internal */
+export declare const HealthCheckAuthenticationLoginAuthRequestHeader$inboundSchema: z.ZodType<HealthCheckAuthenticationLoginAuthRequestHeader, z.ZodTypeDef, unknown>;
+/** @internal */
+export type HealthCheckAuthenticationLoginAuthRequestHeader$Outbound = {
+    name: string;
+    value: string;
+};
+/** @internal */
+export declare const HealthCheckAuthenticationLoginAuthRequestHeader$outboundSchema: z.ZodType<HealthCheckAuthenticationLoginAuthRequestHeader$Outbound, z.ZodTypeDef, HealthCheckAuthenticationLoginAuthRequestHeader>;
+export declare function healthCheckAuthenticationLoginAuthRequestHeaderToJSON(healthCheckAuthenticationLoginAuthRequestHeader: HealthCheckAuthenticationLoginAuthRequestHeader): string;
+export declare function healthCheckAuthenticationLoginAuthRequestHeaderFromJSON(jsonString: string): SafeParseResult<HealthCheckAuthenticationLoginAuthRequestHeader, SDKValidationError>;
+/** @internal */
+export declare const HealthCheckAuthenticationLoginDiscoverType$inboundSchema: z.ZodType<HealthCheckAuthenticationLoginDiscoverType, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const HealthCheckAuthenticationLoginDiscoverType$outboundSchema: z.ZodType<string, z.ZodTypeDef, HealthCheckAuthenticationLoginDiscoverType>;
+/** @internal */
+export declare const HealthCheckAuthenticationLoginDiscovery$inboundSchema: z.ZodType<HealthCheckAuthenticationLoginDiscovery, z.ZodTypeDef, unknown>;
+/** @internal */
+export type HealthCheckAuthenticationLoginDiscovery$Outbound = {
+    discoverType: string;
+};
+/** @internal */
+export declare const HealthCheckAuthenticationLoginDiscovery$outboundSchema: z.ZodType<HealthCheckAuthenticationLoginDiscovery$Outbound, z.ZodTypeDef, HealthCheckAuthenticationLoginDiscovery>;
+export declare function healthCheckAuthenticationLoginDiscoveryToJSON(healthCheckAuthenticationLoginDiscovery: HealthCheckAuthenticationLoginDiscovery): string;
+export declare function healthCheckAuthenticationLoginDiscoveryFromJSON(jsonString: string): SafeParseResult<HealthCheckAuthenticationLoginDiscovery, SDKValidationError>;
+/** @internal */
+export declare const HealthCheckAuthenticationLoginHealthCheckMethod$inboundSchema: z.ZodType<HealthCheckAuthenticationLoginHealthCheckMethod, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const HealthCheckAuthenticationLoginHealthCheckMethod$outboundSchema: z.ZodType<string, z.ZodTypeDef, HealthCheckAuthenticationLoginHealthCheckMethod>;
+/** @internal */
+export declare const HealthCheckAuthenticationLoginCollectRequestHeader$inboundSchema: z.ZodType<HealthCheckAuthenticationLoginCollectRequestHeader, z.ZodTypeDef, unknown>;
+/** @internal */
+export type HealthCheckAuthenticationLoginCollectRequestHeader$Outbound = {
+    name: string;
+    value: string;
+};
+/** @internal */
+export declare const HealthCheckAuthenticationLoginCollectRequestHeader$outboundSchema: z.ZodType<HealthCheckAuthenticationLoginCollectRequestHeader$Outbound, z.ZodTypeDef, HealthCheckAuthenticationLoginCollectRequestHeader>;
+export declare function healthCheckAuthenticationLoginCollectRequestHeaderToJSON(healthCheckAuthenticationLoginCollectRequestHeader: HealthCheckAuthenticationLoginCollectRequestHeader): string;
+export declare function healthCheckAuthenticationLoginCollectRequestHeaderFromJSON(jsonString: string): SafeParseResult<HealthCheckAuthenticationLoginCollectRequestHeader, SDKValidationError>;
+/** @internal */
+export declare const HealthCheckAuthenticationLoginHiddenDefaultBreakers$inboundSchema: z.ZodType<HealthCheckAuthenticationLoginHiddenDefaultBreakers, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const HealthCheckAuthenticationLoginHiddenDefaultBreakers$outboundSchema: z.ZodType<string, z.ZodTypeDef, HealthCheckAuthenticationLoginHiddenDefaultBreakers>;
+/** @internal */
+export declare const HealthCheckAuthenticationLoginRetryType$inboundSchema: z.ZodType<HealthCheckAuthenticationLoginRetryType, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const HealthCheckAuthenticationLoginRetryType$outboundSchema: z.ZodType<string, z.ZodTypeDef, HealthCheckAuthenticationLoginRetryType>;
+/** @internal */
+export declare const HealthCheckAuthenticationLoginRetryRules$inboundSchema: z.ZodType<HealthCheckAuthenticationLoginRetryRules, z.ZodTypeDef, unknown>;
+/** @internal */
+export type HealthCheckAuthenticationLoginRetryRules$Outbound = {
+    type: string;
+    interval?: any | undefined;
+    limit?: any | undefined;
+    multiplier?: any | undefined;
+    codes?: any | undefined;
+    enableHeader?: any | undefined;
+};
+/** @internal */
+export declare const HealthCheckAuthenticationLoginRetryRules$outboundSchema: z.ZodType<HealthCheckAuthenticationLoginRetryRules$Outbound, z.ZodTypeDef, HealthCheckAuthenticationLoginRetryRules>;
+export declare function healthCheckAuthenticationLoginRetryRulesToJSON(healthCheckAuthenticationLoginRetryRules: HealthCheckAuthenticationLoginRetryRules): string;
+export declare function healthCheckAuthenticationLoginRetryRulesFromJSON(jsonString: string): SafeParseResult<HealthCheckAuthenticationLoginRetryRules, SDKValidationError>;
+/** @internal */
+export declare const HealthCheckAuthenticationLogin$inboundSchema: z.ZodType<HealthCheckAuthenticationLogin, z.ZodTypeDef, unknown>;
+/** @internal */
+export type HealthCheckAuthenticationLogin$Outbound = {
+    authentication: "login";
+    loginUrl: string;
+    username: string;
+    password: string;
+    loginBody: string;
+    tokenRespAttribute?: string | undefined;
+    authHeaderExpr: string;
+    authRequestHeaders?: Array<HealthCheckAuthenticationLoginAuthRequestHeader$Outbound> | undefined;
+    discovery?: HealthCheckAuthenticationLoginDiscovery$Outbound | undefined;
+    collectUrl: string;
+    collectMethod: string;
+    collectRequestParams?: any | undefined;
+    collectBody?: any | undefined;
+    collectRequestHeaders?: Array<HealthCheckAuthenticationLoginCollectRequestHeader$Outbound> | undefined;
+    authenticateCollect: boolean;
+    timeout: number;
+    rejectUnauthorized: boolean;
+    defaultBreakers?: string | undefined;
+    safeHeaders?: Array<string> | undefined;
+    retryRules?: HealthCheckAuthenticationLoginRetryRules$Outbound | undefined;
+};
+/** @internal */
+export declare const HealthCheckAuthenticationLogin$outboundSchema: z.ZodType<HealthCheckAuthenticationLogin$Outbound, z.ZodTypeDef, HealthCheckAuthenticationLogin>;
+export declare function healthCheckAuthenticationLoginToJSON(healthCheckAuthenticationLogin: HealthCheckAuthenticationLogin): string;
+export declare function healthCheckAuthenticationLoginFromJSON(jsonString: string): SafeParseResult<HealthCheckAuthenticationLogin, SDKValidationError>;
+/** @internal */
+export declare const HealthCheckAuthenticationBasicSecretDiscoverType$inboundSchema: z.ZodType<HealthCheckAuthenticationBasicSecretDiscoverType, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const HealthCheckAuthenticationBasicSecretDiscoverType$outboundSchema: z.ZodType<string, z.ZodTypeDef, HealthCheckAuthenticationBasicSecretDiscoverType>;
+/** @internal */
+export declare const HealthCheckAuthenticationBasicSecretDiscovery$inboundSchema: z.ZodType<HealthCheckAuthenticationBasicSecretDiscovery, z.ZodTypeDef, unknown>;
+/** @internal */
+export type HealthCheckAuthenticationBasicSecretDiscovery$Outbound = {
+    discoverType: string;
+};
+/** @internal */
+export declare const HealthCheckAuthenticationBasicSecretDiscovery$outboundSchema: z.ZodType<HealthCheckAuthenticationBasicSecretDiscovery$Outbound, z.ZodTypeDef, HealthCheckAuthenticationBasicSecretDiscovery>;
+export declare function healthCheckAuthenticationBasicSecretDiscoveryToJSON(healthCheckAuthenticationBasicSecretDiscovery: HealthCheckAuthenticationBasicSecretDiscovery): string;
+export declare function healthCheckAuthenticationBasicSecretDiscoveryFromJSON(jsonString: string): SafeParseResult<HealthCheckAuthenticationBasicSecretDiscovery, SDKValidationError>;
+/** @internal */
+export declare const HealthCheckAuthenticationBasicSecretHealthCheckMethod$inboundSchema: z.ZodType<HealthCheckAuthenticationBasicSecretHealthCheckMethod, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const HealthCheckAuthenticationBasicSecretHealthCheckMethod$outboundSchema: z.ZodType<string, z.ZodTypeDef, HealthCheckAuthenticationBasicSecretHealthCheckMethod>;
+/** @internal */
+export declare const HealthCheckAuthenticationBasicSecretCollectRequestHeader$inboundSchema: z.ZodType<HealthCheckAuthenticationBasicSecretCollectRequestHeader, z.ZodTypeDef, unknown>;
+/** @internal */
+export type HealthCheckAuthenticationBasicSecretCollectRequestHeader$Outbound = {
+    name: string;
+    value: string;
+};
+/** @internal */
+export declare const HealthCheckAuthenticationBasicSecretCollectRequestHeader$outboundSchema: z.ZodType<HealthCheckAuthenticationBasicSecretCollectRequestHeader$Outbound, z.ZodTypeDef, HealthCheckAuthenticationBasicSecretCollectRequestHeader>;
+export declare function healthCheckAuthenticationBasicSecretCollectRequestHeaderToJSON(healthCheckAuthenticationBasicSecretCollectRequestHeader: HealthCheckAuthenticationBasicSecretCollectRequestHeader): string;
+export declare function healthCheckAuthenticationBasicSecretCollectRequestHeaderFromJSON(jsonString: string): SafeParseResult<HealthCheckAuthenticationBasicSecretCollectRequestHeader, SDKValidationError>;
+/** @internal */
+export declare const HealthCheckAuthenticationBasicSecretHiddenDefaultBreakers$inboundSchema: z.ZodType<HealthCheckAuthenticationBasicSecretHiddenDefaultBreakers, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const HealthCheckAuthenticationBasicSecretHiddenDefaultBreakers$outboundSchema: z.ZodType<string, z.ZodTypeDef, HealthCheckAuthenticationBasicSecretHiddenDefaultBreakers>;
+/** @internal */
+export declare const HealthCheckAuthenticationBasicSecretRetryType$inboundSchema: z.ZodType<HealthCheckAuthenticationBasicSecretRetryType, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const HealthCheckAuthenticationBasicSecretRetryType$outboundSchema: z.ZodType<string, z.ZodTypeDef, HealthCheckAuthenticationBasicSecretRetryType>;
+/** @internal */
+export declare const HealthCheckAuthenticationBasicSecretRetryRules$inboundSchema: z.ZodType<HealthCheckAuthenticationBasicSecretRetryRules, z.ZodTypeDef, unknown>;
+/** @internal */
+export type HealthCheckAuthenticationBasicSecretRetryRules$Outbound = {
+    type: string;
+    interval?: any | undefined;
+    limit?: any | undefined;
+    multiplier?: any | undefined;
+    codes?: any | undefined;
+    enableHeader?: any | undefined;
+};
+/** @internal */
+export declare const HealthCheckAuthenticationBasicSecretRetryRules$outboundSchema: z.ZodType<HealthCheckAuthenticationBasicSecretRetryRules$Outbound, z.ZodTypeDef, HealthCheckAuthenticationBasicSecretRetryRules>;
+export declare function healthCheckAuthenticationBasicSecretRetryRulesToJSON(healthCheckAuthenticationBasicSecretRetryRules: HealthCheckAuthenticationBasicSecretRetryRules): string;
+export declare function healthCheckAuthenticationBasicSecretRetryRulesFromJSON(jsonString: string): SafeParseResult<HealthCheckAuthenticationBasicSecretRetryRules, SDKValidationError>;
+/** @internal */
+export declare const HealthCheckAuthenticationBasicSecret$inboundSchema: z.ZodType<HealthCheckAuthenticationBasicSecret, z.ZodTypeDef, unknown>;
+/** @internal */
+export type HealthCheckAuthenticationBasicSecret$Outbound = {
+    authentication: "basicSecret";
+    credentialsSecret: string;
+    discovery?: HealthCheckAuthenticationBasicSecretDiscovery$Outbound | undefined;
+    collectUrl: string;
+    collectMethod: string;
+    collectRequestParams?: any | undefined;
+    collectBody?: any | undefined;
+    collectRequestHeaders?: Array<HealthCheckAuthenticationBasicSecretCollectRequestHeader$Outbound> | undefined;
+    authenticateCollect: boolean;
+    timeout: number;
+    rejectUnauthorized: boolean;
+    defaultBreakers?: string | undefined;
+    safeHeaders?: Array<string> | undefined;
+    retryRules?: HealthCheckAuthenticationBasicSecretRetryRules$Outbound | undefined;
+};
+/** @internal */
+export declare const HealthCheckAuthenticationBasicSecret$outboundSchema: z.ZodType<HealthCheckAuthenticationBasicSecret$Outbound, z.ZodTypeDef, HealthCheckAuthenticationBasicSecret>;
+export declare function healthCheckAuthenticationBasicSecretToJSON(healthCheckAuthenticationBasicSecret: HealthCheckAuthenticationBasicSecret): string;
+export declare function healthCheckAuthenticationBasicSecretFromJSON(jsonString: string): SafeParseResult<HealthCheckAuthenticationBasicSecret, SDKValidationError>;
+/** @internal */
+export declare const HealthCheckAuthenticationBasicDiscoverType$inboundSchema: z.ZodType<HealthCheckAuthenticationBasicDiscoverType, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const HealthCheckAuthenticationBasicDiscoverType$outboundSchema: z.ZodType<string, z.ZodTypeDef, HealthCheckAuthenticationBasicDiscoverType>;
+/** @internal */
+export declare const HealthCheckAuthenticationBasicDiscovery$inboundSchema: z.ZodType<HealthCheckAuthenticationBasicDiscovery, z.ZodTypeDef, unknown>;
+/** @internal */
+export type HealthCheckAuthenticationBasicDiscovery$Outbound = {
+    discoverType: string;
+};
+/** @internal */
+export declare const HealthCheckAuthenticationBasicDiscovery$outboundSchema: z.ZodType<HealthCheckAuthenticationBasicDiscovery$Outbound, z.ZodTypeDef, HealthCheckAuthenticationBasicDiscovery>;
+export declare function healthCheckAuthenticationBasicDiscoveryToJSON(healthCheckAuthenticationBasicDiscovery: HealthCheckAuthenticationBasicDiscovery): string;
+export declare function healthCheckAuthenticationBasicDiscoveryFromJSON(jsonString: string): SafeParseResult<HealthCheckAuthenticationBasicDiscovery, SDKValidationError>;
+/** @internal */
+export declare const HealthCheckAuthenticationBasicHealthCheckMethod$inboundSchema: z.ZodType<HealthCheckAuthenticationBasicHealthCheckMethod, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const HealthCheckAuthenticationBasicHealthCheckMethod$outboundSchema: z.ZodType<string, z.ZodTypeDef, HealthCheckAuthenticationBasicHealthCheckMethod>;
+/** @internal */
+export declare const HealthCheckAuthenticationBasicCollectRequestHeader$inboundSchema: z.ZodType<HealthCheckAuthenticationBasicCollectRequestHeader, z.ZodTypeDef, unknown>;
+/** @internal */
+export type HealthCheckAuthenticationBasicCollectRequestHeader$Outbound = {
+    name: string;
+    value: string;
+};
+/** @internal */
+export declare const HealthCheckAuthenticationBasicCollectRequestHeader$outboundSchema: z.ZodType<HealthCheckAuthenticationBasicCollectRequestHeader$Outbound, z.ZodTypeDef, HealthCheckAuthenticationBasicCollectRequestHeader>;
+export declare function healthCheckAuthenticationBasicCollectRequestHeaderToJSON(healthCheckAuthenticationBasicCollectRequestHeader: HealthCheckAuthenticationBasicCollectRequestHeader): string;
+export declare function healthCheckAuthenticationBasicCollectRequestHeaderFromJSON(jsonString: string): SafeParseResult<HealthCheckAuthenticationBasicCollectRequestHeader, SDKValidationError>;
+/** @internal */
+export declare const HealthCheckAuthenticationBasicHiddenDefaultBreakers$inboundSchema: z.ZodType<HealthCheckAuthenticationBasicHiddenDefaultBreakers, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const HealthCheckAuthenticationBasicHiddenDefaultBreakers$outboundSchema: z.ZodType<string, z.ZodTypeDef, HealthCheckAuthenticationBasicHiddenDefaultBreakers>;
+/** @internal */
+export declare const HealthCheckAuthenticationBasicRetryType$inboundSchema: z.ZodType<HealthCheckAuthenticationBasicRetryType, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const HealthCheckAuthenticationBasicRetryType$outboundSchema: z.ZodType<string, z.ZodTypeDef, HealthCheckAuthenticationBasicRetryType>;
+/** @internal */
+export declare const HealthCheckAuthenticationBasicRetryRules$inboundSchema: z.ZodType<HealthCheckAuthenticationBasicRetryRules, z.ZodTypeDef, unknown>;
+/** @internal */
+export type HealthCheckAuthenticationBasicRetryRules$Outbound = {
+    type: string;
+    interval?: any | undefined;
+    limit?: any | undefined;
+    multiplier?: any | undefined;
+    codes?: any | undefined;
+    enableHeader?: any | undefined;
+};
+/** @internal */
+export declare const HealthCheckAuthenticationBasicRetryRules$outboundSchema: z.ZodType<HealthCheckAuthenticationBasicRetryRules$Outbound, z.ZodTypeDef, HealthCheckAuthenticationBasicRetryRules>;
+export declare function healthCheckAuthenticationBasicRetryRulesToJSON(healthCheckAuthenticationBasicRetryRules: HealthCheckAuthenticationBasicRetryRules): string;
+export declare function healthCheckAuthenticationBasicRetryRulesFromJSON(jsonString: string): SafeParseResult<HealthCheckAuthenticationBasicRetryRules, SDKValidationError>;
+/** @internal */
+export declare const HealthCheckAuthenticationBasic$inboundSchema: z.ZodType<HealthCheckAuthenticationBasic, z.ZodTypeDef, unknown>;
+/** @internal */
+export type HealthCheckAuthenticationBasic$Outbound = {
+    authentication: "basic";
+    username: string;
+    password: string;
+    discovery?: HealthCheckAuthenticationBasicDiscovery$Outbound | undefined;
+    collectUrl: string;
+    collectMethod: string;
+    collectRequestParams?: any | undefined;
+    collectBody?: any | undefined;
+    collectRequestHeaders?: Array<HealthCheckAuthenticationBasicCollectRequestHeader$Outbound> | undefined;
+    authenticateCollect: boolean;
+    timeout: number;
+    rejectUnauthorized: boolean;
+    defaultBreakers?: string | undefined;
+    safeHeaders?: Array<string> | undefined;
+    retryRules?: HealthCheckAuthenticationBasicRetryRules$Outbound | undefined;
+};
+/** @internal */
+export declare const HealthCheckAuthenticationBasic$outboundSchema: z.ZodType<HealthCheckAuthenticationBasic$Outbound, z.ZodTypeDef, HealthCheckAuthenticationBasic>;
+export declare function healthCheckAuthenticationBasicToJSON(healthCheckAuthenticationBasic: HealthCheckAuthenticationBasic): string;
+export declare function healthCheckAuthenticationBasicFromJSON(jsonString: string): SafeParseResult<HealthCheckAuthenticationBasic, SDKValidationError>;
+/** @internal */
+export declare const HealthCheckAuthenticationNoneDiscoverType$inboundSchema: z.ZodType<HealthCheckAuthenticationNoneDiscoverType, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const HealthCheckAuthenticationNoneDiscoverType$outboundSchema: z.ZodType<string, z.ZodTypeDef, HealthCheckAuthenticationNoneDiscoverType>;
+/** @internal */
+export declare const HealthCheckAuthenticationNoneDiscovery$inboundSchema: z.ZodType<HealthCheckAuthenticationNoneDiscovery, z.ZodTypeDef, unknown>;
+/** @internal */
+export type HealthCheckAuthenticationNoneDiscovery$Outbound = {
+    discoverType: string;
+};
+/** @internal */
+export declare const HealthCheckAuthenticationNoneDiscovery$outboundSchema: z.ZodType<HealthCheckAuthenticationNoneDiscovery$Outbound, z.ZodTypeDef, HealthCheckAuthenticationNoneDiscovery>;
+export declare function healthCheckAuthenticationNoneDiscoveryToJSON(healthCheckAuthenticationNoneDiscovery: HealthCheckAuthenticationNoneDiscovery): string;
+export declare function healthCheckAuthenticationNoneDiscoveryFromJSON(jsonString: string): SafeParseResult<HealthCheckAuthenticationNoneDiscovery, SDKValidationError>;
+/** @internal */
+export declare const HealthCheckAuthenticationNoneHealthCheckMethod$inboundSchema: z.ZodType<HealthCheckAuthenticationNoneHealthCheckMethod, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const HealthCheckAuthenticationNoneHealthCheckMethod$outboundSchema: z.ZodType<string, z.ZodTypeDef, HealthCheckAuthenticationNoneHealthCheckMethod>;
+/** @internal */
+export declare const HealthCheckAuthenticationNoneCollectRequestHeader$inboundSchema: z.ZodType<HealthCheckAuthenticationNoneCollectRequestHeader, z.ZodTypeDef, unknown>;
+/** @internal */
+export type HealthCheckAuthenticationNoneCollectRequestHeader$Outbound = {
+    name: string;
+    value: string;
+};
+/** @internal */
+export declare const HealthCheckAuthenticationNoneCollectRequestHeader$outboundSchema: z.ZodType<HealthCheckAuthenticationNoneCollectRequestHeader$Outbound, z.ZodTypeDef, HealthCheckAuthenticationNoneCollectRequestHeader>;
+export declare function healthCheckAuthenticationNoneCollectRequestHeaderToJSON(healthCheckAuthenticationNoneCollectRequestHeader: HealthCheckAuthenticationNoneCollectRequestHeader): string;
+export declare function healthCheckAuthenticationNoneCollectRequestHeaderFromJSON(jsonString: string): SafeParseResult<HealthCheckAuthenticationNoneCollectRequestHeader, SDKValidationError>;
+/** @internal */
+export declare const HealthCheckAuthenticationNoneHiddenDefaultBreakers$inboundSchema: z.ZodType<HealthCheckAuthenticationNoneHiddenDefaultBreakers, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const HealthCheckAuthenticationNoneHiddenDefaultBreakers$outboundSchema: z.ZodType<string, z.ZodTypeDef, HealthCheckAuthenticationNoneHiddenDefaultBreakers>;
+/** @internal */
+export declare const HealthCheckAuthenticationNoneRetryType$inboundSchema: z.ZodType<HealthCheckAuthenticationNoneRetryType, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const HealthCheckAuthenticationNoneRetryType$outboundSchema: z.ZodType<string, z.ZodTypeDef, HealthCheckAuthenticationNoneRetryType>;
+/** @internal */
+export declare const HealthCheckAuthenticationNoneRetryRules$inboundSchema: z.ZodType<HealthCheckAuthenticationNoneRetryRules, z.ZodTypeDef, unknown>;
+/** @internal */
+export type HealthCheckAuthenticationNoneRetryRules$Outbound = {
+    type: string;
+    interval?: any | undefined;
+    limit?: any | undefined;
+    multiplier?: any | undefined;
+    codes?: any | undefined;
+    enableHeader?: any | undefined;
+};
+/** @internal */
+export declare const HealthCheckAuthenticationNoneRetryRules$outboundSchema: z.ZodType<HealthCheckAuthenticationNoneRetryRules$Outbound, z.ZodTypeDef, HealthCheckAuthenticationNoneRetryRules>;
+export declare function healthCheckAuthenticationNoneRetryRulesToJSON(healthCheckAuthenticationNoneRetryRules: HealthCheckAuthenticationNoneRetryRules): string;
+export declare function healthCheckAuthenticationNoneRetryRulesFromJSON(jsonString: string): SafeParseResult<HealthCheckAuthenticationNoneRetryRules, SDKValidationError>;
+/** @internal */
+export declare const HealthCheckAuthenticationNone$inboundSchema: z.ZodType<HealthCheckAuthenticationNone, z.ZodTypeDef, unknown>;
+/** @internal */
+export type HealthCheckAuthenticationNone$Outbound = {
+    authentication: "none";
+    discovery?: HealthCheckAuthenticationNoneDiscovery$Outbound | undefined;
+    collectUrl: string;
+    collectMethod: string;
+    collectRequestParams?: any | undefined;
+    collectBody?: any | undefined;
+    collectRequestHeaders?: Array<HealthCheckAuthenticationNoneCollectRequestHeader$Outbound> | undefined;
+    authenticateCollect: boolean;
+    timeout: number;
+    rejectUnauthorized: boolean;
+    defaultBreakers?: string | undefined;
+    safeHeaders?: Array<string> | undefined;
+    retryRules?: HealthCheckAuthenticationNoneRetryRules$Outbound | undefined;
+};
+/** @internal */
+export declare const HealthCheckAuthenticationNone$outboundSchema: z.ZodType<HealthCheckAuthenticationNone$Outbound, z.ZodTypeDef, HealthCheckAuthenticationNone>;
+export declare function healthCheckAuthenticationNoneToJSON(healthCheckAuthenticationNone: HealthCheckAuthenticationNone): string;
+export declare function healthCheckAuthenticationNoneFromJSON(jsonString: string): SafeParseResult<HealthCheckAuthenticationNone, SDKValidationError>;
+/** @internal */
+export declare const HealthCheckCollectMethodPostWithBodyHealthCheckMethod$inboundSchema: z.ZodType<HealthCheckCollectMethodPostWithBodyHealthCheckMethod, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const HealthCheckCollectMethodPostWithBodyHealthCheckMethod$outboundSchema: z.ZodType<string, z.ZodTypeDef, HealthCheckCollectMethodPostWithBodyHealthCheckMethod>;
+/** @internal */
+export declare const HealthCheckCollectMethodPostWithBodyDiscoverType$inboundSchema: z.ZodType<HealthCheckCollectMethodPostWithBodyDiscoverType, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const HealthCheckCollectMethodPostWithBodyDiscoverType$outboundSchema: z.ZodType<string, z.ZodTypeDef, HealthCheckCollectMethodPostWithBodyDiscoverType>;
+/** @internal */
+export declare const HealthCheckCollectMethodPostWithBodyDiscovery$inboundSchema: z.ZodType<HealthCheckCollectMethodPostWithBodyDiscovery, z.ZodTypeDef, unknown>;
+/** @internal */
+export type HealthCheckCollectMethodPostWithBodyDiscovery$Outbound = {
+    discoverType: string;
+};
+/** @internal */
+export declare const HealthCheckCollectMethodPostWithBodyDiscovery$outboundSchema: z.ZodType<HealthCheckCollectMethodPostWithBodyDiscovery$Outbound, z.ZodTypeDef, HealthCheckCollectMethodPostWithBodyDiscovery>;
+export declare function healthCheckCollectMethodPostWithBodyDiscoveryToJSON(healthCheckCollectMethodPostWithBodyDiscovery: HealthCheckCollectMethodPostWithBodyDiscovery): string;
+export declare function healthCheckCollectMethodPostWithBodyDiscoveryFromJSON(jsonString: string): SafeParseResult<HealthCheckCollectMethodPostWithBodyDiscovery, SDKValidationError>;
+/** @internal */
+export declare const HealthCheckCollectMethodPostWithBodyCollectRequestHeader$inboundSchema: z.ZodType<HealthCheckCollectMethodPostWithBodyCollectRequestHeader, z.ZodTypeDef, unknown>;
+/** @internal */
+export type HealthCheckCollectMethodPostWithBodyCollectRequestHeader$Outbound = {
+    name: string;
+    value: string;
+};
+/** @internal */
+export declare const HealthCheckCollectMethodPostWithBodyCollectRequestHeader$outboundSchema: z.ZodType<HealthCheckCollectMethodPostWithBodyCollectRequestHeader$Outbound, z.ZodTypeDef, HealthCheckCollectMethodPostWithBodyCollectRequestHeader>;
+export declare function healthCheckCollectMethodPostWithBodyCollectRequestHeaderToJSON(healthCheckCollectMethodPostWithBodyCollectRequestHeader: HealthCheckCollectMethodPostWithBodyCollectRequestHeader): string;
+export declare function healthCheckCollectMethodPostWithBodyCollectRequestHeaderFromJSON(jsonString: string): SafeParseResult<HealthCheckCollectMethodPostWithBodyCollectRequestHeader, SDKValidationError>;
+/** @internal */
+export declare const HealthCheckCollectMethodPostWithBodyAuthentication$inboundSchema: z.ZodType<HealthCheckCollectMethodPostWithBodyAuthentication, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const HealthCheckCollectMethodPostWithBodyAuthentication$outboundSchema: z.ZodType<string, z.ZodTypeDef, HealthCheckCollectMethodPostWithBodyAuthentication>;
+/** @internal */
+export declare const HealthCheckCollectMethodPostWithBodyHiddenDefaultBreakers$inboundSchema: z.ZodType<HealthCheckCollectMethodPostWithBodyHiddenDefaultBreakers, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const HealthCheckCollectMethodPostWithBodyHiddenDefaultBreakers$outboundSchema: z.ZodType<string, z.ZodTypeDef, HealthCheckCollectMethodPostWithBodyHiddenDefaultBreakers>;
+/** @internal */
+export declare const HealthCheckCollectMethodPostWithBodyRetryType$inboundSchema: z.ZodType<HealthCheckCollectMethodPostWithBodyRetryType, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const HealthCheckCollectMethodPostWithBodyRetryType$outboundSchema: z.ZodType<string, z.ZodTypeDef, HealthCheckCollectMethodPostWithBodyRetryType>;
+/** @internal */
+export declare const HealthCheckCollectMethodPostWithBodyRetryRules$inboundSchema: z.ZodType<HealthCheckCollectMethodPostWithBodyRetryRules, z.ZodTypeDef, unknown>;
+/** @internal */
+export type HealthCheckCollectMethodPostWithBodyRetryRules$Outbound = {
+    type: string;
+    interval?: any | undefined;
+    limit?: any | undefined;
+    multiplier?: any | undefined;
+    codes?: any | undefined;
+    enableHeader?: any | undefined;
+};
+/** @internal */
+export declare const HealthCheckCollectMethodPostWithBodyRetryRules$outboundSchema: z.ZodType<HealthCheckCollectMethodPostWithBodyRetryRules$Outbound, z.ZodTypeDef, HealthCheckCollectMethodPostWithBodyRetryRules>;
+export declare function healthCheckCollectMethodPostWithBodyRetryRulesToJSON(healthCheckCollectMethodPostWithBodyRetryRules: HealthCheckCollectMethodPostWithBodyRetryRules): string;
+export declare function healthCheckCollectMethodPostWithBodyRetryRulesFromJSON(jsonString: string): SafeParseResult<HealthCheckCollectMethodPostWithBodyRetryRules, SDKValidationError>;
+/** @internal */
+export declare const HealthCheckCollectMethodPostWithBody$inboundSchema: z.ZodType<HealthCheckCollectMethodPostWithBody, z.ZodTypeDef, unknown>;
+/** @internal */
+export type HealthCheckCollectMethodPostWithBody$Outbound = {
+    collectMethod: string;
+    collectBody?: any | undefined;
+    discovery?: HealthCheckCollectMethodPostWithBodyDiscovery$Outbound | undefined;
+    collectUrl: string;
+    collectRequestParams?: any | undefined;
+    collectRequestHeaders?: Array<HealthCheckCollectMethodPostWithBodyCollectRequestHeader$Outbound> | undefined;
+    authenticateCollect: boolean;
+    authentication: string;
+    timeout: number;
+    rejectUnauthorized: boolean;
+    defaultBreakers?: string | undefined;
+    safeHeaders?: Array<string> | undefined;
+    retryRules?: HealthCheckCollectMethodPostWithBodyRetryRules$Outbound | undefined;
+};
+/** @internal */
+export declare const HealthCheckCollectMethodPostWithBody$outboundSchema: z.ZodType<HealthCheckCollectMethodPostWithBody$Outbound, z.ZodTypeDef, HealthCheckCollectMethodPostWithBody>;
+export declare function healthCheckCollectMethodPostWithBodyToJSON(healthCheckCollectMethodPostWithBody: HealthCheckCollectMethodPostWithBody): string;
+export declare function healthCheckCollectMethodPostWithBodyFromJSON(jsonString: string): SafeParseResult<HealthCheckCollectMethodPostWithBody, SDKValidationError>;
+/** @internal */
+export declare const HealthCheckCollectMethodPostHealthCheckMethod$inboundSchema: z.ZodType<HealthCheckCollectMethodPostHealthCheckMethod, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const HealthCheckCollectMethodPostHealthCheckMethod$outboundSchema: z.ZodType<string, z.ZodTypeDef, HealthCheckCollectMethodPostHealthCheckMethod>;
+/** @internal */
+export declare const HealthCheckCollectMethodPostDiscoverType$inboundSchema: z.ZodType<HealthCheckCollectMethodPostDiscoverType, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const HealthCheckCollectMethodPostDiscoverType$outboundSchema: z.ZodType<string, z.ZodTypeDef, HealthCheckCollectMethodPostDiscoverType>;
+/** @internal */
+export declare const HealthCheckCollectMethodPostDiscovery$inboundSchema: z.ZodType<HealthCheckCollectMethodPostDiscovery, z.ZodTypeDef, unknown>;
+/** @internal */
+export type HealthCheckCollectMethodPostDiscovery$Outbound = {
+    discoverType: string;
+};
+/** @internal */
+export declare const HealthCheckCollectMethodPostDiscovery$outboundSchema: z.ZodType<HealthCheckCollectMethodPostDiscovery$Outbound, z.ZodTypeDef, HealthCheckCollectMethodPostDiscovery>;
+export declare function healthCheckCollectMethodPostDiscoveryToJSON(healthCheckCollectMethodPostDiscovery: HealthCheckCollectMethodPostDiscovery): string;
+export declare function healthCheckCollectMethodPostDiscoveryFromJSON(jsonString: string): SafeParseResult<HealthCheckCollectMethodPostDiscovery, SDKValidationError>;
+/** @internal */
+export declare const HealthCheckCollectMethodPostCollectRequestHeader$inboundSchema: z.ZodType<HealthCheckCollectMethodPostCollectRequestHeader, z.ZodTypeDef, unknown>;
+/** @internal */
+export type HealthCheckCollectMethodPostCollectRequestHeader$Outbound = {
+    name: string;
+    value: string;
+};
+/** @internal */
+export declare const HealthCheckCollectMethodPostCollectRequestHeader$outboundSchema: z.ZodType<HealthCheckCollectMethodPostCollectRequestHeader$Outbound, z.ZodTypeDef, HealthCheckCollectMethodPostCollectRequestHeader>;
+export declare function healthCheckCollectMethodPostCollectRequestHeaderToJSON(healthCheckCollectMethodPostCollectRequestHeader: HealthCheckCollectMethodPostCollectRequestHeader): string;
+export declare function healthCheckCollectMethodPostCollectRequestHeaderFromJSON(jsonString: string): SafeParseResult<HealthCheckCollectMethodPostCollectRequestHeader, SDKValidationError>;
+/** @internal */
+export declare const HealthCheckCollectMethodPostAuthentication$inboundSchema: z.ZodType<HealthCheckCollectMethodPostAuthentication, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const HealthCheckCollectMethodPostAuthentication$outboundSchema: z.ZodType<string, z.ZodTypeDef, HealthCheckCollectMethodPostAuthentication>;
+/** @internal */
+export declare const HealthCheckCollectMethodPostHiddenDefaultBreakers$inboundSchema: z.ZodType<HealthCheckCollectMethodPostHiddenDefaultBreakers, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const HealthCheckCollectMethodPostHiddenDefaultBreakers$outboundSchema: z.ZodType<string, z.ZodTypeDef, HealthCheckCollectMethodPostHiddenDefaultBreakers>;
+/** @internal */
+export declare const HealthCheckCollectMethodPostRetryType$inboundSchema: z.ZodType<HealthCheckCollectMethodPostRetryType, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const HealthCheckCollectMethodPostRetryType$outboundSchema: z.ZodType<string, z.ZodTypeDef, HealthCheckCollectMethodPostRetryType>;
+/** @internal */
+export declare const HealthCheckCollectMethodPostRetryRules$inboundSchema: z.ZodType<HealthCheckCollectMethodPostRetryRules, z.ZodTypeDef, unknown>;
+/** @internal */
+export type HealthCheckCollectMethodPostRetryRules$Outbound = {
+    type: string;
+    interval?: any | undefined;
+    limit?: any | undefined;
+    multiplier?: any | undefined;
+    codes?: any | undefined;
+    enableHeader?: any | undefined;
+};
+/** @internal */
+export declare const HealthCheckCollectMethodPostRetryRules$outboundSchema: z.ZodType<HealthCheckCollectMethodPostRetryRules$Outbound, z.ZodTypeDef, HealthCheckCollectMethodPostRetryRules>;
+export declare function healthCheckCollectMethodPostRetryRulesToJSON(healthCheckCollectMethodPostRetryRules: HealthCheckCollectMethodPostRetryRules): string;
+export declare function healthCheckCollectMethodPostRetryRulesFromJSON(jsonString: string): SafeParseResult<HealthCheckCollectMethodPostRetryRules, SDKValidationError>;
+/** @internal */
+export declare const HealthCheckCollectMethodPost$inboundSchema: z.ZodType<HealthCheckCollectMethodPost, z.ZodTypeDef, unknown>;
+/** @internal */
+export type HealthCheckCollectMethodPost$Outbound = {
+    collectMethod: string;
+    collectRequestParams?: any | undefined;
+    discovery?: HealthCheckCollectMethodPostDiscovery$Outbound | undefined;
+    collectUrl: string;
+    collectBody?: any | undefined;
+    collectRequestHeaders?: Array<HealthCheckCollectMethodPostCollectRequestHeader$Outbound> | undefined;
+    authenticateCollect: boolean;
+    authentication: string;
+    timeout: number;
+    rejectUnauthorized: boolean;
+    defaultBreakers?: string | undefined;
+    safeHeaders?: Array<string> | undefined;
+    retryRules?: HealthCheckCollectMethodPostRetryRules$Outbound | undefined;
+};
+/** @internal */
+export declare const HealthCheckCollectMethodPost$outboundSchema: z.ZodType<HealthCheckCollectMethodPost$Outbound, z.ZodTypeDef, HealthCheckCollectMethodPost>;
+export declare function healthCheckCollectMethodPostToJSON(healthCheckCollectMethodPost: HealthCheckCollectMethodPost): string;
+export declare function healthCheckCollectMethodPostFromJSON(jsonString: string): SafeParseResult<HealthCheckCollectMethodPost, SDKValidationError>;
+/** @internal */
+export declare const HealthCheckCollectMethodGetHealthCheckMethod$inboundSchema: z.ZodType<HealthCheckCollectMethodGetHealthCheckMethod, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const HealthCheckCollectMethodGetHealthCheckMethod$outboundSchema: z.ZodType<string, z.ZodTypeDef, HealthCheckCollectMethodGetHealthCheckMethod>;
+/** @internal */
+export declare const HealthCheckCollectMethodGetDiscoverType$inboundSchema: z.ZodType<HealthCheckCollectMethodGetDiscoverType, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const HealthCheckCollectMethodGetDiscoverType$outboundSchema: z.ZodType<string, z.ZodTypeDef, HealthCheckCollectMethodGetDiscoverType>;
+/** @internal */
+export declare const HealthCheckCollectMethodGetDiscovery$inboundSchema: z.ZodType<HealthCheckCollectMethodGetDiscovery, z.ZodTypeDef, unknown>;
+/** @internal */
+export type HealthCheckCollectMethodGetDiscovery$Outbound = {
+    discoverType: string;
+};
+/** @internal */
+export declare const HealthCheckCollectMethodGetDiscovery$outboundSchema: z.ZodType<HealthCheckCollectMethodGetDiscovery$Outbound, z.ZodTypeDef, HealthCheckCollectMethodGetDiscovery>;
+export declare function healthCheckCollectMethodGetDiscoveryToJSON(healthCheckCollectMethodGetDiscovery: HealthCheckCollectMethodGetDiscovery): string;
+export declare function healthCheckCollectMethodGetDiscoveryFromJSON(jsonString: string): SafeParseResult<HealthCheckCollectMethodGetDiscovery, SDKValidationError>;
+/** @internal */
+export declare const HealthCheckCollectMethodGetCollectRequestHeader$inboundSchema: z.ZodType<HealthCheckCollectMethodGetCollectRequestHeader, z.ZodTypeDef, unknown>;
+/** @internal */
+export type HealthCheckCollectMethodGetCollectRequestHeader$Outbound = {
+    name: string;
+    value: string;
+};
+/** @internal */
+export declare const HealthCheckCollectMethodGetCollectRequestHeader$outboundSchema: z.ZodType<HealthCheckCollectMethodGetCollectRequestHeader$Outbound, z.ZodTypeDef, HealthCheckCollectMethodGetCollectRequestHeader>;
+export declare function healthCheckCollectMethodGetCollectRequestHeaderToJSON(healthCheckCollectMethodGetCollectRequestHeader: HealthCheckCollectMethodGetCollectRequestHeader): string;
+export declare function healthCheckCollectMethodGetCollectRequestHeaderFromJSON(jsonString: string): SafeParseResult<HealthCheckCollectMethodGetCollectRequestHeader, SDKValidationError>;
+/** @internal */
+export declare const HealthCheckCollectMethodGetAuthentication$inboundSchema: z.ZodType<HealthCheckCollectMethodGetAuthentication, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const HealthCheckCollectMethodGetAuthentication$outboundSchema: z.ZodType<string, z.ZodTypeDef, HealthCheckCollectMethodGetAuthentication>;
+/** @internal */
+export declare const HealthCheckCollectMethodGetHiddenDefaultBreakers$inboundSchema: z.ZodType<HealthCheckCollectMethodGetHiddenDefaultBreakers, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const HealthCheckCollectMethodGetHiddenDefaultBreakers$outboundSchema: z.ZodType<string, z.ZodTypeDef, HealthCheckCollectMethodGetHiddenDefaultBreakers>;
+/** @internal */
+export declare const HealthCheckCollectMethodGetRetryType$inboundSchema: z.ZodType<HealthCheckCollectMethodGetRetryType, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const HealthCheckCollectMethodGetRetryType$outboundSchema: z.ZodType<string, z.ZodTypeDef, HealthCheckCollectMethodGetRetryType>;
+/** @internal */
+export declare const HealthCheckCollectMethodGetRetryRules$inboundSchema: z.ZodType<HealthCheckCollectMethodGetRetryRules, z.ZodTypeDef, unknown>;
+/** @internal */
+export type HealthCheckCollectMethodGetRetryRules$Outbound = {
+    type: string;
+    interval?: any | undefined;
+    limit?: any | undefined;
+    multiplier?: any | undefined;
+    codes?: any | undefined;
+    enableHeader?: any | undefined;
+};
+/** @internal */
+export declare const HealthCheckCollectMethodGetRetryRules$outboundSchema: z.ZodType<HealthCheckCollectMethodGetRetryRules$Outbound, z.ZodTypeDef, HealthCheckCollectMethodGetRetryRules>;
+export declare function healthCheckCollectMethodGetRetryRulesToJSON(healthCheckCollectMethodGetRetryRules: HealthCheckCollectMethodGetRetryRules): string;
+export declare function healthCheckCollectMethodGetRetryRulesFromJSON(jsonString: string): SafeParseResult<HealthCheckCollectMethodGetRetryRules, SDKValidationError>;
+/** @internal */
+export declare const HealthCheckCollectMethodGet$inboundSchema: z.ZodType<HealthCheckCollectMethodGet, z.ZodTypeDef, unknown>;
+/** @internal */
+export type HealthCheckCollectMethodGet$Outbound = {
+    collectMethod: string;
+    collectRequestParams?: any | undefined;
+    discovery?: HealthCheckCollectMethodGetDiscovery$Outbound | undefined;
+    collectUrl: string;
+    collectBody?: any | undefined;
+    collectRequestHeaders?: Array<HealthCheckCollectMethodGetCollectRequestHeader$Outbound> | undefined;
+    authenticateCollect: boolean;
+    authentication: string;
+    timeout: number;
+    rejectUnauthorized: boolean;
+    defaultBreakers?: string | undefined;
+    safeHeaders?: Array<string> | undefined;
+    retryRules?: HealthCheckCollectMethodGetRetryRules$Outbound | undefined;
+};
+/** @internal */
+export declare const HealthCheckCollectMethodGet$outboundSchema: z.ZodType<HealthCheckCollectMethodGet$Outbound, z.ZodTypeDef, HealthCheckCollectMethodGet>;
+export declare function healthCheckCollectMethodGetToJSON(healthCheckCollectMethodGet: HealthCheckCollectMethodGet): string;
+export declare function healthCheckCollectMethodGetFromJSON(jsonString: string): SafeParseResult<HealthCheckCollectMethodGet, SDKValidationError>;
+/** @internal */
+export declare const HealthCheckCollectorConf$inboundSchema: z.ZodType<HealthCheckCollectorConf, z.ZodTypeDef, unknown>;
+/** @internal */
+export type HealthCheckCollectorConf$Outbound = HealthCheckAuthenticationNone$Outbound | HealthCheckAuthenticationBasic$Outbound | HealthCheckAuthenticationBasicSecret$Outbound | HealthCheckAuthenticationLogin$Outbound | HealthCheckAuthenticationLoginSecret$Outbound | HealthCheckAuthenticationOauth$Outbound | HealthCheckAuthenticationOauthSecret$Outbound;
 /** @internal */
 export declare const HealthCheckCollectorConf$outboundSchema: z.ZodType<HealthCheckCollectorConf$Outbound, z.ZodTypeDef, HealthCheckCollectorConf>;
 export declare function healthCheckCollectorConfToJSON(healthCheckCollectorConf: HealthCheckCollectorConf): string;