cribl-control-plane 0.5.0-beta.13 → 0.5.0-beta.14

package/dist/esm/models/healthcheckcollectorconf.js

@@ -0,0 +1,1963 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v3";
+import { safeParse } from "../lib/schemas.js";
+import * as openEnums from "../types/enums.js";
+/**
+ * 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 const HealthCheckAuthenticationOauthSecretDiscoverType = {
+    /**
+     * HTTP Request
+     */
+    Http: "http",
+    /**
+     * JSON Response
+     */
+    Json: "json",
+    /**
+     * Item List
+     */
+    List: "list",
+    /**
+     * None
+     */
+    None: "none",
+};
+/**
+ * Health check HTTP method.
+ */
+export const HealthCheckAuthenticationOauthSecretHealthCheckMethod = {
+    /**
+     * GET
+     */
+    Get: "get",
+    /**
+     * POST
+     */
+    Post: "post",
+    /**
+     * POST with Body
+     */
+    PostWithBody: "post_with_body",
+};
+export const HealthCheckAuthenticationOauthSecretHiddenDefaultBreakers = {
+    Cribl: "Cribl",
+};
+/**
+ * The algorithm to use when performing HTTP retries
+ */
+export const HealthCheckAuthenticationOauthSecretRetryType = {
+    /**
+     * Disabled
+     */
+    None: "none",
+    /**
+     * Backoff
+     */
+    Backoff: "backoff",
+    /**
+     * Static
+     */
+    Static: "static",
+};
+/**
+ * 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 const HealthCheckAuthenticationOauthDiscoverType = {
+    /**
+     * HTTP Request
+     */
+    Http: "http",
+    /**
+     * JSON Response
+     */
+    Json: "json",
+    /**
+     * Item List
+     */
+    List: "list",
+    /**
+     * None
+     */
+    None: "none",
+};
+/**
+ * Health check HTTP method.
+ */
+export const HealthCheckAuthenticationOauthHealthCheckMethod = {
+    /**
+     * GET
+     */
+    Get: "get",
+    /**
+     * POST
+     */
+    Post: "post",
+    /**
+     * POST with Body
+     */
+    PostWithBody: "post_with_body",
+};
+export const HealthCheckAuthenticationOauthHiddenDefaultBreakers = {
+    Cribl: "Cribl",
+};
+/**
+ * The algorithm to use when performing HTTP retries
+ */
+export const HealthCheckAuthenticationOauthRetryType = {
+    /**
+     * Disabled
+     */
+    None: "none",
+    /**
+     * Backoff
+     */
+    Backoff: "backoff",
+    /**
+     * Static
+     */
+    Static: "static",
+};
+/**
+ * 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 const HealthCheckAuthenticationLoginSecretDiscoverType = {
+    /**
+     * HTTP Request
+     */
+    Http: "http",
+    /**
+     * JSON Response
+     */
+    Json: "json",
+    /**
+     * Item List
+     */
+    List: "list",
+    /**
+     * None
+     */
+    None: "none",
+};
+/**
+ * Health check HTTP method.
+ */
+export const HealthCheckAuthenticationLoginSecretHealthCheckMethod = {
+    /**
+     * GET
+     */
+    Get: "get",
+    /**
+     * POST
+     */
+    Post: "post",
+    /**
+     * POST with Body
+     */
+    PostWithBody: "post_with_body",
+};
+export const HealthCheckAuthenticationLoginSecretHiddenDefaultBreakers = {
+    Cribl: "Cribl",
+};
+/**
+ * The algorithm to use when performing HTTP retries
+ */
+export const HealthCheckAuthenticationLoginSecretRetryType = {
+    /**
+     * Disabled
+     */
+    None: "none",
+    /**
+     * Backoff
+     */
+    Backoff: "backoff",
+    /**
+     * Static
+     */
+    Static: "static",
+};
+/**
+ * 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 const HealthCheckAuthenticationLoginDiscoverType = {
+    /**
+     * HTTP Request
+     */
+    Http: "http",
+    /**
+     * JSON Response
+     */
+    Json: "json",
+    /**
+     * Item List
+     */
+    List: "list",
+    /**
+     * None
+     */
+    None: "none",
+};
+/**
+ * Health check HTTP method.
+ */
+export const HealthCheckAuthenticationLoginHealthCheckMethod = {
+    /**
+     * GET
+     */
+    Get: "get",
+    /**
+     * POST
+     */
+    Post: "post",
+    /**
+     * POST with Body
+     */
+    PostWithBody: "post_with_body",
+};
+export const HealthCheckAuthenticationLoginHiddenDefaultBreakers = {
+    Cribl: "Cribl",
+};
+/**
+ * The algorithm to use when performing HTTP retries
+ */
+export const HealthCheckAuthenticationLoginRetryType = {
+    /**
+     * Disabled
+     */
+    None: "none",
+    /**
+     * Backoff
+     */
+    Backoff: "backoff",
+    /**
+     * Static
+     */
+    Static: "static",
+};
+/**
+ * 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 const HealthCheckAuthenticationBasicSecretDiscoverType = {
+    /**
+     * HTTP Request
+     */
+    Http: "http",
+    /**
+     * JSON Response
+     */
+    Json: "json",
+    /**
+     * Item List
+     */
+    List: "list",
+    /**
+     * None
+     */
+    None: "none",
+};
+/**
+ * Health check HTTP method.
+ */
+export const HealthCheckAuthenticationBasicSecretHealthCheckMethod = {
+    /**
+     * GET
+     */
+    Get: "get",
+    /**
+     * POST
+     */
+    Post: "post",
+    /**
+     * POST with Body
+     */
+    PostWithBody: "post_with_body",
+};
+export const HealthCheckAuthenticationBasicSecretHiddenDefaultBreakers = {
+    Cribl: "Cribl",
+};
+/**
+ * The algorithm to use when performing HTTP retries
+ */
+export const HealthCheckAuthenticationBasicSecretRetryType = {
+    /**
+     * Disabled
+     */
+    None: "none",
+    /**
+     * Backoff
+     */
+    Backoff: "backoff",
+    /**
+     * Static
+     */
+    Static: "static",
+};
+/**
+ * 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 const HealthCheckAuthenticationBasicDiscoverType = {
+    /**
+     * HTTP Request
+     */
+    Http: "http",
+    /**
+     * JSON Response
+     */
+    Json: "json",
+    /**
+     * Item List
+     */
+    List: "list",
+    /**
+     * None
+     */
+    None: "none",
+};
+/**
+ * Health check HTTP method.
+ */
+export const HealthCheckAuthenticationBasicHealthCheckMethod = {
+    /**
+     * GET
+     */
+    Get: "get",
+    /**
+     * POST
+     */
+    Post: "post",
+    /**
+     * POST with Body
+     */
+    PostWithBody: "post_with_body",
+};
+export const HealthCheckAuthenticationBasicHiddenDefaultBreakers = {
+    Cribl: "Cribl",
+};
+/**
+ * The algorithm to use when performing HTTP retries
+ */
+export const HealthCheckAuthenticationBasicRetryType = {
+    /**
+     * Disabled
+     */
+    None: "none",
+    /**
+     * Backoff
+     */
+    Backoff: "backoff",
+    /**
+     * Static
+     */
+    Static: "static",
+};
+/**
+ * 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 const HealthCheckAuthenticationNoneDiscoverType = {
+    /**
+     * HTTP Request
+     */
+    Http: "http",
+    /**
+     * JSON Response
+     */
+    Json: "json",
+    /**
+     * Item List
+     */
+    List: "list",
+    /**
+     * None
+     */
+    None: "none",
+};
+/**
+ * Health check HTTP method.
+ */
+export const HealthCheckAuthenticationNoneHealthCheckMethod = {
+    /**
+     * GET
+     */
+    Get: "get",
+    /**
+     * POST
+     */
+    Post: "post",
+    /**
+     * POST with Body
+     */
+    PostWithBody: "post_with_body",
+};
+export const HealthCheckAuthenticationNoneHiddenDefaultBreakers = {
+    Cribl: "Cribl",
+};
+/**
+ * The algorithm to use when performing HTTP retries
+ */
+export const HealthCheckAuthenticationNoneRetryType = {
+    /**
+     * Disabled
+     */
+    None: "none",
+    /**
+     * Backoff
+     */
+    Backoff: "backoff",
+    /**
+     * Static
+     */
+    Static: "static",
+};
+/**
+ * Health check HTTP method.
+ */
+export const HealthCheckCollectMethodPostWithBodyHealthCheckMethod = {
+    /**
+     * GET
+     */
+    Get: "get",
+    /**
+     * POST
+     */
+    Post: "post",
+    /**
+     * POST with Body
+     */
+    PostWithBody: "post_with_body",
+};
+/**
+ * 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 const HealthCheckCollectMethodPostWithBodyDiscoverType = {
+    /**
+     * HTTP Request
+     */
+    Http: "http",
+    /**
+     * JSON Response
+     */
+    Json: "json",
+    /**
+     * Item List
+     */
+    List: "list",
+    /**
+     * None
+     */
+    None: "none",
+};
+/**
+ * Authentication method for Discover and Collect REST calls. You can specify API Key–based authentication by adding the appropriate Collect headers.
+ */
+export const HealthCheckCollectMethodPostWithBodyAuthentication = {
+    None: "none",
+    Basic: "basic",
+    BasicSecret: "basicSecret",
+    Login: "login",
+    LoginSecret: "loginSecret",
+    Oauth: "oauth",
+    OauthSecret: "oauthSecret",
+};
+export const HealthCheckCollectMethodPostWithBodyHiddenDefaultBreakers = {
+    Cribl: "Cribl",
+};
+/**
+ * The algorithm to use when performing HTTP retries
+ */
+export const HealthCheckCollectMethodPostWithBodyRetryType = {
+    /**
+     * Disabled
+     */
+    None: "none",
+    /**
+     * Backoff
+     */
+    Backoff: "backoff",
+    /**
+     * Static
+     */
+    Static: "static",
+};
+/**
+ * Health check HTTP method.
+ */
+export const HealthCheckCollectMethodPostHealthCheckMethod = {
+    /**
+     * GET
+     */
+    Get: "get",
+    /**
+     * POST
+     */
+    Post: "post",
+    /**
+     * POST with Body
+     */
+    PostWithBody: "post_with_body",
+};
+/**
+ * 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 const HealthCheckCollectMethodPostDiscoverType = {
+    /**
+     * HTTP Request
+     */
+    Http: "http",
+    /**
+     * JSON Response
+     */
+    Json: "json",
+    /**
+     * Item List
+     */
+    List: "list",
+    /**
+     * None
+     */
+    None: "none",
+};
+/**
+ * Authentication method for Discover and Collect REST calls. You can specify API Key–based authentication by adding the appropriate Collect headers.
+ */
+export const HealthCheckCollectMethodPostAuthentication = {
+    None: "none",
+    Basic: "basic",
+    BasicSecret: "basicSecret",
+    Login: "login",
+    LoginSecret: "loginSecret",
+    Oauth: "oauth",
+    OauthSecret: "oauthSecret",
+};
+export const HealthCheckCollectMethodPostHiddenDefaultBreakers = {
+    Cribl: "Cribl",
+};
+/**
+ * The algorithm to use when performing HTTP retries
+ */
+export const HealthCheckCollectMethodPostRetryType = {
+    /**
+     * Disabled
+     */
+    None: "none",
+    /**
+     * Backoff
+     */
+    Backoff: "backoff",
+    /**
+     * Static
+     */
+    Static: "static",
+};
+/**
+ * Health check HTTP method.
+ */
+export const HealthCheckCollectMethodGetHealthCheckMethod = {
+    /**
+     * GET
+     */
+    Get: "get",
+    /**
+     * POST
+     */
+    Post: "post",
+    /**
+     * POST with Body
+     */
+    PostWithBody: "post_with_body",
+};
+/**
+ * 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 const HealthCheckCollectMethodGetDiscoverType = {
+    /**
+     * HTTP Request
+     */
+    Http: "http",
+    /**
+     * JSON Response
+     */
+    Json: "json",
+    /**
+     * Item List
+     */
+    List: "list",
+    /**
+     * None
+     */
+    None: "none",
+};
+/**
+ * Authentication method for Discover and Collect REST calls. You can specify API Key–based authentication by adding the appropriate Collect headers.
+ */
+export const HealthCheckCollectMethodGetAuthentication = {
+    None: "none",
+    Basic: "basic",
+    BasicSecret: "basicSecret",
+    Login: "login",
+    LoginSecret: "loginSecret",
+    Oauth: "oauth",
+    OauthSecret: "oauthSecret",
+};
+export const HealthCheckCollectMethodGetHiddenDefaultBreakers = {
+    Cribl: "Cribl",
+};
+/**
+ * The algorithm to use when performing HTTP retries
+ */
+export const HealthCheckCollectMethodGetRetryType = {
+    /**
+     * Disabled
+     */
+    None: "none",
+    /**
+     * Backoff
+     */
+    Backoff: "backoff",
+    /**
+     * Static
+     */
+    Static: "static",
+};
+/** @internal */
+export const HealthCheckAuthenticationOauthSecretAuthRequestParam$inboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+/** @internal */
+export const HealthCheckAuthenticationOauthSecretAuthRequestParam$outboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+export function healthCheckAuthenticationOauthSecretAuthRequestParamToJSON(healthCheckAuthenticationOauthSecretAuthRequestParam) {
+    return JSON.stringify(HealthCheckAuthenticationOauthSecretAuthRequestParam$outboundSchema.parse(healthCheckAuthenticationOauthSecretAuthRequestParam));
+}
+export function healthCheckAuthenticationOauthSecretAuthRequestParamFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => HealthCheckAuthenticationOauthSecretAuthRequestParam$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'HealthCheckAuthenticationOauthSecretAuthRequestParam' from JSON`);
+}
+/** @internal */
+export const HealthCheckAuthenticationOauthSecretAuthRequestHeader$inboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+/** @internal */
+export const HealthCheckAuthenticationOauthSecretAuthRequestHeader$outboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+export function healthCheckAuthenticationOauthSecretAuthRequestHeaderToJSON(healthCheckAuthenticationOauthSecretAuthRequestHeader) {
+    return JSON.stringify(HealthCheckAuthenticationOauthSecretAuthRequestHeader$outboundSchema.parse(healthCheckAuthenticationOauthSecretAuthRequestHeader));
+}
+export function healthCheckAuthenticationOauthSecretAuthRequestHeaderFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => HealthCheckAuthenticationOauthSecretAuthRequestHeader$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'HealthCheckAuthenticationOauthSecretAuthRequestHeader' from JSON`);
+}
+/** @internal */
+export const HealthCheckAuthenticationOauthSecretDiscoverType$inboundSchema = openEnums.inboundSchema(HealthCheckAuthenticationOauthSecretDiscoverType);
+/** @internal */
+export const HealthCheckAuthenticationOauthSecretDiscoverType$outboundSchema = openEnums.outboundSchema(HealthCheckAuthenticationOauthSecretDiscoverType);
+/** @internal */
+export const HealthCheckAuthenticationOauthSecretDiscovery$inboundSchema = z.object({
+    discoverType: HealthCheckAuthenticationOauthSecretDiscoverType$inboundSchema
+        .default("none"),
+});
+/** @internal */
+export const HealthCheckAuthenticationOauthSecretDiscovery$outboundSchema = z.object({
+    discoverType: HealthCheckAuthenticationOauthSecretDiscoverType$outboundSchema.default("none"),
+});
+export function healthCheckAuthenticationOauthSecretDiscoveryToJSON(healthCheckAuthenticationOauthSecretDiscovery) {
+    return JSON.stringify(HealthCheckAuthenticationOauthSecretDiscovery$outboundSchema.parse(healthCheckAuthenticationOauthSecretDiscovery));
+}
+export function healthCheckAuthenticationOauthSecretDiscoveryFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => HealthCheckAuthenticationOauthSecretDiscovery$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'HealthCheckAuthenticationOauthSecretDiscovery' from JSON`);
+}
+/** @internal */
+export const HealthCheckAuthenticationOauthSecretHealthCheckMethod$inboundSchema = openEnums.inboundSchema(HealthCheckAuthenticationOauthSecretHealthCheckMethod);
+/** @internal */
+export const HealthCheckAuthenticationOauthSecretHealthCheckMethod$outboundSchema = openEnums.outboundSchema(HealthCheckAuthenticationOauthSecretHealthCheckMethod);
+/** @internal */
+export const HealthCheckAuthenticationOauthSecretCollectRequestHeader$inboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+/** @internal */
+export const HealthCheckAuthenticationOauthSecretCollectRequestHeader$outboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+export function healthCheckAuthenticationOauthSecretCollectRequestHeaderToJSON(healthCheckAuthenticationOauthSecretCollectRequestHeader) {
+    return JSON.stringify(HealthCheckAuthenticationOauthSecretCollectRequestHeader$outboundSchema
+        .parse(healthCheckAuthenticationOauthSecretCollectRequestHeader));
+}
+export function healthCheckAuthenticationOauthSecretCollectRequestHeaderFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => HealthCheckAuthenticationOauthSecretCollectRequestHeader$inboundSchema
+        .parse(JSON.parse(x)), `Failed to parse 'HealthCheckAuthenticationOauthSecretCollectRequestHeader' from JSON`);
+}
+/** @internal */
+export const HealthCheckAuthenticationOauthSecretHiddenDefaultBreakers$inboundSchema = openEnums.inboundSchema(HealthCheckAuthenticationOauthSecretHiddenDefaultBreakers);
+/** @internal */
+export const HealthCheckAuthenticationOauthSecretHiddenDefaultBreakers$outboundSchema = openEnums.outboundSchema(HealthCheckAuthenticationOauthSecretHiddenDefaultBreakers);
+/** @internal */
+export const HealthCheckAuthenticationOauthSecretRetryType$inboundSchema = openEnums.inboundSchema(HealthCheckAuthenticationOauthSecretRetryType);
+/** @internal */
+export const HealthCheckAuthenticationOauthSecretRetryType$outboundSchema = openEnums.outboundSchema(HealthCheckAuthenticationOauthSecretRetryType);
+/** @internal */
+export const HealthCheckAuthenticationOauthSecretRetryRules$inboundSchema = z.object({
+    type: HealthCheckAuthenticationOauthSecretRetryType$inboundSchema.default("backoff"),
+    interval: z.any().optional(),
+    limit: z.any().optional(),
+    multiplier: z.any().optional(),
+    codes: z.any().optional(),
+    enableHeader: z.any().optional(),
+});
+/** @internal */
+export const HealthCheckAuthenticationOauthSecretRetryRules$outboundSchema = z.object({
+    type: HealthCheckAuthenticationOauthSecretRetryType$outboundSchema.default("backoff"),
+    interval: z.any().optional(),
+    limit: z.any().optional(),
+    multiplier: z.any().optional(),
+    codes: z.any().optional(),
+    enableHeader: z.any().optional(),
+});
+export function healthCheckAuthenticationOauthSecretRetryRulesToJSON(healthCheckAuthenticationOauthSecretRetryRules) {
+    return JSON.stringify(HealthCheckAuthenticationOauthSecretRetryRules$outboundSchema.parse(healthCheckAuthenticationOauthSecretRetryRules));
+}
+export function healthCheckAuthenticationOauthSecretRetryRulesFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => HealthCheckAuthenticationOauthSecretRetryRules$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'HealthCheckAuthenticationOauthSecretRetryRules' from JSON`);
+}
+/** @internal */
+export const HealthCheckAuthenticationOauthSecret$inboundSchema = z.object({
+    authentication: z.literal("oauthSecret"),
+    loginUrl: z.string().default(""),
+    tokenRespAttribute: z.string().optional(),
+    authHeaderExpr: z.string().default("`Bearer ${token}`"),
+    clientSecretParamName: z.string().default("client_secret"),
+    textSecret: z.string(),
+    authRequestParams: z.array(z.lazy(() => HealthCheckAuthenticationOauthSecretAuthRequestParam$inboundSchema)).optional(),
+    authRequestHeaders: z.array(z.lazy(() => HealthCheckAuthenticationOauthSecretAuthRequestHeader$inboundSchema)).optional(),
+    discovery: z.lazy(() => HealthCheckAuthenticationOauthSecretDiscovery$inboundSchema).optional(),
+    collectUrl: z.string(),
+    collectMethod: HealthCheckAuthenticationOauthSecretHealthCheckMethod$inboundSchema.default("get"),
+    collectRequestParams: z.any().optional(),
+    collectBody: z.any().optional(),
+    collectRequestHeaders: z.array(z.lazy(() => HealthCheckAuthenticationOauthSecretCollectRequestHeader$inboundSchema)).optional(),
+    authenticateCollect: z.boolean().default(false),
+    timeout: z.number().default(30),
+    rejectUnauthorized: z.boolean().default(false),
+    defaultBreakers: HealthCheckAuthenticationOauthSecretHiddenDefaultBreakers$inboundSchema
+        .optional(),
+    safeHeaders: z.array(z.string()).optional(),
+    retryRules: z.lazy(() => HealthCheckAuthenticationOauthSecretRetryRules$inboundSchema).optional(),
+});
+/** @internal */
+export const HealthCheckAuthenticationOauthSecret$outboundSchema = z.object({
+    authentication: z.literal("oauthSecret"),
+    loginUrl: z.string().default(""),
+    tokenRespAttribute: z.string().optional(),
+    authHeaderExpr: z.string().default("`Bearer ${token}`"),
+    clientSecretParamName: z.string().default("client_secret"),
+    textSecret: z.string(),
+    authRequestParams: z.array(z.lazy(() => HealthCheckAuthenticationOauthSecretAuthRequestParam$outboundSchema)).optional(),
+    authRequestHeaders: z.array(z.lazy(() => HealthCheckAuthenticationOauthSecretAuthRequestHeader$outboundSchema)).optional(),
+    discovery: z.lazy(() => HealthCheckAuthenticationOauthSecretDiscovery$outboundSchema).optional(),
+    collectUrl: z.string(),
+    collectMethod: HealthCheckAuthenticationOauthSecretHealthCheckMethod$outboundSchema
+        .default("get"),
+    collectRequestParams: z.any().optional(),
+    collectBody: z.any().optional(),
+    collectRequestHeaders: z.array(z.lazy(() => HealthCheckAuthenticationOauthSecretCollectRequestHeader$outboundSchema)).optional(),
+    authenticateCollect: z.boolean().default(false),
+    timeout: z.number().default(30),
+    rejectUnauthorized: z.boolean().default(false),
+    defaultBreakers: HealthCheckAuthenticationOauthSecretHiddenDefaultBreakers$outboundSchema
+        .optional(),
+    safeHeaders: z.array(z.string()).optional(),
+    retryRules: z.lazy(() => HealthCheckAuthenticationOauthSecretRetryRules$outboundSchema).optional(),
+});
+export function healthCheckAuthenticationOauthSecretToJSON(healthCheckAuthenticationOauthSecret) {
+    return JSON.stringify(HealthCheckAuthenticationOauthSecret$outboundSchema.parse(healthCheckAuthenticationOauthSecret));
+}
+export function healthCheckAuthenticationOauthSecretFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => HealthCheckAuthenticationOauthSecret$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'HealthCheckAuthenticationOauthSecret' from JSON`);
+}
+/** @internal */
+export const HealthCheckAuthenticationOauthAuthRequestParam$inboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+/** @internal */
+export const HealthCheckAuthenticationOauthAuthRequestParam$outboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+export function healthCheckAuthenticationOauthAuthRequestParamToJSON(healthCheckAuthenticationOauthAuthRequestParam) {
+    return JSON.stringify(HealthCheckAuthenticationOauthAuthRequestParam$outboundSchema.parse(healthCheckAuthenticationOauthAuthRequestParam));
+}
+export function healthCheckAuthenticationOauthAuthRequestParamFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => HealthCheckAuthenticationOauthAuthRequestParam$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'HealthCheckAuthenticationOauthAuthRequestParam' from JSON`);
+}
+/** @internal */
+export const HealthCheckAuthenticationOauthAuthRequestHeader$inboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+/** @internal */
+export const HealthCheckAuthenticationOauthAuthRequestHeader$outboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+export function healthCheckAuthenticationOauthAuthRequestHeaderToJSON(healthCheckAuthenticationOauthAuthRequestHeader) {
+    return JSON.stringify(HealthCheckAuthenticationOauthAuthRequestHeader$outboundSchema.parse(healthCheckAuthenticationOauthAuthRequestHeader));
+}
+export function healthCheckAuthenticationOauthAuthRequestHeaderFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => HealthCheckAuthenticationOauthAuthRequestHeader$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'HealthCheckAuthenticationOauthAuthRequestHeader' from JSON`);
+}
+/** @internal */
+export const HealthCheckAuthenticationOauthDiscoverType$inboundSchema = openEnums.inboundSchema(HealthCheckAuthenticationOauthDiscoverType);
+/** @internal */
+export const HealthCheckAuthenticationOauthDiscoverType$outboundSchema = openEnums.outboundSchema(HealthCheckAuthenticationOauthDiscoverType);
+/** @internal */
+export const HealthCheckAuthenticationOauthDiscovery$inboundSchema = z.object({
+    discoverType: HealthCheckAuthenticationOauthDiscoverType$inboundSchema
+        .default("none"),
+});
+/** @internal */
+export const HealthCheckAuthenticationOauthDiscovery$outboundSchema = z.object({
+    discoverType: HealthCheckAuthenticationOauthDiscoverType$outboundSchema
+        .default("none"),
+});
+export function healthCheckAuthenticationOauthDiscoveryToJSON(healthCheckAuthenticationOauthDiscovery) {
+    return JSON.stringify(HealthCheckAuthenticationOauthDiscovery$outboundSchema.parse(healthCheckAuthenticationOauthDiscovery));
+}
+export function healthCheckAuthenticationOauthDiscoveryFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => HealthCheckAuthenticationOauthDiscovery$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'HealthCheckAuthenticationOauthDiscovery' from JSON`);
+}
+/** @internal */
+export const HealthCheckAuthenticationOauthHealthCheckMethod$inboundSchema = openEnums.inboundSchema(HealthCheckAuthenticationOauthHealthCheckMethod);
+/** @internal */
+export const HealthCheckAuthenticationOauthHealthCheckMethod$outboundSchema = openEnums.outboundSchema(HealthCheckAuthenticationOauthHealthCheckMethod);
+/** @internal */
+export const HealthCheckAuthenticationOauthCollectRequestHeader$inboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+/** @internal */
+export const HealthCheckAuthenticationOauthCollectRequestHeader$outboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+export function healthCheckAuthenticationOauthCollectRequestHeaderToJSON(healthCheckAuthenticationOauthCollectRequestHeader) {
+    return JSON.stringify(HealthCheckAuthenticationOauthCollectRequestHeader$outboundSchema.parse(healthCheckAuthenticationOauthCollectRequestHeader));
+}
+export function healthCheckAuthenticationOauthCollectRequestHeaderFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => HealthCheckAuthenticationOauthCollectRequestHeader$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'HealthCheckAuthenticationOauthCollectRequestHeader' from JSON`);
+}
+/** @internal */
+export const HealthCheckAuthenticationOauthHiddenDefaultBreakers$inboundSchema = openEnums.inboundSchema(HealthCheckAuthenticationOauthHiddenDefaultBreakers);
+/** @internal */
+export const HealthCheckAuthenticationOauthHiddenDefaultBreakers$outboundSchema = openEnums.outboundSchema(HealthCheckAuthenticationOauthHiddenDefaultBreakers);
+/** @internal */
+export const HealthCheckAuthenticationOauthRetryType$inboundSchema = openEnums.inboundSchema(HealthCheckAuthenticationOauthRetryType);
+/** @internal */
+export const HealthCheckAuthenticationOauthRetryType$outboundSchema = openEnums.outboundSchema(HealthCheckAuthenticationOauthRetryType);
+/** @internal */
+export const HealthCheckAuthenticationOauthRetryRules$inboundSchema = z.object({
+    type: HealthCheckAuthenticationOauthRetryType$inboundSchema.default("backoff"),
+    interval: z.any().optional(),
+    limit: z.any().optional(),
+    multiplier: z.any().optional(),
+    codes: z.any().optional(),
+    enableHeader: z.any().optional(),
+});
+/** @internal */
+export const HealthCheckAuthenticationOauthRetryRules$outboundSchema = z.object({
+    type: HealthCheckAuthenticationOauthRetryType$outboundSchema.default("backoff"),
+    interval: z.any().optional(),
+    limit: z.any().optional(),
+    multiplier: z.any().optional(),
+    codes: z.any().optional(),
+    enableHeader: z.any().optional(),
+});
+export function healthCheckAuthenticationOauthRetryRulesToJSON(healthCheckAuthenticationOauthRetryRules) {
+    return JSON.stringify(HealthCheckAuthenticationOauthRetryRules$outboundSchema.parse(healthCheckAuthenticationOauthRetryRules));
+}
+export function healthCheckAuthenticationOauthRetryRulesFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => HealthCheckAuthenticationOauthRetryRules$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'HealthCheckAuthenticationOauthRetryRules' from JSON`);
+}
+/** @internal */
+export const HealthCheckAuthenticationOauth$inboundSchema = z.object({
+    authentication: z.literal("oauth"),
+    loginUrl: z.string().default(""),
+    tokenRespAttribute: z.string().optional(),
+    authHeaderExpr: z.string().default("`Bearer ${token}`"),
+    clientSecretParamName: z.string().default("client_secret"),
+    clientSecretParamValue: z.string(),
+    authRequestParams: z.array(z.lazy(() => HealthCheckAuthenticationOauthAuthRequestParam$inboundSchema)).optional(),
+    authRequestHeaders: z.array(z.lazy(() => HealthCheckAuthenticationOauthAuthRequestHeader$inboundSchema)).optional(),
+    discovery: z.lazy(() => HealthCheckAuthenticationOauthDiscovery$inboundSchema)
+        .optional(),
+    collectUrl: z.string(),
+    collectMethod: HealthCheckAuthenticationOauthHealthCheckMethod$inboundSchema
+        .default("get"),
+    collectRequestParams: z.any().optional(),
+    collectBody: z.any().optional(),
+    collectRequestHeaders: z.array(z.lazy(() => HealthCheckAuthenticationOauthCollectRequestHeader$inboundSchema)).optional(),
+    authenticateCollect: z.boolean().default(false),
+    timeout: z.number().default(30),
+    rejectUnauthorized: z.boolean().default(false),
+    defaultBreakers: HealthCheckAuthenticationOauthHiddenDefaultBreakers$inboundSchema
+        .optional(),
+    safeHeaders: z.array(z.string()).optional(),
+    retryRules: z.lazy(() => HealthCheckAuthenticationOauthRetryRules$inboundSchema).optional(),
+});
+/** @internal */
+export const HealthCheckAuthenticationOauth$outboundSchema = z.object({
+    authentication: z.literal("oauth"),
+    loginUrl: z.string().default(""),
+    tokenRespAttribute: z.string().optional(),
+    authHeaderExpr: z.string().default("`Bearer ${token}`"),
+    clientSecretParamName: z.string().default("client_secret"),
+    clientSecretParamValue: z.string(),
+    authRequestParams: z.array(z.lazy(() => HealthCheckAuthenticationOauthAuthRequestParam$outboundSchema)).optional(),
+    authRequestHeaders: z.array(z.lazy(() => HealthCheckAuthenticationOauthAuthRequestHeader$outboundSchema)).optional(),
+    discovery: z.lazy(() => HealthCheckAuthenticationOauthDiscovery$outboundSchema).optional(),
+    collectUrl: z.string(),
+    collectMethod: HealthCheckAuthenticationOauthHealthCheckMethod$outboundSchema
+        .default("get"),
+    collectRequestParams: z.any().optional(),
+    collectBody: z.any().optional(),
+    collectRequestHeaders: z.array(z.lazy(() => HealthCheckAuthenticationOauthCollectRequestHeader$outboundSchema)).optional(),
+    authenticateCollect: z.boolean().default(false),
+    timeout: z.number().default(30),
+    rejectUnauthorized: z.boolean().default(false),
+    defaultBreakers: HealthCheckAuthenticationOauthHiddenDefaultBreakers$outboundSchema
+        .optional(),
+    safeHeaders: z.array(z.string()).optional(),
+    retryRules: z.lazy(() => HealthCheckAuthenticationOauthRetryRules$outboundSchema).optional(),
+});
+export function healthCheckAuthenticationOauthToJSON(healthCheckAuthenticationOauth) {
+    return JSON.stringify(HealthCheckAuthenticationOauth$outboundSchema.parse(healthCheckAuthenticationOauth));
+}
+export function healthCheckAuthenticationOauthFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => HealthCheckAuthenticationOauth$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'HealthCheckAuthenticationOauth' from JSON`);
+}
+/** @internal */
+export const HealthCheckAuthenticationLoginSecretAuthRequestHeader$inboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+/** @internal */
+export const HealthCheckAuthenticationLoginSecretAuthRequestHeader$outboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+export function healthCheckAuthenticationLoginSecretAuthRequestHeaderToJSON(healthCheckAuthenticationLoginSecretAuthRequestHeader) {
+    return JSON.stringify(HealthCheckAuthenticationLoginSecretAuthRequestHeader$outboundSchema.parse(healthCheckAuthenticationLoginSecretAuthRequestHeader));
+}
+export function healthCheckAuthenticationLoginSecretAuthRequestHeaderFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => HealthCheckAuthenticationLoginSecretAuthRequestHeader$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'HealthCheckAuthenticationLoginSecretAuthRequestHeader' from JSON`);
+}
+/** @internal */
+export const HealthCheckAuthenticationLoginSecretDiscoverType$inboundSchema = openEnums.inboundSchema(HealthCheckAuthenticationLoginSecretDiscoverType);
+/** @internal */
+export const HealthCheckAuthenticationLoginSecretDiscoverType$outboundSchema = openEnums.outboundSchema(HealthCheckAuthenticationLoginSecretDiscoverType);
+/** @internal */
+export const HealthCheckAuthenticationLoginSecretDiscovery$inboundSchema = z.object({
+    discoverType: HealthCheckAuthenticationLoginSecretDiscoverType$inboundSchema
+        .default("none"),
+});
+/** @internal */
+export const HealthCheckAuthenticationLoginSecretDiscovery$outboundSchema = z.object({
+    discoverType: HealthCheckAuthenticationLoginSecretDiscoverType$outboundSchema.default("none"),
+});
+export function healthCheckAuthenticationLoginSecretDiscoveryToJSON(healthCheckAuthenticationLoginSecretDiscovery) {
+    return JSON.stringify(HealthCheckAuthenticationLoginSecretDiscovery$outboundSchema.parse(healthCheckAuthenticationLoginSecretDiscovery));
+}
+export function healthCheckAuthenticationLoginSecretDiscoveryFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => HealthCheckAuthenticationLoginSecretDiscovery$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'HealthCheckAuthenticationLoginSecretDiscovery' from JSON`);
+}
+/** @internal */
+export const HealthCheckAuthenticationLoginSecretHealthCheckMethod$inboundSchema = openEnums.inboundSchema(HealthCheckAuthenticationLoginSecretHealthCheckMethod);
+/** @internal */
+export const HealthCheckAuthenticationLoginSecretHealthCheckMethod$outboundSchema = openEnums.outboundSchema(HealthCheckAuthenticationLoginSecretHealthCheckMethod);
+/** @internal */
+export const HealthCheckAuthenticationLoginSecretCollectRequestHeader$inboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+/** @internal */
+export const HealthCheckAuthenticationLoginSecretCollectRequestHeader$outboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+export function healthCheckAuthenticationLoginSecretCollectRequestHeaderToJSON(healthCheckAuthenticationLoginSecretCollectRequestHeader) {
+    return JSON.stringify(HealthCheckAuthenticationLoginSecretCollectRequestHeader$outboundSchema
+        .parse(healthCheckAuthenticationLoginSecretCollectRequestHeader));
+}
+export function healthCheckAuthenticationLoginSecretCollectRequestHeaderFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => HealthCheckAuthenticationLoginSecretCollectRequestHeader$inboundSchema
+        .parse(JSON.parse(x)), `Failed to parse 'HealthCheckAuthenticationLoginSecretCollectRequestHeader' from JSON`);
+}
+/** @internal */
+export const HealthCheckAuthenticationLoginSecretHiddenDefaultBreakers$inboundSchema = openEnums.inboundSchema(HealthCheckAuthenticationLoginSecretHiddenDefaultBreakers);
+/** @internal */
+export const HealthCheckAuthenticationLoginSecretHiddenDefaultBreakers$outboundSchema = openEnums.outboundSchema(HealthCheckAuthenticationLoginSecretHiddenDefaultBreakers);
+/** @internal */
+export const HealthCheckAuthenticationLoginSecretRetryType$inboundSchema = openEnums.inboundSchema(HealthCheckAuthenticationLoginSecretRetryType);
+/** @internal */
+export const HealthCheckAuthenticationLoginSecretRetryType$outboundSchema = openEnums.outboundSchema(HealthCheckAuthenticationLoginSecretRetryType);
+/** @internal */
+export const HealthCheckAuthenticationLoginSecretRetryRules$inboundSchema = z.object({
+    type: HealthCheckAuthenticationLoginSecretRetryType$inboundSchema.default("backoff"),
+    interval: z.any().optional(),
+    limit: z.any().optional(),
+    multiplier: z.any().optional(),
+    codes: z.any().optional(),
+    enableHeader: z.any().optional(),
+});
+/** @internal */
+export const HealthCheckAuthenticationLoginSecretRetryRules$outboundSchema = z.object({
+    type: HealthCheckAuthenticationLoginSecretRetryType$outboundSchema.default("backoff"),
+    interval: z.any().optional(),
+    limit: z.any().optional(),
+    multiplier: z.any().optional(),
+    codes: z.any().optional(),
+    enableHeader: z.any().optional(),
+});
+export function healthCheckAuthenticationLoginSecretRetryRulesToJSON(healthCheckAuthenticationLoginSecretRetryRules) {
+    return JSON.stringify(HealthCheckAuthenticationLoginSecretRetryRules$outboundSchema.parse(healthCheckAuthenticationLoginSecretRetryRules));
+}
+export function healthCheckAuthenticationLoginSecretRetryRulesFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => HealthCheckAuthenticationLoginSecretRetryRules$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'HealthCheckAuthenticationLoginSecretRetryRules' from JSON`);
+}
+/** @internal */
+export const HealthCheckAuthenticationLoginSecret$inboundSchema = z.object({
+    authentication: z.literal("loginSecret"),
+    loginUrl: z.string().default("`https://localhost:9000/api/v1/auth/login`"),
+    credentialsSecret: z.string(),
+    loginBody: z.string().default("`{ \"username\": \"${username}\", \"password\": \"${password}\" }`"),
+    tokenRespAttribute: z.string().optional(),
+    authHeaderExpr: z.string().default("`Bearer ${token}`"),
+    authRequestHeaders: z.array(z.lazy(() => HealthCheckAuthenticationLoginSecretAuthRequestHeader$inboundSchema)).optional(),
+    discovery: z.lazy(() => HealthCheckAuthenticationLoginSecretDiscovery$inboundSchema).optional(),
+    collectUrl: z.string(),
+    collectMethod: HealthCheckAuthenticationLoginSecretHealthCheckMethod$inboundSchema.default("get"),
+    collectRequestParams: z.any().optional(),
+    collectBody: z.any().optional(),
+    collectRequestHeaders: z.array(z.lazy(() => HealthCheckAuthenticationLoginSecretCollectRequestHeader$inboundSchema)).optional(),
+    authenticateCollect: z.boolean().default(false),
+    timeout: z.number().default(30),
+    rejectUnauthorized: z.boolean().default(false),
+    defaultBreakers: HealthCheckAuthenticationLoginSecretHiddenDefaultBreakers$inboundSchema
+        .optional(),
+    safeHeaders: z.array(z.string()).optional(),
+    retryRules: z.lazy(() => HealthCheckAuthenticationLoginSecretRetryRules$inboundSchema).optional(),
+});
+/** @internal */
+export const HealthCheckAuthenticationLoginSecret$outboundSchema = z.object({
+    authentication: z.literal("loginSecret"),
+    loginUrl: z.string().default("`https://localhost:9000/api/v1/auth/login`"),
+    credentialsSecret: z.string(),
+    loginBody: z.string().default("`{ \"username\": \"${username}\", \"password\": \"${password}\" }`"),
+    tokenRespAttribute: z.string().optional(),
+    authHeaderExpr: z.string().default("`Bearer ${token}`"),
+    authRequestHeaders: z.array(z.lazy(() => HealthCheckAuthenticationLoginSecretAuthRequestHeader$outboundSchema)).optional(),
+    discovery: z.lazy(() => HealthCheckAuthenticationLoginSecretDiscovery$outboundSchema).optional(),
+    collectUrl: z.string(),
+    collectMethod: HealthCheckAuthenticationLoginSecretHealthCheckMethod$outboundSchema
+        .default("get"),
+    collectRequestParams: z.any().optional(),
+    collectBody: z.any().optional(),
+    collectRequestHeaders: z.array(z.lazy(() => HealthCheckAuthenticationLoginSecretCollectRequestHeader$outboundSchema)).optional(),
+    authenticateCollect: z.boolean().default(false),
+    timeout: z.number().default(30),
+    rejectUnauthorized: z.boolean().default(false),
+    defaultBreakers: HealthCheckAuthenticationLoginSecretHiddenDefaultBreakers$outboundSchema
+        .optional(),
+    safeHeaders: z.array(z.string()).optional(),
+    retryRules: z.lazy(() => HealthCheckAuthenticationLoginSecretRetryRules$outboundSchema).optional(),
+});
+export function healthCheckAuthenticationLoginSecretToJSON(healthCheckAuthenticationLoginSecret) {
+    return JSON.stringify(HealthCheckAuthenticationLoginSecret$outboundSchema.parse(healthCheckAuthenticationLoginSecret));
+}
+export function healthCheckAuthenticationLoginSecretFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => HealthCheckAuthenticationLoginSecret$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'HealthCheckAuthenticationLoginSecret' from JSON`);
+}
+/** @internal */
+export const HealthCheckAuthenticationLoginAuthRequestHeader$inboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+/** @internal */
+export const HealthCheckAuthenticationLoginAuthRequestHeader$outboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+export function healthCheckAuthenticationLoginAuthRequestHeaderToJSON(healthCheckAuthenticationLoginAuthRequestHeader) {
+    return JSON.stringify(HealthCheckAuthenticationLoginAuthRequestHeader$outboundSchema.parse(healthCheckAuthenticationLoginAuthRequestHeader));
+}
+export function healthCheckAuthenticationLoginAuthRequestHeaderFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => HealthCheckAuthenticationLoginAuthRequestHeader$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'HealthCheckAuthenticationLoginAuthRequestHeader' from JSON`);
+}
+/** @internal */
+export const HealthCheckAuthenticationLoginDiscoverType$inboundSchema = openEnums.inboundSchema(HealthCheckAuthenticationLoginDiscoverType);
+/** @internal */
+export const HealthCheckAuthenticationLoginDiscoverType$outboundSchema = openEnums.outboundSchema(HealthCheckAuthenticationLoginDiscoverType);
+/** @internal */
+export const HealthCheckAuthenticationLoginDiscovery$inboundSchema = z.object({
+    discoverType: HealthCheckAuthenticationLoginDiscoverType$inboundSchema
+        .default("none"),
+});
+/** @internal */
+export const HealthCheckAuthenticationLoginDiscovery$outboundSchema = z.object({
+    discoverType: HealthCheckAuthenticationLoginDiscoverType$outboundSchema
+        .default("none"),
+});
+export function healthCheckAuthenticationLoginDiscoveryToJSON(healthCheckAuthenticationLoginDiscovery) {
+    return JSON.stringify(HealthCheckAuthenticationLoginDiscovery$outboundSchema.parse(healthCheckAuthenticationLoginDiscovery));
+}
+export function healthCheckAuthenticationLoginDiscoveryFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => HealthCheckAuthenticationLoginDiscovery$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'HealthCheckAuthenticationLoginDiscovery' from JSON`);
+}
+/** @internal */
+export const HealthCheckAuthenticationLoginHealthCheckMethod$inboundSchema = openEnums.inboundSchema(HealthCheckAuthenticationLoginHealthCheckMethod);
+/** @internal */
+export const HealthCheckAuthenticationLoginHealthCheckMethod$outboundSchema = openEnums.outboundSchema(HealthCheckAuthenticationLoginHealthCheckMethod);
+/** @internal */
+export const HealthCheckAuthenticationLoginCollectRequestHeader$inboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+/** @internal */
+export const HealthCheckAuthenticationLoginCollectRequestHeader$outboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+export function healthCheckAuthenticationLoginCollectRequestHeaderToJSON(healthCheckAuthenticationLoginCollectRequestHeader) {
+    return JSON.stringify(HealthCheckAuthenticationLoginCollectRequestHeader$outboundSchema.parse(healthCheckAuthenticationLoginCollectRequestHeader));
+}
+export function healthCheckAuthenticationLoginCollectRequestHeaderFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => HealthCheckAuthenticationLoginCollectRequestHeader$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'HealthCheckAuthenticationLoginCollectRequestHeader' from JSON`);
+}
+/** @internal */
+export const HealthCheckAuthenticationLoginHiddenDefaultBreakers$inboundSchema = openEnums.inboundSchema(HealthCheckAuthenticationLoginHiddenDefaultBreakers);
+/** @internal */
+export const HealthCheckAuthenticationLoginHiddenDefaultBreakers$outboundSchema = openEnums.outboundSchema(HealthCheckAuthenticationLoginHiddenDefaultBreakers);
+/** @internal */
+export const HealthCheckAuthenticationLoginRetryType$inboundSchema = openEnums.inboundSchema(HealthCheckAuthenticationLoginRetryType);
+/** @internal */
+export const HealthCheckAuthenticationLoginRetryType$outboundSchema = openEnums.outboundSchema(HealthCheckAuthenticationLoginRetryType);
+/** @internal */
+export const HealthCheckAuthenticationLoginRetryRules$inboundSchema = z.object({
+    type: HealthCheckAuthenticationLoginRetryType$inboundSchema.default("backoff"),
+    interval: z.any().optional(),
+    limit: z.any().optional(),
+    multiplier: z.any().optional(),
+    codes: z.any().optional(),
+    enableHeader: z.any().optional(),
+});
+/** @internal */
+export const HealthCheckAuthenticationLoginRetryRules$outboundSchema = z.object({
+    type: HealthCheckAuthenticationLoginRetryType$outboundSchema.default("backoff"),
+    interval: z.any().optional(),
+    limit: z.any().optional(),
+    multiplier: z.any().optional(),
+    codes: z.any().optional(),
+    enableHeader: z.any().optional(),
+});
+export function healthCheckAuthenticationLoginRetryRulesToJSON(healthCheckAuthenticationLoginRetryRules) {
+    return JSON.stringify(HealthCheckAuthenticationLoginRetryRules$outboundSchema.parse(healthCheckAuthenticationLoginRetryRules));
+}
+export function healthCheckAuthenticationLoginRetryRulesFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => HealthCheckAuthenticationLoginRetryRules$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'HealthCheckAuthenticationLoginRetryRules' from JSON`);
+}
+/** @internal */
+export const HealthCheckAuthenticationLogin$inboundSchema = z.object({
+    authentication: z.literal("login"),
+    loginUrl: z.string().default("`https://localhost:9000/api/v1/auth/login`"),
+    username: z.string(),
+    password: z.string(),
+    loginBody: z.string().default("`{ \"username\": \"${username}\", \"password\": \"${password}\" }`"),
+    tokenRespAttribute: z.string().optional(),
+    authHeaderExpr: z.string().default("`Bearer ${token}`"),
+    authRequestHeaders: z.array(z.lazy(() => HealthCheckAuthenticationLoginAuthRequestHeader$inboundSchema)).optional(),
+    discovery: z.lazy(() => HealthCheckAuthenticationLoginDiscovery$inboundSchema)
+        .optional(),
+    collectUrl: z.string(),
+    collectMethod: HealthCheckAuthenticationLoginHealthCheckMethod$inboundSchema
+        .default("get"),
+    collectRequestParams: z.any().optional(),
+    collectBody: z.any().optional(),
+    collectRequestHeaders: z.array(z.lazy(() => HealthCheckAuthenticationLoginCollectRequestHeader$inboundSchema)).optional(),
+    authenticateCollect: z.boolean().default(false),
+    timeout: z.number().default(30),
+    rejectUnauthorized: z.boolean().default(false),
+    defaultBreakers: HealthCheckAuthenticationLoginHiddenDefaultBreakers$inboundSchema
+        .optional(),
+    safeHeaders: z.array(z.string()).optional(),
+    retryRules: z.lazy(() => HealthCheckAuthenticationLoginRetryRules$inboundSchema).optional(),
+});
+/** @internal */
+export const HealthCheckAuthenticationLogin$outboundSchema = z.object({
+    authentication: z.literal("login"),
+    loginUrl: z.string().default("`https://localhost:9000/api/v1/auth/login`"),
+    username: z.string(),
+    password: z.string(),
+    loginBody: z.string().default("`{ \"username\": \"${username}\", \"password\": \"${password}\" }`"),
+    tokenRespAttribute: z.string().optional(),
+    authHeaderExpr: z.string().default("`Bearer ${token}`"),
+    authRequestHeaders: z.array(z.lazy(() => HealthCheckAuthenticationLoginAuthRequestHeader$outboundSchema)).optional(),
+    discovery: z.lazy(() => HealthCheckAuthenticationLoginDiscovery$outboundSchema).optional(),
+    collectUrl: z.string(),
+    collectMethod: HealthCheckAuthenticationLoginHealthCheckMethod$outboundSchema
+        .default("get"),
+    collectRequestParams: z.any().optional(),
+    collectBody: z.any().optional(),
+    collectRequestHeaders: z.array(z.lazy(() => HealthCheckAuthenticationLoginCollectRequestHeader$outboundSchema)).optional(),
+    authenticateCollect: z.boolean().default(false),
+    timeout: z.number().default(30),
+    rejectUnauthorized: z.boolean().default(false),
+    defaultBreakers: HealthCheckAuthenticationLoginHiddenDefaultBreakers$outboundSchema
+        .optional(),
+    safeHeaders: z.array(z.string()).optional(),
+    retryRules: z.lazy(() => HealthCheckAuthenticationLoginRetryRules$outboundSchema).optional(),
+});
+export function healthCheckAuthenticationLoginToJSON(healthCheckAuthenticationLogin) {
+    return JSON.stringify(HealthCheckAuthenticationLogin$outboundSchema.parse(healthCheckAuthenticationLogin));
+}
+export function healthCheckAuthenticationLoginFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => HealthCheckAuthenticationLogin$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'HealthCheckAuthenticationLogin' from JSON`);
+}
+/** @internal */
+export const HealthCheckAuthenticationBasicSecretDiscoverType$inboundSchema = openEnums.inboundSchema(HealthCheckAuthenticationBasicSecretDiscoverType);
+/** @internal */
+export const HealthCheckAuthenticationBasicSecretDiscoverType$outboundSchema = openEnums.outboundSchema(HealthCheckAuthenticationBasicSecretDiscoverType);
+/** @internal */
+export const HealthCheckAuthenticationBasicSecretDiscovery$inboundSchema = z.object({
+    discoverType: HealthCheckAuthenticationBasicSecretDiscoverType$inboundSchema
+        .default("none"),
+});
+/** @internal */
+export const HealthCheckAuthenticationBasicSecretDiscovery$outboundSchema = z.object({
+    discoverType: HealthCheckAuthenticationBasicSecretDiscoverType$outboundSchema.default("none"),
+});
+export function healthCheckAuthenticationBasicSecretDiscoveryToJSON(healthCheckAuthenticationBasicSecretDiscovery) {
+    return JSON.stringify(HealthCheckAuthenticationBasicSecretDiscovery$outboundSchema.parse(healthCheckAuthenticationBasicSecretDiscovery));
+}
+export function healthCheckAuthenticationBasicSecretDiscoveryFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => HealthCheckAuthenticationBasicSecretDiscovery$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'HealthCheckAuthenticationBasicSecretDiscovery' from JSON`);
+}
+/** @internal */
+export const HealthCheckAuthenticationBasicSecretHealthCheckMethod$inboundSchema = openEnums.inboundSchema(HealthCheckAuthenticationBasicSecretHealthCheckMethod);
+/** @internal */
+export const HealthCheckAuthenticationBasicSecretHealthCheckMethod$outboundSchema = openEnums.outboundSchema(HealthCheckAuthenticationBasicSecretHealthCheckMethod);
+/** @internal */
+export const HealthCheckAuthenticationBasicSecretCollectRequestHeader$inboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+/** @internal */
+export const HealthCheckAuthenticationBasicSecretCollectRequestHeader$outboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+export function healthCheckAuthenticationBasicSecretCollectRequestHeaderToJSON(healthCheckAuthenticationBasicSecretCollectRequestHeader) {
+    return JSON.stringify(HealthCheckAuthenticationBasicSecretCollectRequestHeader$outboundSchema
+        .parse(healthCheckAuthenticationBasicSecretCollectRequestHeader));
+}
+export function healthCheckAuthenticationBasicSecretCollectRequestHeaderFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => HealthCheckAuthenticationBasicSecretCollectRequestHeader$inboundSchema
+        .parse(JSON.parse(x)), `Failed to parse 'HealthCheckAuthenticationBasicSecretCollectRequestHeader' from JSON`);
+}
+/** @internal */
+export const HealthCheckAuthenticationBasicSecretHiddenDefaultBreakers$inboundSchema = openEnums.inboundSchema(HealthCheckAuthenticationBasicSecretHiddenDefaultBreakers);
+/** @internal */
+export const HealthCheckAuthenticationBasicSecretHiddenDefaultBreakers$outboundSchema = openEnums.outboundSchema(HealthCheckAuthenticationBasicSecretHiddenDefaultBreakers);
+/** @internal */
+export const HealthCheckAuthenticationBasicSecretRetryType$inboundSchema = openEnums.inboundSchema(HealthCheckAuthenticationBasicSecretRetryType);
+/** @internal */
+export const HealthCheckAuthenticationBasicSecretRetryType$outboundSchema = openEnums.outboundSchema(HealthCheckAuthenticationBasicSecretRetryType);
+/** @internal */
+export const HealthCheckAuthenticationBasicSecretRetryRules$inboundSchema = z.object({
+    type: HealthCheckAuthenticationBasicSecretRetryType$inboundSchema.default("backoff"),
+    interval: z.any().optional(),
+    limit: z.any().optional(),
+    multiplier: z.any().optional(),
+    codes: z.any().optional(),
+    enableHeader: z.any().optional(),
+});
+/** @internal */
+export const HealthCheckAuthenticationBasicSecretRetryRules$outboundSchema = z.object({
+    type: HealthCheckAuthenticationBasicSecretRetryType$outboundSchema.default("backoff"),
+    interval: z.any().optional(),
+    limit: z.any().optional(),
+    multiplier: z.any().optional(),
+    codes: z.any().optional(),
+    enableHeader: z.any().optional(),
+});
+export function healthCheckAuthenticationBasicSecretRetryRulesToJSON(healthCheckAuthenticationBasicSecretRetryRules) {
+    return JSON.stringify(HealthCheckAuthenticationBasicSecretRetryRules$outboundSchema.parse(healthCheckAuthenticationBasicSecretRetryRules));
+}
+export function healthCheckAuthenticationBasicSecretRetryRulesFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => HealthCheckAuthenticationBasicSecretRetryRules$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'HealthCheckAuthenticationBasicSecretRetryRules' from JSON`);
+}
+/** @internal */
+export const HealthCheckAuthenticationBasicSecret$inboundSchema = z.object({
+    authentication: z.literal("basicSecret"),
+    credentialsSecret: z.string(),
+    discovery: z.lazy(() => HealthCheckAuthenticationBasicSecretDiscovery$inboundSchema).optional(),
+    collectUrl: z.string(),
+    collectMethod: HealthCheckAuthenticationBasicSecretHealthCheckMethod$inboundSchema.default("get"),
+    collectRequestParams: z.any().optional(),
+    collectBody: z.any().optional(),
+    collectRequestHeaders: z.array(z.lazy(() => HealthCheckAuthenticationBasicSecretCollectRequestHeader$inboundSchema)).optional(),
+    authenticateCollect: z.boolean().default(false),
+    timeout: z.number().default(30),
+    rejectUnauthorized: z.boolean().default(false),
+    defaultBreakers: HealthCheckAuthenticationBasicSecretHiddenDefaultBreakers$inboundSchema
+        .optional(),
+    safeHeaders: z.array(z.string()).optional(),
+    retryRules: z.lazy(() => HealthCheckAuthenticationBasicSecretRetryRules$inboundSchema).optional(),
+});
+/** @internal */
+export const HealthCheckAuthenticationBasicSecret$outboundSchema = z.object({
+    authentication: z.literal("basicSecret"),
+    credentialsSecret: z.string(),
+    discovery: z.lazy(() => HealthCheckAuthenticationBasicSecretDiscovery$outboundSchema).optional(),
+    collectUrl: z.string(),
+    collectMethod: HealthCheckAuthenticationBasicSecretHealthCheckMethod$outboundSchema
+        .default("get"),
+    collectRequestParams: z.any().optional(),
+    collectBody: z.any().optional(),
+    collectRequestHeaders: z.array(z.lazy(() => HealthCheckAuthenticationBasicSecretCollectRequestHeader$outboundSchema)).optional(),
+    authenticateCollect: z.boolean().default(false),
+    timeout: z.number().default(30),
+    rejectUnauthorized: z.boolean().default(false),
+    defaultBreakers: HealthCheckAuthenticationBasicSecretHiddenDefaultBreakers$outboundSchema
+        .optional(),
+    safeHeaders: z.array(z.string()).optional(),
+    retryRules: z.lazy(() => HealthCheckAuthenticationBasicSecretRetryRules$outboundSchema).optional(),
+});
+export function healthCheckAuthenticationBasicSecretToJSON(healthCheckAuthenticationBasicSecret) {
+    return JSON.stringify(HealthCheckAuthenticationBasicSecret$outboundSchema.parse(healthCheckAuthenticationBasicSecret));
+}
+export function healthCheckAuthenticationBasicSecretFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => HealthCheckAuthenticationBasicSecret$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'HealthCheckAuthenticationBasicSecret' from JSON`);
+}
+/** @internal */
+export const HealthCheckAuthenticationBasicDiscoverType$inboundSchema = openEnums.inboundSchema(HealthCheckAuthenticationBasicDiscoverType);
+/** @internal */
+export const HealthCheckAuthenticationBasicDiscoverType$outboundSchema = openEnums.outboundSchema(HealthCheckAuthenticationBasicDiscoverType);
+/** @internal */
+export const HealthCheckAuthenticationBasicDiscovery$inboundSchema = z.object({
+    discoverType: HealthCheckAuthenticationBasicDiscoverType$inboundSchema
+        .default("none"),
+});
+/** @internal */
+export const HealthCheckAuthenticationBasicDiscovery$outboundSchema = z.object({
+    discoverType: HealthCheckAuthenticationBasicDiscoverType$outboundSchema
+        .default("none"),
+});
+export function healthCheckAuthenticationBasicDiscoveryToJSON(healthCheckAuthenticationBasicDiscovery) {
+    return JSON.stringify(HealthCheckAuthenticationBasicDiscovery$outboundSchema.parse(healthCheckAuthenticationBasicDiscovery));
+}
+export function healthCheckAuthenticationBasicDiscoveryFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => HealthCheckAuthenticationBasicDiscovery$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'HealthCheckAuthenticationBasicDiscovery' from JSON`);
+}
+/** @internal */
+export const HealthCheckAuthenticationBasicHealthCheckMethod$inboundSchema = openEnums.inboundSchema(HealthCheckAuthenticationBasicHealthCheckMethod);
+/** @internal */
+export const HealthCheckAuthenticationBasicHealthCheckMethod$outboundSchema = openEnums.outboundSchema(HealthCheckAuthenticationBasicHealthCheckMethod);
+/** @internal */
+export const HealthCheckAuthenticationBasicCollectRequestHeader$inboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+/** @internal */
+export const HealthCheckAuthenticationBasicCollectRequestHeader$outboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+export function healthCheckAuthenticationBasicCollectRequestHeaderToJSON(healthCheckAuthenticationBasicCollectRequestHeader) {
+    return JSON.stringify(HealthCheckAuthenticationBasicCollectRequestHeader$outboundSchema.parse(healthCheckAuthenticationBasicCollectRequestHeader));
+}
+export function healthCheckAuthenticationBasicCollectRequestHeaderFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => HealthCheckAuthenticationBasicCollectRequestHeader$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'HealthCheckAuthenticationBasicCollectRequestHeader' from JSON`);
+}
+/** @internal */
+export const HealthCheckAuthenticationBasicHiddenDefaultBreakers$inboundSchema = openEnums.inboundSchema(HealthCheckAuthenticationBasicHiddenDefaultBreakers);
+/** @internal */
+export const HealthCheckAuthenticationBasicHiddenDefaultBreakers$outboundSchema = openEnums.outboundSchema(HealthCheckAuthenticationBasicHiddenDefaultBreakers);
+/** @internal */
+export const HealthCheckAuthenticationBasicRetryType$inboundSchema = openEnums.inboundSchema(HealthCheckAuthenticationBasicRetryType);
+/** @internal */
+export const HealthCheckAuthenticationBasicRetryType$outboundSchema = openEnums.outboundSchema(HealthCheckAuthenticationBasicRetryType);
+/** @internal */
+export const HealthCheckAuthenticationBasicRetryRules$inboundSchema = z.object({
+    type: HealthCheckAuthenticationBasicRetryType$inboundSchema.default("backoff"),
+    interval: z.any().optional(),
+    limit: z.any().optional(),
+    multiplier: z.any().optional(),
+    codes: z.any().optional(),
+    enableHeader: z.any().optional(),
+});
+/** @internal */
+export const HealthCheckAuthenticationBasicRetryRules$outboundSchema = z.object({
+    type: HealthCheckAuthenticationBasicRetryType$outboundSchema.default("backoff"),
+    interval: z.any().optional(),
+    limit: z.any().optional(),
+    multiplier: z.any().optional(),
+    codes: z.any().optional(),
+    enableHeader: z.any().optional(),
+});
+export function healthCheckAuthenticationBasicRetryRulesToJSON(healthCheckAuthenticationBasicRetryRules) {
+    return JSON.stringify(HealthCheckAuthenticationBasicRetryRules$outboundSchema.parse(healthCheckAuthenticationBasicRetryRules));
+}
+export function healthCheckAuthenticationBasicRetryRulesFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => HealthCheckAuthenticationBasicRetryRules$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'HealthCheckAuthenticationBasicRetryRules' from JSON`);
+}
+/** @internal */
+export const HealthCheckAuthenticationBasic$inboundSchema = z.object({
+    authentication: z.literal("basic"),
+    username: z.string(),
+    password: z.string(),
+    discovery: z.lazy(() => HealthCheckAuthenticationBasicDiscovery$inboundSchema)
+        .optional(),
+    collectUrl: z.string(),
+    collectMethod: HealthCheckAuthenticationBasicHealthCheckMethod$inboundSchema
+        .default("get"),
+    collectRequestParams: z.any().optional(),
+    collectBody: z.any().optional(),
+    collectRequestHeaders: z.array(z.lazy(() => HealthCheckAuthenticationBasicCollectRequestHeader$inboundSchema)).optional(),
+    authenticateCollect: z.boolean().default(false),
+    timeout: z.number().default(30),
+    rejectUnauthorized: z.boolean().default(false),
+    defaultBreakers: HealthCheckAuthenticationBasicHiddenDefaultBreakers$inboundSchema
+        .optional(),
+    safeHeaders: z.array(z.string()).optional(),
+    retryRules: z.lazy(() => HealthCheckAuthenticationBasicRetryRules$inboundSchema).optional(),
+});
+/** @internal */
+export const HealthCheckAuthenticationBasic$outboundSchema = z.object({
+    authentication: z.literal("basic"),
+    username: z.string(),
+    password: z.string(),
+    discovery: z.lazy(() => HealthCheckAuthenticationBasicDiscovery$outboundSchema).optional(),
+    collectUrl: z.string(),
+    collectMethod: HealthCheckAuthenticationBasicHealthCheckMethod$outboundSchema
+        .default("get"),
+    collectRequestParams: z.any().optional(),
+    collectBody: z.any().optional(),
+    collectRequestHeaders: z.array(z.lazy(() => HealthCheckAuthenticationBasicCollectRequestHeader$outboundSchema)).optional(),
+    authenticateCollect: z.boolean().default(false),
+    timeout: z.number().default(30),
+    rejectUnauthorized: z.boolean().default(false),
+    defaultBreakers: HealthCheckAuthenticationBasicHiddenDefaultBreakers$outboundSchema
+        .optional(),
+    safeHeaders: z.array(z.string()).optional(),
+    retryRules: z.lazy(() => HealthCheckAuthenticationBasicRetryRules$outboundSchema).optional(),
+});
+export function healthCheckAuthenticationBasicToJSON(healthCheckAuthenticationBasic) {
+    return JSON.stringify(HealthCheckAuthenticationBasic$outboundSchema.parse(healthCheckAuthenticationBasic));
+}
+export function healthCheckAuthenticationBasicFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => HealthCheckAuthenticationBasic$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'HealthCheckAuthenticationBasic' from JSON`);
+}
+/** @internal */
+export const HealthCheckAuthenticationNoneDiscoverType$inboundSchema = openEnums.inboundSchema(HealthCheckAuthenticationNoneDiscoverType);
+/** @internal */
+export const HealthCheckAuthenticationNoneDiscoverType$outboundSchema = openEnums.outboundSchema(HealthCheckAuthenticationNoneDiscoverType);
+/** @internal */
+export const HealthCheckAuthenticationNoneDiscovery$inboundSchema = z.object({
+    discoverType: HealthCheckAuthenticationNoneDiscoverType$inboundSchema.default("none"),
+});
+/** @internal */
+export const HealthCheckAuthenticationNoneDiscovery$outboundSchema = z.object({
+    discoverType: HealthCheckAuthenticationNoneDiscoverType$outboundSchema
+        .default("none"),
+});
+export function healthCheckAuthenticationNoneDiscoveryToJSON(healthCheckAuthenticationNoneDiscovery) {
+    return JSON.stringify(HealthCheckAuthenticationNoneDiscovery$outboundSchema.parse(healthCheckAuthenticationNoneDiscovery));
+}
+export function healthCheckAuthenticationNoneDiscoveryFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => HealthCheckAuthenticationNoneDiscovery$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'HealthCheckAuthenticationNoneDiscovery' from JSON`);
+}
+/** @internal */
+export const HealthCheckAuthenticationNoneHealthCheckMethod$inboundSchema = openEnums.inboundSchema(HealthCheckAuthenticationNoneHealthCheckMethod);
+/** @internal */
+export const HealthCheckAuthenticationNoneHealthCheckMethod$outboundSchema = openEnums.outboundSchema(HealthCheckAuthenticationNoneHealthCheckMethod);
+/** @internal */
+export const HealthCheckAuthenticationNoneCollectRequestHeader$inboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+/** @internal */
+export const HealthCheckAuthenticationNoneCollectRequestHeader$outboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+export function healthCheckAuthenticationNoneCollectRequestHeaderToJSON(healthCheckAuthenticationNoneCollectRequestHeader) {
+    return JSON.stringify(HealthCheckAuthenticationNoneCollectRequestHeader$outboundSchema.parse(healthCheckAuthenticationNoneCollectRequestHeader));
+}
+export function healthCheckAuthenticationNoneCollectRequestHeaderFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => HealthCheckAuthenticationNoneCollectRequestHeader$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'HealthCheckAuthenticationNoneCollectRequestHeader' from JSON`);
+}
+/** @internal */
+export const HealthCheckAuthenticationNoneHiddenDefaultBreakers$inboundSchema = openEnums.inboundSchema(HealthCheckAuthenticationNoneHiddenDefaultBreakers);
+/** @internal */
+export const HealthCheckAuthenticationNoneHiddenDefaultBreakers$outboundSchema = openEnums.outboundSchema(HealthCheckAuthenticationNoneHiddenDefaultBreakers);
+/** @internal */
+export const HealthCheckAuthenticationNoneRetryType$inboundSchema = openEnums.inboundSchema(HealthCheckAuthenticationNoneRetryType);
+/** @internal */
+export const HealthCheckAuthenticationNoneRetryType$outboundSchema = openEnums.outboundSchema(HealthCheckAuthenticationNoneRetryType);
+/** @internal */
+export const HealthCheckAuthenticationNoneRetryRules$inboundSchema = z.object({
+    type: HealthCheckAuthenticationNoneRetryType$inboundSchema.default("backoff"),
+    interval: z.any().optional(),
+    limit: z.any().optional(),
+    multiplier: z.any().optional(),
+    codes: z.any().optional(),
+    enableHeader: z.any().optional(),
+});
+/** @internal */
+export const HealthCheckAuthenticationNoneRetryRules$outboundSchema = z.object({
+    type: HealthCheckAuthenticationNoneRetryType$outboundSchema.default("backoff"),
+    interval: z.any().optional(),
+    limit: z.any().optional(),
+    multiplier: z.any().optional(),
+    codes: z.any().optional(),
+    enableHeader: z.any().optional(),
+});
+export function healthCheckAuthenticationNoneRetryRulesToJSON(healthCheckAuthenticationNoneRetryRules) {
+    return JSON.stringify(HealthCheckAuthenticationNoneRetryRules$outboundSchema.parse(healthCheckAuthenticationNoneRetryRules));
+}
+export function healthCheckAuthenticationNoneRetryRulesFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => HealthCheckAuthenticationNoneRetryRules$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'HealthCheckAuthenticationNoneRetryRules' from JSON`);
+}
+/** @internal */
+export const HealthCheckAuthenticationNone$inboundSchema = z.object({
+    authentication: z.literal("none"),
+    discovery: z.lazy(() => HealthCheckAuthenticationNoneDiscovery$inboundSchema)
+        .optional(),
+    collectUrl: z.string(),
+    collectMethod: HealthCheckAuthenticationNoneHealthCheckMethod$inboundSchema
+        .default("get"),
+    collectRequestParams: z.any().optional(),
+    collectBody: z.any().optional(),
+    collectRequestHeaders: z.array(z.lazy(() => HealthCheckAuthenticationNoneCollectRequestHeader$inboundSchema)).optional(),
+    authenticateCollect: z.boolean().default(false),
+    timeout: z.number().default(30),
+    rejectUnauthorized: z.boolean().default(false),
+    defaultBreakers: HealthCheckAuthenticationNoneHiddenDefaultBreakers$inboundSchema.optional(),
+    safeHeaders: z.array(z.string()).optional(),
+    retryRules: z.lazy(() => HealthCheckAuthenticationNoneRetryRules$inboundSchema).optional(),
+});
+/** @internal */
+export const HealthCheckAuthenticationNone$outboundSchema = z.object({
+    authentication: z.literal("none"),
+    discovery: z.lazy(() => HealthCheckAuthenticationNoneDiscovery$outboundSchema)
+        .optional(),
+    collectUrl: z.string(),
+    collectMethod: HealthCheckAuthenticationNoneHealthCheckMethod$outboundSchema
+        .default("get"),
+    collectRequestParams: z.any().optional(),
+    collectBody: z.any().optional(),
+    collectRequestHeaders: z.array(z.lazy(() => HealthCheckAuthenticationNoneCollectRequestHeader$outboundSchema)).optional(),
+    authenticateCollect: z.boolean().default(false),
+    timeout: z.number().default(30),
+    rejectUnauthorized: z.boolean().default(false),
+    defaultBreakers: HealthCheckAuthenticationNoneHiddenDefaultBreakers$outboundSchema
+        .optional(),
+    safeHeaders: z.array(z.string()).optional(),
+    retryRules: z.lazy(() => HealthCheckAuthenticationNoneRetryRules$outboundSchema).optional(),
+});
+export function healthCheckAuthenticationNoneToJSON(healthCheckAuthenticationNone) {
+    return JSON.stringify(HealthCheckAuthenticationNone$outboundSchema.parse(healthCheckAuthenticationNone));
+}
+export function healthCheckAuthenticationNoneFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => HealthCheckAuthenticationNone$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'HealthCheckAuthenticationNone' from JSON`);
+}
+/** @internal */
+export const HealthCheckCollectMethodPostWithBodyHealthCheckMethod$inboundSchema = openEnums.inboundSchema(HealthCheckCollectMethodPostWithBodyHealthCheckMethod);
+/** @internal */
+export const HealthCheckCollectMethodPostWithBodyHealthCheckMethod$outboundSchema = openEnums.outboundSchema(HealthCheckCollectMethodPostWithBodyHealthCheckMethod);
+/** @internal */
+export const HealthCheckCollectMethodPostWithBodyDiscoverType$inboundSchema = openEnums.inboundSchema(HealthCheckCollectMethodPostWithBodyDiscoverType);
+/** @internal */
+export const HealthCheckCollectMethodPostWithBodyDiscoverType$outboundSchema = openEnums.outboundSchema(HealthCheckCollectMethodPostWithBodyDiscoverType);
+/** @internal */
+export const HealthCheckCollectMethodPostWithBodyDiscovery$inboundSchema = z.object({
+    discoverType: HealthCheckCollectMethodPostWithBodyDiscoverType$inboundSchema
+        .default("none"),
+});
+/** @internal */
+export const HealthCheckCollectMethodPostWithBodyDiscovery$outboundSchema = z.object({
+    discoverType: HealthCheckCollectMethodPostWithBodyDiscoverType$outboundSchema.default("none"),
+});
+export function healthCheckCollectMethodPostWithBodyDiscoveryToJSON(healthCheckCollectMethodPostWithBodyDiscovery) {
+    return JSON.stringify(HealthCheckCollectMethodPostWithBodyDiscovery$outboundSchema.parse(healthCheckCollectMethodPostWithBodyDiscovery));
+}
+export function healthCheckCollectMethodPostWithBodyDiscoveryFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => HealthCheckCollectMethodPostWithBodyDiscovery$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'HealthCheckCollectMethodPostWithBodyDiscovery' from JSON`);
+}
+/** @internal */
+export const HealthCheckCollectMethodPostWithBodyCollectRequestHeader$inboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+/** @internal */
+export const HealthCheckCollectMethodPostWithBodyCollectRequestHeader$outboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+export function healthCheckCollectMethodPostWithBodyCollectRequestHeaderToJSON(healthCheckCollectMethodPostWithBodyCollectRequestHeader) {
+    return JSON.stringify(HealthCheckCollectMethodPostWithBodyCollectRequestHeader$outboundSchema
+        .parse(healthCheckCollectMethodPostWithBodyCollectRequestHeader));
+}
+export function healthCheckCollectMethodPostWithBodyCollectRequestHeaderFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => HealthCheckCollectMethodPostWithBodyCollectRequestHeader$inboundSchema
+        .parse(JSON.parse(x)), `Failed to parse 'HealthCheckCollectMethodPostWithBodyCollectRequestHeader' from JSON`);
+}
+/** @internal */
+export const HealthCheckCollectMethodPostWithBodyAuthentication$inboundSchema = openEnums.inboundSchema(HealthCheckCollectMethodPostWithBodyAuthentication);
+/** @internal */
+export const HealthCheckCollectMethodPostWithBodyAuthentication$outboundSchema = openEnums.outboundSchema(HealthCheckCollectMethodPostWithBodyAuthentication);
+/** @internal */
+export const HealthCheckCollectMethodPostWithBodyHiddenDefaultBreakers$inboundSchema = openEnums.inboundSchema(HealthCheckCollectMethodPostWithBodyHiddenDefaultBreakers);
+/** @internal */
+export const HealthCheckCollectMethodPostWithBodyHiddenDefaultBreakers$outboundSchema = openEnums.outboundSchema(HealthCheckCollectMethodPostWithBodyHiddenDefaultBreakers);
+/** @internal */
+export const HealthCheckCollectMethodPostWithBodyRetryType$inboundSchema = openEnums.inboundSchema(HealthCheckCollectMethodPostWithBodyRetryType);
+/** @internal */
+export const HealthCheckCollectMethodPostWithBodyRetryType$outboundSchema = openEnums.outboundSchema(HealthCheckCollectMethodPostWithBodyRetryType);
+/** @internal */
+export const HealthCheckCollectMethodPostWithBodyRetryRules$inboundSchema = z.object({
+    type: HealthCheckCollectMethodPostWithBodyRetryType$inboundSchema.default("backoff"),
+    interval: z.any().optional(),
+    limit: z.any().optional(),
+    multiplier: z.any().optional(),
+    codes: z.any().optional(),
+    enableHeader: z.any().optional(),
+});
+/** @internal */
+export const HealthCheckCollectMethodPostWithBodyRetryRules$outboundSchema = z.object({
+    type: HealthCheckCollectMethodPostWithBodyRetryType$outboundSchema.default("backoff"),
+    interval: z.any().optional(),
+    limit: z.any().optional(),
+    multiplier: z.any().optional(),
+    codes: z.any().optional(),
+    enableHeader: z.any().optional(),
+});
+export function healthCheckCollectMethodPostWithBodyRetryRulesToJSON(healthCheckCollectMethodPostWithBodyRetryRules) {
+    return JSON.stringify(HealthCheckCollectMethodPostWithBodyRetryRules$outboundSchema.parse(healthCheckCollectMethodPostWithBodyRetryRules));
+}
+export function healthCheckCollectMethodPostWithBodyRetryRulesFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => HealthCheckCollectMethodPostWithBodyRetryRules$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'HealthCheckCollectMethodPostWithBodyRetryRules' from JSON`);
+}
+/** @internal */
+export const HealthCheckCollectMethodPostWithBody$inboundSchema = z.object({
+    collectMethod: HealthCheckCollectMethodPostWithBodyHealthCheckMethod$inboundSchema.default("get"),
+    collectBody: z.any().optional(),
+    discovery: z.lazy(() => HealthCheckCollectMethodPostWithBodyDiscovery$inboundSchema).optional(),
+    collectUrl: z.string(),
+    collectRequestParams: z.any().optional(),
+    collectRequestHeaders: z.array(z.lazy(() => HealthCheckCollectMethodPostWithBodyCollectRequestHeader$inboundSchema)).optional(),
+    authenticateCollect: z.boolean().default(false),
+    authentication: HealthCheckCollectMethodPostWithBodyAuthentication$inboundSchema.default("none"),
+    timeout: z.number().default(30),
+    rejectUnauthorized: z.boolean().default(false),
+    defaultBreakers: HealthCheckCollectMethodPostWithBodyHiddenDefaultBreakers$inboundSchema
+        .optional(),
+    safeHeaders: z.array(z.string()).optional(),
+    retryRules: z.lazy(() => HealthCheckCollectMethodPostWithBodyRetryRules$inboundSchema).optional(),
+});
+/** @internal */
+export const HealthCheckCollectMethodPostWithBody$outboundSchema = z.object({
+    collectMethod: HealthCheckCollectMethodPostWithBodyHealthCheckMethod$outboundSchema
+        .default("get"),
+    collectBody: z.any().optional(),
+    discovery: z.lazy(() => HealthCheckCollectMethodPostWithBodyDiscovery$outboundSchema).optional(),
+    collectUrl: z.string(),
+    collectRequestParams: z.any().optional(),
+    collectRequestHeaders: z.array(z.lazy(() => HealthCheckCollectMethodPostWithBodyCollectRequestHeader$outboundSchema)).optional(),
+    authenticateCollect: z.boolean().default(false),
+    authentication: HealthCheckCollectMethodPostWithBodyAuthentication$outboundSchema.default("none"),
+    timeout: z.number().default(30),
+    rejectUnauthorized: z.boolean().default(false),
+    defaultBreakers: HealthCheckCollectMethodPostWithBodyHiddenDefaultBreakers$outboundSchema
+        .optional(),
+    safeHeaders: z.array(z.string()).optional(),
+    retryRules: z.lazy(() => HealthCheckCollectMethodPostWithBodyRetryRules$outboundSchema).optional(),
+});
+export function healthCheckCollectMethodPostWithBodyToJSON(healthCheckCollectMethodPostWithBody) {
+    return JSON.stringify(HealthCheckCollectMethodPostWithBody$outboundSchema.parse(healthCheckCollectMethodPostWithBody));
+}
+export function healthCheckCollectMethodPostWithBodyFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => HealthCheckCollectMethodPostWithBody$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'HealthCheckCollectMethodPostWithBody' from JSON`);
+}
+/** @internal */
+export const HealthCheckCollectMethodPostHealthCheckMethod$inboundSchema = openEnums.inboundSchema(HealthCheckCollectMethodPostHealthCheckMethod);
+/** @internal */
+export const HealthCheckCollectMethodPostHealthCheckMethod$outboundSchema = openEnums.outboundSchema(HealthCheckCollectMethodPostHealthCheckMethod);
+/** @internal */
+export const HealthCheckCollectMethodPostDiscoverType$inboundSchema = openEnums.inboundSchema(HealthCheckCollectMethodPostDiscoverType);
+/** @internal */
+export const HealthCheckCollectMethodPostDiscoverType$outboundSchema = openEnums.outboundSchema(HealthCheckCollectMethodPostDiscoverType);
+/** @internal */
+export const HealthCheckCollectMethodPostDiscovery$inboundSchema = z.object({
+    discoverType: HealthCheckCollectMethodPostDiscoverType$inboundSchema.default("none"),
+});
+/** @internal */
+export const HealthCheckCollectMethodPostDiscovery$outboundSchema = z.object({
+    discoverType: HealthCheckCollectMethodPostDiscoverType$outboundSchema.default("none"),
+});
+export function healthCheckCollectMethodPostDiscoveryToJSON(healthCheckCollectMethodPostDiscovery) {
+    return JSON.stringify(HealthCheckCollectMethodPostDiscovery$outboundSchema.parse(healthCheckCollectMethodPostDiscovery));
+}
+export function healthCheckCollectMethodPostDiscoveryFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => HealthCheckCollectMethodPostDiscovery$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'HealthCheckCollectMethodPostDiscovery' from JSON`);
+}
+/** @internal */
+export const HealthCheckCollectMethodPostCollectRequestHeader$inboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+/** @internal */
+export const HealthCheckCollectMethodPostCollectRequestHeader$outboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+export function healthCheckCollectMethodPostCollectRequestHeaderToJSON(healthCheckCollectMethodPostCollectRequestHeader) {
+    return JSON.stringify(HealthCheckCollectMethodPostCollectRequestHeader$outboundSchema.parse(healthCheckCollectMethodPostCollectRequestHeader));
+}
+export function healthCheckCollectMethodPostCollectRequestHeaderFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => HealthCheckCollectMethodPostCollectRequestHeader$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'HealthCheckCollectMethodPostCollectRequestHeader' from JSON`);
+}
+/** @internal */
+export const HealthCheckCollectMethodPostAuthentication$inboundSchema = openEnums.inboundSchema(HealthCheckCollectMethodPostAuthentication);
+/** @internal */
+export const HealthCheckCollectMethodPostAuthentication$outboundSchema = openEnums.outboundSchema(HealthCheckCollectMethodPostAuthentication);
+/** @internal */
+export const HealthCheckCollectMethodPostHiddenDefaultBreakers$inboundSchema = openEnums.inboundSchema(HealthCheckCollectMethodPostHiddenDefaultBreakers);
+/** @internal */
+export const HealthCheckCollectMethodPostHiddenDefaultBreakers$outboundSchema = openEnums.outboundSchema(HealthCheckCollectMethodPostHiddenDefaultBreakers);
+/** @internal */
+export const HealthCheckCollectMethodPostRetryType$inboundSchema = openEnums.inboundSchema(HealthCheckCollectMethodPostRetryType);
+/** @internal */
+export const HealthCheckCollectMethodPostRetryType$outboundSchema = openEnums.outboundSchema(HealthCheckCollectMethodPostRetryType);
+/** @internal */
+export const HealthCheckCollectMethodPostRetryRules$inboundSchema = z.object({
+    type: HealthCheckCollectMethodPostRetryType$inboundSchema.default("backoff"),
+    interval: z.any().optional(),
+    limit: z.any().optional(),
+    multiplier: z.any().optional(),
+    codes: z.any().optional(),
+    enableHeader: z.any().optional(),
+});
+/** @internal */
+export const HealthCheckCollectMethodPostRetryRules$outboundSchema = z.object({
+    type: HealthCheckCollectMethodPostRetryType$outboundSchema.default("backoff"),
+    interval: z.any().optional(),
+    limit: z.any().optional(),
+    multiplier: z.any().optional(),
+    codes: z.any().optional(),
+    enableHeader: z.any().optional(),
+});
+export function healthCheckCollectMethodPostRetryRulesToJSON(healthCheckCollectMethodPostRetryRules) {
+    return JSON.stringify(HealthCheckCollectMethodPostRetryRules$outboundSchema.parse(healthCheckCollectMethodPostRetryRules));
+}
+export function healthCheckCollectMethodPostRetryRulesFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => HealthCheckCollectMethodPostRetryRules$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'HealthCheckCollectMethodPostRetryRules' from JSON`);
+}
+/** @internal */
+export const HealthCheckCollectMethodPost$inboundSchema = z.object({
+    collectMethod: HealthCheckCollectMethodPostHealthCheckMethod$inboundSchema
+        .default("get"),
+    collectRequestParams: z.any().optional(),
+    discovery: z.lazy(() => HealthCheckCollectMethodPostDiscovery$inboundSchema)
+        .optional(),
+    collectUrl: z.string(),
+    collectBody: z.any().optional(),
+    collectRequestHeaders: z.array(z.lazy(() => HealthCheckCollectMethodPostCollectRequestHeader$inboundSchema)).optional(),
+    authenticateCollect: z.boolean().default(false),
+    authentication: HealthCheckCollectMethodPostAuthentication$inboundSchema
+        .default("none"),
+    timeout: z.number().default(30),
+    rejectUnauthorized: z.boolean().default(false),
+    defaultBreakers: HealthCheckCollectMethodPostHiddenDefaultBreakers$inboundSchema.optional(),
+    safeHeaders: z.array(z.string()).optional(),
+    retryRules: z.lazy(() => HealthCheckCollectMethodPostRetryRules$inboundSchema)
+        .optional(),
+});
+/** @internal */
+export const HealthCheckCollectMethodPost$outboundSchema = z.object({
+    collectMethod: HealthCheckCollectMethodPostHealthCheckMethod$outboundSchema
+        .default("get"),
+    collectRequestParams: z.any().optional(),
+    discovery: z.lazy(() => HealthCheckCollectMethodPostDiscovery$outboundSchema)
+        .optional(),
+    collectUrl: z.string(),
+    collectBody: z.any().optional(),
+    collectRequestHeaders: z.array(z.lazy(() => HealthCheckCollectMethodPostCollectRequestHeader$outboundSchema)).optional(),
+    authenticateCollect: z.boolean().default(false),
+    authentication: HealthCheckCollectMethodPostAuthentication$outboundSchema
+        .default("none"),
+    timeout: z.number().default(30),
+    rejectUnauthorized: z.boolean().default(false),
+    defaultBreakers: HealthCheckCollectMethodPostHiddenDefaultBreakers$outboundSchema.optional(),
+    safeHeaders: z.array(z.string()).optional(),
+    retryRules: z.lazy(() => HealthCheckCollectMethodPostRetryRules$outboundSchema).optional(),
+});
+export function healthCheckCollectMethodPostToJSON(healthCheckCollectMethodPost) {
+    return JSON.stringify(HealthCheckCollectMethodPost$outboundSchema.parse(healthCheckCollectMethodPost));
+}
+export function healthCheckCollectMethodPostFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => HealthCheckCollectMethodPost$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'HealthCheckCollectMethodPost' from JSON`);
+}
+/** @internal */
+export const HealthCheckCollectMethodGetHealthCheckMethod$inboundSchema = openEnums.inboundSchema(HealthCheckCollectMethodGetHealthCheckMethod);
+/** @internal */
+export const HealthCheckCollectMethodGetHealthCheckMethod$outboundSchema = openEnums.outboundSchema(HealthCheckCollectMethodGetHealthCheckMethod);
+/** @internal */
+export const HealthCheckCollectMethodGetDiscoverType$inboundSchema = openEnums.inboundSchema(HealthCheckCollectMethodGetDiscoverType);
+/** @internal */
+export const HealthCheckCollectMethodGetDiscoverType$outboundSchema = openEnums.outboundSchema(HealthCheckCollectMethodGetDiscoverType);
+/** @internal */
+export const HealthCheckCollectMethodGetDiscovery$inboundSchema = z.object({
+    discoverType: HealthCheckCollectMethodGetDiscoverType$inboundSchema.default("none"),
+});
+/** @internal */
+export const HealthCheckCollectMethodGetDiscovery$outboundSchema = z.object({
+    discoverType: HealthCheckCollectMethodGetDiscoverType$outboundSchema.default("none"),
+});
+export function healthCheckCollectMethodGetDiscoveryToJSON(healthCheckCollectMethodGetDiscovery) {
+    return JSON.stringify(HealthCheckCollectMethodGetDiscovery$outboundSchema.parse(healthCheckCollectMethodGetDiscovery));
+}
+export function healthCheckCollectMethodGetDiscoveryFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => HealthCheckCollectMethodGetDiscovery$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'HealthCheckCollectMethodGetDiscovery' from JSON`);
+}
+/** @internal */
+export const HealthCheckCollectMethodGetCollectRequestHeader$inboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+/** @internal */
+export const HealthCheckCollectMethodGetCollectRequestHeader$outboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+export function healthCheckCollectMethodGetCollectRequestHeaderToJSON(healthCheckCollectMethodGetCollectRequestHeader) {
+    return JSON.stringify(HealthCheckCollectMethodGetCollectRequestHeader$outboundSchema.parse(healthCheckCollectMethodGetCollectRequestHeader));
+}
+export function healthCheckCollectMethodGetCollectRequestHeaderFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => HealthCheckCollectMethodGetCollectRequestHeader$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'HealthCheckCollectMethodGetCollectRequestHeader' from JSON`);
+}
+/** @internal */
+export const HealthCheckCollectMethodGetAuthentication$inboundSchema = openEnums.inboundSchema(HealthCheckCollectMethodGetAuthentication);
+/** @internal */
+export const HealthCheckCollectMethodGetAuthentication$outboundSchema = openEnums.outboundSchema(HealthCheckCollectMethodGetAuthentication);
+/** @internal */
+export const HealthCheckCollectMethodGetHiddenDefaultBreakers$inboundSchema = openEnums.inboundSchema(HealthCheckCollectMethodGetHiddenDefaultBreakers);
+/** @internal */
+export const HealthCheckCollectMethodGetHiddenDefaultBreakers$outboundSchema = openEnums.outboundSchema(HealthCheckCollectMethodGetHiddenDefaultBreakers);
+/** @internal */
+export const HealthCheckCollectMethodGetRetryType$inboundSchema = openEnums.inboundSchema(HealthCheckCollectMethodGetRetryType);
+/** @internal */
+export const HealthCheckCollectMethodGetRetryType$outboundSchema = openEnums.outboundSchema(HealthCheckCollectMethodGetRetryType);
+/** @internal */
+export const HealthCheckCollectMethodGetRetryRules$inboundSchema = z.object({
+    type: HealthCheckCollectMethodGetRetryType$inboundSchema.default("backoff"),
+    interval: z.any().optional(),
+    limit: z.any().optional(),
+    multiplier: z.any().optional(),
+    codes: z.any().optional(),
+    enableHeader: z.any().optional(),
+});
+/** @internal */
+export const HealthCheckCollectMethodGetRetryRules$outboundSchema = z.object({
+    type: HealthCheckCollectMethodGetRetryType$outboundSchema.default("backoff"),
+    interval: z.any().optional(),
+    limit: z.any().optional(),
+    multiplier: z.any().optional(),
+    codes: z.any().optional(),
+    enableHeader: z.any().optional(),
+});
+export function healthCheckCollectMethodGetRetryRulesToJSON(healthCheckCollectMethodGetRetryRules) {
+    return JSON.stringify(HealthCheckCollectMethodGetRetryRules$outboundSchema.parse(healthCheckCollectMethodGetRetryRules));
+}
+export function healthCheckCollectMethodGetRetryRulesFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => HealthCheckCollectMethodGetRetryRules$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'HealthCheckCollectMethodGetRetryRules' from JSON`);
+}
+/** @internal */
+export const HealthCheckCollectMethodGet$inboundSchema = z.object({
+    collectMethod: HealthCheckCollectMethodGetHealthCheckMethod$inboundSchema
+        .default("get"),
+    collectRequestParams: z.any().optional(),
+    discovery: z.lazy(() => HealthCheckCollectMethodGetDiscovery$inboundSchema)
+        .optional(),
+    collectUrl: z.string(),
+    collectBody: z.any().optional(),
+    collectRequestHeaders: z.array(z.lazy(() => HealthCheckCollectMethodGetCollectRequestHeader$inboundSchema)).optional(),
+    authenticateCollect: z.boolean().default(false),
+    authentication: HealthCheckCollectMethodGetAuthentication$inboundSchema
+        .default("none"),
+    timeout: z.number().default(30),
+    rejectUnauthorized: z.boolean().default(false),
+    defaultBreakers: HealthCheckCollectMethodGetHiddenDefaultBreakers$inboundSchema.optional(),
+    safeHeaders: z.array(z.string()).optional(),
+    retryRules: z.lazy(() => HealthCheckCollectMethodGetRetryRules$inboundSchema)
+        .optional(),
+});
+/** @internal */
+export const HealthCheckCollectMethodGet$outboundSchema = z.object({
+    collectMethod: HealthCheckCollectMethodGetHealthCheckMethod$outboundSchema
+        .default("get"),
+    collectRequestParams: z.any().optional(),
+    discovery: z.lazy(() => HealthCheckCollectMethodGetDiscovery$outboundSchema)
+        .optional(),
+    collectUrl: z.string(),
+    collectBody: z.any().optional(),
+    collectRequestHeaders: z.array(z.lazy(() => HealthCheckCollectMethodGetCollectRequestHeader$outboundSchema)).optional(),
+    authenticateCollect: z.boolean().default(false),
+    authentication: HealthCheckCollectMethodGetAuthentication$outboundSchema
+        .default("none"),
+    timeout: z.number().default(30),
+    rejectUnauthorized: z.boolean().default(false),
+    defaultBreakers: HealthCheckCollectMethodGetHiddenDefaultBreakers$outboundSchema.optional(),
+    safeHeaders: z.array(z.string()).optional(),
+    retryRules: z.lazy(() => HealthCheckCollectMethodGetRetryRules$outboundSchema)
+        .optional(),
+});
+export function healthCheckCollectMethodGetToJSON(healthCheckCollectMethodGet) {
+    return JSON.stringify(HealthCheckCollectMethodGet$outboundSchema.parse(healthCheckCollectMethodGet));
+}
+export function healthCheckCollectMethodGetFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => HealthCheckCollectMethodGet$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'HealthCheckCollectMethodGet' from JSON`);
+}
+/** @internal */
+export const HealthCheckCollectorConf$inboundSchema = z.union([
+    z.lazy(() => HealthCheckAuthenticationNone$inboundSchema),
+    z.lazy(() => HealthCheckAuthenticationBasic$inboundSchema),
+    z.lazy(() => HealthCheckAuthenticationBasicSecret$inboundSchema),
+    z.lazy(() => HealthCheckAuthenticationLogin$inboundSchema),
+    z.lazy(() => HealthCheckAuthenticationLoginSecret$inboundSchema),
+    z.lazy(() => HealthCheckAuthenticationOauth$inboundSchema),
+    z.lazy(() => HealthCheckAuthenticationOauthSecret$inboundSchema),
+]);
+/** @internal */
+export const HealthCheckCollectorConf$outboundSchema = z.union([
+    z.lazy(() => HealthCheckAuthenticationNone$outboundSchema),
+    z.lazy(() => HealthCheckAuthenticationBasic$outboundSchema),
+    z.lazy(() => HealthCheckAuthenticationBasicSecret$outboundSchema),
+    z.lazy(() => HealthCheckAuthenticationLogin$outboundSchema),
+    z.lazy(() => HealthCheckAuthenticationLoginSecret$outboundSchema),
+    z.lazy(() => HealthCheckAuthenticationOauth$outboundSchema),
+    z.lazy(() => HealthCheckAuthenticationOauthSecret$outboundSchema),
+]);
+export function healthCheckCollectorConfToJSON(healthCheckCollectorConf) {
+    return JSON.stringify(HealthCheckCollectorConf$outboundSchema.parse(healthCheckCollectorConf));
+}
+export function healthCheckCollectorConfFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => HealthCheckCollectorConf$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'HealthCheckCollectorConf' from JSON`);
+}
+//# sourceMappingURL=healthcheckcollectorconf.js.map