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

package/dist/esm/models/splunkcollectorconf.d.ts

@@ -2,35 +2,177 @@ import * as z from "zod/v3";
 import { OpenEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+/**
+ * Authentication method for Discover and Collect REST calls
+ */
+export declare const SplunkAuthenticationLoginSecretAuthentication: {
+    /**
+     * None
+     */
+    readonly None: "none";
+    /**
+     * Basic
+     */
+    readonly Basic: "basic";
+    /**
+     * Basic (credentials secret)
+     */
+    readonly BasicSecret: "basicSecret";
+    /**
+     * Bearer Token
+     */
+    readonly Token: "token";
+    /**
+     * Bearer Token (text secret)
+     */
+    readonly TokenSecret: "tokenSecret";
+};
+/**
+ * Authentication method for Discover and Collect REST calls
+ */
+export type SplunkAuthenticationLoginSecretAuthentication = OpenEnum<typeof SplunkAuthenticationLoginSecretAuthentication>;
 /**
  * Format of the returned output
  */
-export declare const SplunkCollectorConfOutputMode: {
+export declare const SplunkAuthenticationLoginSecretOutputMode: {
     readonly Csv: "csv";
     readonly Json: "json";
 };
 /**
  * Format of the returned output
  */
-export type SplunkCollectorConfOutputMode = OpenEnum<typeof SplunkCollectorConfOutputMode>;
-export type CollectRequestParam = {
+export type SplunkAuthenticationLoginSecretOutputMode = OpenEnum<typeof SplunkAuthenticationLoginSecretOutputMode>;
+export type SplunkAuthenticationLoginSecretCollectRequestParam = {
     name: string;
     /**
      * JavaScript expression to compute the parameter's value, normally enclosed in backticks (`${earliest}`). If a constant, use single quotes ('earliest'). Values without delimiters (earliest) are evaluated as strings.
      */
     value: string;
 };
-export type SplunkCollectorConfCollectRequestHeader = {
+export type SplunkAuthenticationLoginSecretCollectRequestHeader = {
     name: string;
     /**
      * JavaScript expression to compute the header's value, normally enclosed in backticks (`${earliest}`). If a constant, use single quotes ('earliest'). Values without delimiters (earliest) are evaluated as strings.
      */
     value: string;
 };
+/**
+ * Algorithm to use when performing HTTP retries
+ */
+export declare const SplunkAuthenticationLoginSecretRetryType: {
+    /**
+     * Disabled
+     */
+    readonly None: "none";
+    /**
+     * Backoff
+     */
+    readonly Backoff: "backoff";
+    /**
+     * Static
+     */
+    readonly Static: "static";
+};
+/**
+ * Algorithm to use when performing HTTP retries
+ */
+export type SplunkAuthenticationLoginSecretRetryType = OpenEnum<typeof SplunkAuthenticationLoginSecretRetryType>;
+export type SplunkAuthenticationLoginSecretRetryRules = {
+    /**
+     * Algorithm to use when performing HTTP retries
+     */
+    type?: SplunkAuthenticationLoginSecretRetryType | undefined;
+    interval?: any | undefined;
+    limit?: any | undefined;
+    multiplier?: any | undefined;
+    codes?: any | undefined;
+    enableHeader?: any | undefined;
+    retryConnectTimeout?: any | undefined;
+    retryConnectReset?: any | undefined;
+};
+export type SplunkAuthenticationLoginSecret = {
+    /**
+     * Authentication method for Discover and Collect REST calls
+     */
+    authentication?: SplunkAuthenticationLoginSecretAuthentication | undefined;
+    /**
+     * URL to use for login API call, this call is expected to be a POST.
+     */
+    loginUrl?: string | undefined;
+    /**
+     * Select or create a stored secret that references your login credentials
+     */
+    credentialsSecret: string;
+    /**
+     * Template for POST body to send with login request, ${username} and ${password} are used to specify location of these attributes in the message
+     */
+    loginBody?: string | undefined;
+    /**
+     * Path to token attribute in login response body. Nested attributes are allowed.
+     */
+    tokenRespAttribute?: string | undefined;
+    /**
+     * JavaScript expression to compute the Authorization header to pass in discover and collect calls. The value ${token} is used to reference the token obtained from login.
+     */
+    authHeaderExpr?: string | undefined;
+    /**
+     * Search head base URL. Can be an expression. Default is https://localhost:8089.
+     */
+    searchHead?: string | undefined;
+    /**
+     * Examples: 'index=myAppLogs level=error channel=myApp' OR '| mstats avg(myStat) as myStat WHERE index=myStatsIndex.'
+     */
+    search: string;
+    /**
+     * The earliest time boundary for the search. Can be an exact or relative time. Examples: '2022-01-14T12:00:00Z' or '-16m@m'
+     */
+    earliest?: string | undefined;
+    /**
+     * The latest time boundary for the search. Can be an exact or relative time. Examples: '2022-01-14T12:00:00Z' or '-1m@m'
+     */
+    latest?: string | undefined;
+    /**
+     * REST API used to create a search
+     */
+    endpoint?: string | undefined;
+    /**
+     * Format of the returned output
+     */
+    outputMode?: SplunkAuthenticationLoginSecretOutputMode | undefined;
+    /**
+     * Optional collect request parameters
+     */
+    collectRequestParams?: Array<SplunkAuthenticationLoginSecretCollectRequestParam> | undefined;
+    /**
+     * Optional collect request headers
+     */
+    collectRequestHeaders?: Array<SplunkAuthenticationLoginSecretCollectRequestHeader> | undefined;
+    /**
+     * HTTP request inactivity timeout. Use 0 for no timeout.
+     */
+    timeout?: number | undefined;
+    /**
+     * Use round-robin DNS lookup. Suitable when DNS server returns multiple addresses in sort order.
+     */
+    useRoundRobinDns?: boolean | undefined;
+    /**
+     * Disable collector event time filtering when a date range is specified
+     */
+    disableTimeFilter?: boolean | undefined;
+    /**
+     * Reject certificates that cannot be verified against a valid CA (such as self-signed certificates)
+     */
+    rejectUnauthorized?: boolean | undefined;
+    /**
+     * Escape characters (\") in search queries will be passed directly to Splunk
+     */
+    handleEscapedChars?: boolean | undefined;
+    retryRules?: SplunkAuthenticationLoginSecretRetryRules | undefined;
+};
 /**
  * Authentication method for Discover and Collect REST calls
  */
-export declare const SplunkCollectorConfAuthentication: {
+export declare const SplunkAuthenticationLoginAuthentication: {
     /**
      * None
      */
@@ -55,11 +197,36 @@ export declare const SplunkCollectorConfAuthentication: {
 /**
  * Authentication method for Discover and Collect REST calls
  */
-export type SplunkCollectorConfAuthentication = OpenEnum<typeof SplunkCollectorConfAuthentication>;
+export type SplunkAuthenticationLoginAuthentication = OpenEnum<typeof SplunkAuthenticationLoginAuthentication>;
+/**
+ * Format of the returned output
+ */
+export declare const SplunkAuthenticationLoginOutputMode: {
+    readonly Csv: "csv";
+    readonly Json: "json";
+};
+/**
+ * Format of the returned output
+ */
+export type SplunkAuthenticationLoginOutputMode = OpenEnum<typeof SplunkAuthenticationLoginOutputMode>;
+export type SplunkAuthenticationLoginCollectRequestParam = {
+    name: string;
+    /**
+     * JavaScript expression to compute the parameter's value, normally enclosed in backticks (`${earliest}`). If a constant, use single quotes ('earliest'). Values without delimiters (earliest) are evaluated as strings.
+     */
+    value: string;
+};
+export type SplunkAuthenticationLoginCollectRequestHeader = {
+    name: string;
+    /**
+     * JavaScript expression to compute the header's value, normally enclosed in backticks (`${earliest}`). If a constant, use single quotes ('earliest'). Values without delimiters (earliest) are evaluated as strings.
+     */
+    value: string;
+};
 /**
  * Algorithm to use when performing HTTP retries
  */
-export declare const SplunkCollectorConfRetryType: {
+export declare const SplunkAuthenticationLoginRetryType: {
     /**
      * Disabled
      */
@@ -76,12 +243,12 @@ export declare const SplunkCollectorConfRetryType: {
 /**
  * Algorithm to use when performing HTTP retries
  */
-export type SplunkCollectorConfRetryType = OpenEnum<typeof SplunkCollectorConfRetryType>;
-export type SplunkCollectorConfRetryRules = {
+export type SplunkAuthenticationLoginRetryType = OpenEnum<typeof SplunkAuthenticationLoginRetryType>;
+export type SplunkAuthenticationLoginRetryRules = {
     /**
      * Algorithm to use when performing HTTP retries
      */
-    type?: SplunkCollectorConfRetryType | undefined;
+    type?: SplunkAuthenticationLoginRetryType | undefined;
     interval?: any | undefined;
     limit?: any | undefined;
     multiplier?: any | undefined;
@@ -90,7 +257,29 @@ export type SplunkCollectorConfRetryRules = {
     retryConnectTimeout?: any | undefined;
     retryConnectReset?: any | undefined;
 };
-export type SplunkCollectorConf = {
+export type SplunkAuthenticationLogin = {
+    /**
+     * Authentication method for Discover and Collect REST calls
+     */
+    authentication?: SplunkAuthenticationLoginAuthentication | undefined;
+    /**
+     * URL to use for login API call. This call is expected to be a POST.
+     */
+    loginUrl?: string | undefined;
+    username: string;
+    password: string;
+    /**
+     * Template for POST body to send with login request. ${username} and ${password} are used to specify location of these attributes in the message.
+     */
+    loginBody?: string | undefined;
+    /**
+     * Path to token attribute in login response body. Nested attributes are allowed.
+     */
+    tokenRespAttribute?: string | undefined;
+    /**
+     * JavaScript expression to compute the Authorization header to pass in discover and collect calls. The value ${token} is used to reference the token obtained from login.
+     */
+    authHeaderExpr?: string | undefined;
     /**
      * Search head base URL. Can be an expression. Default is https://localhost:8089.
      */
@@ -114,19 +303,15 @@ export type SplunkCollectorConf = {
     /**
      * Format of the returned output
      */
-    outputMode?: SplunkCollectorConfOutputMode | undefined;
+    outputMode?: SplunkAuthenticationLoginOutputMode | undefined;
     /**
      * Optional collect request parameters
      */
-    collectRequestParams?: Array<CollectRequestParam> | undefined;
+    collectRequestParams?: Array<SplunkAuthenticationLoginCollectRequestParam> | undefined;
     /**
      * Optional collect request headers
      */
-    collectRequestHeaders?: Array<SplunkCollectorConfCollectRequestHeader> | undefined;
-    /**
-     * Authentication method for Discover and Collect REST calls
-     */
-    authentication?: SplunkCollectorConfAuthentication | undefined;
+    collectRequestHeaders?: Array<SplunkAuthenticationLoginCollectRequestHeader> | undefined;
     /**
      * HTTP request inactivity timeout. Use 0 for no timeout.
      */
@@ -147,47 +332,88 @@ export type SplunkCollectorConf = {
      * Escape characters (\") in search queries will be passed directly to Splunk
      */
     handleEscapedChars?: boolean | undefined;
-    retryRules?: SplunkCollectorConfRetryRules | undefined;
+    retryRules?: SplunkAuthenticationLoginRetryRules | undefined;
 };
-/** @internal */
-export declare const SplunkCollectorConfOutputMode$inboundSchema: z.ZodType<SplunkCollectorConfOutputMode, z.ZodTypeDef, unknown>;
-/** @internal */
-export declare const SplunkCollectorConfOutputMode$outboundSchema: z.ZodType<string, z.ZodTypeDef, SplunkCollectorConfOutputMode>;
-/** @internal */
-export declare const CollectRequestParam$inboundSchema: z.ZodType<CollectRequestParam, z.ZodTypeDef, unknown>;
-/** @internal */
-export type CollectRequestParam$Outbound = {
+/**
+ * Authentication method for Discover and Collect REST calls
+ */
+export declare const SplunkAuthenticationTokenSecretAuthentication: {
+    /**
+     * None
+     */
+    readonly None: "none";
+    /**
+     * Basic
+     */
+    readonly Basic: "basic";
+    /**
+     * Basic (credentials secret)
+     */
+    readonly BasicSecret: "basicSecret";
+    /**
+     * Bearer Token
+     */
+    readonly Token: "token";
+    /**
+     * Bearer Token (text secret)
+     */
+    readonly TokenSecret: "tokenSecret";
+};
+/**
+ * Authentication method for Discover and Collect REST calls
+ */
+export type SplunkAuthenticationTokenSecretAuthentication = OpenEnum<typeof SplunkAuthenticationTokenSecretAuthentication>;
+/**
+ * Format of the returned output
+ */
+export declare const SplunkAuthenticationTokenSecretOutputMode: {
+    readonly Csv: "csv";
+    readonly Json: "json";
+};
+/**
+ * Format of the returned output
+ */
+export type SplunkAuthenticationTokenSecretOutputMode = OpenEnum<typeof SplunkAuthenticationTokenSecretOutputMode>;
+export type SplunkAuthenticationTokenSecretCollectRequestParam = {
     name: string;
+    /**
+     * JavaScript expression to compute the parameter's value, normally enclosed in backticks (`${earliest}`). If a constant, use single quotes ('earliest'). Values without delimiters (earliest) are evaluated as strings.
+     */
     value: string;
 };
-/** @internal */
-export declare const CollectRequestParam$outboundSchema: z.ZodType<CollectRequestParam$Outbound, z.ZodTypeDef, CollectRequestParam>;
-export declare function collectRequestParamToJSON(collectRequestParam: CollectRequestParam): string;
-export declare function collectRequestParamFromJSON(jsonString: string): SafeParseResult<CollectRequestParam, SDKValidationError>;
-/** @internal */
-export declare const SplunkCollectorConfCollectRequestHeader$inboundSchema: z.ZodType<SplunkCollectorConfCollectRequestHeader, z.ZodTypeDef, unknown>;
-/** @internal */
-export type SplunkCollectorConfCollectRequestHeader$Outbound = {
+export type SplunkAuthenticationTokenSecretCollectRequestHeader = {
     name: string;
+    /**
+     * JavaScript expression to compute the header's value, normally enclosed in backticks (`${earliest}`). If a constant, use single quotes ('earliest'). Values without delimiters (earliest) are evaluated as strings.
+     */
     value: string;
 };
-/** @internal */
-export declare const SplunkCollectorConfCollectRequestHeader$outboundSchema: z.ZodType<SplunkCollectorConfCollectRequestHeader$Outbound, z.ZodTypeDef, SplunkCollectorConfCollectRequestHeader>;
-export declare function splunkCollectorConfCollectRequestHeaderToJSON(splunkCollectorConfCollectRequestHeader: SplunkCollectorConfCollectRequestHeader): string;
-export declare function splunkCollectorConfCollectRequestHeaderFromJSON(jsonString: string): SafeParseResult<SplunkCollectorConfCollectRequestHeader, SDKValidationError>;
-/** @internal */
-export declare const SplunkCollectorConfAuthentication$inboundSchema: z.ZodType<SplunkCollectorConfAuthentication, z.ZodTypeDef, unknown>;
-/** @internal */
-export declare const SplunkCollectorConfAuthentication$outboundSchema: z.ZodType<string, z.ZodTypeDef, SplunkCollectorConfAuthentication>;
-/** @internal */
-export declare const SplunkCollectorConfRetryType$inboundSchema: z.ZodType<SplunkCollectorConfRetryType, z.ZodTypeDef, unknown>;
-/** @internal */
-export declare const SplunkCollectorConfRetryType$outboundSchema: z.ZodType<string, z.ZodTypeDef, SplunkCollectorConfRetryType>;
-/** @internal */
-export declare const SplunkCollectorConfRetryRules$inboundSchema: z.ZodType<SplunkCollectorConfRetryRules, z.ZodTypeDef, unknown>;
-/** @internal */
-export type SplunkCollectorConfRetryRules$Outbound = {
-    type: string;
+/**
+ * Algorithm to use when performing HTTP retries
+ */
+export declare const SplunkAuthenticationTokenSecretRetryType: {
+    /**
+     * Disabled
+     */
+    readonly None: "none";
+    /**
+     * Backoff
+     */
+    readonly Backoff: "backoff";
+    /**
+     * Static
+     */
+    readonly Static: "static";
+};
+/**
+ * Algorithm to use when performing HTTP retries
+ */
+export type SplunkAuthenticationTokenSecretRetryType = OpenEnum<typeof SplunkAuthenticationTokenSecretRetryType>;
+export type SplunkAuthenticationTokenSecretRetryRules = {
+    /**
+     * Algorithm to use when performing HTTP retries
+     */
+    type?: SplunkAuthenticationTokenSecretRetryType | undefined;
     interval?: any | undefined;
     limit?: any | undefined;
     multiplier?: any | undefined;
@@ -196,31 +422,1217 @@ export type SplunkCollectorConfRetryRules$Outbound = {
     retryConnectTimeout?: any | undefined;
     retryConnectReset?: any | undefined;
 };
-/** @internal */
-export declare const SplunkCollectorConfRetryRules$outboundSchema: z.ZodType<SplunkCollectorConfRetryRules$Outbound, z.ZodTypeDef, SplunkCollectorConfRetryRules>;
-export declare function splunkCollectorConfRetryRulesToJSON(splunkCollectorConfRetryRules: SplunkCollectorConfRetryRules): string;
-export declare function splunkCollectorConfRetryRulesFromJSON(jsonString: string): SafeParseResult<SplunkCollectorConfRetryRules, SDKValidationError>;
-/** @internal */
-export declare const SplunkCollectorConf$inboundSchema: z.ZodType<SplunkCollectorConf, z.ZodTypeDef, unknown>;
-/** @internal */
-export type SplunkCollectorConf$Outbound = {
-    searchHead: string;
+export type SplunkAuthenticationTokenSecret = {
+    /**
+     * Authentication method for Discover and Collect REST calls
+     */
+    authentication?: SplunkAuthenticationTokenSecretAuthentication | undefined;
+    /**
+     * Select or create a stored secret that references your Bearer token
+     */
+    tokenSecret: string;
+    /**
+     * Search head base URL. Can be an expression. Default is https://localhost:8089.
+     */
+    searchHead?: string | undefined;
+    /**
+     * Examples: 'index=myAppLogs level=error channel=myApp' OR '| mstats avg(myStat) as myStat WHERE index=myStatsIndex.'
+     */
     search: string;
+    /**
+     * The earliest time boundary for the search. Can be an exact or relative time. Examples: '2022-01-14T12:00:00Z' or '-16m@m'
+     */
     earliest?: string | undefined;
-    latest?: string | undefined;
-    endpoint: string;
+    /**
+     * The latest time boundary for the search. Can be an exact or relative time. Examples: '2022-01-14T12:00:00Z' or '-1m@m'
+     */
+    latest?: string | undefined;
+    /**
+     * REST API used to create a search
+     */
+    endpoint?: string | undefined;
+    /**
+     * Format of the returned output
+     */
+    outputMode?: SplunkAuthenticationTokenSecretOutputMode | undefined;
+    /**
+     * Optional collect request parameters
+     */
+    collectRequestParams?: Array<SplunkAuthenticationTokenSecretCollectRequestParam> | undefined;
+    /**
+     * Optional collect request headers
+     */
+    collectRequestHeaders?: Array<SplunkAuthenticationTokenSecretCollectRequestHeader> | undefined;
+    /**
+     * HTTP request inactivity timeout. Use 0 for no timeout.
+     */
+    timeout?: number | undefined;
+    /**
+     * Use round-robin DNS lookup. Suitable when DNS server returns multiple addresses in sort order.
+     */
+    useRoundRobinDns?: boolean | undefined;
+    /**
+     * Disable collector event time filtering when a date range is specified
+     */
+    disableTimeFilter?: boolean | undefined;
+    /**
+     * Reject certificates that cannot be verified against a valid CA (such as self-signed certificates)
+     */
+    rejectUnauthorized?: boolean | undefined;
+    /**
+     * Escape characters (\") in search queries will be passed directly to Splunk
+     */
+    handleEscapedChars?: boolean | undefined;
+    retryRules?: SplunkAuthenticationTokenSecretRetryRules | undefined;
+};
+/**
+ * Authentication method for Discover and Collect REST calls
+ */
+export declare const SplunkAuthenticationTokenAuthentication: {
+    /**
+     * None
+     */
+    readonly None: "none";
+    /**
+     * Basic
+     */
+    readonly Basic: "basic";
+    /**
+     * Basic (credentials secret)
+     */
+    readonly BasicSecret: "basicSecret";
+    /**
+     * Bearer Token
+     */
+    readonly Token: "token";
+    /**
+     * Bearer Token (text secret)
+     */
+    readonly TokenSecret: "tokenSecret";
+};
+/**
+ * Authentication method for Discover and Collect REST calls
+ */
+export type SplunkAuthenticationTokenAuthentication = OpenEnum<typeof SplunkAuthenticationTokenAuthentication>;
+/**
+ * Format of the returned output
+ */
+export declare const SplunkAuthenticationTokenOutputMode: {
+    readonly Csv: "csv";
+    readonly Json: "json";
+};
+/**
+ * Format of the returned output
+ */
+export type SplunkAuthenticationTokenOutputMode = OpenEnum<typeof SplunkAuthenticationTokenOutputMode>;
+export type SplunkAuthenticationTokenCollectRequestParam = {
+    name: string;
+    /**
+     * JavaScript expression to compute the parameter's value, normally enclosed in backticks (`${earliest}`). If a constant, use single quotes ('earliest'). Values without delimiters (earliest) are evaluated as strings.
+     */
+    value: string;
+};
+export type SplunkAuthenticationTokenCollectRequestHeader = {
+    name: string;
+    /**
+     * JavaScript expression to compute the header's value, normally enclosed in backticks (`${earliest}`). If a constant, use single quotes ('earliest'). Values without delimiters (earliest) are evaluated as strings.
+     */
+    value: string;
+};
+/**
+ * Algorithm to use when performing HTTP retries
+ */
+export declare const SplunkAuthenticationTokenRetryType: {
+    /**
+     * Disabled
+     */
+    readonly None: "none";
+    /**
+     * Backoff
+     */
+    readonly Backoff: "backoff";
+    /**
+     * Static
+     */
+    readonly Static: "static";
+};
+/**
+ * Algorithm to use when performing HTTP retries
+ */
+export type SplunkAuthenticationTokenRetryType = OpenEnum<typeof SplunkAuthenticationTokenRetryType>;
+export type SplunkAuthenticationTokenRetryRules = {
+    /**
+     * Algorithm to use when performing HTTP retries
+     */
+    type?: SplunkAuthenticationTokenRetryType | undefined;
+    interval?: any | undefined;
+    limit?: any | undefined;
+    multiplier?: any | undefined;
+    codes?: any | undefined;
+    enableHeader?: any | undefined;
+    retryConnectTimeout?: any | undefined;
+    retryConnectReset?: any | undefined;
+};
+export type SplunkAuthenticationToken = {
+    /**
+     * Authentication method for Discover and Collect REST calls
+     */
+    authentication?: SplunkAuthenticationTokenAuthentication | undefined;
+    token: string;
+    /**
+     * Search head base URL. Can be an expression. Default is https://localhost:8089.
+     */
+    searchHead?: string | undefined;
+    /**
+     * Examples: 'index=myAppLogs level=error channel=myApp' OR '| mstats avg(myStat) as myStat WHERE index=myStatsIndex.'
+     */
+    search: string;
+    /**
+     * The earliest time boundary for the search. Can be an exact or relative time. Examples: '2022-01-14T12:00:00Z' or '-16m@m'
+     */
+    earliest?: string | undefined;
+    /**
+     * The latest time boundary for the search. Can be an exact or relative time. Examples: '2022-01-14T12:00:00Z' or '-1m@m'
+     */
+    latest?: string | undefined;
+    /**
+     * REST API used to create a search
+     */
+    endpoint?: string | undefined;
+    /**
+     * Format of the returned output
+     */
+    outputMode?: SplunkAuthenticationTokenOutputMode | undefined;
+    /**
+     * Optional collect request parameters
+     */
+    collectRequestParams?: Array<SplunkAuthenticationTokenCollectRequestParam> | undefined;
+    /**
+     * Optional collect request headers
+     */
+    collectRequestHeaders?: Array<SplunkAuthenticationTokenCollectRequestHeader> | undefined;
+    /**
+     * HTTP request inactivity timeout. Use 0 for no timeout.
+     */
+    timeout?: number | undefined;
+    /**
+     * Use round-robin DNS lookup. Suitable when DNS server returns multiple addresses in sort order.
+     */
+    useRoundRobinDns?: boolean | undefined;
+    /**
+     * Disable collector event time filtering when a date range is specified
+     */
+    disableTimeFilter?: boolean | undefined;
+    /**
+     * Reject certificates that cannot be verified against a valid CA (such as self-signed certificates)
+     */
+    rejectUnauthorized?: boolean | undefined;
+    /**
+     * Escape characters (\") in search queries will be passed directly to Splunk
+     */
+    handleEscapedChars?: boolean | undefined;
+    retryRules?: SplunkAuthenticationTokenRetryRules | undefined;
+};
+/**
+ * Authentication method for Discover and Collect REST calls
+ */
+export declare const SplunkAuthenticationBasicSecretAuthentication: {
+    /**
+     * None
+     */
+    readonly None: "none";
+    /**
+     * Basic
+     */
+    readonly Basic: "basic";
+    /**
+     * Basic (credentials secret)
+     */
+    readonly BasicSecret: "basicSecret";
+    /**
+     * Bearer Token
+     */
+    readonly Token: "token";
+    /**
+     * Bearer Token (text secret)
+     */
+    readonly TokenSecret: "tokenSecret";
+};
+/**
+ * Authentication method for Discover and Collect REST calls
+ */
+export type SplunkAuthenticationBasicSecretAuthentication = OpenEnum<typeof SplunkAuthenticationBasicSecretAuthentication>;
+/**
+ * Format of the returned output
+ */
+export declare const SplunkAuthenticationBasicSecretOutputMode: {
+    readonly Csv: "csv";
+    readonly Json: "json";
+};
+/**
+ * Format of the returned output
+ */
+export type SplunkAuthenticationBasicSecretOutputMode = OpenEnum<typeof SplunkAuthenticationBasicSecretOutputMode>;
+export type SplunkAuthenticationBasicSecretCollectRequestParam = {
+    name: string;
+    /**
+     * JavaScript expression to compute the parameter's value, normally enclosed in backticks (`${earliest}`). If a constant, use single quotes ('earliest'). Values without delimiters (earliest) are evaluated as strings.
+     */
+    value: string;
+};
+export type SplunkAuthenticationBasicSecretCollectRequestHeader = {
+    name: string;
+    /**
+     * JavaScript expression to compute the header's value, normally enclosed in backticks (`${earliest}`). If a constant, use single quotes ('earliest'). Values without delimiters (earliest) are evaluated as strings.
+     */
+    value: string;
+};
+/**
+ * Algorithm to use when performing HTTP retries
+ */
+export declare const SplunkAuthenticationBasicSecretRetryType: {
+    /**
+     * Disabled
+     */
+    readonly None: "none";
+    /**
+     * Backoff
+     */
+    readonly Backoff: "backoff";
+    /**
+     * Static
+     */
+    readonly Static: "static";
+};
+/**
+ * Algorithm to use when performing HTTP retries
+ */
+export type SplunkAuthenticationBasicSecretRetryType = OpenEnum<typeof SplunkAuthenticationBasicSecretRetryType>;
+export type SplunkAuthenticationBasicSecretRetryRules = {
+    /**
+     * Algorithm to use when performing HTTP retries
+     */
+    type?: SplunkAuthenticationBasicSecretRetryType | undefined;
+    interval?: any | undefined;
+    limit?: any | undefined;
+    multiplier?: any | undefined;
+    codes?: any | undefined;
+    enableHeader?: any | undefined;
+    retryConnectTimeout?: any | undefined;
+    retryConnectReset?: any | undefined;
+};
+export type SplunkAuthenticationBasicSecret = {
+    /**
+     * Authentication method for Discover and Collect REST calls
+     */
+    authentication?: SplunkAuthenticationBasicSecretAuthentication | undefined;
+    /**
+     * Select or create a stored secret that references your credentials
+     */
+    credentialsSecret: string;
+    /**
+     * Search head base URL. Can be an expression. Default is https://localhost:8089.
+     */
+    searchHead?: string | undefined;
+    /**
+     * Examples: 'index=myAppLogs level=error channel=myApp' OR '| mstats avg(myStat) as myStat WHERE index=myStatsIndex.'
+     */
+    search: string;
+    /**
+     * The earliest time boundary for the search. Can be an exact or relative time. Examples: '2022-01-14T12:00:00Z' or '-16m@m'
+     */
+    earliest?: string | undefined;
+    /**
+     * The latest time boundary for the search. Can be an exact or relative time. Examples: '2022-01-14T12:00:00Z' or '-1m@m'
+     */
+    latest?: string | undefined;
+    /**
+     * REST API used to create a search
+     */
+    endpoint?: string | undefined;
+    /**
+     * Format of the returned output
+     */
+    outputMode?: SplunkAuthenticationBasicSecretOutputMode | undefined;
+    /**
+     * Optional collect request parameters
+     */
+    collectRequestParams?: Array<SplunkAuthenticationBasicSecretCollectRequestParam> | undefined;
+    /**
+     * Optional collect request headers
+     */
+    collectRequestHeaders?: Array<SplunkAuthenticationBasicSecretCollectRequestHeader> | undefined;
+    /**
+     * HTTP request inactivity timeout. Use 0 for no timeout.
+     */
+    timeout?: number | undefined;
+    /**
+     * Use round-robin DNS lookup. Suitable when DNS server returns multiple addresses in sort order.
+     */
+    useRoundRobinDns?: boolean | undefined;
+    /**
+     * Disable collector event time filtering when a date range is specified
+     */
+    disableTimeFilter?: boolean | undefined;
+    /**
+     * Reject certificates that cannot be verified against a valid CA (such as self-signed certificates)
+     */
+    rejectUnauthorized?: boolean | undefined;
+    /**
+     * Escape characters (\") in search queries will be passed directly to Splunk
+     */
+    handleEscapedChars?: boolean | undefined;
+    retryRules?: SplunkAuthenticationBasicSecretRetryRules | undefined;
+};
+/**
+ * Authentication method for Discover and Collect REST calls
+ */
+export declare const SplunkAuthenticationBasicAuthentication: {
+    /**
+     * None
+     */
+    readonly None: "none";
+    /**
+     * Basic
+     */
+    readonly Basic: "basic";
+    /**
+     * Basic (credentials secret)
+     */
+    readonly BasicSecret: "basicSecret";
+    /**
+     * Bearer Token
+     */
+    readonly Token: "token";
+    /**
+     * Bearer Token (text secret)
+     */
+    readonly TokenSecret: "tokenSecret";
+};
+/**
+ * Authentication method for Discover and Collect REST calls
+ */
+export type SplunkAuthenticationBasicAuthentication = OpenEnum<typeof SplunkAuthenticationBasicAuthentication>;
+/**
+ * Format of the returned output
+ */
+export declare const SplunkAuthenticationBasicOutputMode: {
+    readonly Csv: "csv";
+    readonly Json: "json";
+};
+/**
+ * Format of the returned output
+ */
+export type SplunkAuthenticationBasicOutputMode = OpenEnum<typeof SplunkAuthenticationBasicOutputMode>;
+export type SplunkAuthenticationBasicCollectRequestParam = {
+    name: string;
+    /**
+     * JavaScript expression to compute the parameter's value, normally enclosed in backticks (`${earliest}`). If a constant, use single quotes ('earliest'). Values without delimiters (earliest) are evaluated as strings.
+     */
+    value: string;
+};
+export type SplunkAuthenticationBasicCollectRequestHeader = {
+    name: string;
+    /**
+     * JavaScript expression to compute the header's value, normally enclosed in backticks (`${earliest}`). If a constant, use single quotes ('earliest'). Values without delimiters (earliest) are evaluated as strings.
+     */
+    value: string;
+};
+/**
+ * Algorithm to use when performing HTTP retries
+ */
+export declare const SplunkAuthenticationBasicRetryType: {
+    /**
+     * Disabled
+     */
+    readonly None: "none";
+    /**
+     * Backoff
+     */
+    readonly Backoff: "backoff";
+    /**
+     * Static
+     */
+    readonly Static: "static";
+};
+/**
+ * Algorithm to use when performing HTTP retries
+ */
+export type SplunkAuthenticationBasicRetryType = OpenEnum<typeof SplunkAuthenticationBasicRetryType>;
+export type SplunkAuthenticationBasicRetryRules = {
+    /**
+     * Algorithm to use when performing HTTP retries
+     */
+    type?: SplunkAuthenticationBasicRetryType | undefined;
+    interval?: any | undefined;
+    limit?: any | undefined;
+    multiplier?: any | undefined;
+    codes?: any | undefined;
+    enableHeader?: any | undefined;
+    retryConnectTimeout?: any | undefined;
+    retryConnectReset?: any | undefined;
+};
+export type SplunkAuthenticationBasic = {
+    /**
+     * Authentication method for Discover and Collect REST calls
+     */
+    authentication?: SplunkAuthenticationBasicAuthentication | undefined;
+    /**
+     * Basic authentication username
+     */
+    username: string;
+    /**
+     * Basic authentication password
+     */
+    password: string;
+    /**
+     * Search head base URL. Can be an expression. Default is https://localhost:8089.
+     */
+    searchHead?: string | undefined;
+    /**
+     * Examples: 'index=myAppLogs level=error channel=myApp' OR '| mstats avg(myStat) as myStat WHERE index=myStatsIndex.'
+     */
+    search: string;
+    /**
+     * The earliest time boundary for the search. Can be an exact or relative time. Examples: '2022-01-14T12:00:00Z' or '-16m@m'
+     */
+    earliest?: string | undefined;
+    /**
+     * The latest time boundary for the search. Can be an exact or relative time. Examples: '2022-01-14T12:00:00Z' or '-1m@m'
+     */
+    latest?: string | undefined;
+    /**
+     * REST API used to create a search
+     */
+    endpoint?: string | undefined;
+    /**
+     * Format of the returned output
+     */
+    outputMode?: SplunkAuthenticationBasicOutputMode | undefined;
+    /**
+     * Optional collect request parameters
+     */
+    collectRequestParams?: Array<SplunkAuthenticationBasicCollectRequestParam> | undefined;
+    /**
+     * Optional collect request headers
+     */
+    collectRequestHeaders?: Array<SplunkAuthenticationBasicCollectRequestHeader> | undefined;
+    /**
+     * HTTP request inactivity timeout. Use 0 for no timeout.
+     */
+    timeout?: number | undefined;
+    /**
+     * Use round-robin DNS lookup. Suitable when DNS server returns multiple addresses in sort order.
+     */
+    useRoundRobinDns?: boolean | undefined;
+    /**
+     * Disable collector event time filtering when a date range is specified
+     */
+    disableTimeFilter?: boolean | undefined;
+    /**
+     * Reject certificates that cannot be verified against a valid CA (such as self-signed certificates)
+     */
+    rejectUnauthorized?: boolean | undefined;
+    /**
+     * Escape characters (\") in search queries will be passed directly to Splunk
+     */
+    handleEscapedChars?: boolean | undefined;
+    retryRules?: SplunkAuthenticationBasicRetryRules | undefined;
+};
+/**
+ * Authentication method for Discover and Collect REST calls
+ */
+export declare const SplunkAuthenticationNoneAuthentication: {
+    /**
+     * None
+     */
+    readonly None: "none";
+    /**
+     * Basic
+     */
+    readonly Basic: "basic";
+    /**
+     * Basic (credentials secret)
+     */
+    readonly BasicSecret: "basicSecret";
+    /**
+     * Bearer Token
+     */
+    readonly Token: "token";
+    /**
+     * Bearer Token (text secret)
+     */
+    readonly TokenSecret: "tokenSecret";
+};
+/**
+ * Authentication method for Discover and Collect REST calls
+ */
+export type SplunkAuthenticationNoneAuthentication = OpenEnum<typeof SplunkAuthenticationNoneAuthentication>;
+/**
+ * Format of the returned output
+ */
+export declare const SplunkAuthenticationNoneOutputMode: {
+    readonly Csv: "csv";
+    readonly Json: "json";
+};
+/**
+ * Format of the returned output
+ */
+export type SplunkAuthenticationNoneOutputMode = OpenEnum<typeof SplunkAuthenticationNoneOutputMode>;
+export type SplunkAuthenticationNoneCollectRequestParam = {
+    name: string;
+    /**
+     * JavaScript expression to compute the parameter's value, normally enclosed in backticks (`${earliest}`). If a constant, use single quotes ('earliest'). Values without delimiters (earliest) are evaluated as strings.
+     */
+    value: string;
+};
+export type SplunkAuthenticationNoneCollectRequestHeader = {
+    name: string;
+    /**
+     * JavaScript expression to compute the header's value, normally enclosed in backticks (`${earliest}`). If a constant, use single quotes ('earliest'). Values without delimiters (earliest) are evaluated as strings.
+     */
+    value: string;
+};
+/**
+ * Algorithm to use when performing HTTP retries
+ */
+export declare const SplunkAuthenticationNoneRetryType: {
+    /**
+     * Disabled
+     */
+    readonly None: "none";
+    /**
+     * Backoff
+     */
+    readonly Backoff: "backoff";
+    /**
+     * Static
+     */
+    readonly Static: "static";
+};
+/**
+ * Algorithm to use when performing HTTP retries
+ */
+export type SplunkAuthenticationNoneRetryType = OpenEnum<typeof SplunkAuthenticationNoneRetryType>;
+export type SplunkAuthenticationNoneRetryRules = {
+    /**
+     * Algorithm to use when performing HTTP retries
+     */
+    type?: SplunkAuthenticationNoneRetryType | undefined;
+    interval?: any | undefined;
+    limit?: any | undefined;
+    multiplier?: any | undefined;
+    codes?: any | undefined;
+    enableHeader?: any | undefined;
+    retryConnectTimeout?: any | undefined;
+    retryConnectReset?: any | undefined;
+};
+export type SplunkAuthenticationNone = {
+    /**
+     * Authentication method for Discover and Collect REST calls
+     */
+    authentication?: SplunkAuthenticationNoneAuthentication | undefined;
+    /**
+     * Search head base URL. Can be an expression. Default is https://localhost:8089.
+     */
+    searchHead?: string | undefined;
+    /**
+     * Examples: 'index=myAppLogs level=error channel=myApp' OR '| mstats avg(myStat) as myStat WHERE index=myStatsIndex.'
+     */
+    search: string;
+    /**
+     * The earliest time boundary for the search. Can be an exact or relative time. Examples: '2022-01-14T12:00:00Z' or '-16m@m'
+     */
+    earliest?: string | undefined;
+    /**
+     * The latest time boundary for the search. Can be an exact or relative time. Examples: '2022-01-14T12:00:00Z' or '-1m@m'
+     */
+    latest?: string | undefined;
+    /**
+     * REST API used to create a search
+     */
+    endpoint?: string | undefined;
+    /**
+     * Format of the returned output
+     */
+    outputMode?: SplunkAuthenticationNoneOutputMode | undefined;
+    /**
+     * Optional collect request parameters
+     */
+    collectRequestParams?: Array<SplunkAuthenticationNoneCollectRequestParam> | undefined;
+    /**
+     * Optional collect request headers
+     */
+    collectRequestHeaders?: Array<SplunkAuthenticationNoneCollectRequestHeader> | undefined;
+    /**
+     * HTTP request inactivity timeout. Use 0 for no timeout.
+     */
+    timeout?: number | undefined;
+    /**
+     * Use round-robin DNS lookup. Suitable when DNS server returns multiple addresses in sort order.
+     */
+    useRoundRobinDns?: boolean | undefined;
+    /**
+     * Disable collector event time filtering when a date range is specified
+     */
+    disableTimeFilter?: boolean | undefined;
+    /**
+     * Reject certificates that cannot be verified against a valid CA (such as self-signed certificates)
+     */
+    rejectUnauthorized?: boolean | undefined;
+    /**
+     * Escape characters (\") in search queries will be passed directly to Splunk
+     */
+    handleEscapedChars?: boolean | undefined;
+    retryRules?: SplunkAuthenticationNoneRetryRules | undefined;
+};
+export type SplunkCollectorConf = SplunkAuthenticationBasic | SplunkAuthenticationLogin | SplunkAuthenticationBasicSecret | SplunkAuthenticationToken | SplunkAuthenticationTokenSecret | SplunkAuthenticationLoginSecret | SplunkAuthenticationNone;
+/** @internal */
+export declare const SplunkAuthenticationLoginSecretAuthentication$inboundSchema: z.ZodType<SplunkAuthenticationLoginSecretAuthentication, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const SplunkAuthenticationLoginSecretAuthentication$outboundSchema: z.ZodType<string, z.ZodTypeDef, SplunkAuthenticationLoginSecretAuthentication>;
+/** @internal */
+export declare const SplunkAuthenticationLoginSecretOutputMode$inboundSchema: z.ZodType<SplunkAuthenticationLoginSecretOutputMode, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const SplunkAuthenticationLoginSecretOutputMode$outboundSchema: z.ZodType<string, z.ZodTypeDef, SplunkAuthenticationLoginSecretOutputMode>;
+/** @internal */
+export declare const SplunkAuthenticationLoginSecretCollectRequestParam$inboundSchema: z.ZodType<SplunkAuthenticationLoginSecretCollectRequestParam, z.ZodTypeDef, unknown>;
+/** @internal */
+export type SplunkAuthenticationLoginSecretCollectRequestParam$Outbound = {
+    name: string;
+    value: string;
+};
+/** @internal */
+export declare const SplunkAuthenticationLoginSecretCollectRequestParam$outboundSchema: z.ZodType<SplunkAuthenticationLoginSecretCollectRequestParam$Outbound, z.ZodTypeDef, SplunkAuthenticationLoginSecretCollectRequestParam>;
+export declare function splunkAuthenticationLoginSecretCollectRequestParamToJSON(splunkAuthenticationLoginSecretCollectRequestParam: SplunkAuthenticationLoginSecretCollectRequestParam): string;
+export declare function splunkAuthenticationLoginSecretCollectRequestParamFromJSON(jsonString: string): SafeParseResult<SplunkAuthenticationLoginSecretCollectRequestParam, SDKValidationError>;
+/** @internal */
+export declare const SplunkAuthenticationLoginSecretCollectRequestHeader$inboundSchema: z.ZodType<SplunkAuthenticationLoginSecretCollectRequestHeader, z.ZodTypeDef, unknown>;
+/** @internal */
+export type SplunkAuthenticationLoginSecretCollectRequestHeader$Outbound = {
+    name: string;
+    value: string;
+};
+/** @internal */
+export declare const SplunkAuthenticationLoginSecretCollectRequestHeader$outboundSchema: z.ZodType<SplunkAuthenticationLoginSecretCollectRequestHeader$Outbound, z.ZodTypeDef, SplunkAuthenticationLoginSecretCollectRequestHeader>;
+export declare function splunkAuthenticationLoginSecretCollectRequestHeaderToJSON(splunkAuthenticationLoginSecretCollectRequestHeader: SplunkAuthenticationLoginSecretCollectRequestHeader): string;
+export declare function splunkAuthenticationLoginSecretCollectRequestHeaderFromJSON(jsonString: string): SafeParseResult<SplunkAuthenticationLoginSecretCollectRequestHeader, SDKValidationError>;
+/** @internal */
+export declare const SplunkAuthenticationLoginSecretRetryType$inboundSchema: z.ZodType<SplunkAuthenticationLoginSecretRetryType, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const SplunkAuthenticationLoginSecretRetryType$outboundSchema: z.ZodType<string, z.ZodTypeDef, SplunkAuthenticationLoginSecretRetryType>;
+/** @internal */
+export declare const SplunkAuthenticationLoginSecretRetryRules$inboundSchema: z.ZodType<SplunkAuthenticationLoginSecretRetryRules, z.ZodTypeDef, unknown>;
+/** @internal */
+export type SplunkAuthenticationLoginSecretRetryRules$Outbound = {
+    type: string;
+    interval?: any | undefined;
+    limit?: any | undefined;
+    multiplier?: any | undefined;
+    codes?: any | undefined;
+    enableHeader?: any | undefined;
+    retryConnectTimeout?: any | undefined;
+    retryConnectReset?: any | undefined;
+};
+/** @internal */
+export declare const SplunkAuthenticationLoginSecretRetryRules$outboundSchema: z.ZodType<SplunkAuthenticationLoginSecretRetryRules$Outbound, z.ZodTypeDef, SplunkAuthenticationLoginSecretRetryRules>;
+export declare function splunkAuthenticationLoginSecretRetryRulesToJSON(splunkAuthenticationLoginSecretRetryRules: SplunkAuthenticationLoginSecretRetryRules): string;
+export declare function splunkAuthenticationLoginSecretRetryRulesFromJSON(jsonString: string): SafeParseResult<SplunkAuthenticationLoginSecretRetryRules, SDKValidationError>;
+/** @internal */
+export declare const SplunkAuthenticationLoginSecret$inboundSchema: z.ZodType<SplunkAuthenticationLoginSecret, z.ZodTypeDef, unknown>;
+/** @internal */
+export type SplunkAuthenticationLoginSecret$Outbound = {
+    authentication: string;
+    loginUrl: string;
+    credentialsSecret: string;
+    loginBody: string;
+    tokenRespAttribute: string;
+    authHeaderExpr: string;
+    searchHead: string;
+    search: string;
+    earliest?: string | undefined;
+    latest?: string | undefined;
+    endpoint: string;
+    outputMode: string;
+    collectRequestParams?: Array<SplunkAuthenticationLoginSecretCollectRequestParam$Outbound> | undefined;
+    collectRequestHeaders?: Array<SplunkAuthenticationLoginSecretCollectRequestHeader$Outbound> | undefined;
+    timeout: number;
+    useRoundRobinDns: boolean;
+    disableTimeFilter: boolean;
+    rejectUnauthorized: boolean;
+    handleEscapedChars: boolean;
+    retryRules?: SplunkAuthenticationLoginSecretRetryRules$Outbound | undefined;
+};
+/** @internal */
+export declare const SplunkAuthenticationLoginSecret$outboundSchema: z.ZodType<SplunkAuthenticationLoginSecret$Outbound, z.ZodTypeDef, SplunkAuthenticationLoginSecret>;
+export declare function splunkAuthenticationLoginSecretToJSON(splunkAuthenticationLoginSecret: SplunkAuthenticationLoginSecret): string;
+export declare function splunkAuthenticationLoginSecretFromJSON(jsonString: string): SafeParseResult<SplunkAuthenticationLoginSecret, SDKValidationError>;
+/** @internal */
+export declare const SplunkAuthenticationLoginAuthentication$inboundSchema: z.ZodType<SplunkAuthenticationLoginAuthentication, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const SplunkAuthenticationLoginAuthentication$outboundSchema: z.ZodType<string, z.ZodTypeDef, SplunkAuthenticationLoginAuthentication>;
+/** @internal */
+export declare const SplunkAuthenticationLoginOutputMode$inboundSchema: z.ZodType<SplunkAuthenticationLoginOutputMode, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const SplunkAuthenticationLoginOutputMode$outboundSchema: z.ZodType<string, z.ZodTypeDef, SplunkAuthenticationLoginOutputMode>;
+/** @internal */
+export declare const SplunkAuthenticationLoginCollectRequestParam$inboundSchema: z.ZodType<SplunkAuthenticationLoginCollectRequestParam, z.ZodTypeDef, unknown>;
+/** @internal */
+export type SplunkAuthenticationLoginCollectRequestParam$Outbound = {
+    name: string;
+    value: string;
+};
+/** @internal */
+export declare const SplunkAuthenticationLoginCollectRequestParam$outboundSchema: z.ZodType<SplunkAuthenticationLoginCollectRequestParam$Outbound, z.ZodTypeDef, SplunkAuthenticationLoginCollectRequestParam>;
+export declare function splunkAuthenticationLoginCollectRequestParamToJSON(splunkAuthenticationLoginCollectRequestParam: SplunkAuthenticationLoginCollectRequestParam): string;
+export declare function splunkAuthenticationLoginCollectRequestParamFromJSON(jsonString: string): SafeParseResult<SplunkAuthenticationLoginCollectRequestParam, SDKValidationError>;
+/** @internal */
+export declare const SplunkAuthenticationLoginCollectRequestHeader$inboundSchema: z.ZodType<SplunkAuthenticationLoginCollectRequestHeader, z.ZodTypeDef, unknown>;
+/** @internal */
+export type SplunkAuthenticationLoginCollectRequestHeader$Outbound = {
+    name: string;
+    value: string;
+};
+/** @internal */
+export declare const SplunkAuthenticationLoginCollectRequestHeader$outboundSchema: z.ZodType<SplunkAuthenticationLoginCollectRequestHeader$Outbound, z.ZodTypeDef, SplunkAuthenticationLoginCollectRequestHeader>;
+export declare function splunkAuthenticationLoginCollectRequestHeaderToJSON(splunkAuthenticationLoginCollectRequestHeader: SplunkAuthenticationLoginCollectRequestHeader): string;
+export declare function splunkAuthenticationLoginCollectRequestHeaderFromJSON(jsonString: string): SafeParseResult<SplunkAuthenticationLoginCollectRequestHeader, SDKValidationError>;
+/** @internal */
+export declare const SplunkAuthenticationLoginRetryType$inboundSchema: z.ZodType<SplunkAuthenticationLoginRetryType, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const SplunkAuthenticationLoginRetryType$outboundSchema: z.ZodType<string, z.ZodTypeDef, SplunkAuthenticationLoginRetryType>;
+/** @internal */
+export declare const SplunkAuthenticationLoginRetryRules$inboundSchema: z.ZodType<SplunkAuthenticationLoginRetryRules, z.ZodTypeDef, unknown>;
+/** @internal */
+export type SplunkAuthenticationLoginRetryRules$Outbound = {
+    type: string;
+    interval?: any | undefined;
+    limit?: any | undefined;
+    multiplier?: any | undefined;
+    codes?: any | undefined;
+    enableHeader?: any | undefined;
+    retryConnectTimeout?: any | undefined;
+    retryConnectReset?: any | undefined;
+};
+/** @internal */
+export declare const SplunkAuthenticationLoginRetryRules$outboundSchema: z.ZodType<SplunkAuthenticationLoginRetryRules$Outbound, z.ZodTypeDef, SplunkAuthenticationLoginRetryRules>;
+export declare function splunkAuthenticationLoginRetryRulesToJSON(splunkAuthenticationLoginRetryRules: SplunkAuthenticationLoginRetryRules): string;
+export declare function splunkAuthenticationLoginRetryRulesFromJSON(jsonString: string): SafeParseResult<SplunkAuthenticationLoginRetryRules, SDKValidationError>;
+/** @internal */
+export declare const SplunkAuthenticationLogin$inboundSchema: z.ZodType<SplunkAuthenticationLogin, z.ZodTypeDef, unknown>;
+/** @internal */
+export type SplunkAuthenticationLogin$Outbound = {
+    authentication: string;
+    loginUrl: string;
+    username: string;
+    password: string;
+    loginBody: string;
+    tokenRespAttribute: string;
+    authHeaderExpr: string;
+    searchHead: string;
+    search: string;
+    earliest?: string | undefined;
+    latest?: string | undefined;
+    endpoint: string;
+    outputMode: string;
+    collectRequestParams?: Array<SplunkAuthenticationLoginCollectRequestParam$Outbound> | undefined;
+    collectRequestHeaders?: Array<SplunkAuthenticationLoginCollectRequestHeader$Outbound> | undefined;
+    timeout: number;
+    useRoundRobinDns: boolean;
+    disableTimeFilter: boolean;
+    rejectUnauthorized: boolean;
+    handleEscapedChars: boolean;
+    retryRules?: SplunkAuthenticationLoginRetryRules$Outbound | undefined;
+};
+/** @internal */
+export declare const SplunkAuthenticationLogin$outboundSchema: z.ZodType<SplunkAuthenticationLogin$Outbound, z.ZodTypeDef, SplunkAuthenticationLogin>;
+export declare function splunkAuthenticationLoginToJSON(splunkAuthenticationLogin: SplunkAuthenticationLogin): string;
+export declare function splunkAuthenticationLoginFromJSON(jsonString: string): SafeParseResult<SplunkAuthenticationLogin, SDKValidationError>;
+/** @internal */
+export declare const SplunkAuthenticationTokenSecretAuthentication$inboundSchema: z.ZodType<SplunkAuthenticationTokenSecretAuthentication, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const SplunkAuthenticationTokenSecretAuthentication$outboundSchema: z.ZodType<string, z.ZodTypeDef, SplunkAuthenticationTokenSecretAuthentication>;
+/** @internal */
+export declare const SplunkAuthenticationTokenSecretOutputMode$inboundSchema: z.ZodType<SplunkAuthenticationTokenSecretOutputMode, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const SplunkAuthenticationTokenSecretOutputMode$outboundSchema: z.ZodType<string, z.ZodTypeDef, SplunkAuthenticationTokenSecretOutputMode>;
+/** @internal */
+export declare const SplunkAuthenticationTokenSecretCollectRequestParam$inboundSchema: z.ZodType<SplunkAuthenticationTokenSecretCollectRequestParam, z.ZodTypeDef, unknown>;
+/** @internal */
+export type SplunkAuthenticationTokenSecretCollectRequestParam$Outbound = {
+    name: string;
+    value: string;
+};
+/** @internal */
+export declare const SplunkAuthenticationTokenSecretCollectRequestParam$outboundSchema: z.ZodType<SplunkAuthenticationTokenSecretCollectRequestParam$Outbound, z.ZodTypeDef, SplunkAuthenticationTokenSecretCollectRequestParam>;
+export declare function splunkAuthenticationTokenSecretCollectRequestParamToJSON(splunkAuthenticationTokenSecretCollectRequestParam: SplunkAuthenticationTokenSecretCollectRequestParam): string;
+export declare function splunkAuthenticationTokenSecretCollectRequestParamFromJSON(jsonString: string): SafeParseResult<SplunkAuthenticationTokenSecretCollectRequestParam, SDKValidationError>;
+/** @internal */
+export declare const SplunkAuthenticationTokenSecretCollectRequestHeader$inboundSchema: z.ZodType<SplunkAuthenticationTokenSecretCollectRequestHeader, z.ZodTypeDef, unknown>;
+/** @internal */
+export type SplunkAuthenticationTokenSecretCollectRequestHeader$Outbound = {
+    name: string;
+    value: string;
+};
+/** @internal */
+export declare const SplunkAuthenticationTokenSecretCollectRequestHeader$outboundSchema: z.ZodType<SplunkAuthenticationTokenSecretCollectRequestHeader$Outbound, z.ZodTypeDef, SplunkAuthenticationTokenSecretCollectRequestHeader>;
+export declare function splunkAuthenticationTokenSecretCollectRequestHeaderToJSON(splunkAuthenticationTokenSecretCollectRequestHeader: SplunkAuthenticationTokenSecretCollectRequestHeader): string;
+export declare function splunkAuthenticationTokenSecretCollectRequestHeaderFromJSON(jsonString: string): SafeParseResult<SplunkAuthenticationTokenSecretCollectRequestHeader, SDKValidationError>;
+/** @internal */
+export declare const SplunkAuthenticationTokenSecretRetryType$inboundSchema: z.ZodType<SplunkAuthenticationTokenSecretRetryType, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const SplunkAuthenticationTokenSecretRetryType$outboundSchema: z.ZodType<string, z.ZodTypeDef, SplunkAuthenticationTokenSecretRetryType>;
+/** @internal */
+export declare const SplunkAuthenticationTokenSecretRetryRules$inboundSchema: z.ZodType<SplunkAuthenticationTokenSecretRetryRules, z.ZodTypeDef, unknown>;
+/** @internal */
+export type SplunkAuthenticationTokenSecretRetryRules$Outbound = {
+    type: string;
+    interval?: any | undefined;
+    limit?: any | undefined;
+    multiplier?: any | undefined;
+    codes?: any | undefined;
+    enableHeader?: any | undefined;
+    retryConnectTimeout?: any | undefined;
+    retryConnectReset?: any | undefined;
+};
+/** @internal */
+export declare const SplunkAuthenticationTokenSecretRetryRules$outboundSchema: z.ZodType<SplunkAuthenticationTokenSecretRetryRules$Outbound, z.ZodTypeDef, SplunkAuthenticationTokenSecretRetryRules>;
+export declare function splunkAuthenticationTokenSecretRetryRulesToJSON(splunkAuthenticationTokenSecretRetryRules: SplunkAuthenticationTokenSecretRetryRules): string;
+export declare function splunkAuthenticationTokenSecretRetryRulesFromJSON(jsonString: string): SafeParseResult<SplunkAuthenticationTokenSecretRetryRules, SDKValidationError>;
+/** @internal */
+export declare const SplunkAuthenticationTokenSecret$inboundSchema: z.ZodType<SplunkAuthenticationTokenSecret, z.ZodTypeDef, unknown>;
+/** @internal */
+export type SplunkAuthenticationTokenSecret$Outbound = {
+    authentication: string;
+    tokenSecret: string;
+    searchHead: string;
+    search: string;
+    earliest?: string | undefined;
+    latest?: string | undefined;
+    endpoint: string;
+    outputMode: string;
+    collectRequestParams?: Array<SplunkAuthenticationTokenSecretCollectRequestParam$Outbound> | undefined;
+    collectRequestHeaders?: Array<SplunkAuthenticationTokenSecretCollectRequestHeader$Outbound> | undefined;
+    timeout: number;
+    useRoundRobinDns: boolean;
+    disableTimeFilter: boolean;
+    rejectUnauthorized: boolean;
+    handleEscapedChars: boolean;
+    retryRules?: SplunkAuthenticationTokenSecretRetryRules$Outbound | undefined;
+};
+/** @internal */
+export declare const SplunkAuthenticationTokenSecret$outboundSchema: z.ZodType<SplunkAuthenticationTokenSecret$Outbound, z.ZodTypeDef, SplunkAuthenticationTokenSecret>;
+export declare function splunkAuthenticationTokenSecretToJSON(splunkAuthenticationTokenSecret: SplunkAuthenticationTokenSecret): string;
+export declare function splunkAuthenticationTokenSecretFromJSON(jsonString: string): SafeParseResult<SplunkAuthenticationTokenSecret, SDKValidationError>;
+/** @internal */
+export declare const SplunkAuthenticationTokenAuthentication$inboundSchema: z.ZodType<SplunkAuthenticationTokenAuthentication, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const SplunkAuthenticationTokenAuthentication$outboundSchema: z.ZodType<string, z.ZodTypeDef, SplunkAuthenticationTokenAuthentication>;
+/** @internal */
+export declare const SplunkAuthenticationTokenOutputMode$inboundSchema: z.ZodType<SplunkAuthenticationTokenOutputMode, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const SplunkAuthenticationTokenOutputMode$outboundSchema: z.ZodType<string, z.ZodTypeDef, SplunkAuthenticationTokenOutputMode>;
+/** @internal */
+export declare const SplunkAuthenticationTokenCollectRequestParam$inboundSchema: z.ZodType<SplunkAuthenticationTokenCollectRequestParam, z.ZodTypeDef, unknown>;
+/** @internal */
+export type SplunkAuthenticationTokenCollectRequestParam$Outbound = {
+    name: string;
+    value: string;
+};
+/** @internal */
+export declare const SplunkAuthenticationTokenCollectRequestParam$outboundSchema: z.ZodType<SplunkAuthenticationTokenCollectRequestParam$Outbound, z.ZodTypeDef, SplunkAuthenticationTokenCollectRequestParam>;
+export declare function splunkAuthenticationTokenCollectRequestParamToJSON(splunkAuthenticationTokenCollectRequestParam: SplunkAuthenticationTokenCollectRequestParam): string;
+export declare function splunkAuthenticationTokenCollectRequestParamFromJSON(jsonString: string): SafeParseResult<SplunkAuthenticationTokenCollectRequestParam, SDKValidationError>;
+/** @internal */
+export declare const SplunkAuthenticationTokenCollectRequestHeader$inboundSchema: z.ZodType<SplunkAuthenticationTokenCollectRequestHeader, z.ZodTypeDef, unknown>;
+/** @internal */
+export type SplunkAuthenticationTokenCollectRequestHeader$Outbound = {
+    name: string;
+    value: string;
+};
+/** @internal */
+export declare const SplunkAuthenticationTokenCollectRequestHeader$outboundSchema: z.ZodType<SplunkAuthenticationTokenCollectRequestHeader$Outbound, z.ZodTypeDef, SplunkAuthenticationTokenCollectRequestHeader>;
+export declare function splunkAuthenticationTokenCollectRequestHeaderToJSON(splunkAuthenticationTokenCollectRequestHeader: SplunkAuthenticationTokenCollectRequestHeader): string;
+export declare function splunkAuthenticationTokenCollectRequestHeaderFromJSON(jsonString: string): SafeParseResult<SplunkAuthenticationTokenCollectRequestHeader, SDKValidationError>;
+/** @internal */
+export declare const SplunkAuthenticationTokenRetryType$inboundSchema: z.ZodType<SplunkAuthenticationTokenRetryType, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const SplunkAuthenticationTokenRetryType$outboundSchema: z.ZodType<string, z.ZodTypeDef, SplunkAuthenticationTokenRetryType>;
+/** @internal */
+export declare const SplunkAuthenticationTokenRetryRules$inboundSchema: z.ZodType<SplunkAuthenticationTokenRetryRules, z.ZodTypeDef, unknown>;
+/** @internal */
+export type SplunkAuthenticationTokenRetryRules$Outbound = {
+    type: string;
+    interval?: any | undefined;
+    limit?: any | undefined;
+    multiplier?: any | undefined;
+    codes?: any | undefined;
+    enableHeader?: any | undefined;
+    retryConnectTimeout?: any | undefined;
+    retryConnectReset?: any | undefined;
+};
+/** @internal */
+export declare const SplunkAuthenticationTokenRetryRules$outboundSchema: z.ZodType<SplunkAuthenticationTokenRetryRules$Outbound, z.ZodTypeDef, SplunkAuthenticationTokenRetryRules>;
+export declare function splunkAuthenticationTokenRetryRulesToJSON(splunkAuthenticationTokenRetryRules: SplunkAuthenticationTokenRetryRules): string;
+export declare function splunkAuthenticationTokenRetryRulesFromJSON(jsonString: string): SafeParseResult<SplunkAuthenticationTokenRetryRules, SDKValidationError>;
+/** @internal */
+export declare const SplunkAuthenticationToken$inboundSchema: z.ZodType<SplunkAuthenticationToken, z.ZodTypeDef, unknown>;
+/** @internal */
+export type SplunkAuthenticationToken$Outbound = {
+    authentication: string;
+    token: string;
+    searchHead: string;
+    search: string;
+    earliest?: string | undefined;
+    latest?: string | undefined;
+    endpoint: string;
+    outputMode: string;
+    collectRequestParams?: Array<SplunkAuthenticationTokenCollectRequestParam$Outbound> | undefined;
+    collectRequestHeaders?: Array<SplunkAuthenticationTokenCollectRequestHeader$Outbound> | undefined;
+    timeout: number;
+    useRoundRobinDns: boolean;
+    disableTimeFilter: boolean;
+    rejectUnauthorized: boolean;
+    handleEscapedChars: boolean;
+    retryRules?: SplunkAuthenticationTokenRetryRules$Outbound | undefined;
+};
+/** @internal */
+export declare const SplunkAuthenticationToken$outboundSchema: z.ZodType<SplunkAuthenticationToken$Outbound, z.ZodTypeDef, SplunkAuthenticationToken>;
+export declare function splunkAuthenticationTokenToJSON(splunkAuthenticationToken: SplunkAuthenticationToken): string;
+export declare function splunkAuthenticationTokenFromJSON(jsonString: string): SafeParseResult<SplunkAuthenticationToken, SDKValidationError>;
+/** @internal */
+export declare const SplunkAuthenticationBasicSecretAuthentication$inboundSchema: z.ZodType<SplunkAuthenticationBasicSecretAuthentication, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const SplunkAuthenticationBasicSecretAuthentication$outboundSchema: z.ZodType<string, z.ZodTypeDef, SplunkAuthenticationBasicSecretAuthentication>;
+/** @internal */
+export declare const SplunkAuthenticationBasicSecretOutputMode$inboundSchema: z.ZodType<SplunkAuthenticationBasicSecretOutputMode, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const SplunkAuthenticationBasicSecretOutputMode$outboundSchema: z.ZodType<string, z.ZodTypeDef, SplunkAuthenticationBasicSecretOutputMode>;
+/** @internal */
+export declare const SplunkAuthenticationBasicSecretCollectRequestParam$inboundSchema: z.ZodType<SplunkAuthenticationBasicSecretCollectRequestParam, z.ZodTypeDef, unknown>;
+/** @internal */
+export type SplunkAuthenticationBasicSecretCollectRequestParam$Outbound = {
+    name: string;
+    value: string;
+};
+/** @internal */
+export declare const SplunkAuthenticationBasicSecretCollectRequestParam$outboundSchema: z.ZodType<SplunkAuthenticationBasicSecretCollectRequestParam$Outbound, z.ZodTypeDef, SplunkAuthenticationBasicSecretCollectRequestParam>;
+export declare function splunkAuthenticationBasicSecretCollectRequestParamToJSON(splunkAuthenticationBasicSecretCollectRequestParam: SplunkAuthenticationBasicSecretCollectRequestParam): string;
+export declare function splunkAuthenticationBasicSecretCollectRequestParamFromJSON(jsonString: string): SafeParseResult<SplunkAuthenticationBasicSecretCollectRequestParam, SDKValidationError>;
+/** @internal */
+export declare const SplunkAuthenticationBasicSecretCollectRequestHeader$inboundSchema: z.ZodType<SplunkAuthenticationBasicSecretCollectRequestHeader, z.ZodTypeDef, unknown>;
+/** @internal */
+export type SplunkAuthenticationBasicSecretCollectRequestHeader$Outbound = {
+    name: string;
+    value: string;
+};
+/** @internal */
+export declare const SplunkAuthenticationBasicSecretCollectRequestHeader$outboundSchema: z.ZodType<SplunkAuthenticationBasicSecretCollectRequestHeader$Outbound, z.ZodTypeDef, SplunkAuthenticationBasicSecretCollectRequestHeader>;
+export declare function splunkAuthenticationBasicSecretCollectRequestHeaderToJSON(splunkAuthenticationBasicSecretCollectRequestHeader: SplunkAuthenticationBasicSecretCollectRequestHeader): string;
+export declare function splunkAuthenticationBasicSecretCollectRequestHeaderFromJSON(jsonString: string): SafeParseResult<SplunkAuthenticationBasicSecretCollectRequestHeader, SDKValidationError>;
+/** @internal */
+export declare const SplunkAuthenticationBasicSecretRetryType$inboundSchema: z.ZodType<SplunkAuthenticationBasicSecretRetryType, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const SplunkAuthenticationBasicSecretRetryType$outboundSchema: z.ZodType<string, z.ZodTypeDef, SplunkAuthenticationBasicSecretRetryType>;
+/** @internal */
+export declare const SplunkAuthenticationBasicSecretRetryRules$inboundSchema: z.ZodType<SplunkAuthenticationBasicSecretRetryRules, z.ZodTypeDef, unknown>;
+/** @internal */
+export type SplunkAuthenticationBasicSecretRetryRules$Outbound = {
+    type: string;
+    interval?: any | undefined;
+    limit?: any | undefined;
+    multiplier?: any | undefined;
+    codes?: any | undefined;
+    enableHeader?: any | undefined;
+    retryConnectTimeout?: any | undefined;
+    retryConnectReset?: any | undefined;
+};
+/** @internal */
+export declare const SplunkAuthenticationBasicSecretRetryRules$outboundSchema: z.ZodType<SplunkAuthenticationBasicSecretRetryRules$Outbound, z.ZodTypeDef, SplunkAuthenticationBasicSecretRetryRules>;
+export declare function splunkAuthenticationBasicSecretRetryRulesToJSON(splunkAuthenticationBasicSecretRetryRules: SplunkAuthenticationBasicSecretRetryRules): string;
+export declare function splunkAuthenticationBasicSecretRetryRulesFromJSON(jsonString: string): SafeParseResult<SplunkAuthenticationBasicSecretRetryRules, SDKValidationError>;
+/** @internal */
+export declare const SplunkAuthenticationBasicSecret$inboundSchema: z.ZodType<SplunkAuthenticationBasicSecret, z.ZodTypeDef, unknown>;
+/** @internal */
+export type SplunkAuthenticationBasicSecret$Outbound = {
+    authentication: string;
+    credentialsSecret: string;
+    searchHead: string;
+    search: string;
+    earliest?: string | undefined;
+    latest?: string | undefined;
+    endpoint: string;
+    outputMode: string;
+    collectRequestParams?: Array<SplunkAuthenticationBasicSecretCollectRequestParam$Outbound> | undefined;
+    collectRequestHeaders?: Array<SplunkAuthenticationBasicSecretCollectRequestHeader$Outbound> | undefined;
+    timeout: number;
+    useRoundRobinDns: boolean;
+    disableTimeFilter: boolean;
+    rejectUnauthorized: boolean;
+    handleEscapedChars: boolean;
+    retryRules?: SplunkAuthenticationBasicSecretRetryRules$Outbound | undefined;
+};
+/** @internal */
+export declare const SplunkAuthenticationBasicSecret$outboundSchema: z.ZodType<SplunkAuthenticationBasicSecret$Outbound, z.ZodTypeDef, SplunkAuthenticationBasicSecret>;
+export declare function splunkAuthenticationBasicSecretToJSON(splunkAuthenticationBasicSecret: SplunkAuthenticationBasicSecret): string;
+export declare function splunkAuthenticationBasicSecretFromJSON(jsonString: string): SafeParseResult<SplunkAuthenticationBasicSecret, SDKValidationError>;
+/** @internal */
+export declare const SplunkAuthenticationBasicAuthentication$inboundSchema: z.ZodType<SplunkAuthenticationBasicAuthentication, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const SplunkAuthenticationBasicAuthentication$outboundSchema: z.ZodType<string, z.ZodTypeDef, SplunkAuthenticationBasicAuthentication>;
+/** @internal */
+export declare const SplunkAuthenticationBasicOutputMode$inboundSchema: z.ZodType<SplunkAuthenticationBasicOutputMode, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const SplunkAuthenticationBasicOutputMode$outboundSchema: z.ZodType<string, z.ZodTypeDef, SplunkAuthenticationBasicOutputMode>;
+/** @internal */
+export declare const SplunkAuthenticationBasicCollectRequestParam$inboundSchema: z.ZodType<SplunkAuthenticationBasicCollectRequestParam, z.ZodTypeDef, unknown>;
+/** @internal */
+export type SplunkAuthenticationBasicCollectRequestParam$Outbound = {
+    name: string;
+    value: string;
+};
+/** @internal */
+export declare const SplunkAuthenticationBasicCollectRequestParam$outboundSchema: z.ZodType<SplunkAuthenticationBasicCollectRequestParam$Outbound, z.ZodTypeDef, SplunkAuthenticationBasicCollectRequestParam>;
+export declare function splunkAuthenticationBasicCollectRequestParamToJSON(splunkAuthenticationBasicCollectRequestParam: SplunkAuthenticationBasicCollectRequestParam): string;
+export declare function splunkAuthenticationBasicCollectRequestParamFromJSON(jsonString: string): SafeParseResult<SplunkAuthenticationBasicCollectRequestParam, SDKValidationError>;
+/** @internal */
+export declare const SplunkAuthenticationBasicCollectRequestHeader$inboundSchema: z.ZodType<SplunkAuthenticationBasicCollectRequestHeader, z.ZodTypeDef, unknown>;
+/** @internal */
+export type SplunkAuthenticationBasicCollectRequestHeader$Outbound = {
+    name: string;
+    value: string;
+};
+/** @internal */
+export declare const SplunkAuthenticationBasicCollectRequestHeader$outboundSchema: z.ZodType<SplunkAuthenticationBasicCollectRequestHeader$Outbound, z.ZodTypeDef, SplunkAuthenticationBasicCollectRequestHeader>;
+export declare function splunkAuthenticationBasicCollectRequestHeaderToJSON(splunkAuthenticationBasicCollectRequestHeader: SplunkAuthenticationBasicCollectRequestHeader): string;
+export declare function splunkAuthenticationBasicCollectRequestHeaderFromJSON(jsonString: string): SafeParseResult<SplunkAuthenticationBasicCollectRequestHeader, SDKValidationError>;
+/** @internal */
+export declare const SplunkAuthenticationBasicRetryType$inboundSchema: z.ZodType<SplunkAuthenticationBasicRetryType, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const SplunkAuthenticationBasicRetryType$outboundSchema: z.ZodType<string, z.ZodTypeDef, SplunkAuthenticationBasicRetryType>;
+/** @internal */
+export declare const SplunkAuthenticationBasicRetryRules$inboundSchema: z.ZodType<SplunkAuthenticationBasicRetryRules, z.ZodTypeDef, unknown>;
+/** @internal */
+export type SplunkAuthenticationBasicRetryRules$Outbound = {
+    type: string;
+    interval?: any | undefined;
+    limit?: any | undefined;
+    multiplier?: any | undefined;
+    codes?: any | undefined;
+    enableHeader?: any | undefined;
+    retryConnectTimeout?: any | undefined;
+    retryConnectReset?: any | undefined;
+};
+/** @internal */
+export declare const SplunkAuthenticationBasicRetryRules$outboundSchema: z.ZodType<SplunkAuthenticationBasicRetryRules$Outbound, z.ZodTypeDef, SplunkAuthenticationBasicRetryRules>;
+export declare function splunkAuthenticationBasicRetryRulesToJSON(splunkAuthenticationBasicRetryRules: SplunkAuthenticationBasicRetryRules): string;
+export declare function splunkAuthenticationBasicRetryRulesFromJSON(jsonString: string): SafeParseResult<SplunkAuthenticationBasicRetryRules, SDKValidationError>;
+/** @internal */
+export declare const SplunkAuthenticationBasic$inboundSchema: z.ZodType<SplunkAuthenticationBasic, z.ZodTypeDef, unknown>;
+/** @internal */
+export type SplunkAuthenticationBasic$Outbound = {
+    authentication: string;
+    username: string;
+    password: string;
+    searchHead: string;
+    search: string;
+    earliest?: string | undefined;
+    latest?: string | undefined;
+    endpoint: string;
     outputMode: string;
-    collectRequestParams?: Array<CollectRequestParam$Outbound> | undefined;
-    collectRequestHeaders?: Array<SplunkCollectorConfCollectRequestHeader$Outbound> | undefined;
+    collectRequestParams?: Array<SplunkAuthenticationBasicCollectRequestParam$Outbound> | undefined;
+    collectRequestHeaders?: Array<SplunkAuthenticationBasicCollectRequestHeader$Outbound> | undefined;
+    timeout: number;
+    useRoundRobinDns: boolean;
+    disableTimeFilter: boolean;
+    rejectUnauthorized: boolean;
+    handleEscapedChars: boolean;
+    retryRules?: SplunkAuthenticationBasicRetryRules$Outbound | undefined;
+};
+/** @internal */
+export declare const SplunkAuthenticationBasic$outboundSchema: z.ZodType<SplunkAuthenticationBasic$Outbound, z.ZodTypeDef, SplunkAuthenticationBasic>;
+export declare function splunkAuthenticationBasicToJSON(splunkAuthenticationBasic: SplunkAuthenticationBasic): string;
+export declare function splunkAuthenticationBasicFromJSON(jsonString: string): SafeParseResult<SplunkAuthenticationBasic, SDKValidationError>;
+/** @internal */
+export declare const SplunkAuthenticationNoneAuthentication$inboundSchema: z.ZodType<SplunkAuthenticationNoneAuthentication, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const SplunkAuthenticationNoneAuthentication$outboundSchema: z.ZodType<string, z.ZodTypeDef, SplunkAuthenticationNoneAuthentication>;
+/** @internal */
+export declare const SplunkAuthenticationNoneOutputMode$inboundSchema: z.ZodType<SplunkAuthenticationNoneOutputMode, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const SplunkAuthenticationNoneOutputMode$outboundSchema: z.ZodType<string, z.ZodTypeDef, SplunkAuthenticationNoneOutputMode>;
+/** @internal */
+export declare const SplunkAuthenticationNoneCollectRequestParam$inboundSchema: z.ZodType<SplunkAuthenticationNoneCollectRequestParam, z.ZodTypeDef, unknown>;
+/** @internal */
+export type SplunkAuthenticationNoneCollectRequestParam$Outbound = {
+    name: string;
+    value: string;
+};
+/** @internal */
+export declare const SplunkAuthenticationNoneCollectRequestParam$outboundSchema: z.ZodType<SplunkAuthenticationNoneCollectRequestParam$Outbound, z.ZodTypeDef, SplunkAuthenticationNoneCollectRequestParam>;
+export declare function splunkAuthenticationNoneCollectRequestParamToJSON(splunkAuthenticationNoneCollectRequestParam: SplunkAuthenticationNoneCollectRequestParam): string;
+export declare function splunkAuthenticationNoneCollectRequestParamFromJSON(jsonString: string): SafeParseResult<SplunkAuthenticationNoneCollectRequestParam, SDKValidationError>;
+/** @internal */
+export declare const SplunkAuthenticationNoneCollectRequestHeader$inboundSchema: z.ZodType<SplunkAuthenticationNoneCollectRequestHeader, z.ZodTypeDef, unknown>;
+/** @internal */
+export type SplunkAuthenticationNoneCollectRequestHeader$Outbound = {
+    name: string;
+    value: string;
+};
+/** @internal */
+export declare const SplunkAuthenticationNoneCollectRequestHeader$outboundSchema: z.ZodType<SplunkAuthenticationNoneCollectRequestHeader$Outbound, z.ZodTypeDef, SplunkAuthenticationNoneCollectRequestHeader>;
+export declare function splunkAuthenticationNoneCollectRequestHeaderToJSON(splunkAuthenticationNoneCollectRequestHeader: SplunkAuthenticationNoneCollectRequestHeader): string;
+export declare function splunkAuthenticationNoneCollectRequestHeaderFromJSON(jsonString: string): SafeParseResult<SplunkAuthenticationNoneCollectRequestHeader, SDKValidationError>;
+/** @internal */
+export declare const SplunkAuthenticationNoneRetryType$inboundSchema: z.ZodType<SplunkAuthenticationNoneRetryType, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const SplunkAuthenticationNoneRetryType$outboundSchema: z.ZodType<string, z.ZodTypeDef, SplunkAuthenticationNoneRetryType>;
+/** @internal */
+export declare const SplunkAuthenticationNoneRetryRules$inboundSchema: z.ZodType<SplunkAuthenticationNoneRetryRules, z.ZodTypeDef, unknown>;
+/** @internal */
+export type SplunkAuthenticationNoneRetryRules$Outbound = {
+    type: string;
+    interval?: any | undefined;
+    limit?: any | undefined;
+    multiplier?: any | undefined;
+    codes?: any | undefined;
+    enableHeader?: any | undefined;
+    retryConnectTimeout?: any | undefined;
+    retryConnectReset?: any | undefined;
+};
+/** @internal */
+export declare const SplunkAuthenticationNoneRetryRules$outboundSchema: z.ZodType<SplunkAuthenticationNoneRetryRules$Outbound, z.ZodTypeDef, SplunkAuthenticationNoneRetryRules>;
+export declare function splunkAuthenticationNoneRetryRulesToJSON(splunkAuthenticationNoneRetryRules: SplunkAuthenticationNoneRetryRules): string;
+export declare function splunkAuthenticationNoneRetryRulesFromJSON(jsonString: string): SafeParseResult<SplunkAuthenticationNoneRetryRules, SDKValidationError>;
+/** @internal */
+export declare const SplunkAuthenticationNone$inboundSchema: z.ZodType<SplunkAuthenticationNone, z.ZodTypeDef, unknown>;
+/** @internal */
+export type SplunkAuthenticationNone$Outbound = {
     authentication: string;
+    searchHead: string;
+    search: string;
+    earliest?: string | undefined;
+    latest?: string | undefined;
+    endpoint: string;
+    outputMode: string;
+    collectRequestParams?: Array<SplunkAuthenticationNoneCollectRequestParam$Outbound> | undefined;
+    collectRequestHeaders?: Array<SplunkAuthenticationNoneCollectRequestHeader$Outbound> | undefined;
     timeout: number;
     useRoundRobinDns: boolean;
     disableTimeFilter: boolean;
     rejectUnauthorized: boolean;
     handleEscapedChars: boolean;
-    retryRules?: SplunkCollectorConfRetryRules$Outbound | undefined;
+    retryRules?: SplunkAuthenticationNoneRetryRules$Outbound | undefined;
 };
 /** @internal */
+export declare const SplunkAuthenticationNone$outboundSchema: z.ZodType<SplunkAuthenticationNone$Outbound, z.ZodTypeDef, SplunkAuthenticationNone>;
+export declare function splunkAuthenticationNoneToJSON(splunkAuthenticationNone: SplunkAuthenticationNone): string;
+export declare function splunkAuthenticationNoneFromJSON(jsonString: string): SafeParseResult<SplunkAuthenticationNone, SDKValidationError>;
+/** @internal */
+export declare const SplunkCollectorConf$inboundSchema: z.ZodType<SplunkCollectorConf, z.ZodTypeDef, unknown>;
+/** @internal */
+export type SplunkCollectorConf$Outbound = SplunkAuthenticationBasic$Outbound | SplunkAuthenticationLogin$Outbound | SplunkAuthenticationBasicSecret$Outbound | SplunkAuthenticationToken$Outbound | SplunkAuthenticationTokenSecret$Outbound | SplunkAuthenticationLoginSecret$Outbound | SplunkAuthenticationNone$Outbound;
+/** @internal */
 export declare const SplunkCollectorConf$outboundSchema: z.ZodType<SplunkCollectorConf$Outbound, z.ZodTypeDef, SplunkCollectorConf>;
 export declare function splunkCollectorConfToJSON(splunkCollectorConf: SplunkCollectorConf): string;
 export declare function splunkCollectorConfFromJSON(jsonString: string): SafeParseResult<SplunkCollectorConf, SDKValidationError>;