cribl-control-plane 0.4.0 → 0.5.0-beta.10

package/dist/esm/models/collectorhealthcheck.js

@@ -0,0 +1,2759 @@
+/*
+ * 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";
+/**
+ * Authentication method for Discover and Collect REST calls. You can specify API Key–based authentication by adding the appropriate Collect headers.
+ */
+export const CollectorHealthCheckAuthentication10 = {
+    None: "none",
+    Basic: "basic",
+    BasicSecret: "basicSecret",
+    Login: "login",
+    LoginSecret: "loginSecret",
+    Oauth: "oauth",
+    OauthSecret: "oauthSecret",
+};
+/**
+ * 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 CollectorHealthCheckDiscoverType10 = {
+    /**
+     * HTTP Request
+     */
+    Http: "http",
+    /**
+     * JSON Response
+     */
+    Json: "json",
+    /**
+     * Item List
+     */
+    List: "list",
+    /**
+     * None
+     */
+    None: "none",
+};
+/**
+ * Health check HTTP method.
+ */
+export const HealthCheckMethod10 = {
+    /**
+     * GET
+     */
+    Get: "get",
+    /**
+     * POST
+     */
+    Post: "post",
+    /**
+     * POST with Body
+     */
+    PostWithBody: "post_with_body",
+};
+export const CollectorHealthCheckHiddenDefaultBreakers10 = {
+    Cribl: "Cribl",
+};
+/**
+ * The algorithm to use when performing HTTP retries
+ */
+export const CollectorHealthCheckRetryType10 = {
+    /**
+     * Disabled
+     */
+    None: "none",
+    /**
+     * Backoff
+     */
+    Backoff: "backoff",
+    /**
+     * Static
+     */
+    Static: "static",
+};
+/**
+ * Collector type: health_check
+ */
+export const CollectorHealthCheckType10 = {
+    HealthCheck: "health_check",
+};
+/**
+ * Authentication method for Discover and Collect REST calls. You can specify API Key–based authentication by adding the appropriate Collect headers.
+ */
+export const CollectorHealthCheckAuthentication9 = {
+    None: "none",
+    Basic: "basic",
+    BasicSecret: "basicSecret",
+    Login: "login",
+    LoginSecret: "loginSecret",
+    Oauth: "oauth",
+    OauthSecret: "oauthSecret",
+};
+/**
+ * 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 CollectorHealthCheckDiscoverType9 = {
+    /**
+     * HTTP Request
+     */
+    Http: "http",
+    /**
+     * JSON Response
+     */
+    Json: "json",
+    /**
+     * Item List
+     */
+    List: "list",
+    /**
+     * None
+     */
+    None: "none",
+};
+/**
+ * Health check HTTP method.
+ */
+export const HealthCheckMethod9 = {
+    /**
+     * GET
+     */
+    Get: "get",
+    /**
+     * POST
+     */
+    Post: "post",
+    /**
+     * POST with Body
+     */
+    PostWithBody: "post_with_body",
+};
+export const CollectorHealthCheckHiddenDefaultBreakers9 = {
+    Cribl: "Cribl",
+};
+/**
+ * The algorithm to use when performing HTTP retries
+ */
+export const CollectorHealthCheckRetryType9 = {
+    /**
+     * Disabled
+     */
+    None: "none",
+    /**
+     * Backoff
+     */
+    Backoff: "backoff",
+    /**
+     * Static
+     */
+    Static: "static",
+};
+/**
+ * Collector type: health_check
+ */
+export const CollectorHealthCheckType9 = {
+    HealthCheck: "health_check",
+};
+/**
+ * Authentication method for Discover and Collect REST calls. You can specify API Key–based authentication by adding the appropriate Collect headers.
+ */
+export const CollectorHealthCheckAuthentication8 = {
+    None: "none",
+    Basic: "basic",
+    BasicSecret: "basicSecret",
+    Login: "login",
+    LoginSecret: "loginSecret",
+    Oauth: "oauth",
+    OauthSecret: "oauthSecret",
+};
+/**
+ * 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 CollectorHealthCheckDiscoverType8 = {
+    /**
+     * HTTP Request
+     */
+    Http: "http",
+    /**
+     * JSON Response
+     */
+    Json: "json",
+    /**
+     * Item List
+     */
+    List: "list",
+    /**
+     * None
+     */
+    None: "none",
+};
+/**
+ * Health check HTTP method.
+ */
+export const HealthCheckMethod8 = {
+    /**
+     * GET
+     */
+    Get: "get",
+    /**
+     * POST
+     */
+    Post: "post",
+    /**
+     * POST with Body
+     */
+    PostWithBody: "post_with_body",
+};
+export const CollectorHealthCheckHiddenDefaultBreakers8 = {
+    Cribl: "Cribl",
+};
+/**
+ * The algorithm to use when performing HTTP retries
+ */
+export const CollectorHealthCheckRetryType8 = {
+    /**
+     * Disabled
+     */
+    None: "none",
+    /**
+     * Backoff
+     */
+    Backoff: "backoff",
+    /**
+     * Static
+     */
+    Static: "static",
+};
+/**
+ * Collector type: health_check
+ */
+export const CollectorHealthCheckType8 = {
+    HealthCheck: "health_check",
+};
+/**
+ * Authentication method for Discover and Collect REST calls. You can specify API Key–based authentication by adding the appropriate Collect headers.
+ */
+export const CollectorHealthCheckAuthentication7 = {
+    None: "none",
+    Basic: "basic",
+    BasicSecret: "basicSecret",
+    Login: "login",
+    LoginSecret: "loginSecret",
+    Oauth: "oauth",
+    OauthSecret: "oauthSecret",
+};
+/**
+ * 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 CollectorHealthCheckDiscoverType7 = {
+    /**
+     * HTTP Request
+     */
+    Http: "http",
+    /**
+     * JSON Response
+     */
+    Json: "json",
+    /**
+     * Item List
+     */
+    List: "list",
+    /**
+     * None
+     */
+    None: "none",
+};
+/**
+ * Health check HTTP method.
+ */
+export const HealthCheckMethod7 = {
+    /**
+     * GET
+     */
+    Get: "get",
+    /**
+     * POST
+     */
+    Post: "post",
+    /**
+     * POST with Body
+     */
+    PostWithBody: "post_with_body",
+};
+export const CollectorHealthCheckHiddenDefaultBreakers7 = {
+    Cribl: "Cribl",
+};
+/**
+ * The algorithm to use when performing HTTP retries
+ */
+export const CollectorHealthCheckRetryType7 = {
+    /**
+     * Disabled
+     */
+    None: "none",
+    /**
+     * Backoff
+     */
+    Backoff: "backoff",
+    /**
+     * Static
+     */
+    Static: "static",
+};
+/**
+ * Collector type: health_check
+ */
+export const CollectorHealthCheckType7 = {
+    HealthCheck: "health_check",
+};
+/**
+ * Authentication method for Discover and Collect REST calls. You can specify API Key–based authentication by adding the appropriate Collect headers.
+ */
+export const CollectorHealthCheckAuthentication6 = {
+    None: "none",
+    Basic: "basic",
+    BasicSecret: "basicSecret",
+    Login: "login",
+    LoginSecret: "loginSecret",
+    Oauth: "oauth",
+    OauthSecret: "oauthSecret",
+};
+/**
+ * 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 CollectorHealthCheckDiscoverType6 = {
+    /**
+     * HTTP Request
+     */
+    Http: "http",
+    /**
+     * JSON Response
+     */
+    Json: "json",
+    /**
+     * Item List
+     */
+    List: "list",
+    /**
+     * None
+     */
+    None: "none",
+};
+/**
+ * Health check HTTP method.
+ */
+export const HealthCheckMethod6 = {
+    /**
+     * GET
+     */
+    Get: "get",
+    /**
+     * POST
+     */
+    Post: "post",
+    /**
+     * POST with Body
+     */
+    PostWithBody: "post_with_body",
+};
+export const CollectorHealthCheckHiddenDefaultBreakers6 = {
+    Cribl: "Cribl",
+};
+/**
+ * The algorithm to use when performing HTTP retries
+ */
+export const CollectorHealthCheckRetryType6 = {
+    /**
+     * Disabled
+     */
+    None: "none",
+    /**
+     * Backoff
+     */
+    Backoff: "backoff",
+    /**
+     * Static
+     */
+    Static: "static",
+};
+/**
+ * Collector type: health_check
+ */
+export const CollectorHealthCheckType6 = {
+    HealthCheck: "health_check",
+};
+/**
+ * Authentication method for Discover and Collect REST calls. You can specify API Key–based authentication by adding the appropriate Collect headers.
+ */
+export const CollectorHealthCheckAuthentication5 = {
+    None: "none",
+    Basic: "basic",
+    BasicSecret: "basicSecret",
+    Login: "login",
+    LoginSecret: "loginSecret",
+    Oauth: "oauth",
+    OauthSecret: "oauthSecret",
+};
+/**
+ * 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 CollectorHealthCheckDiscoverType5 = {
+    /**
+     * HTTP Request
+     */
+    Http: "http",
+    /**
+     * JSON Response
+     */
+    Json: "json",
+    /**
+     * Item List
+     */
+    List: "list",
+    /**
+     * None
+     */
+    None: "none",
+};
+/**
+ * Health check HTTP method.
+ */
+export const HealthCheckMethod5 = {
+    /**
+     * GET
+     */
+    Get: "get",
+    /**
+     * POST
+     */
+    Post: "post",
+    /**
+     * POST with Body
+     */
+    PostWithBody: "post_with_body",
+};
+export const CollectorHealthCheckHiddenDefaultBreakers5 = {
+    Cribl: "Cribl",
+};
+/**
+ * The algorithm to use when performing HTTP retries
+ */
+export const CollectorHealthCheckRetryType5 = {
+    /**
+     * Disabled
+     */
+    None: "none",
+    /**
+     * Backoff
+     */
+    Backoff: "backoff",
+    /**
+     * Static
+     */
+    Static: "static",
+};
+/**
+ * Collector type: health_check
+ */
+export const CollectorHealthCheckType5 = {
+    HealthCheck: "health_check",
+};
+/**
+ * Authentication method for Discover and Collect REST calls. You can specify API Key–based authentication by adding the appropriate Collect headers.
+ */
+export const CollectorHealthCheckAuthentication4 = {
+    None: "none",
+    Basic: "basic",
+    BasicSecret: "basicSecret",
+    Login: "login",
+    LoginSecret: "loginSecret",
+    Oauth: "oauth",
+    OauthSecret: "oauthSecret",
+};
+/**
+ * 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 CollectorHealthCheckDiscoverType4 = {
+    /**
+     * HTTP Request
+     */
+    Http: "http",
+    /**
+     * JSON Response
+     */
+    Json: "json",
+    /**
+     * Item List
+     */
+    List: "list",
+    /**
+     * None
+     */
+    None: "none",
+};
+/**
+ * Health check HTTP method.
+ */
+export const HealthCheckMethod4 = {
+    /**
+     * GET
+     */
+    Get: "get",
+    /**
+     * POST
+     */
+    Post: "post",
+    /**
+     * POST with Body
+     */
+    PostWithBody: "post_with_body",
+};
+export const CollectorHealthCheckHiddenDefaultBreakers4 = {
+    Cribl: "Cribl",
+};
+/**
+ * The algorithm to use when performing HTTP retries
+ */
+export const CollectorHealthCheckRetryType4 = {
+    /**
+     * Disabled
+     */
+    None: "none",
+    /**
+     * Backoff
+     */
+    Backoff: "backoff",
+    /**
+     * Static
+     */
+    Static: "static",
+};
+/**
+ * Collector type: health_check
+ */
+export const CollectorHealthCheckType4 = {
+    HealthCheck: "health_check",
+};
+/**
+ * Health check HTTP method.
+ */
+export const HealthCheckMethod3 = {
+    /**
+     * 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 CollectorHealthCheckDiscoverType3 = {
+    /**
+     * 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 CollectorHealthCheckAuthentication3 = {
+    None: "none",
+    Basic: "basic",
+    BasicSecret: "basicSecret",
+    Login: "login",
+    LoginSecret: "loginSecret",
+    Oauth: "oauth",
+    OauthSecret: "oauthSecret",
+};
+export const CollectorHealthCheckHiddenDefaultBreakers3 = {
+    Cribl: "Cribl",
+};
+/**
+ * The algorithm to use when performing HTTP retries
+ */
+export const CollectorHealthCheckRetryType3 = {
+    /**
+     * Disabled
+     */
+    None: "none",
+    /**
+     * Backoff
+     */
+    Backoff: "backoff",
+    /**
+     * Static
+     */
+    Static: "static",
+};
+/**
+ * Collector type: health_check
+ */
+export const CollectorHealthCheckType3 = {
+    HealthCheck: "health_check",
+};
+/**
+ * Health check HTTP method.
+ */
+export const HealthCheckMethod2 = {
+    /**
+     * 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 CollectorHealthCheckDiscoverType2 = {
+    /**
+     * 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 CollectorHealthCheckAuthentication2 = {
+    None: "none",
+    Basic: "basic",
+    BasicSecret: "basicSecret",
+    Login: "login",
+    LoginSecret: "loginSecret",
+    Oauth: "oauth",
+    OauthSecret: "oauthSecret",
+};
+export const CollectorHealthCheckHiddenDefaultBreakers2 = {
+    Cribl: "Cribl",
+};
+/**
+ * The algorithm to use when performing HTTP retries
+ */
+export const CollectorHealthCheckRetryType2 = {
+    /**
+     * Disabled
+     */
+    None: "none",
+    /**
+     * Backoff
+     */
+    Backoff: "backoff",
+    /**
+     * Static
+     */
+    Static: "static",
+};
+/**
+ * Collector type: health_check
+ */
+export const CollectorHealthCheckType2 = {
+    HealthCheck: "health_check",
+};
+/**
+ * Health check HTTP method.
+ */
+export const HealthCheckMethod1 = {
+    /**
+     * 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 CollectorHealthCheckDiscoverType1 = {
+    /**
+     * 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 CollectorHealthCheckAuthentication1 = {
+    None: "none",
+    Basic: "basic",
+    BasicSecret: "basicSecret",
+    Login: "login",
+    LoginSecret: "loginSecret",
+    Oauth: "oauth",
+    OauthSecret: "oauthSecret",
+};
+export const CollectorHealthCheckHiddenDefaultBreakers1 = {
+    Cribl: "Cribl",
+};
+/**
+ * The algorithm to use when performing HTTP retries
+ */
+export const CollectorHealthCheckRetryType1 = {
+    /**
+     * Disabled
+     */
+    None: "none",
+    /**
+     * Backoff
+     */
+    Backoff: "backoff",
+    /**
+     * Static
+     */
+    Static: "static",
+};
+/**
+ * Collector type: health_check
+ */
+export const CollectorHealthCheckType1 = {
+    HealthCheck: "health_check",
+};
+/** @internal */
+export const CollectorHealthCheckAuthentication10$inboundSchema = openEnums.inboundSchema(CollectorHealthCheckAuthentication10);
+/** @internal */
+export const CollectorHealthCheckAuthentication10$outboundSchema = openEnums.outboundSchema(CollectorHealthCheckAuthentication10);
+/** @internal */
+export const CollectorHealthCheckAuthRequestParam10$inboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+/** @internal */
+export const CollectorHealthCheckAuthRequestParam10$outboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+export function collectorHealthCheckAuthRequestParam10ToJSON(collectorHealthCheckAuthRequestParam10) {
+    return JSON.stringify(CollectorHealthCheckAuthRequestParam10$outboundSchema.parse(collectorHealthCheckAuthRequestParam10));
+}
+export function collectorHealthCheckAuthRequestParam10FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorHealthCheckAuthRequestParam10$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorHealthCheckAuthRequestParam10' from JSON`);
+}
+/** @internal */
+export const CollectorHealthCheckAuthRequestHeader10$inboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+/** @internal */
+export const CollectorHealthCheckAuthRequestHeader10$outboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+export function collectorHealthCheckAuthRequestHeader10ToJSON(collectorHealthCheckAuthRequestHeader10) {
+    return JSON.stringify(CollectorHealthCheckAuthRequestHeader10$outboundSchema.parse(collectorHealthCheckAuthRequestHeader10));
+}
+export function collectorHealthCheckAuthRequestHeader10FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorHealthCheckAuthRequestHeader10$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorHealthCheckAuthRequestHeader10' from JSON`);
+}
+/** @internal */
+export const CollectorHealthCheckDiscoverType10$inboundSchema = openEnums.inboundSchema(CollectorHealthCheckDiscoverType10);
+/** @internal */
+export const CollectorHealthCheckDiscoverType10$outboundSchema = openEnums.outboundSchema(CollectorHealthCheckDiscoverType10);
+/** @internal */
+export const CollectorHealthCheckDiscovery10$inboundSchema = z.object({
+    discoverType: CollectorHealthCheckDiscoverType10$inboundSchema.default("none"),
+});
+/** @internal */
+export const CollectorHealthCheckDiscovery10$outboundSchema = z.object({
+    discoverType: CollectorHealthCheckDiscoverType10$outboundSchema.default("none"),
+});
+export function collectorHealthCheckDiscovery10ToJSON(collectorHealthCheckDiscovery10) {
+    return JSON.stringify(CollectorHealthCheckDiscovery10$outboundSchema.parse(collectorHealthCheckDiscovery10));
+}
+export function collectorHealthCheckDiscovery10FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorHealthCheckDiscovery10$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorHealthCheckDiscovery10' from JSON`);
+}
+/** @internal */
+export const HealthCheckMethod10$inboundSchema = openEnums.inboundSchema(HealthCheckMethod10);
+/** @internal */
+export const HealthCheckMethod10$outboundSchema = openEnums.outboundSchema(HealthCheckMethod10);
+/** @internal */
+export const CollectorHealthCheckCollectRequestParam10$inboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+/** @internal */
+export const CollectorHealthCheckCollectRequestParam10$outboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+export function collectorHealthCheckCollectRequestParam10ToJSON(collectorHealthCheckCollectRequestParam10) {
+    return JSON.stringify(CollectorHealthCheckCollectRequestParam10$outboundSchema.parse(collectorHealthCheckCollectRequestParam10));
+}
+export function collectorHealthCheckCollectRequestParam10FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorHealthCheckCollectRequestParam10$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorHealthCheckCollectRequestParam10' from JSON`);
+}
+/** @internal */
+export const CollectorHealthCheckCollectRequestHeader10$inboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+/** @internal */
+export const CollectorHealthCheckCollectRequestHeader10$outboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+export function collectorHealthCheckCollectRequestHeader10ToJSON(collectorHealthCheckCollectRequestHeader10) {
+    return JSON.stringify(CollectorHealthCheckCollectRequestHeader10$outboundSchema.parse(collectorHealthCheckCollectRequestHeader10));
+}
+export function collectorHealthCheckCollectRequestHeader10FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorHealthCheckCollectRequestHeader10$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorHealthCheckCollectRequestHeader10' from JSON`);
+}
+/** @internal */
+export const CollectorHealthCheckHiddenDefaultBreakers10$inboundSchema = openEnums.inboundSchema(CollectorHealthCheckHiddenDefaultBreakers10);
+/** @internal */
+export const CollectorHealthCheckHiddenDefaultBreakers10$outboundSchema = openEnums.outboundSchema(CollectorHealthCheckHiddenDefaultBreakers10);
+/** @internal */
+export const CollectorHealthCheckRetryType10$inboundSchema = openEnums.inboundSchema(CollectorHealthCheckRetryType10);
+/** @internal */
+export const CollectorHealthCheckRetryType10$outboundSchema = openEnums.outboundSchema(CollectorHealthCheckRetryType10);
+/** @internal */
+export const CollectorHealthCheckRetryRules10$inboundSchema = z.object({
+    type: CollectorHealthCheckRetryType10$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 CollectorHealthCheckRetryRules10$outboundSchema = z.object({
+    type: CollectorHealthCheckRetryType10$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 collectorHealthCheckRetryRules10ToJSON(collectorHealthCheckRetryRules10) {
+    return JSON.stringify(CollectorHealthCheckRetryRules10$outboundSchema.parse(collectorHealthCheckRetryRules10));
+}
+export function collectorHealthCheckRetryRules10FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorHealthCheckRetryRules10$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorHealthCheckRetryRules10' from JSON`);
+}
+/** @internal */
+export const CollectorHealthCheckType10$inboundSchema = z.nativeEnum(CollectorHealthCheckType10);
+/** @internal */
+export const CollectorHealthCheckType10$outboundSchema = CollectorHealthCheckType10$inboundSchema;
+/** @internal */
+export const CollectorHealthCheckHealthCheck10$inboundSchema = z.object({
+    authentication: CollectorHealthCheckAuthentication10$inboundSchema.default("none"),
+    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(() => CollectorHealthCheckAuthRequestParam10$inboundSchema)).optional(),
+    authRequestHeaders: z.array(z.lazy(() => CollectorHealthCheckAuthRequestHeader10$inboundSchema)).optional(),
+    discovery: z.lazy(() => CollectorHealthCheckDiscovery10$inboundSchema)
+        .optional(),
+    collectUrl: z.string(),
+    collectMethod: HealthCheckMethod10$inboundSchema.default("get"),
+    collectRequestParams: z.array(z.lazy(() => CollectorHealthCheckCollectRequestParam10$inboundSchema)).optional(),
+    collectBody: z.string().default("`{ }`"),
+    collectRequestHeaders: z.array(z.lazy(() => CollectorHealthCheckCollectRequestHeader10$inboundSchema)).optional(),
+    authenticateCollect: z.boolean().default(false),
+    timeout: z.number().default(30),
+    rejectUnauthorized: z.boolean().default(false),
+    defaultBreakers: CollectorHealthCheckHiddenDefaultBreakers10$inboundSchema
+        .optional(),
+    safeHeaders: z.array(z.string()).optional(),
+    retryRules: z.lazy(() => CollectorHealthCheckRetryRules10$inboundSchema)
+        .optional(),
+    username: z.string().optional(),
+    password: z.string().optional(),
+    credentialsSecret: z.string().optional(),
+    loginBody: z.string().default("`{ \"username\": \"${username}\", \"password\": \"${password}\" }`"),
+    clientSecretParamValue: z.string().optional(),
+    type: CollectorHealthCheckType10$inboundSchema,
+});
+/** @internal */
+export const CollectorHealthCheckHealthCheck10$outboundSchema = z.object({
+    authentication: CollectorHealthCheckAuthentication10$outboundSchema.default("none"),
+    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(() => CollectorHealthCheckAuthRequestParam10$outboundSchema)).optional(),
+    authRequestHeaders: z.array(z.lazy(() => CollectorHealthCheckAuthRequestHeader10$outboundSchema)).optional(),
+    discovery: z.lazy(() => CollectorHealthCheckDiscovery10$outboundSchema)
+        .optional(),
+    collectUrl: z.string(),
+    collectMethod: HealthCheckMethod10$outboundSchema.default("get"),
+    collectRequestParams: z.array(z.lazy(() => CollectorHealthCheckCollectRequestParam10$outboundSchema)).optional(),
+    collectBody: z.string().default("`{ }`"),
+    collectRequestHeaders: z.array(z.lazy(() => CollectorHealthCheckCollectRequestHeader10$outboundSchema)).optional(),
+    authenticateCollect: z.boolean().default(false),
+    timeout: z.number().default(30),
+    rejectUnauthorized: z.boolean().default(false),
+    defaultBreakers: CollectorHealthCheckHiddenDefaultBreakers10$outboundSchema
+        .optional(),
+    safeHeaders: z.array(z.string()).optional(),
+    retryRules: z.lazy(() => CollectorHealthCheckRetryRules10$outboundSchema)
+        .optional(),
+    username: z.string().optional(),
+    password: z.string().optional(),
+    credentialsSecret: z.string().optional(),
+    loginBody: z.string().default("`{ \"username\": \"${username}\", \"password\": \"${password}\" }`"),
+    clientSecretParamValue: z.string().optional(),
+    type: CollectorHealthCheckType10$outboundSchema,
+});
+export function collectorHealthCheckHealthCheck10ToJSON(collectorHealthCheckHealthCheck10) {
+    return JSON.stringify(CollectorHealthCheckHealthCheck10$outboundSchema.parse(collectorHealthCheckHealthCheck10));
+}
+export function collectorHealthCheckHealthCheck10FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorHealthCheckHealthCheck10$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorHealthCheckHealthCheck10' from JSON`);
+}
+/** @internal */
+export const CollectorHealthCheckAuthentication9$inboundSchema = openEnums.inboundSchema(CollectorHealthCheckAuthentication9);
+/** @internal */
+export const CollectorHealthCheckAuthentication9$outboundSchema = openEnums.outboundSchema(CollectorHealthCheckAuthentication9);
+/** @internal */
+export const CollectorHealthCheckAuthRequestParam9$inboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+/** @internal */
+export const CollectorHealthCheckAuthRequestParam9$outboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+export function collectorHealthCheckAuthRequestParam9ToJSON(collectorHealthCheckAuthRequestParam9) {
+    return JSON.stringify(CollectorHealthCheckAuthRequestParam9$outboundSchema.parse(collectorHealthCheckAuthRequestParam9));
+}
+export function collectorHealthCheckAuthRequestParam9FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorHealthCheckAuthRequestParam9$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorHealthCheckAuthRequestParam9' from JSON`);
+}
+/** @internal */
+export const CollectorHealthCheckAuthRequestHeader9$inboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+/** @internal */
+export const CollectorHealthCheckAuthRequestHeader9$outboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+export function collectorHealthCheckAuthRequestHeader9ToJSON(collectorHealthCheckAuthRequestHeader9) {
+    return JSON.stringify(CollectorHealthCheckAuthRequestHeader9$outboundSchema.parse(collectorHealthCheckAuthRequestHeader9));
+}
+export function collectorHealthCheckAuthRequestHeader9FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorHealthCheckAuthRequestHeader9$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorHealthCheckAuthRequestHeader9' from JSON`);
+}
+/** @internal */
+export const CollectorHealthCheckDiscoverType9$inboundSchema = openEnums.inboundSchema(CollectorHealthCheckDiscoverType9);
+/** @internal */
+export const CollectorHealthCheckDiscoverType9$outboundSchema = openEnums.outboundSchema(CollectorHealthCheckDiscoverType9);
+/** @internal */
+export const CollectorHealthCheckDiscovery9$inboundSchema = z.object({
+    discoverType: CollectorHealthCheckDiscoverType9$inboundSchema.default("none"),
+});
+/** @internal */
+export const CollectorHealthCheckDiscovery9$outboundSchema = z.object({
+    discoverType: CollectorHealthCheckDiscoverType9$outboundSchema.default("none"),
+});
+export function collectorHealthCheckDiscovery9ToJSON(collectorHealthCheckDiscovery9) {
+    return JSON.stringify(CollectorHealthCheckDiscovery9$outboundSchema.parse(collectorHealthCheckDiscovery9));
+}
+export function collectorHealthCheckDiscovery9FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorHealthCheckDiscovery9$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorHealthCheckDiscovery9' from JSON`);
+}
+/** @internal */
+export const HealthCheckMethod9$inboundSchema = openEnums.inboundSchema(HealthCheckMethod9);
+/** @internal */
+export const HealthCheckMethod9$outboundSchema = openEnums.outboundSchema(HealthCheckMethod9);
+/** @internal */
+export const CollectorHealthCheckCollectRequestParam9$inboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+/** @internal */
+export const CollectorHealthCheckCollectRequestParam9$outboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+export function collectorHealthCheckCollectRequestParam9ToJSON(collectorHealthCheckCollectRequestParam9) {
+    return JSON.stringify(CollectorHealthCheckCollectRequestParam9$outboundSchema.parse(collectorHealthCheckCollectRequestParam9));
+}
+export function collectorHealthCheckCollectRequestParam9FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorHealthCheckCollectRequestParam9$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorHealthCheckCollectRequestParam9' from JSON`);
+}
+/** @internal */
+export const CollectorHealthCheckCollectRequestHeader9$inboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+/** @internal */
+export const CollectorHealthCheckCollectRequestHeader9$outboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+export function collectorHealthCheckCollectRequestHeader9ToJSON(collectorHealthCheckCollectRequestHeader9) {
+    return JSON.stringify(CollectorHealthCheckCollectRequestHeader9$outboundSchema.parse(collectorHealthCheckCollectRequestHeader9));
+}
+export function collectorHealthCheckCollectRequestHeader9FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorHealthCheckCollectRequestHeader9$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorHealthCheckCollectRequestHeader9' from JSON`);
+}
+/** @internal */
+export const CollectorHealthCheckHiddenDefaultBreakers9$inboundSchema = openEnums.inboundSchema(CollectorHealthCheckHiddenDefaultBreakers9);
+/** @internal */
+export const CollectorHealthCheckHiddenDefaultBreakers9$outboundSchema = openEnums.outboundSchema(CollectorHealthCheckHiddenDefaultBreakers9);
+/** @internal */
+export const CollectorHealthCheckRetryType9$inboundSchema = openEnums.inboundSchema(CollectorHealthCheckRetryType9);
+/** @internal */
+export const CollectorHealthCheckRetryType9$outboundSchema = openEnums.outboundSchema(CollectorHealthCheckRetryType9);
+/** @internal */
+export const CollectorHealthCheckRetryRules9$inboundSchema = z.object({
+    type: CollectorHealthCheckRetryType9$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 CollectorHealthCheckRetryRules9$outboundSchema = z.object({
+    type: CollectorHealthCheckRetryType9$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 collectorHealthCheckRetryRules9ToJSON(collectorHealthCheckRetryRules9) {
+    return JSON.stringify(CollectorHealthCheckRetryRules9$outboundSchema.parse(collectorHealthCheckRetryRules9));
+}
+export function collectorHealthCheckRetryRules9FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorHealthCheckRetryRules9$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorHealthCheckRetryRules9' from JSON`);
+}
+/** @internal */
+export const CollectorHealthCheckType9$inboundSchema = z.nativeEnum(CollectorHealthCheckType9);
+/** @internal */
+export const CollectorHealthCheckType9$outboundSchema = CollectorHealthCheckType9$inboundSchema;
+/** @internal */
+export const CollectorHealthCheckHealthCheck9$inboundSchema = z.object({
+    authentication: CollectorHealthCheckAuthentication9$inboundSchema.default("none"),
+    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(() => CollectorHealthCheckAuthRequestParam9$inboundSchema)).optional(),
+    authRequestHeaders: z.array(z.lazy(() => CollectorHealthCheckAuthRequestHeader9$inboundSchema)).optional(),
+    discovery: z.lazy(() => CollectorHealthCheckDiscovery9$inboundSchema)
+        .optional(),
+    collectUrl: z.string(),
+    collectMethod: HealthCheckMethod9$inboundSchema.default("get"),
+    collectRequestParams: z.array(z.lazy(() => CollectorHealthCheckCollectRequestParam9$inboundSchema)).optional(),
+    collectBody: z.string().default("`{ }`"),
+    collectRequestHeaders: z.array(z.lazy(() => CollectorHealthCheckCollectRequestHeader9$inboundSchema)).optional(),
+    authenticateCollect: z.boolean().default(false),
+    timeout: z.number().default(30),
+    rejectUnauthorized: z.boolean().default(false),
+    defaultBreakers: CollectorHealthCheckHiddenDefaultBreakers9$inboundSchema
+        .optional(),
+    safeHeaders: z.array(z.string()).optional(),
+    retryRules: z.lazy(() => CollectorHealthCheckRetryRules9$inboundSchema)
+        .optional(),
+    username: z.string().optional(),
+    password: z.string().optional(),
+    credentialsSecret: z.string().optional(),
+    loginBody: z.string().default("`{ \"username\": \"${username}\", \"password\": \"${password}\" }`"),
+    textSecret: z.string().optional(),
+    type: CollectorHealthCheckType9$inboundSchema,
+});
+/** @internal */
+export const CollectorHealthCheckHealthCheck9$outboundSchema = z.object({
+    authentication: CollectorHealthCheckAuthentication9$outboundSchema.default("none"),
+    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(() => CollectorHealthCheckAuthRequestParam9$outboundSchema)).optional(),
+    authRequestHeaders: z.array(z.lazy(() => CollectorHealthCheckAuthRequestHeader9$outboundSchema)).optional(),
+    discovery: z.lazy(() => CollectorHealthCheckDiscovery9$outboundSchema)
+        .optional(),
+    collectUrl: z.string(),
+    collectMethod: HealthCheckMethod9$outboundSchema.default("get"),
+    collectRequestParams: z.array(z.lazy(() => CollectorHealthCheckCollectRequestParam9$outboundSchema)).optional(),
+    collectBody: z.string().default("`{ }`"),
+    collectRequestHeaders: z.array(z.lazy(() => CollectorHealthCheckCollectRequestHeader9$outboundSchema)).optional(),
+    authenticateCollect: z.boolean().default(false),
+    timeout: z.number().default(30),
+    rejectUnauthorized: z.boolean().default(false),
+    defaultBreakers: CollectorHealthCheckHiddenDefaultBreakers9$outboundSchema
+        .optional(),
+    safeHeaders: z.array(z.string()).optional(),
+    retryRules: z.lazy(() => CollectorHealthCheckRetryRules9$outboundSchema)
+        .optional(),
+    username: z.string().optional(),
+    password: z.string().optional(),
+    credentialsSecret: z.string().optional(),
+    loginBody: z.string().default("`{ \"username\": \"${username}\", \"password\": \"${password}\" }`"),
+    textSecret: z.string().optional(),
+    type: CollectorHealthCheckType9$outboundSchema,
+});
+export function collectorHealthCheckHealthCheck9ToJSON(collectorHealthCheckHealthCheck9) {
+    return JSON.stringify(CollectorHealthCheckHealthCheck9$outboundSchema.parse(collectorHealthCheckHealthCheck9));
+}
+export function collectorHealthCheckHealthCheck9FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorHealthCheckHealthCheck9$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorHealthCheckHealthCheck9' from JSON`);
+}
+/** @internal */
+export const CollectorHealthCheckAuthentication8$inboundSchema = openEnums.inboundSchema(CollectorHealthCheckAuthentication8);
+/** @internal */
+export const CollectorHealthCheckAuthentication8$outboundSchema = openEnums.outboundSchema(CollectorHealthCheckAuthentication8);
+/** @internal */
+export const CollectorHealthCheckAuthRequestHeader8$inboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+/** @internal */
+export const CollectorHealthCheckAuthRequestHeader8$outboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+export function collectorHealthCheckAuthRequestHeader8ToJSON(collectorHealthCheckAuthRequestHeader8) {
+    return JSON.stringify(CollectorHealthCheckAuthRequestHeader8$outboundSchema.parse(collectorHealthCheckAuthRequestHeader8));
+}
+export function collectorHealthCheckAuthRequestHeader8FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorHealthCheckAuthRequestHeader8$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorHealthCheckAuthRequestHeader8' from JSON`);
+}
+/** @internal */
+export const CollectorHealthCheckDiscoverType8$inboundSchema = openEnums.inboundSchema(CollectorHealthCheckDiscoverType8);
+/** @internal */
+export const CollectorHealthCheckDiscoverType8$outboundSchema = openEnums.outboundSchema(CollectorHealthCheckDiscoverType8);
+/** @internal */
+export const CollectorHealthCheckDiscovery8$inboundSchema = z.object({
+    discoverType: CollectorHealthCheckDiscoverType8$inboundSchema.default("none"),
+});
+/** @internal */
+export const CollectorHealthCheckDiscovery8$outboundSchema = z.object({
+    discoverType: CollectorHealthCheckDiscoverType8$outboundSchema.default("none"),
+});
+export function collectorHealthCheckDiscovery8ToJSON(collectorHealthCheckDiscovery8) {
+    return JSON.stringify(CollectorHealthCheckDiscovery8$outboundSchema.parse(collectorHealthCheckDiscovery8));
+}
+export function collectorHealthCheckDiscovery8FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorHealthCheckDiscovery8$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorHealthCheckDiscovery8' from JSON`);
+}
+/** @internal */
+export const HealthCheckMethod8$inboundSchema = openEnums.inboundSchema(HealthCheckMethod8);
+/** @internal */
+export const HealthCheckMethod8$outboundSchema = openEnums.outboundSchema(HealthCheckMethod8);
+/** @internal */
+export const CollectorHealthCheckCollectRequestParam8$inboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+/** @internal */
+export const CollectorHealthCheckCollectRequestParam8$outboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+export function collectorHealthCheckCollectRequestParam8ToJSON(collectorHealthCheckCollectRequestParam8) {
+    return JSON.stringify(CollectorHealthCheckCollectRequestParam8$outboundSchema.parse(collectorHealthCheckCollectRequestParam8));
+}
+export function collectorHealthCheckCollectRequestParam8FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorHealthCheckCollectRequestParam8$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorHealthCheckCollectRequestParam8' from JSON`);
+}
+/** @internal */
+export const CollectorHealthCheckCollectRequestHeader8$inboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+/** @internal */
+export const CollectorHealthCheckCollectRequestHeader8$outboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+export function collectorHealthCheckCollectRequestHeader8ToJSON(collectorHealthCheckCollectRequestHeader8) {
+    return JSON.stringify(CollectorHealthCheckCollectRequestHeader8$outboundSchema.parse(collectorHealthCheckCollectRequestHeader8));
+}
+export function collectorHealthCheckCollectRequestHeader8FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorHealthCheckCollectRequestHeader8$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorHealthCheckCollectRequestHeader8' from JSON`);
+}
+/** @internal */
+export const CollectorHealthCheckHiddenDefaultBreakers8$inboundSchema = openEnums.inboundSchema(CollectorHealthCheckHiddenDefaultBreakers8);
+/** @internal */
+export const CollectorHealthCheckHiddenDefaultBreakers8$outboundSchema = openEnums.outboundSchema(CollectorHealthCheckHiddenDefaultBreakers8);
+/** @internal */
+export const CollectorHealthCheckRetryType8$inboundSchema = openEnums.inboundSchema(CollectorHealthCheckRetryType8);
+/** @internal */
+export const CollectorHealthCheckRetryType8$outboundSchema = openEnums.outboundSchema(CollectorHealthCheckRetryType8);
+/** @internal */
+export const CollectorHealthCheckRetryRules8$inboundSchema = z.object({
+    type: CollectorHealthCheckRetryType8$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 CollectorHealthCheckRetryRules8$outboundSchema = z.object({
+    type: CollectorHealthCheckRetryType8$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 collectorHealthCheckRetryRules8ToJSON(collectorHealthCheckRetryRules8) {
+    return JSON.stringify(CollectorHealthCheckRetryRules8$outboundSchema.parse(collectorHealthCheckRetryRules8));
+}
+export function collectorHealthCheckRetryRules8FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorHealthCheckRetryRules8$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorHealthCheckRetryRules8' from JSON`);
+}
+/** @internal */
+export const CollectorHealthCheckAuthRequestParam8$inboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+/** @internal */
+export const CollectorHealthCheckAuthRequestParam8$outboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+export function collectorHealthCheckAuthRequestParam8ToJSON(collectorHealthCheckAuthRequestParam8) {
+    return JSON.stringify(CollectorHealthCheckAuthRequestParam8$outboundSchema.parse(collectorHealthCheckAuthRequestParam8));
+}
+export function collectorHealthCheckAuthRequestParam8FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorHealthCheckAuthRequestParam8$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorHealthCheckAuthRequestParam8' from JSON`);
+}
+/** @internal */
+export const CollectorHealthCheckType8$inboundSchema = z.nativeEnum(CollectorHealthCheckType8);
+/** @internal */
+export const CollectorHealthCheckType8$outboundSchema = CollectorHealthCheckType8$inboundSchema;
+/** @internal */
+export const CollectorHealthCheckHealthCheck8$inboundSchema = z.object({
+    authentication: CollectorHealthCheckAuthentication8$inboundSchema.default("none"),
+    loginUrl: z.string().default(""),
+    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(() => CollectorHealthCheckAuthRequestHeader8$inboundSchema)).optional(),
+    discovery: z.lazy(() => CollectorHealthCheckDiscovery8$inboundSchema)
+        .optional(),
+    collectUrl: z.string(),
+    collectMethod: HealthCheckMethod8$inboundSchema.default("get"),
+    collectRequestParams: z.array(z.lazy(() => CollectorHealthCheckCollectRequestParam8$inboundSchema)).optional(),
+    collectBody: z.string().default("`{ }`"),
+    collectRequestHeaders: z.array(z.lazy(() => CollectorHealthCheckCollectRequestHeader8$inboundSchema)).optional(),
+    authenticateCollect: z.boolean().default(false),
+    timeout: z.number().default(30),
+    rejectUnauthorized: z.boolean().default(false),
+    defaultBreakers: CollectorHealthCheckHiddenDefaultBreakers8$inboundSchema
+        .optional(),
+    safeHeaders: z.array(z.string()).optional(),
+    retryRules: z.lazy(() => CollectorHealthCheckRetryRules8$inboundSchema)
+        .optional(),
+    username: z.string().optional(),
+    password: z.string().optional(),
+    clientSecretParamName: z.string().default("client_secret"),
+    clientSecretParamValue: z.string().optional(),
+    authRequestParams: z.array(z.lazy(() => CollectorHealthCheckAuthRequestParam8$inboundSchema)).optional(),
+    textSecret: z.string().optional(),
+    type: CollectorHealthCheckType8$inboundSchema,
+});
+/** @internal */
+export const CollectorHealthCheckHealthCheck8$outboundSchema = z.object({
+    authentication: CollectorHealthCheckAuthentication8$outboundSchema.default("none"),
+    loginUrl: z.string().default(""),
+    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(() => CollectorHealthCheckAuthRequestHeader8$outboundSchema)).optional(),
+    discovery: z.lazy(() => CollectorHealthCheckDiscovery8$outboundSchema)
+        .optional(),
+    collectUrl: z.string(),
+    collectMethod: HealthCheckMethod8$outboundSchema.default("get"),
+    collectRequestParams: z.array(z.lazy(() => CollectorHealthCheckCollectRequestParam8$outboundSchema)).optional(),
+    collectBody: z.string().default("`{ }`"),
+    collectRequestHeaders: z.array(z.lazy(() => CollectorHealthCheckCollectRequestHeader8$outboundSchema)).optional(),
+    authenticateCollect: z.boolean().default(false),
+    timeout: z.number().default(30),
+    rejectUnauthorized: z.boolean().default(false),
+    defaultBreakers: CollectorHealthCheckHiddenDefaultBreakers8$outboundSchema
+        .optional(),
+    safeHeaders: z.array(z.string()).optional(),
+    retryRules: z.lazy(() => CollectorHealthCheckRetryRules8$outboundSchema)
+        .optional(),
+    username: z.string().optional(),
+    password: z.string().optional(),
+    clientSecretParamName: z.string().default("client_secret"),
+    clientSecretParamValue: z.string().optional(),
+    authRequestParams: z.array(z.lazy(() => CollectorHealthCheckAuthRequestParam8$outboundSchema)).optional(),
+    textSecret: z.string().optional(),
+    type: CollectorHealthCheckType8$outboundSchema,
+});
+export function collectorHealthCheckHealthCheck8ToJSON(collectorHealthCheckHealthCheck8) {
+    return JSON.stringify(CollectorHealthCheckHealthCheck8$outboundSchema.parse(collectorHealthCheckHealthCheck8));
+}
+export function collectorHealthCheckHealthCheck8FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorHealthCheckHealthCheck8$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorHealthCheckHealthCheck8' from JSON`);
+}
+/** @internal */
+export const CollectorHealthCheckAuthentication7$inboundSchema = openEnums.inboundSchema(CollectorHealthCheckAuthentication7);
+/** @internal */
+export const CollectorHealthCheckAuthentication7$outboundSchema = openEnums.outboundSchema(CollectorHealthCheckAuthentication7);
+/** @internal */
+export const CollectorHealthCheckAuthRequestHeader7$inboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+/** @internal */
+export const CollectorHealthCheckAuthRequestHeader7$outboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+export function collectorHealthCheckAuthRequestHeader7ToJSON(collectorHealthCheckAuthRequestHeader7) {
+    return JSON.stringify(CollectorHealthCheckAuthRequestHeader7$outboundSchema.parse(collectorHealthCheckAuthRequestHeader7));
+}
+export function collectorHealthCheckAuthRequestHeader7FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorHealthCheckAuthRequestHeader7$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorHealthCheckAuthRequestHeader7' from JSON`);
+}
+/** @internal */
+export const CollectorHealthCheckDiscoverType7$inboundSchema = openEnums.inboundSchema(CollectorHealthCheckDiscoverType7);
+/** @internal */
+export const CollectorHealthCheckDiscoverType7$outboundSchema = openEnums.outboundSchema(CollectorHealthCheckDiscoverType7);
+/** @internal */
+export const CollectorHealthCheckDiscovery7$inboundSchema = z.object({
+    discoverType: CollectorHealthCheckDiscoverType7$inboundSchema.default("none"),
+});
+/** @internal */
+export const CollectorHealthCheckDiscovery7$outboundSchema = z.object({
+    discoverType: CollectorHealthCheckDiscoverType7$outboundSchema.default("none"),
+});
+export function collectorHealthCheckDiscovery7ToJSON(collectorHealthCheckDiscovery7) {
+    return JSON.stringify(CollectorHealthCheckDiscovery7$outboundSchema.parse(collectorHealthCheckDiscovery7));
+}
+export function collectorHealthCheckDiscovery7FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorHealthCheckDiscovery7$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorHealthCheckDiscovery7' from JSON`);
+}
+/** @internal */
+export const HealthCheckMethod7$inboundSchema = openEnums.inboundSchema(HealthCheckMethod7);
+/** @internal */
+export const HealthCheckMethod7$outboundSchema = openEnums.outboundSchema(HealthCheckMethod7);
+/** @internal */
+export const CollectorHealthCheckCollectRequestParam7$inboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+/** @internal */
+export const CollectorHealthCheckCollectRequestParam7$outboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+export function collectorHealthCheckCollectRequestParam7ToJSON(collectorHealthCheckCollectRequestParam7) {
+    return JSON.stringify(CollectorHealthCheckCollectRequestParam7$outboundSchema.parse(collectorHealthCheckCollectRequestParam7));
+}
+export function collectorHealthCheckCollectRequestParam7FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorHealthCheckCollectRequestParam7$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorHealthCheckCollectRequestParam7' from JSON`);
+}
+/** @internal */
+export const CollectorHealthCheckCollectRequestHeader7$inboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+/** @internal */
+export const CollectorHealthCheckCollectRequestHeader7$outboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+export function collectorHealthCheckCollectRequestHeader7ToJSON(collectorHealthCheckCollectRequestHeader7) {
+    return JSON.stringify(CollectorHealthCheckCollectRequestHeader7$outboundSchema.parse(collectorHealthCheckCollectRequestHeader7));
+}
+export function collectorHealthCheckCollectRequestHeader7FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorHealthCheckCollectRequestHeader7$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorHealthCheckCollectRequestHeader7' from JSON`);
+}
+/** @internal */
+export const CollectorHealthCheckHiddenDefaultBreakers7$inboundSchema = openEnums.inboundSchema(CollectorHealthCheckHiddenDefaultBreakers7);
+/** @internal */
+export const CollectorHealthCheckHiddenDefaultBreakers7$outboundSchema = openEnums.outboundSchema(CollectorHealthCheckHiddenDefaultBreakers7);
+/** @internal */
+export const CollectorHealthCheckRetryType7$inboundSchema = openEnums.inboundSchema(CollectorHealthCheckRetryType7);
+/** @internal */
+export const CollectorHealthCheckRetryType7$outboundSchema = openEnums.outboundSchema(CollectorHealthCheckRetryType7);
+/** @internal */
+export const CollectorHealthCheckRetryRules7$inboundSchema = z.object({
+    type: CollectorHealthCheckRetryType7$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 CollectorHealthCheckRetryRules7$outboundSchema = z.object({
+    type: CollectorHealthCheckRetryType7$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 collectorHealthCheckRetryRules7ToJSON(collectorHealthCheckRetryRules7) {
+    return JSON.stringify(CollectorHealthCheckRetryRules7$outboundSchema.parse(collectorHealthCheckRetryRules7));
+}
+export function collectorHealthCheckRetryRules7FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorHealthCheckRetryRules7$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorHealthCheckRetryRules7' from JSON`);
+}
+/** @internal */
+export const CollectorHealthCheckAuthRequestParam7$inboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+/** @internal */
+export const CollectorHealthCheckAuthRequestParam7$outboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+export function collectorHealthCheckAuthRequestParam7ToJSON(collectorHealthCheckAuthRequestParam7) {
+    return JSON.stringify(CollectorHealthCheckAuthRequestParam7$outboundSchema.parse(collectorHealthCheckAuthRequestParam7));
+}
+export function collectorHealthCheckAuthRequestParam7FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorHealthCheckAuthRequestParam7$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorHealthCheckAuthRequestParam7' from JSON`);
+}
+/** @internal */
+export const CollectorHealthCheckType7$inboundSchema = z.nativeEnum(CollectorHealthCheckType7);
+/** @internal */
+export const CollectorHealthCheckType7$outboundSchema = CollectorHealthCheckType7$inboundSchema;
+/** @internal */
+export const CollectorHealthCheckHealthCheck7$inboundSchema = z.object({
+    authentication: CollectorHealthCheckAuthentication7$inboundSchema.default("none"),
+    loginUrl: z.string().default(""),
+    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(() => CollectorHealthCheckAuthRequestHeader7$inboundSchema)).optional(),
+    discovery: z.lazy(() => CollectorHealthCheckDiscovery7$inboundSchema)
+        .optional(),
+    collectUrl: z.string(),
+    collectMethod: HealthCheckMethod7$inboundSchema.default("get"),
+    collectRequestParams: z.array(z.lazy(() => CollectorHealthCheckCollectRequestParam7$inboundSchema)).optional(),
+    collectBody: z.string().default("`{ }`"),
+    collectRequestHeaders: z.array(z.lazy(() => CollectorHealthCheckCollectRequestHeader7$inboundSchema)).optional(),
+    authenticateCollect: z.boolean().default(false),
+    timeout: z.number().default(30),
+    rejectUnauthorized: z.boolean().default(false),
+    defaultBreakers: CollectorHealthCheckHiddenDefaultBreakers7$inboundSchema
+        .optional(),
+    safeHeaders: z.array(z.string()).optional(),
+    retryRules: z.lazy(() => CollectorHealthCheckRetryRules7$inboundSchema)
+        .optional(),
+    credentialsSecret: z.string().optional(),
+    clientSecretParamName: z.string().default("client_secret"),
+    clientSecretParamValue: z.string().optional(),
+    authRequestParams: z.array(z.lazy(() => CollectorHealthCheckAuthRequestParam7$inboundSchema)).optional(),
+    textSecret: z.string().optional(),
+    type: CollectorHealthCheckType7$inboundSchema,
+});
+/** @internal */
+export const CollectorHealthCheckHealthCheck7$outboundSchema = z.object({
+    authentication: CollectorHealthCheckAuthentication7$outboundSchema.default("none"),
+    loginUrl: z.string().default(""),
+    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(() => CollectorHealthCheckAuthRequestHeader7$outboundSchema)).optional(),
+    discovery: z.lazy(() => CollectorHealthCheckDiscovery7$outboundSchema)
+        .optional(),
+    collectUrl: z.string(),
+    collectMethod: HealthCheckMethod7$outboundSchema.default("get"),
+    collectRequestParams: z.array(z.lazy(() => CollectorHealthCheckCollectRequestParam7$outboundSchema)).optional(),
+    collectBody: z.string().default("`{ }`"),
+    collectRequestHeaders: z.array(z.lazy(() => CollectorHealthCheckCollectRequestHeader7$outboundSchema)).optional(),
+    authenticateCollect: z.boolean().default(false),
+    timeout: z.number().default(30),
+    rejectUnauthorized: z.boolean().default(false),
+    defaultBreakers: CollectorHealthCheckHiddenDefaultBreakers7$outboundSchema
+        .optional(),
+    safeHeaders: z.array(z.string()).optional(),
+    retryRules: z.lazy(() => CollectorHealthCheckRetryRules7$outboundSchema)
+        .optional(),
+    credentialsSecret: z.string().optional(),
+    clientSecretParamName: z.string().default("client_secret"),
+    clientSecretParamValue: z.string().optional(),
+    authRequestParams: z.array(z.lazy(() => CollectorHealthCheckAuthRequestParam7$outboundSchema)).optional(),
+    textSecret: z.string().optional(),
+    type: CollectorHealthCheckType7$outboundSchema,
+});
+export function collectorHealthCheckHealthCheck7ToJSON(collectorHealthCheckHealthCheck7) {
+    return JSON.stringify(CollectorHealthCheckHealthCheck7$outboundSchema.parse(collectorHealthCheckHealthCheck7));
+}
+export function collectorHealthCheckHealthCheck7FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorHealthCheckHealthCheck7$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorHealthCheckHealthCheck7' from JSON`);
+}
+/** @internal */
+export const CollectorHealthCheckAuthentication6$inboundSchema = openEnums.inboundSchema(CollectorHealthCheckAuthentication6);
+/** @internal */
+export const CollectorHealthCheckAuthentication6$outboundSchema = openEnums.outboundSchema(CollectorHealthCheckAuthentication6);
+/** @internal */
+export const CollectorHealthCheckDiscoverType6$inboundSchema = openEnums.inboundSchema(CollectorHealthCheckDiscoverType6);
+/** @internal */
+export const CollectorHealthCheckDiscoverType6$outboundSchema = openEnums.outboundSchema(CollectorHealthCheckDiscoverType6);
+/** @internal */
+export const CollectorHealthCheckDiscovery6$inboundSchema = z.object({
+    discoverType: CollectorHealthCheckDiscoverType6$inboundSchema.default("none"),
+});
+/** @internal */
+export const CollectorHealthCheckDiscovery6$outboundSchema = z.object({
+    discoverType: CollectorHealthCheckDiscoverType6$outboundSchema.default("none"),
+});
+export function collectorHealthCheckDiscovery6ToJSON(collectorHealthCheckDiscovery6) {
+    return JSON.stringify(CollectorHealthCheckDiscovery6$outboundSchema.parse(collectorHealthCheckDiscovery6));
+}
+export function collectorHealthCheckDiscovery6FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorHealthCheckDiscovery6$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorHealthCheckDiscovery6' from JSON`);
+}
+/** @internal */
+export const HealthCheckMethod6$inboundSchema = openEnums.inboundSchema(HealthCheckMethod6);
+/** @internal */
+export const HealthCheckMethod6$outboundSchema = openEnums.outboundSchema(HealthCheckMethod6);
+/** @internal */
+export const CollectorHealthCheckCollectRequestParam6$inboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+/** @internal */
+export const CollectorHealthCheckCollectRequestParam6$outboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+export function collectorHealthCheckCollectRequestParam6ToJSON(collectorHealthCheckCollectRequestParam6) {
+    return JSON.stringify(CollectorHealthCheckCollectRequestParam6$outboundSchema.parse(collectorHealthCheckCollectRequestParam6));
+}
+export function collectorHealthCheckCollectRequestParam6FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorHealthCheckCollectRequestParam6$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorHealthCheckCollectRequestParam6' from JSON`);
+}
+/** @internal */
+export const CollectorHealthCheckCollectRequestHeader6$inboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+/** @internal */
+export const CollectorHealthCheckCollectRequestHeader6$outboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+export function collectorHealthCheckCollectRequestHeader6ToJSON(collectorHealthCheckCollectRequestHeader6) {
+    return JSON.stringify(CollectorHealthCheckCollectRequestHeader6$outboundSchema.parse(collectorHealthCheckCollectRequestHeader6));
+}
+export function collectorHealthCheckCollectRequestHeader6FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorHealthCheckCollectRequestHeader6$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorHealthCheckCollectRequestHeader6' from JSON`);
+}
+/** @internal */
+export const CollectorHealthCheckHiddenDefaultBreakers6$inboundSchema = openEnums.inboundSchema(CollectorHealthCheckHiddenDefaultBreakers6);
+/** @internal */
+export const CollectorHealthCheckHiddenDefaultBreakers6$outboundSchema = openEnums.outboundSchema(CollectorHealthCheckHiddenDefaultBreakers6);
+/** @internal */
+export const CollectorHealthCheckRetryType6$inboundSchema = openEnums.inboundSchema(CollectorHealthCheckRetryType6);
+/** @internal */
+export const CollectorHealthCheckRetryType6$outboundSchema = openEnums.outboundSchema(CollectorHealthCheckRetryType6);
+/** @internal */
+export const CollectorHealthCheckRetryRules6$inboundSchema = z.object({
+    type: CollectorHealthCheckRetryType6$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 CollectorHealthCheckRetryRules6$outboundSchema = z.object({
+    type: CollectorHealthCheckRetryType6$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 collectorHealthCheckRetryRules6ToJSON(collectorHealthCheckRetryRules6) {
+    return JSON.stringify(CollectorHealthCheckRetryRules6$outboundSchema.parse(collectorHealthCheckRetryRules6));
+}
+export function collectorHealthCheckRetryRules6FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorHealthCheckRetryRules6$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorHealthCheckRetryRules6' from JSON`);
+}
+/** @internal */
+export const CollectorHealthCheckAuthRequestHeader6$inboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+/** @internal */
+export const CollectorHealthCheckAuthRequestHeader6$outboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+export function collectorHealthCheckAuthRequestHeader6ToJSON(collectorHealthCheckAuthRequestHeader6) {
+    return JSON.stringify(CollectorHealthCheckAuthRequestHeader6$outboundSchema.parse(collectorHealthCheckAuthRequestHeader6));
+}
+export function collectorHealthCheckAuthRequestHeader6FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorHealthCheckAuthRequestHeader6$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorHealthCheckAuthRequestHeader6' from JSON`);
+}
+/** @internal */
+export const CollectorHealthCheckAuthRequestParam6$inboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+/** @internal */
+export const CollectorHealthCheckAuthRequestParam6$outboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+export function collectorHealthCheckAuthRequestParam6ToJSON(collectorHealthCheckAuthRequestParam6) {
+    return JSON.stringify(CollectorHealthCheckAuthRequestParam6$outboundSchema.parse(collectorHealthCheckAuthRequestParam6));
+}
+export function collectorHealthCheckAuthRequestParam6FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorHealthCheckAuthRequestParam6$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorHealthCheckAuthRequestParam6' from JSON`);
+}
+/** @internal */
+export const CollectorHealthCheckType6$inboundSchema = z.nativeEnum(CollectorHealthCheckType6);
+/** @internal */
+export const CollectorHealthCheckType6$outboundSchema = CollectorHealthCheckType6$inboundSchema;
+/** @internal */
+export const CollectorHealthCheckHealthCheck6$inboundSchema = z.object({
+    authentication: CollectorHealthCheckAuthentication6$inboundSchema.default("none"),
+    credentialsSecret: z.string(),
+    discovery: z.lazy(() => CollectorHealthCheckDiscovery6$inboundSchema)
+        .optional(),
+    collectUrl: z.string(),
+    collectMethod: HealthCheckMethod6$inboundSchema.default("get"),
+    collectRequestParams: z.array(z.lazy(() => CollectorHealthCheckCollectRequestParam6$inboundSchema)).optional(),
+    collectBody: z.string().default("`{ }`"),
+    collectRequestHeaders: z.array(z.lazy(() => CollectorHealthCheckCollectRequestHeader6$inboundSchema)).optional(),
+    authenticateCollect: z.boolean().default(false),
+    timeout: z.number().default(30),
+    rejectUnauthorized: z.boolean().default(false),
+    defaultBreakers: CollectorHealthCheckHiddenDefaultBreakers6$inboundSchema
+        .optional(),
+    safeHeaders: z.array(z.string()).optional(),
+    retryRules: z.lazy(() => CollectorHealthCheckRetryRules6$inboundSchema)
+        .optional(),
+    username: z.string().optional(),
+    password: z.string().optional(),
+    loginUrl: z.string().default(""),
+    loginBody: z.string().default("`{ \"username\": \"${username}\", \"password\": \"${password}\" }`"),
+    tokenRespAttribute: z.string().optional(),
+    authHeaderExpr: z.string().default("`Bearer ${token}`"),
+    authRequestHeaders: z.array(z.lazy(() => CollectorHealthCheckAuthRequestHeader6$inboundSchema)).optional(),
+    clientSecretParamName: z.string().default("client_secret"),
+    clientSecretParamValue: z.string().optional(),
+    authRequestParams: z.array(z.lazy(() => CollectorHealthCheckAuthRequestParam6$inboundSchema)).optional(),
+    textSecret: z.string().optional(),
+    type: CollectorHealthCheckType6$inboundSchema,
+});
+/** @internal */
+export const CollectorHealthCheckHealthCheck6$outboundSchema = z.object({
+    authentication: CollectorHealthCheckAuthentication6$outboundSchema.default("none"),
+    credentialsSecret: z.string(),
+    discovery: z.lazy(() => CollectorHealthCheckDiscovery6$outboundSchema)
+        .optional(),
+    collectUrl: z.string(),
+    collectMethod: HealthCheckMethod6$outboundSchema.default("get"),
+    collectRequestParams: z.array(z.lazy(() => CollectorHealthCheckCollectRequestParam6$outboundSchema)).optional(),
+    collectBody: z.string().default("`{ }`"),
+    collectRequestHeaders: z.array(z.lazy(() => CollectorHealthCheckCollectRequestHeader6$outboundSchema)).optional(),
+    authenticateCollect: z.boolean().default(false),
+    timeout: z.number().default(30),
+    rejectUnauthorized: z.boolean().default(false),
+    defaultBreakers: CollectorHealthCheckHiddenDefaultBreakers6$outboundSchema
+        .optional(),
+    safeHeaders: z.array(z.string()).optional(),
+    retryRules: z.lazy(() => CollectorHealthCheckRetryRules6$outboundSchema)
+        .optional(),
+    username: z.string().optional(),
+    password: z.string().optional(),
+    loginUrl: z.string().default(""),
+    loginBody: z.string().default("`{ \"username\": \"${username}\", \"password\": \"${password}\" }`"),
+    tokenRespAttribute: z.string().optional(),
+    authHeaderExpr: z.string().default("`Bearer ${token}`"),
+    authRequestHeaders: z.array(z.lazy(() => CollectorHealthCheckAuthRequestHeader6$outboundSchema)).optional(),
+    clientSecretParamName: z.string().default("client_secret"),
+    clientSecretParamValue: z.string().optional(),
+    authRequestParams: z.array(z.lazy(() => CollectorHealthCheckAuthRequestParam6$outboundSchema)).optional(),
+    textSecret: z.string().optional(),
+    type: CollectorHealthCheckType6$outboundSchema,
+});
+export function collectorHealthCheckHealthCheck6ToJSON(collectorHealthCheckHealthCheck6) {
+    return JSON.stringify(CollectorHealthCheckHealthCheck6$outboundSchema.parse(collectorHealthCheckHealthCheck6));
+}
+export function collectorHealthCheckHealthCheck6FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorHealthCheckHealthCheck6$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorHealthCheckHealthCheck6' from JSON`);
+}
+/** @internal */
+export const CollectorHealthCheckAuthentication5$inboundSchema = openEnums.inboundSchema(CollectorHealthCheckAuthentication5);
+/** @internal */
+export const CollectorHealthCheckAuthentication5$outboundSchema = openEnums.outboundSchema(CollectorHealthCheckAuthentication5);
+/** @internal */
+export const CollectorHealthCheckDiscoverType5$inboundSchema = openEnums.inboundSchema(CollectorHealthCheckDiscoverType5);
+/** @internal */
+export const CollectorHealthCheckDiscoverType5$outboundSchema = openEnums.outboundSchema(CollectorHealthCheckDiscoverType5);
+/** @internal */
+export const CollectorHealthCheckDiscovery5$inboundSchema = z.object({
+    discoverType: CollectorHealthCheckDiscoverType5$inboundSchema.default("none"),
+});
+/** @internal */
+export const CollectorHealthCheckDiscovery5$outboundSchema = z.object({
+    discoverType: CollectorHealthCheckDiscoverType5$outboundSchema.default("none"),
+});
+export function collectorHealthCheckDiscovery5ToJSON(collectorHealthCheckDiscovery5) {
+    return JSON.stringify(CollectorHealthCheckDiscovery5$outboundSchema.parse(collectorHealthCheckDiscovery5));
+}
+export function collectorHealthCheckDiscovery5FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorHealthCheckDiscovery5$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorHealthCheckDiscovery5' from JSON`);
+}
+/** @internal */
+export const HealthCheckMethod5$inboundSchema = openEnums.inboundSchema(HealthCheckMethod5);
+/** @internal */
+export const HealthCheckMethod5$outboundSchema = openEnums.outboundSchema(HealthCheckMethod5);
+/** @internal */
+export const CollectorHealthCheckCollectRequestParam5$inboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+/** @internal */
+export const CollectorHealthCheckCollectRequestParam5$outboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+export function collectorHealthCheckCollectRequestParam5ToJSON(collectorHealthCheckCollectRequestParam5) {
+    return JSON.stringify(CollectorHealthCheckCollectRequestParam5$outboundSchema.parse(collectorHealthCheckCollectRequestParam5));
+}
+export function collectorHealthCheckCollectRequestParam5FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorHealthCheckCollectRequestParam5$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorHealthCheckCollectRequestParam5' from JSON`);
+}
+/** @internal */
+export const CollectorHealthCheckCollectRequestHeader5$inboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+/** @internal */
+export const CollectorHealthCheckCollectRequestHeader5$outboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+export function collectorHealthCheckCollectRequestHeader5ToJSON(collectorHealthCheckCollectRequestHeader5) {
+    return JSON.stringify(CollectorHealthCheckCollectRequestHeader5$outboundSchema.parse(collectorHealthCheckCollectRequestHeader5));
+}
+export function collectorHealthCheckCollectRequestHeader5FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorHealthCheckCollectRequestHeader5$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorHealthCheckCollectRequestHeader5' from JSON`);
+}
+/** @internal */
+export const CollectorHealthCheckHiddenDefaultBreakers5$inboundSchema = openEnums.inboundSchema(CollectorHealthCheckHiddenDefaultBreakers5);
+/** @internal */
+export const CollectorHealthCheckHiddenDefaultBreakers5$outboundSchema = openEnums.outboundSchema(CollectorHealthCheckHiddenDefaultBreakers5);
+/** @internal */
+export const CollectorHealthCheckRetryType5$inboundSchema = openEnums.inboundSchema(CollectorHealthCheckRetryType5);
+/** @internal */
+export const CollectorHealthCheckRetryType5$outboundSchema = openEnums.outboundSchema(CollectorHealthCheckRetryType5);
+/** @internal */
+export const CollectorHealthCheckRetryRules5$inboundSchema = z.object({
+    type: CollectorHealthCheckRetryType5$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 CollectorHealthCheckRetryRules5$outboundSchema = z.object({
+    type: CollectorHealthCheckRetryType5$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 collectorHealthCheckRetryRules5ToJSON(collectorHealthCheckRetryRules5) {
+    return JSON.stringify(CollectorHealthCheckRetryRules5$outboundSchema.parse(collectorHealthCheckRetryRules5));
+}
+export function collectorHealthCheckRetryRules5FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorHealthCheckRetryRules5$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorHealthCheckRetryRules5' from JSON`);
+}
+/** @internal */
+export const CollectorHealthCheckAuthRequestHeader5$inboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+/** @internal */
+export const CollectorHealthCheckAuthRequestHeader5$outboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+export function collectorHealthCheckAuthRequestHeader5ToJSON(collectorHealthCheckAuthRequestHeader5) {
+    return JSON.stringify(CollectorHealthCheckAuthRequestHeader5$outboundSchema.parse(collectorHealthCheckAuthRequestHeader5));
+}
+export function collectorHealthCheckAuthRequestHeader5FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorHealthCheckAuthRequestHeader5$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorHealthCheckAuthRequestHeader5' from JSON`);
+}
+/** @internal */
+export const CollectorHealthCheckAuthRequestParam5$inboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+/** @internal */
+export const CollectorHealthCheckAuthRequestParam5$outboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+export function collectorHealthCheckAuthRequestParam5ToJSON(collectorHealthCheckAuthRequestParam5) {
+    return JSON.stringify(CollectorHealthCheckAuthRequestParam5$outboundSchema.parse(collectorHealthCheckAuthRequestParam5));
+}
+export function collectorHealthCheckAuthRequestParam5FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorHealthCheckAuthRequestParam5$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorHealthCheckAuthRequestParam5' from JSON`);
+}
+/** @internal */
+export const CollectorHealthCheckType5$inboundSchema = z.nativeEnum(CollectorHealthCheckType5);
+/** @internal */
+export const CollectorHealthCheckType5$outboundSchema = CollectorHealthCheckType5$inboundSchema;
+/** @internal */
+export const CollectorHealthCheckHealthCheck5$inboundSchema = z.object({
+    authentication: CollectorHealthCheckAuthentication5$inboundSchema.default("none"),
+    username: z.string(),
+    password: z.string(),
+    discovery: z.lazy(() => CollectorHealthCheckDiscovery5$inboundSchema)
+        .optional(),
+    collectUrl: z.string(),
+    collectMethod: HealthCheckMethod5$inboundSchema.default("get"),
+    collectRequestParams: z.array(z.lazy(() => CollectorHealthCheckCollectRequestParam5$inboundSchema)).optional(),
+    collectBody: z.string().default("`{ }`"),
+    collectRequestHeaders: z.array(z.lazy(() => CollectorHealthCheckCollectRequestHeader5$inboundSchema)).optional(),
+    authenticateCollect: z.boolean().default(false),
+    timeout: z.number().default(30),
+    rejectUnauthorized: z.boolean().default(false),
+    defaultBreakers: CollectorHealthCheckHiddenDefaultBreakers5$inboundSchema
+        .optional(),
+    safeHeaders: z.array(z.string()).optional(),
+    retryRules: z.lazy(() => CollectorHealthCheckRetryRules5$inboundSchema)
+        .optional(),
+    credentialsSecret: z.string().optional(),
+    loginUrl: z.string().default(""),
+    loginBody: z.string().default("`{ \"username\": \"${username}\", \"password\": \"${password}\" }`"),
+    tokenRespAttribute: z.string().optional(),
+    authHeaderExpr: z.string().default("`Bearer ${token}`"),
+    authRequestHeaders: z.array(z.lazy(() => CollectorHealthCheckAuthRequestHeader5$inboundSchema)).optional(),
+    clientSecretParamName: z.string().default("client_secret"),
+    clientSecretParamValue: z.string().optional(),
+    authRequestParams: z.array(z.lazy(() => CollectorHealthCheckAuthRequestParam5$inboundSchema)).optional(),
+    textSecret: z.string().optional(),
+    type: CollectorHealthCheckType5$inboundSchema,
+});
+/** @internal */
+export const CollectorHealthCheckHealthCheck5$outboundSchema = z.object({
+    authentication: CollectorHealthCheckAuthentication5$outboundSchema.default("none"),
+    username: z.string(),
+    password: z.string(),
+    discovery: z.lazy(() => CollectorHealthCheckDiscovery5$outboundSchema)
+        .optional(),
+    collectUrl: z.string(),
+    collectMethod: HealthCheckMethod5$outboundSchema.default("get"),
+    collectRequestParams: z.array(z.lazy(() => CollectorHealthCheckCollectRequestParam5$outboundSchema)).optional(),
+    collectBody: z.string().default("`{ }`"),
+    collectRequestHeaders: z.array(z.lazy(() => CollectorHealthCheckCollectRequestHeader5$outboundSchema)).optional(),
+    authenticateCollect: z.boolean().default(false),
+    timeout: z.number().default(30),
+    rejectUnauthorized: z.boolean().default(false),
+    defaultBreakers: CollectorHealthCheckHiddenDefaultBreakers5$outboundSchema
+        .optional(),
+    safeHeaders: z.array(z.string()).optional(),
+    retryRules: z.lazy(() => CollectorHealthCheckRetryRules5$outboundSchema)
+        .optional(),
+    credentialsSecret: z.string().optional(),
+    loginUrl: z.string().default(""),
+    loginBody: z.string().default("`{ \"username\": \"${username}\", \"password\": \"${password}\" }`"),
+    tokenRespAttribute: z.string().optional(),
+    authHeaderExpr: z.string().default("`Bearer ${token}`"),
+    authRequestHeaders: z.array(z.lazy(() => CollectorHealthCheckAuthRequestHeader5$outboundSchema)).optional(),
+    clientSecretParamName: z.string().default("client_secret"),
+    clientSecretParamValue: z.string().optional(),
+    authRequestParams: z.array(z.lazy(() => CollectorHealthCheckAuthRequestParam5$outboundSchema)).optional(),
+    textSecret: z.string().optional(),
+    type: CollectorHealthCheckType5$outboundSchema,
+});
+export function collectorHealthCheckHealthCheck5ToJSON(collectorHealthCheckHealthCheck5) {
+    return JSON.stringify(CollectorHealthCheckHealthCheck5$outboundSchema.parse(collectorHealthCheckHealthCheck5));
+}
+export function collectorHealthCheckHealthCheck5FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorHealthCheckHealthCheck5$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorHealthCheckHealthCheck5' from JSON`);
+}
+/** @internal */
+export const CollectorHealthCheckAuthentication4$inboundSchema = openEnums.inboundSchema(CollectorHealthCheckAuthentication4);
+/** @internal */
+export const CollectorHealthCheckAuthentication4$outboundSchema = openEnums.outboundSchema(CollectorHealthCheckAuthentication4);
+/** @internal */
+export const CollectorHealthCheckDiscoverType4$inboundSchema = openEnums.inboundSchema(CollectorHealthCheckDiscoverType4);
+/** @internal */
+export const CollectorHealthCheckDiscoverType4$outboundSchema = openEnums.outboundSchema(CollectorHealthCheckDiscoverType4);
+/** @internal */
+export const CollectorHealthCheckDiscovery4$inboundSchema = z.object({
+    discoverType: CollectorHealthCheckDiscoverType4$inboundSchema.default("none"),
+});
+/** @internal */
+export const CollectorHealthCheckDiscovery4$outboundSchema = z.object({
+    discoverType: CollectorHealthCheckDiscoverType4$outboundSchema.default("none"),
+});
+export function collectorHealthCheckDiscovery4ToJSON(collectorHealthCheckDiscovery4) {
+    return JSON.stringify(CollectorHealthCheckDiscovery4$outboundSchema.parse(collectorHealthCheckDiscovery4));
+}
+export function collectorHealthCheckDiscovery4FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorHealthCheckDiscovery4$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorHealthCheckDiscovery4' from JSON`);
+}
+/** @internal */
+export const HealthCheckMethod4$inboundSchema = openEnums.inboundSchema(HealthCheckMethod4);
+/** @internal */
+export const HealthCheckMethod4$outboundSchema = openEnums.outboundSchema(HealthCheckMethod4);
+/** @internal */
+export const CollectorHealthCheckCollectRequestParam4$inboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+/** @internal */
+export const CollectorHealthCheckCollectRequestParam4$outboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+export function collectorHealthCheckCollectRequestParam4ToJSON(collectorHealthCheckCollectRequestParam4) {
+    return JSON.stringify(CollectorHealthCheckCollectRequestParam4$outboundSchema.parse(collectorHealthCheckCollectRequestParam4));
+}
+export function collectorHealthCheckCollectRequestParam4FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorHealthCheckCollectRequestParam4$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorHealthCheckCollectRequestParam4' from JSON`);
+}
+/** @internal */
+export const CollectorHealthCheckCollectRequestHeader4$inboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+/** @internal */
+export const CollectorHealthCheckCollectRequestHeader4$outboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+export function collectorHealthCheckCollectRequestHeader4ToJSON(collectorHealthCheckCollectRequestHeader4) {
+    return JSON.stringify(CollectorHealthCheckCollectRequestHeader4$outboundSchema.parse(collectorHealthCheckCollectRequestHeader4));
+}
+export function collectorHealthCheckCollectRequestHeader4FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorHealthCheckCollectRequestHeader4$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorHealthCheckCollectRequestHeader4' from JSON`);
+}
+/** @internal */
+export const CollectorHealthCheckHiddenDefaultBreakers4$inboundSchema = openEnums.inboundSchema(CollectorHealthCheckHiddenDefaultBreakers4);
+/** @internal */
+export const CollectorHealthCheckHiddenDefaultBreakers4$outboundSchema = openEnums.outboundSchema(CollectorHealthCheckHiddenDefaultBreakers4);
+/** @internal */
+export const CollectorHealthCheckRetryType4$inboundSchema = openEnums.inboundSchema(CollectorHealthCheckRetryType4);
+/** @internal */
+export const CollectorHealthCheckRetryType4$outboundSchema = openEnums.outboundSchema(CollectorHealthCheckRetryType4);
+/** @internal */
+export const CollectorHealthCheckRetryRules4$inboundSchema = z.object({
+    type: CollectorHealthCheckRetryType4$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 CollectorHealthCheckRetryRules4$outboundSchema = z.object({
+    type: CollectorHealthCheckRetryType4$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 collectorHealthCheckRetryRules4ToJSON(collectorHealthCheckRetryRules4) {
+    return JSON.stringify(CollectorHealthCheckRetryRules4$outboundSchema.parse(collectorHealthCheckRetryRules4));
+}
+export function collectorHealthCheckRetryRules4FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorHealthCheckRetryRules4$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorHealthCheckRetryRules4' from JSON`);
+}
+/** @internal */
+export const CollectorHealthCheckAuthRequestHeader4$inboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+/** @internal */
+export const CollectorHealthCheckAuthRequestHeader4$outboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+export function collectorHealthCheckAuthRequestHeader4ToJSON(collectorHealthCheckAuthRequestHeader4) {
+    return JSON.stringify(CollectorHealthCheckAuthRequestHeader4$outboundSchema.parse(collectorHealthCheckAuthRequestHeader4));
+}
+export function collectorHealthCheckAuthRequestHeader4FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorHealthCheckAuthRequestHeader4$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorHealthCheckAuthRequestHeader4' from JSON`);
+}
+/** @internal */
+export const CollectorHealthCheckAuthRequestParam4$inboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+/** @internal */
+export const CollectorHealthCheckAuthRequestParam4$outboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+export function collectorHealthCheckAuthRequestParam4ToJSON(collectorHealthCheckAuthRequestParam4) {
+    return JSON.stringify(CollectorHealthCheckAuthRequestParam4$outboundSchema.parse(collectorHealthCheckAuthRequestParam4));
+}
+export function collectorHealthCheckAuthRequestParam4FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorHealthCheckAuthRequestParam4$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorHealthCheckAuthRequestParam4' from JSON`);
+}
+/** @internal */
+export const CollectorHealthCheckType4$inboundSchema = z.nativeEnum(CollectorHealthCheckType4);
+/** @internal */
+export const CollectorHealthCheckType4$outboundSchema = CollectorHealthCheckType4$inboundSchema;
+/** @internal */
+export const CollectorHealthCheckHealthCheck4$inboundSchema = z.object({
+    authentication: CollectorHealthCheckAuthentication4$inboundSchema.default("none"),
+    discovery: z.lazy(() => CollectorHealthCheckDiscovery4$inboundSchema)
+        .optional(),
+    collectUrl: z.string(),
+    collectMethod: HealthCheckMethod4$inboundSchema.default("get"),
+    collectRequestParams: z.array(z.lazy(() => CollectorHealthCheckCollectRequestParam4$inboundSchema)).optional(),
+    collectBody: z.string().default("`{ }`"),
+    collectRequestHeaders: z.array(z.lazy(() => CollectorHealthCheckCollectRequestHeader4$inboundSchema)).optional(),
+    authenticateCollect: z.boolean().default(false),
+    timeout: z.number().default(30),
+    rejectUnauthorized: z.boolean().default(false),
+    defaultBreakers: CollectorHealthCheckHiddenDefaultBreakers4$inboundSchema
+        .optional(),
+    safeHeaders: z.array(z.string()).optional(),
+    retryRules: z.lazy(() => CollectorHealthCheckRetryRules4$inboundSchema)
+        .optional(),
+    username: z.string().optional(),
+    password: z.string().optional(),
+    credentialsSecret: z.string().optional(),
+    loginUrl: z.string().default(""),
+    loginBody: z.string().default("`{ \"username\": \"${username}\", \"password\": \"${password}\" }`"),
+    tokenRespAttribute: z.string().optional(),
+    authHeaderExpr: z.string().default("`Bearer ${token}`"),
+    authRequestHeaders: z.array(z.lazy(() => CollectorHealthCheckAuthRequestHeader4$inboundSchema)).optional(),
+    clientSecretParamName: z.string().default("client_secret"),
+    clientSecretParamValue: z.string().optional(),
+    authRequestParams: z.array(z.lazy(() => CollectorHealthCheckAuthRequestParam4$inboundSchema)).optional(),
+    textSecret: z.string().optional(),
+    type: CollectorHealthCheckType4$inboundSchema,
+});
+/** @internal */
+export const CollectorHealthCheckHealthCheck4$outboundSchema = z.object({
+    authentication: CollectorHealthCheckAuthentication4$outboundSchema.default("none"),
+    discovery: z.lazy(() => CollectorHealthCheckDiscovery4$outboundSchema)
+        .optional(),
+    collectUrl: z.string(),
+    collectMethod: HealthCheckMethod4$outboundSchema.default("get"),
+    collectRequestParams: z.array(z.lazy(() => CollectorHealthCheckCollectRequestParam4$outboundSchema)).optional(),
+    collectBody: z.string().default("`{ }`"),
+    collectRequestHeaders: z.array(z.lazy(() => CollectorHealthCheckCollectRequestHeader4$outboundSchema)).optional(),
+    authenticateCollect: z.boolean().default(false),
+    timeout: z.number().default(30),
+    rejectUnauthorized: z.boolean().default(false),
+    defaultBreakers: CollectorHealthCheckHiddenDefaultBreakers4$outboundSchema
+        .optional(),
+    safeHeaders: z.array(z.string()).optional(),
+    retryRules: z.lazy(() => CollectorHealthCheckRetryRules4$outboundSchema)
+        .optional(),
+    username: z.string().optional(),
+    password: z.string().optional(),
+    credentialsSecret: z.string().optional(),
+    loginUrl: z.string().default(""),
+    loginBody: z.string().default("`{ \"username\": \"${username}\", \"password\": \"${password}\" }`"),
+    tokenRespAttribute: z.string().optional(),
+    authHeaderExpr: z.string().default("`Bearer ${token}`"),
+    authRequestHeaders: z.array(z.lazy(() => CollectorHealthCheckAuthRequestHeader4$outboundSchema)).optional(),
+    clientSecretParamName: z.string().default("client_secret"),
+    clientSecretParamValue: z.string().optional(),
+    authRequestParams: z.array(z.lazy(() => CollectorHealthCheckAuthRequestParam4$outboundSchema)).optional(),
+    textSecret: z.string().optional(),
+    type: CollectorHealthCheckType4$outboundSchema,
+});
+export function collectorHealthCheckHealthCheck4ToJSON(collectorHealthCheckHealthCheck4) {
+    return JSON.stringify(CollectorHealthCheckHealthCheck4$outboundSchema.parse(collectorHealthCheckHealthCheck4));
+}
+export function collectorHealthCheckHealthCheck4FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorHealthCheckHealthCheck4$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorHealthCheckHealthCheck4' from JSON`);
+}
+/** @internal */
+export const HealthCheckMethod3$inboundSchema = openEnums.inboundSchema(HealthCheckMethod3);
+/** @internal */
+export const HealthCheckMethod3$outboundSchema = openEnums.outboundSchema(HealthCheckMethod3);
+/** @internal */
+export const CollectorHealthCheckDiscoverType3$inboundSchema = openEnums.inboundSchema(CollectorHealthCheckDiscoverType3);
+/** @internal */
+export const CollectorHealthCheckDiscoverType3$outboundSchema = openEnums.outboundSchema(CollectorHealthCheckDiscoverType3);
+/** @internal */
+export const CollectorHealthCheckDiscovery3$inboundSchema = z.object({
+    discoverType: CollectorHealthCheckDiscoverType3$inboundSchema.default("none"),
+});
+/** @internal */
+export const CollectorHealthCheckDiscovery3$outboundSchema = z.object({
+    discoverType: CollectorHealthCheckDiscoverType3$outboundSchema.default("none"),
+});
+export function collectorHealthCheckDiscovery3ToJSON(collectorHealthCheckDiscovery3) {
+    return JSON.stringify(CollectorHealthCheckDiscovery3$outboundSchema.parse(collectorHealthCheckDiscovery3));
+}
+export function collectorHealthCheckDiscovery3FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorHealthCheckDiscovery3$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorHealthCheckDiscovery3' from JSON`);
+}
+/** @internal */
+export const CollectorHealthCheckCollectRequestParam3$inboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+/** @internal */
+export const CollectorHealthCheckCollectRequestParam3$outboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+export function collectorHealthCheckCollectRequestParam3ToJSON(collectorHealthCheckCollectRequestParam3) {
+    return JSON.stringify(CollectorHealthCheckCollectRequestParam3$outboundSchema.parse(collectorHealthCheckCollectRequestParam3));
+}
+export function collectorHealthCheckCollectRequestParam3FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorHealthCheckCollectRequestParam3$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorHealthCheckCollectRequestParam3' from JSON`);
+}
+/** @internal */
+export const CollectorHealthCheckCollectRequestHeader3$inboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+/** @internal */
+export const CollectorHealthCheckCollectRequestHeader3$outboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+export function collectorHealthCheckCollectRequestHeader3ToJSON(collectorHealthCheckCollectRequestHeader3) {
+    return JSON.stringify(CollectorHealthCheckCollectRequestHeader3$outboundSchema.parse(collectorHealthCheckCollectRequestHeader3));
+}
+export function collectorHealthCheckCollectRequestHeader3FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorHealthCheckCollectRequestHeader3$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorHealthCheckCollectRequestHeader3' from JSON`);
+}
+/** @internal */
+export const CollectorHealthCheckAuthentication3$inboundSchema = openEnums.inboundSchema(CollectorHealthCheckAuthentication3);
+/** @internal */
+export const CollectorHealthCheckAuthentication3$outboundSchema = openEnums.outboundSchema(CollectorHealthCheckAuthentication3);
+/** @internal */
+export const CollectorHealthCheckHiddenDefaultBreakers3$inboundSchema = openEnums.inboundSchema(CollectorHealthCheckHiddenDefaultBreakers3);
+/** @internal */
+export const CollectorHealthCheckHiddenDefaultBreakers3$outboundSchema = openEnums.outboundSchema(CollectorHealthCheckHiddenDefaultBreakers3);
+/** @internal */
+export const CollectorHealthCheckRetryType3$inboundSchema = openEnums.inboundSchema(CollectorHealthCheckRetryType3);
+/** @internal */
+export const CollectorHealthCheckRetryType3$outboundSchema = openEnums.outboundSchema(CollectorHealthCheckRetryType3);
+/** @internal */
+export const CollectorHealthCheckRetryRules3$inboundSchema = z.object({
+    type: CollectorHealthCheckRetryType3$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 CollectorHealthCheckRetryRules3$outboundSchema = z.object({
+    type: CollectorHealthCheckRetryType3$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 collectorHealthCheckRetryRules3ToJSON(collectorHealthCheckRetryRules3) {
+    return JSON.stringify(CollectorHealthCheckRetryRules3$outboundSchema.parse(collectorHealthCheckRetryRules3));
+}
+export function collectorHealthCheckRetryRules3FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorHealthCheckRetryRules3$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorHealthCheckRetryRules3' from JSON`);
+}
+/** @internal */
+export const CollectorHealthCheckAuthRequestHeader3$inboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+/** @internal */
+export const CollectorHealthCheckAuthRequestHeader3$outboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+export function collectorHealthCheckAuthRequestHeader3ToJSON(collectorHealthCheckAuthRequestHeader3) {
+    return JSON.stringify(CollectorHealthCheckAuthRequestHeader3$outboundSchema.parse(collectorHealthCheckAuthRequestHeader3));
+}
+export function collectorHealthCheckAuthRequestHeader3FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorHealthCheckAuthRequestHeader3$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorHealthCheckAuthRequestHeader3' from JSON`);
+}
+/** @internal */
+export const CollectorHealthCheckAuthRequestParam3$inboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+/** @internal */
+export const CollectorHealthCheckAuthRequestParam3$outboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+export function collectorHealthCheckAuthRequestParam3ToJSON(collectorHealthCheckAuthRequestParam3) {
+    return JSON.stringify(CollectorHealthCheckAuthRequestParam3$outboundSchema.parse(collectorHealthCheckAuthRequestParam3));
+}
+export function collectorHealthCheckAuthRequestParam3FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorHealthCheckAuthRequestParam3$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorHealthCheckAuthRequestParam3' from JSON`);
+}
+/** @internal */
+export const CollectorHealthCheckType3$inboundSchema = z.nativeEnum(CollectorHealthCheckType3);
+/** @internal */
+export const CollectorHealthCheckType3$outboundSchema = CollectorHealthCheckType3$inboundSchema;
+/** @internal */
+export const CollectorHealthCheckHealthCheck3$inboundSchema = z.object({
+    collectMethod: HealthCheckMethod3$inboundSchema.default("get"),
+    collectBody: z.string().default("`{ }`"),
+    discovery: z.lazy(() => CollectorHealthCheckDiscovery3$inboundSchema)
+        .optional(),
+    collectUrl: z.string(),
+    collectRequestParams: z.array(z.lazy(() => CollectorHealthCheckCollectRequestParam3$inboundSchema)).optional(),
+    collectRequestHeaders: z.array(z.lazy(() => CollectorHealthCheckCollectRequestHeader3$inboundSchema)).optional(),
+    authenticateCollect: z.boolean().default(false),
+    authentication: CollectorHealthCheckAuthentication3$inboundSchema.default("none"),
+    timeout: z.number().default(30),
+    rejectUnauthorized: z.boolean().default(false),
+    defaultBreakers: CollectorHealthCheckHiddenDefaultBreakers3$inboundSchema
+        .optional(),
+    safeHeaders: z.array(z.string()).optional(),
+    retryRules: z.lazy(() => CollectorHealthCheckRetryRules3$inboundSchema)
+        .optional(),
+    username: z.string().optional(),
+    password: z.string().optional(),
+    credentialsSecret: z.string().optional(),
+    loginUrl: z.string().default(""),
+    loginBody: z.string().default("`{ \"username\": \"${username}\", \"password\": \"${password}\" }`"),
+    tokenRespAttribute: z.string().optional(),
+    authHeaderExpr: z.string().default("`Bearer ${token}`"),
+    authRequestHeaders: z.array(z.lazy(() => CollectorHealthCheckAuthRequestHeader3$inboundSchema)).optional(),
+    clientSecretParamName: z.string().default("client_secret"),
+    clientSecretParamValue: z.string().optional(),
+    authRequestParams: z.array(z.lazy(() => CollectorHealthCheckAuthRequestParam3$inboundSchema)).optional(),
+    textSecret: z.string().optional(),
+    type: CollectorHealthCheckType3$inboundSchema,
+});
+/** @internal */
+export const CollectorHealthCheckHealthCheck3$outboundSchema = z.object({
+    collectMethod: HealthCheckMethod3$outboundSchema.default("get"),
+    collectBody: z.string().default("`{ }`"),
+    discovery: z.lazy(() => CollectorHealthCheckDiscovery3$outboundSchema)
+        .optional(),
+    collectUrl: z.string(),
+    collectRequestParams: z.array(z.lazy(() => CollectorHealthCheckCollectRequestParam3$outboundSchema)).optional(),
+    collectRequestHeaders: z.array(z.lazy(() => CollectorHealthCheckCollectRequestHeader3$outboundSchema)).optional(),
+    authenticateCollect: z.boolean().default(false),
+    authentication: CollectorHealthCheckAuthentication3$outboundSchema.default("none"),
+    timeout: z.number().default(30),
+    rejectUnauthorized: z.boolean().default(false),
+    defaultBreakers: CollectorHealthCheckHiddenDefaultBreakers3$outboundSchema
+        .optional(),
+    safeHeaders: z.array(z.string()).optional(),
+    retryRules: z.lazy(() => CollectorHealthCheckRetryRules3$outboundSchema)
+        .optional(),
+    username: z.string().optional(),
+    password: z.string().optional(),
+    credentialsSecret: z.string().optional(),
+    loginUrl: z.string().default(""),
+    loginBody: z.string().default("`{ \"username\": \"${username}\", \"password\": \"${password}\" }`"),
+    tokenRespAttribute: z.string().optional(),
+    authHeaderExpr: z.string().default("`Bearer ${token}`"),
+    authRequestHeaders: z.array(z.lazy(() => CollectorHealthCheckAuthRequestHeader3$outboundSchema)).optional(),
+    clientSecretParamName: z.string().default("client_secret"),
+    clientSecretParamValue: z.string().optional(),
+    authRequestParams: z.array(z.lazy(() => CollectorHealthCheckAuthRequestParam3$outboundSchema)).optional(),
+    textSecret: z.string().optional(),
+    type: CollectorHealthCheckType3$outboundSchema,
+});
+export function collectorHealthCheckHealthCheck3ToJSON(collectorHealthCheckHealthCheck3) {
+    return JSON.stringify(CollectorHealthCheckHealthCheck3$outboundSchema.parse(collectorHealthCheckHealthCheck3));
+}
+export function collectorHealthCheckHealthCheck3FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorHealthCheckHealthCheck3$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorHealthCheckHealthCheck3' from JSON`);
+}
+/** @internal */
+export const HealthCheckMethod2$inboundSchema = openEnums.inboundSchema(HealthCheckMethod2);
+/** @internal */
+export const HealthCheckMethod2$outboundSchema = openEnums.outboundSchema(HealthCheckMethod2);
+/** @internal */
+export const CollectorHealthCheckCollectRequestParam2$inboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+/** @internal */
+export const CollectorHealthCheckCollectRequestParam2$outboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+export function collectorHealthCheckCollectRequestParam2ToJSON(collectorHealthCheckCollectRequestParam2) {
+    return JSON.stringify(CollectorHealthCheckCollectRequestParam2$outboundSchema.parse(collectorHealthCheckCollectRequestParam2));
+}
+export function collectorHealthCheckCollectRequestParam2FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorHealthCheckCollectRequestParam2$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorHealthCheckCollectRequestParam2' from JSON`);
+}
+/** @internal */
+export const CollectorHealthCheckDiscoverType2$inboundSchema = openEnums.inboundSchema(CollectorHealthCheckDiscoverType2);
+/** @internal */
+export const CollectorHealthCheckDiscoverType2$outboundSchema = openEnums.outboundSchema(CollectorHealthCheckDiscoverType2);
+/** @internal */
+export const CollectorHealthCheckDiscovery2$inboundSchema = z.object({
+    discoverType: CollectorHealthCheckDiscoverType2$inboundSchema.default("none"),
+});
+/** @internal */
+export const CollectorHealthCheckDiscovery2$outboundSchema = z.object({
+    discoverType: CollectorHealthCheckDiscoverType2$outboundSchema.default("none"),
+});
+export function collectorHealthCheckDiscovery2ToJSON(collectorHealthCheckDiscovery2) {
+    return JSON.stringify(CollectorHealthCheckDiscovery2$outboundSchema.parse(collectorHealthCheckDiscovery2));
+}
+export function collectorHealthCheckDiscovery2FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorHealthCheckDiscovery2$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorHealthCheckDiscovery2' from JSON`);
+}
+/** @internal */
+export const CollectorHealthCheckCollectRequestHeader2$inboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+/** @internal */
+export const CollectorHealthCheckCollectRequestHeader2$outboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+export function collectorHealthCheckCollectRequestHeader2ToJSON(collectorHealthCheckCollectRequestHeader2) {
+    return JSON.stringify(CollectorHealthCheckCollectRequestHeader2$outboundSchema.parse(collectorHealthCheckCollectRequestHeader2));
+}
+export function collectorHealthCheckCollectRequestHeader2FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorHealthCheckCollectRequestHeader2$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorHealthCheckCollectRequestHeader2' from JSON`);
+}
+/** @internal */
+export const CollectorHealthCheckAuthentication2$inboundSchema = openEnums.inboundSchema(CollectorHealthCheckAuthentication2);
+/** @internal */
+export const CollectorHealthCheckAuthentication2$outboundSchema = openEnums.outboundSchema(CollectorHealthCheckAuthentication2);
+/** @internal */
+export const CollectorHealthCheckHiddenDefaultBreakers2$inboundSchema = openEnums.inboundSchema(CollectorHealthCheckHiddenDefaultBreakers2);
+/** @internal */
+export const CollectorHealthCheckHiddenDefaultBreakers2$outboundSchema = openEnums.outboundSchema(CollectorHealthCheckHiddenDefaultBreakers2);
+/** @internal */
+export const CollectorHealthCheckRetryType2$inboundSchema = openEnums.inboundSchema(CollectorHealthCheckRetryType2);
+/** @internal */
+export const CollectorHealthCheckRetryType2$outboundSchema = openEnums.outboundSchema(CollectorHealthCheckRetryType2);
+/** @internal */
+export const CollectorHealthCheckRetryRules2$inboundSchema = z.object({
+    type: CollectorHealthCheckRetryType2$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 CollectorHealthCheckRetryRules2$outboundSchema = z.object({
+    type: CollectorHealthCheckRetryType2$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 collectorHealthCheckRetryRules2ToJSON(collectorHealthCheckRetryRules2) {
+    return JSON.stringify(CollectorHealthCheckRetryRules2$outboundSchema.parse(collectorHealthCheckRetryRules2));
+}
+export function collectorHealthCheckRetryRules2FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorHealthCheckRetryRules2$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorHealthCheckRetryRules2' from JSON`);
+}
+/** @internal */
+export const CollectorHealthCheckAuthRequestHeader2$inboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+/** @internal */
+export const CollectorHealthCheckAuthRequestHeader2$outboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+export function collectorHealthCheckAuthRequestHeader2ToJSON(collectorHealthCheckAuthRequestHeader2) {
+    return JSON.stringify(CollectorHealthCheckAuthRequestHeader2$outboundSchema.parse(collectorHealthCheckAuthRequestHeader2));
+}
+export function collectorHealthCheckAuthRequestHeader2FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorHealthCheckAuthRequestHeader2$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorHealthCheckAuthRequestHeader2' from JSON`);
+}
+/** @internal */
+export const CollectorHealthCheckAuthRequestParam2$inboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+/** @internal */
+export const CollectorHealthCheckAuthRequestParam2$outboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+export function collectorHealthCheckAuthRequestParam2ToJSON(collectorHealthCheckAuthRequestParam2) {
+    return JSON.stringify(CollectorHealthCheckAuthRequestParam2$outboundSchema.parse(collectorHealthCheckAuthRequestParam2));
+}
+export function collectorHealthCheckAuthRequestParam2FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorHealthCheckAuthRequestParam2$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorHealthCheckAuthRequestParam2' from JSON`);
+}
+/** @internal */
+export const CollectorHealthCheckType2$inboundSchema = z.nativeEnum(CollectorHealthCheckType2);
+/** @internal */
+export const CollectorHealthCheckType2$outboundSchema = CollectorHealthCheckType2$inboundSchema;
+/** @internal */
+export const CollectorHealthCheckHealthCheck2$inboundSchema = z.object({
+    collectMethod: HealthCheckMethod2$inboundSchema.default("get"),
+    collectRequestParams: z.array(z.lazy(() => CollectorHealthCheckCollectRequestParam2$inboundSchema)).optional(),
+    discovery: z.lazy(() => CollectorHealthCheckDiscovery2$inboundSchema)
+        .optional(),
+    collectUrl: z.string(),
+    collectBody: z.string().default("`{ }`"),
+    collectRequestHeaders: z.array(z.lazy(() => CollectorHealthCheckCollectRequestHeader2$inboundSchema)).optional(),
+    authenticateCollect: z.boolean().default(false),
+    authentication: CollectorHealthCheckAuthentication2$inboundSchema.default("none"),
+    timeout: z.number().default(30),
+    rejectUnauthorized: z.boolean().default(false),
+    defaultBreakers: CollectorHealthCheckHiddenDefaultBreakers2$inboundSchema
+        .optional(),
+    safeHeaders: z.array(z.string()).optional(),
+    retryRules: z.lazy(() => CollectorHealthCheckRetryRules2$inboundSchema)
+        .optional(),
+    username: z.string().optional(),
+    password: z.string().optional(),
+    credentialsSecret: z.string().optional(),
+    loginUrl: z.string().default(""),
+    loginBody: z.string().default("`{ \"username\": \"${username}\", \"password\": \"${password}\" }`"),
+    tokenRespAttribute: z.string().optional(),
+    authHeaderExpr: z.string().default("`Bearer ${token}`"),
+    authRequestHeaders: z.array(z.lazy(() => CollectorHealthCheckAuthRequestHeader2$inboundSchema)).optional(),
+    clientSecretParamName: z.string().default("client_secret"),
+    clientSecretParamValue: z.string().optional(),
+    authRequestParams: z.array(z.lazy(() => CollectorHealthCheckAuthRequestParam2$inboundSchema)).optional(),
+    textSecret: z.string().optional(),
+    type: CollectorHealthCheckType2$inboundSchema,
+});
+/** @internal */
+export const CollectorHealthCheckHealthCheck2$outboundSchema = z.object({
+    collectMethod: HealthCheckMethod2$outboundSchema.default("get"),
+    collectRequestParams: z.array(z.lazy(() => CollectorHealthCheckCollectRequestParam2$outboundSchema)).optional(),
+    discovery: z.lazy(() => CollectorHealthCheckDiscovery2$outboundSchema)
+        .optional(),
+    collectUrl: z.string(),
+    collectBody: z.string().default("`{ }`"),
+    collectRequestHeaders: z.array(z.lazy(() => CollectorHealthCheckCollectRequestHeader2$outboundSchema)).optional(),
+    authenticateCollect: z.boolean().default(false),
+    authentication: CollectorHealthCheckAuthentication2$outboundSchema.default("none"),
+    timeout: z.number().default(30),
+    rejectUnauthorized: z.boolean().default(false),
+    defaultBreakers: CollectorHealthCheckHiddenDefaultBreakers2$outboundSchema
+        .optional(),
+    safeHeaders: z.array(z.string()).optional(),
+    retryRules: z.lazy(() => CollectorHealthCheckRetryRules2$outboundSchema)
+        .optional(),
+    username: z.string().optional(),
+    password: z.string().optional(),
+    credentialsSecret: z.string().optional(),
+    loginUrl: z.string().default(""),
+    loginBody: z.string().default("`{ \"username\": \"${username}\", \"password\": \"${password}\" }`"),
+    tokenRespAttribute: z.string().optional(),
+    authHeaderExpr: z.string().default("`Bearer ${token}`"),
+    authRequestHeaders: z.array(z.lazy(() => CollectorHealthCheckAuthRequestHeader2$outboundSchema)).optional(),
+    clientSecretParamName: z.string().default("client_secret"),
+    clientSecretParamValue: z.string().optional(),
+    authRequestParams: z.array(z.lazy(() => CollectorHealthCheckAuthRequestParam2$outboundSchema)).optional(),
+    textSecret: z.string().optional(),
+    type: CollectorHealthCheckType2$outboundSchema,
+});
+export function collectorHealthCheckHealthCheck2ToJSON(collectorHealthCheckHealthCheck2) {
+    return JSON.stringify(CollectorHealthCheckHealthCheck2$outboundSchema.parse(collectorHealthCheckHealthCheck2));
+}
+export function collectorHealthCheckHealthCheck2FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorHealthCheckHealthCheck2$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorHealthCheckHealthCheck2' from JSON`);
+}
+/** @internal */
+export const HealthCheckMethod1$inboundSchema = openEnums.inboundSchema(HealthCheckMethod1);
+/** @internal */
+export const HealthCheckMethod1$outboundSchema = openEnums.outboundSchema(HealthCheckMethod1);
+/** @internal */
+export const CollectorHealthCheckCollectRequestParam1$inboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+/** @internal */
+export const CollectorHealthCheckCollectRequestParam1$outboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+export function collectorHealthCheckCollectRequestParam1ToJSON(collectorHealthCheckCollectRequestParam1) {
+    return JSON.stringify(CollectorHealthCheckCollectRequestParam1$outboundSchema.parse(collectorHealthCheckCollectRequestParam1));
+}
+export function collectorHealthCheckCollectRequestParam1FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorHealthCheckCollectRequestParam1$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorHealthCheckCollectRequestParam1' from JSON`);
+}
+/** @internal */
+export const CollectorHealthCheckDiscoverType1$inboundSchema = openEnums.inboundSchema(CollectorHealthCheckDiscoverType1);
+/** @internal */
+export const CollectorHealthCheckDiscoverType1$outboundSchema = openEnums.outboundSchema(CollectorHealthCheckDiscoverType1);
+/** @internal */
+export const CollectorHealthCheckDiscovery1$inboundSchema = z.object({
+    discoverType: CollectorHealthCheckDiscoverType1$inboundSchema.default("none"),
+});
+/** @internal */
+export const CollectorHealthCheckDiscovery1$outboundSchema = z.object({
+    discoverType: CollectorHealthCheckDiscoverType1$outboundSchema.default("none"),
+});
+export function collectorHealthCheckDiscovery1ToJSON(collectorHealthCheckDiscovery1) {
+    return JSON.stringify(CollectorHealthCheckDiscovery1$outboundSchema.parse(collectorHealthCheckDiscovery1));
+}
+export function collectorHealthCheckDiscovery1FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorHealthCheckDiscovery1$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorHealthCheckDiscovery1' from JSON`);
+}
+/** @internal */
+export const CollectorHealthCheckCollectRequestHeader1$inboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+/** @internal */
+export const CollectorHealthCheckCollectRequestHeader1$outboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+export function collectorHealthCheckCollectRequestHeader1ToJSON(collectorHealthCheckCollectRequestHeader1) {
+    return JSON.stringify(CollectorHealthCheckCollectRequestHeader1$outboundSchema.parse(collectorHealthCheckCollectRequestHeader1));
+}
+export function collectorHealthCheckCollectRequestHeader1FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorHealthCheckCollectRequestHeader1$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorHealthCheckCollectRequestHeader1' from JSON`);
+}
+/** @internal */
+export const CollectorHealthCheckAuthentication1$inboundSchema = openEnums.inboundSchema(CollectorHealthCheckAuthentication1);
+/** @internal */
+export const CollectorHealthCheckAuthentication1$outboundSchema = openEnums.outboundSchema(CollectorHealthCheckAuthentication1);
+/** @internal */
+export const CollectorHealthCheckHiddenDefaultBreakers1$inboundSchema = openEnums.inboundSchema(CollectorHealthCheckHiddenDefaultBreakers1);
+/** @internal */
+export const CollectorHealthCheckHiddenDefaultBreakers1$outboundSchema = openEnums.outboundSchema(CollectorHealthCheckHiddenDefaultBreakers1);
+/** @internal */
+export const CollectorHealthCheckRetryType1$inboundSchema = openEnums.inboundSchema(CollectorHealthCheckRetryType1);
+/** @internal */
+export const CollectorHealthCheckRetryType1$outboundSchema = openEnums.outboundSchema(CollectorHealthCheckRetryType1);
+/** @internal */
+export const CollectorHealthCheckRetryRules1$inboundSchema = z.object({
+    type: CollectorHealthCheckRetryType1$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 CollectorHealthCheckRetryRules1$outboundSchema = z.object({
+    type: CollectorHealthCheckRetryType1$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 collectorHealthCheckRetryRules1ToJSON(collectorHealthCheckRetryRules1) {
+    return JSON.stringify(CollectorHealthCheckRetryRules1$outboundSchema.parse(collectorHealthCheckRetryRules1));
+}
+export function collectorHealthCheckRetryRules1FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorHealthCheckRetryRules1$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorHealthCheckRetryRules1' from JSON`);
+}
+/** @internal */
+export const CollectorHealthCheckAuthRequestHeader1$inboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+/** @internal */
+export const CollectorHealthCheckAuthRequestHeader1$outboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+export function collectorHealthCheckAuthRequestHeader1ToJSON(collectorHealthCheckAuthRequestHeader1) {
+    return JSON.stringify(CollectorHealthCheckAuthRequestHeader1$outboundSchema.parse(collectorHealthCheckAuthRequestHeader1));
+}
+export function collectorHealthCheckAuthRequestHeader1FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorHealthCheckAuthRequestHeader1$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorHealthCheckAuthRequestHeader1' from JSON`);
+}
+/** @internal */
+export const CollectorHealthCheckAuthRequestParam1$inboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+/** @internal */
+export const CollectorHealthCheckAuthRequestParam1$outboundSchema = z.object({
+    name: z.string(),
+    value: z.string(),
+});
+export function collectorHealthCheckAuthRequestParam1ToJSON(collectorHealthCheckAuthRequestParam1) {
+    return JSON.stringify(CollectorHealthCheckAuthRequestParam1$outboundSchema.parse(collectorHealthCheckAuthRequestParam1));
+}
+export function collectorHealthCheckAuthRequestParam1FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorHealthCheckAuthRequestParam1$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorHealthCheckAuthRequestParam1' from JSON`);
+}
+/** @internal */
+export const CollectorHealthCheckType1$inboundSchema = z.nativeEnum(CollectorHealthCheckType1);
+/** @internal */
+export const CollectorHealthCheckType1$outboundSchema = CollectorHealthCheckType1$inboundSchema;
+/** @internal */
+export const CollectorHealthCheckHealthCheck1$inboundSchema = z.object({
+    collectMethod: HealthCheckMethod1$inboundSchema.default("get"),
+    collectRequestParams: z.array(z.lazy(() => CollectorHealthCheckCollectRequestParam1$inboundSchema)).optional(),
+    discovery: z.lazy(() => CollectorHealthCheckDiscovery1$inboundSchema)
+        .optional(),
+    collectUrl: z.string(),
+    collectBody: z.string().default("`{ }`"),
+    collectRequestHeaders: z.array(z.lazy(() => CollectorHealthCheckCollectRequestHeader1$inboundSchema)).optional(),
+    authenticateCollect: z.boolean().default(false),
+    authentication: CollectorHealthCheckAuthentication1$inboundSchema.default("none"),
+    timeout: z.number().default(30),
+    rejectUnauthorized: z.boolean().default(false),
+    defaultBreakers: CollectorHealthCheckHiddenDefaultBreakers1$inboundSchema
+        .optional(),
+    safeHeaders: z.array(z.string()).optional(),
+    retryRules: z.lazy(() => CollectorHealthCheckRetryRules1$inboundSchema)
+        .optional(),
+    username: z.string().optional(),
+    password: z.string().optional(),
+    credentialsSecret: z.string().optional(),
+    loginUrl: z.string().default(""),
+    loginBody: z.string().default("`{ \"username\": \"${username}\", \"password\": \"${password}\" }`"),
+    tokenRespAttribute: z.string().optional(),
+    authHeaderExpr: z.string().default("`Bearer ${token}`"),
+    authRequestHeaders: z.array(z.lazy(() => CollectorHealthCheckAuthRequestHeader1$inboundSchema)).optional(),
+    clientSecretParamName: z.string().default("client_secret"),
+    clientSecretParamValue: z.string().optional(),
+    authRequestParams: z.array(z.lazy(() => CollectorHealthCheckAuthRequestParam1$inboundSchema)).optional(),
+    textSecret: z.string().optional(),
+    type: CollectorHealthCheckType1$inboundSchema,
+});
+/** @internal */
+export const CollectorHealthCheckHealthCheck1$outboundSchema = z.object({
+    collectMethod: HealthCheckMethod1$outboundSchema.default("get"),
+    collectRequestParams: z.array(z.lazy(() => CollectorHealthCheckCollectRequestParam1$outboundSchema)).optional(),
+    discovery: z.lazy(() => CollectorHealthCheckDiscovery1$outboundSchema)
+        .optional(),
+    collectUrl: z.string(),
+    collectBody: z.string().default("`{ }`"),
+    collectRequestHeaders: z.array(z.lazy(() => CollectorHealthCheckCollectRequestHeader1$outboundSchema)).optional(),
+    authenticateCollect: z.boolean().default(false),
+    authentication: CollectorHealthCheckAuthentication1$outboundSchema.default("none"),
+    timeout: z.number().default(30),
+    rejectUnauthorized: z.boolean().default(false),
+    defaultBreakers: CollectorHealthCheckHiddenDefaultBreakers1$outboundSchema
+        .optional(),
+    safeHeaders: z.array(z.string()).optional(),
+    retryRules: z.lazy(() => CollectorHealthCheckRetryRules1$outboundSchema)
+        .optional(),
+    username: z.string().optional(),
+    password: z.string().optional(),
+    credentialsSecret: z.string().optional(),
+    loginUrl: z.string().default(""),
+    loginBody: z.string().default("`{ \"username\": \"${username}\", \"password\": \"${password}\" }`"),
+    tokenRespAttribute: z.string().optional(),
+    authHeaderExpr: z.string().default("`Bearer ${token}`"),
+    authRequestHeaders: z.array(z.lazy(() => CollectorHealthCheckAuthRequestHeader1$outboundSchema)).optional(),
+    clientSecretParamName: z.string().default("client_secret"),
+    clientSecretParamValue: z.string().optional(),
+    authRequestParams: z.array(z.lazy(() => CollectorHealthCheckAuthRequestParam1$outboundSchema)).optional(),
+    textSecret: z.string().optional(),
+    type: CollectorHealthCheckType1$outboundSchema,
+});
+export function collectorHealthCheckHealthCheck1ToJSON(collectorHealthCheckHealthCheck1) {
+    return JSON.stringify(CollectorHealthCheckHealthCheck1$outboundSchema.parse(collectorHealthCheckHealthCheck1));
+}
+export function collectorHealthCheckHealthCheck1FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorHealthCheckHealthCheck1$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorHealthCheckHealthCheck1' from JSON`);
+}
+/** @internal */
+export const CollectorHealthCheck$inboundSchema = z.union([
+    z.lazy(() => CollectorHealthCheckHealthCheck5$inboundSchema),
+    z.lazy(() => CollectorHealthCheckHealthCheck7$inboundSchema),
+    z.lazy(() => CollectorHealthCheckHealthCheck6$inboundSchema),
+    z.lazy(() => CollectorHealthCheckHealthCheck8$inboundSchema),
+    z.lazy(() => CollectorHealthCheckHealthCheck9$inboundSchema),
+    z.lazy(() => CollectorHealthCheckHealthCheck10$inboundSchema),
+    z.lazy(() => CollectorHealthCheckHealthCheck1$inboundSchema),
+    z.lazy(() => CollectorHealthCheckHealthCheck2$inboundSchema),
+    z.lazy(() => CollectorHealthCheckHealthCheck3$inboundSchema),
+    z.lazy(() => CollectorHealthCheckHealthCheck4$inboundSchema),
+]);
+/** @internal */
+export const CollectorHealthCheck$outboundSchema = z.union([
+    z.lazy(() => CollectorHealthCheckHealthCheck5$outboundSchema),
+    z.lazy(() => CollectorHealthCheckHealthCheck7$outboundSchema),
+    z.lazy(() => CollectorHealthCheckHealthCheck6$outboundSchema),
+    z.lazy(() => CollectorHealthCheckHealthCheck8$outboundSchema),
+    z.lazy(() => CollectorHealthCheckHealthCheck9$outboundSchema),
+    z.lazy(() => CollectorHealthCheckHealthCheck10$outboundSchema),
+    z.lazy(() => CollectorHealthCheckHealthCheck1$outboundSchema),
+    z.lazy(() => CollectorHealthCheckHealthCheck2$outboundSchema),
+    z.lazy(() => CollectorHealthCheckHealthCheck3$outboundSchema),
+    z.lazy(() => CollectorHealthCheckHealthCheck4$outboundSchema),
+]);
+export function collectorHealthCheckToJSON(collectorHealthCheck) {
+    return JSON.stringify(CollectorHealthCheck$outboundSchema.parse(collectorHealthCheck));
+}
+export function collectorHealthCheckFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorHealthCheck$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorHealthCheck' from JSON`);
+}
+//# sourceMappingURL=collectorhealthcheck.js.map