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

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

@@ -0,0 +1,929 @@
+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";
+/**
+ * Partitioning scheme used for this dataset. Using a known scheme like DDSS enables more efficient data reading and retrieval.
+ */
+export declare const S3AwsAuthenticationMethodSecretPartitioningScheme: {
+    /**
+     * Defined in Path
+     */
+    readonly None: "none";
+    /**
+     * DDSS
+     */
+    readonly Ddss: "ddss";
+};
+/**
+ * Partitioning scheme used for this dataset. Using a known scheme like DDSS enables more efficient data reading and retrieval.
+ */
+export type S3AwsAuthenticationMethodSecretPartitioningScheme = OpenEnum<typeof S3AwsAuthenticationMethodSecretPartitioningScheme>;
+export type S3AwsAuthenticationMethodSecretExtractor = {
+    /**
+     * A token from the template path, such as epoch
+     */
+    key: string;
+    /**
+     * JavaScript expression that receives token under "value" variable, and evaluates to populate event fields. Example: {date: new Date(+value*1000)}
+     */
+    expression: string;
+};
+/**
+ * Signature version to use for signing S3 requests
+ */
+export declare const S3AwsAuthenticationMethodSecretSignatureVersion: {
+    readonly V2: "v2";
+    readonly V4: "v4";
+};
+/**
+ * Signature version to use for signing S3 requests
+ */
+export type S3AwsAuthenticationMethodSecretSignatureVersion = OpenEnum<typeof S3AwsAuthenticationMethodSecretSignatureVersion>;
+export type S3AwsAuthenticationMethodSecret = {
+    /**
+     * AWS authentication method. Choose Auto to use IAM roles.
+     */
+    awsAuthenticationMethod: "secret";
+    /**
+     * Select or create a stored secret that references AWS access key and secret key.
+     */
+    awsSecret?: string | undefined;
+    /**
+     * Name of the predefined Destination that will be used to auto-populate Collector settings
+     */
+    outputName?: string | undefined;
+    /**
+     * S3 Bucket from which to collect data
+     */
+    bucket: string;
+    /**
+     * Maximum file size for each Parquet chunk
+     */
+    parquetChunkSizeMB?: number | undefined;
+    /**
+     * Maximum time allowed for downloading a Parquet chunk. Processing will stop if a chunk cannot be downloaded within the time specified.
+     */
+    parquetChunkDownloadTimeout?: number | undefined;
+    /**
+     * Region from which to retrieve data
+     */
+    region?: string | undefined;
+    /**
+     * Directory where data will be collected. Templating (such as 'myDir/${datacenter}/${host}/${app}/') and time-based tokens (such as 'myOtherDir/${_time:%Y}/${_time:%m}/${_time:%d}/') are supported. Can be a constant (enclosed in quotes) or a JavaScript expression.
+     */
+    path?: string | undefined;
+    /**
+     * Partitioning scheme used for this dataset. Using a known scheme like DDSS enables more efficient data reading and retrieval.
+     */
+    partitioningScheme?: S3AwsAuthenticationMethodSecretPartitioningScheme | undefined;
+    /**
+     * Allows using template tokens as context for expressions that enrich discovery results. For example, given a template /path/${epoch}, an extractor under key "epoch" with an expression {date: new Date(+value*1000)}, will enrich discovery results with a human readable "date" field.
+     */
+    extractors?: Array<S3AwsAuthenticationMethodSecretExtractor> | undefined;
+    /**
+     * Must point to an S3-compatible endpoint. If empty, defaults to an AWS region-specific endpoint.
+     */
+    endpoint?: string | undefined;
+    /**
+     * Signature version to use for signing S3 requests
+     */
+    signatureVersion?: S3AwsAuthenticationMethodSecretSignatureVersion | undefined;
+    /**
+     * Use AssumeRole credentials
+     */
+    enableAssumeRole?: boolean | undefined;
+    /**
+     * Amazon Resource Name (ARN) of the role to assume
+     */
+    assumeRoleArn?: string | undefined;
+    /**
+     * External ID to use when assuming role
+     */
+    assumeRoleExternalId?: string | undefined;
+    /**
+     * Duration of the Assumed Role's session, in seconds. Minimum is 900 (15 minutes), default is 3600 (1 hour), and maximum is 43200 (12 hours).
+     */
+    durationSeconds?: number | undefined;
+    /**
+     * Maximum number of metadata objects to batch before recording as results
+     */
+    maxBatchSize?: number | undefined;
+    recurse?: any | undefined;
+    /**
+     * Reuse connections between requests to improve performance
+     */
+    reuseConnections?: boolean | undefined;
+    /**
+     * Reject certificates that cannot be verified against a valid CA (such as a self-signed certificate)
+     */
+    rejectUnauthorized?: boolean | undefined;
+    /**
+     * Disable if you can access files within the bucket but not the bucket itself. Resolves errors of the form "discover task initialization failed...error: Forbidden".
+     */
+    verifyPermissions?: boolean | undefined;
+    /**
+     * Disable Collector event time filtering when a date range is specified
+     */
+    disableTimeFilter?: boolean | undefined;
+};
+/**
+ * Partitioning scheme used for this dataset. Using a known scheme like DDSS enables more efficient data reading and retrieval.
+ */
+export declare const S3AwsAuthenticationMethodManualPartitioningScheme: {
+    /**
+     * Defined in Path
+     */
+    readonly None: "none";
+    /**
+     * DDSS
+     */
+    readonly Ddss: "ddss";
+};
+/**
+ * Partitioning scheme used for this dataset. Using a known scheme like DDSS enables more efficient data reading and retrieval.
+ */
+export type S3AwsAuthenticationMethodManualPartitioningScheme = OpenEnum<typeof S3AwsAuthenticationMethodManualPartitioningScheme>;
+export type S3AwsAuthenticationMethodManualExtractor = {
+    /**
+     * A token from the template path, such as epoch
+     */
+    key: string;
+    /**
+     * JavaScript expression that receives token under "value" variable, and evaluates to populate event fields. Example: {date: new Date(+value*1000)}
+     */
+    expression: string;
+};
+/**
+ * Signature version to use for signing S3 requests
+ */
+export declare const S3AwsAuthenticationMethodManualSignatureVersion: {
+    readonly V2: "v2";
+    readonly V4: "v4";
+};
+/**
+ * Signature version to use for signing S3 requests
+ */
+export type S3AwsAuthenticationMethodManualSignatureVersion = OpenEnum<typeof S3AwsAuthenticationMethodManualSignatureVersion>;
+export type S3AwsAuthenticationMethodManual = {
+    /**
+     * AWS authentication method. Choose Auto to use IAM roles.
+     */
+    awsAuthenticationMethod: "manual";
+    /**
+     * Access key. If not present, will fall back to env.AWS_ACCESS_KEY_ID, or to the metadata endpoint for IAM creds. Optional when running on AWS. This value can be a constant or a JavaScript expression.
+     */
+    awsApiKey?: string | undefined;
+    /**
+     * Secret key. If not present, will fall back to env.AWS_SECRET_ACCESS_KEY, or to the metadata endpoint for IAM creds. Optional when running on AWS. This value can be a constant or a JavaScript expression.
+     */
+    awsSecretKey?: string | undefined;
+    /**
+     * Name of the predefined Destination that will be used to auto-populate Collector settings
+     */
+    outputName?: string | undefined;
+    /**
+     * S3 Bucket from which to collect data
+     */
+    bucket: string;
+    /**
+     * Maximum file size for each Parquet chunk
+     */
+    parquetChunkSizeMB?: number | undefined;
+    /**
+     * Maximum time allowed for downloading a Parquet chunk. Processing will stop if a chunk cannot be downloaded within the time specified.
+     */
+    parquetChunkDownloadTimeout?: number | undefined;
+    /**
+     * Region from which to retrieve data
+     */
+    region?: string | undefined;
+    /**
+     * Directory where data will be collected. Templating (such as 'myDir/${datacenter}/${host}/${app}/') and time-based tokens (such as 'myOtherDir/${_time:%Y}/${_time:%m}/${_time:%d}/') are supported. Can be a constant (enclosed in quotes) or a JavaScript expression.
+     */
+    path?: string | undefined;
+    /**
+     * Partitioning scheme used for this dataset. Using a known scheme like DDSS enables more efficient data reading and retrieval.
+     */
+    partitioningScheme?: S3AwsAuthenticationMethodManualPartitioningScheme | undefined;
+    /**
+     * Allows using template tokens as context for expressions that enrich discovery results. For example, given a template /path/${epoch}, an extractor under key "epoch" with an expression {date: new Date(+value*1000)}, will enrich discovery results with a human readable "date" field.
+     */
+    extractors?: Array<S3AwsAuthenticationMethodManualExtractor> | undefined;
+    /**
+     * Must point to an S3-compatible endpoint. If empty, defaults to an AWS region-specific endpoint.
+     */
+    endpoint?: string | undefined;
+    /**
+     * Signature version to use for signing S3 requests
+     */
+    signatureVersion?: S3AwsAuthenticationMethodManualSignatureVersion | undefined;
+    /**
+     * Use AssumeRole credentials
+     */
+    enableAssumeRole?: boolean | undefined;
+    /**
+     * Amazon Resource Name (ARN) of the role to assume
+     */
+    assumeRoleArn?: string | undefined;
+    /**
+     * External ID to use when assuming role
+     */
+    assumeRoleExternalId?: string | undefined;
+    /**
+     * Duration of the Assumed Role's session, in seconds. Minimum is 900 (15 minutes), default is 3600 (1 hour), and maximum is 43200 (12 hours).
+     */
+    durationSeconds?: number | undefined;
+    /**
+     * Maximum number of metadata objects to batch before recording as results
+     */
+    maxBatchSize?: number | undefined;
+    recurse?: any | undefined;
+    /**
+     * Reuse connections between requests to improve performance
+     */
+    reuseConnections?: boolean | undefined;
+    /**
+     * Reject certificates that cannot be verified against a valid CA (such as a self-signed certificate)
+     */
+    rejectUnauthorized?: boolean | undefined;
+    /**
+     * Disable if you can access files within the bucket but not the bucket itself. Resolves errors of the form "discover task initialization failed...error: Forbidden".
+     */
+    verifyPermissions?: boolean | undefined;
+    /**
+     * Disable Collector event time filtering when a date range is specified
+     */
+    disableTimeFilter?: boolean | undefined;
+};
+/**
+ * Partitioning scheme used for this dataset. Using a known scheme like DDSS enables more efficient data reading and retrieval.
+ */
+export declare const S3AwsAuthenticationMethodAutoPartitioningScheme: {
+    /**
+     * Defined in Path
+     */
+    readonly None: "none";
+    /**
+     * DDSS
+     */
+    readonly Ddss: "ddss";
+};
+/**
+ * Partitioning scheme used for this dataset. Using a known scheme like DDSS enables more efficient data reading and retrieval.
+ */
+export type S3AwsAuthenticationMethodAutoPartitioningScheme = OpenEnum<typeof S3AwsAuthenticationMethodAutoPartitioningScheme>;
+export type S3AwsAuthenticationMethodAutoExtractor = {
+    /**
+     * A token from the template path, such as epoch
+     */
+    key: string;
+    /**
+     * JavaScript expression that receives token under "value" variable, and evaluates to populate event fields. Example: {date: new Date(+value*1000)}
+     */
+    expression: string;
+};
+/**
+ * Signature version to use for signing S3 requests
+ */
+export declare const S3AwsAuthenticationMethodAutoSignatureVersion: {
+    readonly V2: "v2";
+    readonly V4: "v4";
+};
+/**
+ * Signature version to use for signing S3 requests
+ */
+export type S3AwsAuthenticationMethodAutoSignatureVersion = OpenEnum<typeof S3AwsAuthenticationMethodAutoSignatureVersion>;
+export type S3AwsAuthenticationMethodAuto = {
+    /**
+     * AWS authentication method. Choose Auto to use IAM roles.
+     */
+    awsAuthenticationMethod: "auto";
+    /**
+     * Name of the predefined Destination that will be used to auto-populate Collector settings
+     */
+    outputName?: string | undefined;
+    /**
+     * S3 Bucket from which to collect data
+     */
+    bucket: string;
+    /**
+     * Maximum file size for each Parquet chunk
+     */
+    parquetChunkSizeMB?: number | undefined;
+    /**
+     * Maximum time allowed for downloading a Parquet chunk. Processing will stop if a chunk cannot be downloaded within the time specified.
+     */
+    parquetChunkDownloadTimeout?: number | undefined;
+    /**
+     * Region from which to retrieve data
+     */
+    region?: string | undefined;
+    /**
+     * Directory where data will be collected. Templating (such as 'myDir/${datacenter}/${host}/${app}/') and time-based tokens (such as 'myOtherDir/${_time:%Y}/${_time:%m}/${_time:%d}/') are supported. Can be a constant (enclosed in quotes) or a JavaScript expression.
+     */
+    path?: string | undefined;
+    /**
+     * Partitioning scheme used for this dataset. Using a known scheme like DDSS enables more efficient data reading and retrieval.
+     */
+    partitioningScheme?: S3AwsAuthenticationMethodAutoPartitioningScheme | undefined;
+    /**
+     * Allows using template tokens as context for expressions that enrich discovery results. For example, given a template /path/${epoch}, an extractor under key "epoch" with an expression {date: new Date(+value*1000)}, will enrich discovery results with a human readable "date" field.
+     */
+    extractors?: Array<S3AwsAuthenticationMethodAutoExtractor> | undefined;
+    /**
+     * Must point to an S3-compatible endpoint. If empty, defaults to an AWS region-specific endpoint.
+     */
+    endpoint?: string | undefined;
+    /**
+     * Signature version to use for signing S3 requests
+     */
+    signatureVersion?: S3AwsAuthenticationMethodAutoSignatureVersion | undefined;
+    /**
+     * Use AssumeRole credentials
+     */
+    enableAssumeRole?: boolean | undefined;
+    /**
+     * Amazon Resource Name (ARN) of the role to assume
+     */
+    assumeRoleArn?: string | undefined;
+    /**
+     * External ID to use when assuming role
+     */
+    assumeRoleExternalId?: string | undefined;
+    /**
+     * Duration of the Assumed Role's session, in seconds. Minimum is 900 (15 minutes), default is 3600 (1 hour), and maximum is 43200 (12 hours).
+     */
+    durationSeconds?: number | undefined;
+    /**
+     * Maximum number of metadata objects to batch before recording as results
+     */
+    maxBatchSize?: number | undefined;
+    recurse?: any | undefined;
+    /**
+     * Reuse connections between requests to improve performance
+     */
+    reuseConnections?: boolean | undefined;
+    /**
+     * Reject certificates that cannot be verified against a valid CA (such as a self-signed certificate)
+     */
+    rejectUnauthorized?: boolean | undefined;
+    /**
+     * Disable if you can access files within the bucket but not the bucket itself. Resolves errors of the form "discover task initialization failed...error: Forbidden".
+     */
+    verifyPermissions?: boolean | undefined;
+    /**
+     * Disable Collector event time filtering when a date range is specified
+     */
+    disableTimeFilter?: boolean | undefined;
+};
+/**
+ * Partitioning scheme used for this dataset. Using a known scheme like DDSS enables more efficient data reading and retrieval.
+ */
+export declare const S3PartitioningSchemeNonePartitioningScheme: {
+    /**
+     * Defined in Path
+     */
+    readonly None: "none";
+    /**
+     * DDSS
+     */
+    readonly Ddss: "ddss";
+};
+/**
+ * Partitioning scheme used for this dataset. Using a known scheme like DDSS enables more efficient data reading and retrieval.
+ */
+export type S3PartitioningSchemeNonePartitioningScheme = OpenEnum<typeof S3PartitioningSchemeNonePartitioningScheme>;
+export type S3PartitioningSchemeNoneExtractor = {
+    /**
+     * A token from the template path, such as epoch
+     */
+    key: string;
+    /**
+     * JavaScript expression that receives token under "value" variable, and evaluates to populate event fields. Example: {date: new Date(+value*1000)}
+     */
+    expression: string;
+};
+/**
+ * AWS authentication method. Choose Auto to use IAM roles.
+ */
+export declare const S3PartitioningSchemeNoneAuthenticationMethod: {
+    /**
+     * Auto
+     */
+    readonly Auto: "auto";
+    /**
+     * Manual
+     */
+    readonly Manual: "manual";
+    /**
+     * Secret Key pair
+     */
+    readonly Secret: "secret";
+};
+/**
+ * AWS authentication method. Choose Auto to use IAM roles.
+ */
+export type S3PartitioningSchemeNoneAuthenticationMethod = OpenEnum<typeof S3PartitioningSchemeNoneAuthenticationMethod>;
+/**
+ * Signature version to use for signing S3 requests
+ */
+export declare const S3PartitioningSchemeNoneSignatureVersion: {
+    readonly V2: "v2";
+    readonly V4: "v4";
+};
+/**
+ * Signature version to use for signing S3 requests
+ */
+export type S3PartitioningSchemeNoneSignatureVersion = OpenEnum<typeof S3PartitioningSchemeNoneSignatureVersion>;
+export type S3PartitioningSchemeNone = {
+    /**
+     * Partitioning scheme used for this dataset. Using a known scheme like DDSS enables more efficient data reading and retrieval.
+     */
+    partitioningScheme?: S3PartitioningSchemeNonePartitioningScheme | undefined;
+    recurse?: any | undefined;
+    /**
+     * Name of the predefined Destination that will be used to auto-populate Collector settings
+     */
+    outputName?: string | undefined;
+    /**
+     * S3 Bucket from which to collect data
+     */
+    bucket: string;
+    /**
+     * Maximum file size for each Parquet chunk
+     */
+    parquetChunkSizeMB?: number | undefined;
+    /**
+     * Maximum time allowed for downloading a Parquet chunk. Processing will stop if a chunk cannot be downloaded within the time specified.
+     */
+    parquetChunkDownloadTimeout?: number | undefined;
+    /**
+     * Region from which to retrieve data
+     */
+    region?: string | undefined;
+    /**
+     * Directory where data will be collected. Templating (such as 'myDir/${datacenter}/${host}/${app}/') and time-based tokens (such as 'myOtherDir/${_time:%Y}/${_time:%m}/${_time:%d}/') are supported. Can be a constant (enclosed in quotes) or a JavaScript expression.
+     */
+    path?: string | undefined;
+    /**
+     * Allows using template tokens as context for expressions that enrich discovery results. For example, given a template /path/${epoch}, an extractor under key "epoch" with an expression {date: new Date(+value*1000)}, will enrich discovery results with a human readable "date" field.
+     */
+    extractors?: Array<S3PartitioningSchemeNoneExtractor> | undefined;
+    /**
+     * AWS authentication method. Choose Auto to use IAM roles.
+     */
+    awsAuthenticationMethod?: S3PartitioningSchemeNoneAuthenticationMethod | undefined;
+    /**
+     * Must point to an S3-compatible endpoint. If empty, defaults to an AWS region-specific endpoint.
+     */
+    endpoint?: string | undefined;
+    /**
+     * Signature version to use for signing S3 requests
+     */
+    signatureVersion?: S3PartitioningSchemeNoneSignatureVersion | undefined;
+    /**
+     * Use AssumeRole credentials
+     */
+    enableAssumeRole?: boolean | undefined;
+    /**
+     * Amazon Resource Name (ARN) of the role to assume
+     */
+    assumeRoleArn?: string | undefined;
+    /**
+     * External ID to use when assuming role
+     */
+    assumeRoleExternalId?: string | undefined;
+    /**
+     * Duration of the Assumed Role's session, in seconds. Minimum is 900 (15 minutes), default is 3600 (1 hour), and maximum is 43200 (12 hours).
+     */
+    durationSeconds?: number | undefined;
+    /**
+     * Maximum number of metadata objects to batch before recording as results
+     */
+    maxBatchSize?: number | undefined;
+    /**
+     * Reuse connections between requests to improve performance
+     */
+    reuseConnections?: boolean | undefined;
+    /**
+     * Reject certificates that cannot be verified against a valid CA (such as a self-signed certificate)
+     */
+    rejectUnauthorized?: boolean | undefined;
+    /**
+     * Disable if you can access files within the bucket but not the bucket itself. Resolves errors of the form "discover task initialization failed...error: Forbidden".
+     */
+    verifyPermissions?: boolean | undefined;
+    /**
+     * Disable Collector event time filtering when a date range is specified
+     */
+    disableTimeFilter?: boolean | undefined;
+};
+/**
+ * Partitioning scheme used for this dataset. Using a known scheme like DDSS enables more efficient data reading and retrieval.
+ */
+export declare const S3PartitioningSchemeDdssPartitioningScheme: {
+    /**
+     * Defined in Path
+     */
+    readonly None: "none";
+    /**
+     * DDSS
+     */
+    readonly Ddss: "ddss";
+};
+/**
+ * Partitioning scheme used for this dataset. Using a known scheme like DDSS enables more efficient data reading and retrieval.
+ */
+export type S3PartitioningSchemeDdssPartitioningScheme = OpenEnum<typeof S3PartitioningSchemeDdssPartitioningScheme>;
+export type S3PartitioningSchemeDdssExtractor = {
+    /**
+     * A token from the template path, such as epoch
+     */
+    key: string;
+    /**
+     * JavaScript expression that receives token under "value" variable, and evaluates to populate event fields. Example: {date: new Date(+value*1000)}
+     */
+    expression: string;
+};
+/**
+ * AWS authentication method. Choose Auto to use IAM roles.
+ */
+export declare const S3PartitioningSchemeDdssAuthenticationMethod: {
+    /**
+     * Auto
+     */
+    readonly Auto: "auto";
+    /**
+     * Manual
+     */
+    readonly Manual: "manual";
+    /**
+     * Secret Key pair
+     */
+    readonly Secret: "secret";
+};
+/**
+ * AWS authentication method. Choose Auto to use IAM roles.
+ */
+export type S3PartitioningSchemeDdssAuthenticationMethod = OpenEnum<typeof S3PartitioningSchemeDdssAuthenticationMethod>;
+/**
+ * Signature version to use for signing S3 requests
+ */
+export declare const S3PartitioningSchemeDdssSignatureVersion: {
+    readonly V2: "v2";
+    readonly V4: "v4";
+};
+/**
+ * Signature version to use for signing S3 requests
+ */
+export type S3PartitioningSchemeDdssSignatureVersion = OpenEnum<typeof S3PartitioningSchemeDdssSignatureVersion>;
+export type S3PartitioningSchemeDdss = {
+    /**
+     * Partitioning scheme used for this dataset. Using a known scheme like DDSS enables more efficient data reading and retrieval.
+     */
+    partitioningScheme?: S3PartitioningSchemeDdssPartitioningScheme | undefined;
+    /**
+     * Name of the predefined Destination that will be used to auto-populate Collector settings
+     */
+    outputName?: string | undefined;
+    /**
+     * S3 Bucket from which to collect data
+     */
+    bucket: string;
+    /**
+     * Maximum file size for each Parquet chunk
+     */
+    parquetChunkSizeMB?: number | undefined;
+    /**
+     * Maximum time allowed for downloading a Parquet chunk. Processing will stop if a chunk cannot be downloaded within the time specified.
+     */
+    parquetChunkDownloadTimeout?: number | undefined;
+    /**
+     * Region from which to retrieve data
+     */
+    region?: string | undefined;
+    /**
+     * Directory where data will be collected. Templating (such as 'myDir/${datacenter}/${host}/${app}/') and time-based tokens (such as 'myOtherDir/${_time:%Y}/${_time:%m}/${_time:%d}/') are supported. Can be a constant (enclosed in quotes) or a JavaScript expression.
+     */
+    path?: string | undefined;
+    /**
+     * Allows using template tokens as context for expressions that enrich discovery results. For example, given a template /path/${epoch}, an extractor under key "epoch" with an expression {date: new Date(+value*1000)}, will enrich discovery results with a human readable "date" field.
+     */
+    extractors?: Array<S3PartitioningSchemeDdssExtractor> | undefined;
+    /**
+     * AWS authentication method. Choose Auto to use IAM roles.
+     */
+    awsAuthenticationMethod?: S3PartitioningSchemeDdssAuthenticationMethod | undefined;
+    /**
+     * Must point to an S3-compatible endpoint. If empty, defaults to an AWS region-specific endpoint.
+     */
+    endpoint?: string | undefined;
+    /**
+     * Signature version to use for signing S3 requests
+     */
+    signatureVersion?: S3PartitioningSchemeDdssSignatureVersion | undefined;
+    /**
+     * Use AssumeRole credentials
+     */
+    enableAssumeRole?: boolean | undefined;
+    /**
+     * Amazon Resource Name (ARN) of the role to assume
+     */
+    assumeRoleArn?: string | undefined;
+    /**
+     * External ID to use when assuming role
+     */
+    assumeRoleExternalId?: string | undefined;
+    /**
+     * Duration of the Assumed Role's session, in seconds. Minimum is 900 (15 minutes), default is 3600 (1 hour), and maximum is 43200 (12 hours).
+     */
+    durationSeconds?: number | undefined;
+    /**
+     * Maximum number of metadata objects to batch before recording as results
+     */
+    maxBatchSize?: number | undefined;
+    recurse?: any | undefined;
+    /**
+     * Reuse connections between requests to improve performance
+     */
+    reuseConnections?: boolean | undefined;
+    /**
+     * Reject certificates that cannot be verified against a valid CA (such as a self-signed certificate)
+     */
+    rejectUnauthorized?: boolean | undefined;
+    /**
+     * Disable if you can access files within the bucket but not the bucket itself. Resolves errors of the form "discover task initialization failed...error: Forbidden".
+     */
+    verifyPermissions?: boolean | undefined;
+    /**
+     * Disable Collector event time filtering when a date range is specified
+     */
+    disableTimeFilter?: boolean | undefined;
+};
+export type S3CollectorConf = S3AwsAuthenticationMethodAuto | S3AwsAuthenticationMethodManual | S3AwsAuthenticationMethodSecret;
+/** @internal */
+export declare const S3AwsAuthenticationMethodSecretPartitioningScheme$inboundSchema: z.ZodType<S3AwsAuthenticationMethodSecretPartitioningScheme, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const S3AwsAuthenticationMethodSecretPartitioningScheme$outboundSchema: z.ZodType<string, z.ZodTypeDef, S3AwsAuthenticationMethodSecretPartitioningScheme>;
+/** @internal */
+export declare const S3AwsAuthenticationMethodSecretExtractor$inboundSchema: z.ZodType<S3AwsAuthenticationMethodSecretExtractor, z.ZodTypeDef, unknown>;
+/** @internal */
+export type S3AwsAuthenticationMethodSecretExtractor$Outbound = {
+    key: string;
+    expression: string;
+};
+/** @internal */
+export declare const S3AwsAuthenticationMethodSecretExtractor$outboundSchema: z.ZodType<S3AwsAuthenticationMethodSecretExtractor$Outbound, z.ZodTypeDef, S3AwsAuthenticationMethodSecretExtractor>;
+export declare function s3AwsAuthenticationMethodSecretExtractorToJSON(s3AwsAuthenticationMethodSecretExtractor: S3AwsAuthenticationMethodSecretExtractor): string;
+export declare function s3AwsAuthenticationMethodSecretExtractorFromJSON(jsonString: string): SafeParseResult<S3AwsAuthenticationMethodSecretExtractor, SDKValidationError>;
+/** @internal */
+export declare const S3AwsAuthenticationMethodSecretSignatureVersion$inboundSchema: z.ZodType<S3AwsAuthenticationMethodSecretSignatureVersion, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const S3AwsAuthenticationMethodSecretSignatureVersion$outboundSchema: z.ZodType<string, z.ZodTypeDef, S3AwsAuthenticationMethodSecretSignatureVersion>;
+/** @internal */
+export declare const S3AwsAuthenticationMethodSecret$inboundSchema: z.ZodType<S3AwsAuthenticationMethodSecret, z.ZodTypeDef, unknown>;
+/** @internal */
+export type S3AwsAuthenticationMethodSecret$Outbound = {
+    awsAuthenticationMethod: "secret";
+    awsSecret?: string | undefined;
+    outputName?: string | undefined;
+    bucket: string;
+    parquetChunkSizeMB: number;
+    parquetChunkDownloadTimeout: number;
+    region?: string | undefined;
+    path?: string | undefined;
+    partitioningScheme: string;
+    extractors?: Array<S3AwsAuthenticationMethodSecretExtractor$Outbound> | undefined;
+    endpoint?: string | undefined;
+    signatureVersion: string;
+    enableAssumeRole: boolean;
+    assumeRoleArn?: string | undefined;
+    assumeRoleExternalId?: string | undefined;
+    durationSeconds: number;
+    maxBatchSize: number;
+    recurse?: any | undefined;
+    reuseConnections: boolean;
+    rejectUnauthorized: boolean;
+    verifyPermissions: boolean;
+    disableTimeFilter: boolean;
+};
+/** @internal */
+export declare const S3AwsAuthenticationMethodSecret$outboundSchema: z.ZodType<S3AwsAuthenticationMethodSecret$Outbound, z.ZodTypeDef, S3AwsAuthenticationMethodSecret>;
+export declare function s3AwsAuthenticationMethodSecretToJSON(s3AwsAuthenticationMethodSecret: S3AwsAuthenticationMethodSecret): string;
+export declare function s3AwsAuthenticationMethodSecretFromJSON(jsonString: string): SafeParseResult<S3AwsAuthenticationMethodSecret, SDKValidationError>;
+/** @internal */
+export declare const S3AwsAuthenticationMethodManualPartitioningScheme$inboundSchema: z.ZodType<S3AwsAuthenticationMethodManualPartitioningScheme, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const S3AwsAuthenticationMethodManualPartitioningScheme$outboundSchema: z.ZodType<string, z.ZodTypeDef, S3AwsAuthenticationMethodManualPartitioningScheme>;
+/** @internal */
+export declare const S3AwsAuthenticationMethodManualExtractor$inboundSchema: z.ZodType<S3AwsAuthenticationMethodManualExtractor, z.ZodTypeDef, unknown>;
+/** @internal */
+export type S3AwsAuthenticationMethodManualExtractor$Outbound = {
+    key: string;
+    expression: string;
+};
+/** @internal */
+export declare const S3AwsAuthenticationMethodManualExtractor$outboundSchema: z.ZodType<S3AwsAuthenticationMethodManualExtractor$Outbound, z.ZodTypeDef, S3AwsAuthenticationMethodManualExtractor>;
+export declare function s3AwsAuthenticationMethodManualExtractorToJSON(s3AwsAuthenticationMethodManualExtractor: S3AwsAuthenticationMethodManualExtractor): string;
+export declare function s3AwsAuthenticationMethodManualExtractorFromJSON(jsonString: string): SafeParseResult<S3AwsAuthenticationMethodManualExtractor, SDKValidationError>;
+/** @internal */
+export declare const S3AwsAuthenticationMethodManualSignatureVersion$inboundSchema: z.ZodType<S3AwsAuthenticationMethodManualSignatureVersion, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const S3AwsAuthenticationMethodManualSignatureVersion$outboundSchema: z.ZodType<string, z.ZodTypeDef, S3AwsAuthenticationMethodManualSignatureVersion>;
+/** @internal */
+export declare const S3AwsAuthenticationMethodManual$inboundSchema: z.ZodType<S3AwsAuthenticationMethodManual, z.ZodTypeDef, unknown>;
+/** @internal */
+export type S3AwsAuthenticationMethodManual$Outbound = {
+    awsAuthenticationMethod: "manual";
+    awsApiKey?: string | undefined;
+    awsSecretKey?: string | undefined;
+    outputName?: string | undefined;
+    bucket: string;
+    parquetChunkSizeMB: number;
+    parquetChunkDownloadTimeout: number;
+    region?: string | undefined;
+    path?: string | undefined;
+    partitioningScheme: string;
+    extractors?: Array<S3AwsAuthenticationMethodManualExtractor$Outbound> | undefined;
+    endpoint?: string | undefined;
+    signatureVersion: string;
+    enableAssumeRole: boolean;
+    assumeRoleArn?: string | undefined;
+    assumeRoleExternalId?: string | undefined;
+    durationSeconds: number;
+    maxBatchSize: number;
+    recurse?: any | undefined;
+    reuseConnections: boolean;
+    rejectUnauthorized: boolean;
+    verifyPermissions: boolean;
+    disableTimeFilter: boolean;
+};
+/** @internal */
+export declare const S3AwsAuthenticationMethodManual$outboundSchema: z.ZodType<S3AwsAuthenticationMethodManual$Outbound, z.ZodTypeDef, S3AwsAuthenticationMethodManual>;
+export declare function s3AwsAuthenticationMethodManualToJSON(s3AwsAuthenticationMethodManual: S3AwsAuthenticationMethodManual): string;
+export declare function s3AwsAuthenticationMethodManualFromJSON(jsonString: string): SafeParseResult<S3AwsAuthenticationMethodManual, SDKValidationError>;
+/** @internal */
+export declare const S3AwsAuthenticationMethodAutoPartitioningScheme$inboundSchema: z.ZodType<S3AwsAuthenticationMethodAutoPartitioningScheme, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const S3AwsAuthenticationMethodAutoPartitioningScheme$outboundSchema: z.ZodType<string, z.ZodTypeDef, S3AwsAuthenticationMethodAutoPartitioningScheme>;
+/** @internal */
+export declare const S3AwsAuthenticationMethodAutoExtractor$inboundSchema: z.ZodType<S3AwsAuthenticationMethodAutoExtractor, z.ZodTypeDef, unknown>;
+/** @internal */
+export type S3AwsAuthenticationMethodAutoExtractor$Outbound = {
+    key: string;
+    expression: string;
+};
+/** @internal */
+export declare const S3AwsAuthenticationMethodAutoExtractor$outboundSchema: z.ZodType<S3AwsAuthenticationMethodAutoExtractor$Outbound, z.ZodTypeDef, S3AwsAuthenticationMethodAutoExtractor>;
+export declare function s3AwsAuthenticationMethodAutoExtractorToJSON(s3AwsAuthenticationMethodAutoExtractor: S3AwsAuthenticationMethodAutoExtractor): string;
+export declare function s3AwsAuthenticationMethodAutoExtractorFromJSON(jsonString: string): SafeParseResult<S3AwsAuthenticationMethodAutoExtractor, SDKValidationError>;
+/** @internal */
+export declare const S3AwsAuthenticationMethodAutoSignatureVersion$inboundSchema: z.ZodType<S3AwsAuthenticationMethodAutoSignatureVersion, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const S3AwsAuthenticationMethodAutoSignatureVersion$outboundSchema: z.ZodType<string, z.ZodTypeDef, S3AwsAuthenticationMethodAutoSignatureVersion>;
+/** @internal */
+export declare const S3AwsAuthenticationMethodAuto$inboundSchema: z.ZodType<S3AwsAuthenticationMethodAuto, z.ZodTypeDef, unknown>;
+/** @internal */
+export type S3AwsAuthenticationMethodAuto$Outbound = {
+    awsAuthenticationMethod: "auto";
+    outputName?: string | undefined;
+    bucket: string;
+    parquetChunkSizeMB: number;
+    parquetChunkDownloadTimeout: number;
+    region?: string | undefined;
+    path?: string | undefined;
+    partitioningScheme: string;
+    extractors?: Array<S3AwsAuthenticationMethodAutoExtractor$Outbound> | undefined;
+    endpoint?: string | undefined;
+    signatureVersion: string;
+    enableAssumeRole: boolean;
+    assumeRoleArn?: string | undefined;
+    assumeRoleExternalId?: string | undefined;
+    durationSeconds: number;
+    maxBatchSize: number;
+    recurse?: any | undefined;
+    reuseConnections: boolean;
+    rejectUnauthorized: boolean;
+    verifyPermissions: boolean;
+    disableTimeFilter: boolean;
+};
+/** @internal */
+export declare const S3AwsAuthenticationMethodAuto$outboundSchema: z.ZodType<S3AwsAuthenticationMethodAuto$Outbound, z.ZodTypeDef, S3AwsAuthenticationMethodAuto>;
+export declare function s3AwsAuthenticationMethodAutoToJSON(s3AwsAuthenticationMethodAuto: S3AwsAuthenticationMethodAuto): string;
+export declare function s3AwsAuthenticationMethodAutoFromJSON(jsonString: string): SafeParseResult<S3AwsAuthenticationMethodAuto, SDKValidationError>;
+/** @internal */
+export declare const S3PartitioningSchemeNonePartitioningScheme$inboundSchema: z.ZodType<S3PartitioningSchemeNonePartitioningScheme, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const S3PartitioningSchemeNonePartitioningScheme$outboundSchema: z.ZodType<string, z.ZodTypeDef, S3PartitioningSchemeNonePartitioningScheme>;
+/** @internal */
+export declare const S3PartitioningSchemeNoneExtractor$inboundSchema: z.ZodType<S3PartitioningSchemeNoneExtractor, z.ZodTypeDef, unknown>;
+/** @internal */
+export type S3PartitioningSchemeNoneExtractor$Outbound = {
+    key: string;
+    expression: string;
+};
+/** @internal */
+export declare const S3PartitioningSchemeNoneExtractor$outboundSchema: z.ZodType<S3PartitioningSchemeNoneExtractor$Outbound, z.ZodTypeDef, S3PartitioningSchemeNoneExtractor>;
+export declare function s3PartitioningSchemeNoneExtractorToJSON(s3PartitioningSchemeNoneExtractor: S3PartitioningSchemeNoneExtractor): string;
+export declare function s3PartitioningSchemeNoneExtractorFromJSON(jsonString: string): SafeParseResult<S3PartitioningSchemeNoneExtractor, SDKValidationError>;
+/** @internal */
+export declare const S3PartitioningSchemeNoneAuthenticationMethod$inboundSchema: z.ZodType<S3PartitioningSchemeNoneAuthenticationMethod, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const S3PartitioningSchemeNoneAuthenticationMethod$outboundSchema: z.ZodType<string, z.ZodTypeDef, S3PartitioningSchemeNoneAuthenticationMethod>;
+/** @internal */
+export declare const S3PartitioningSchemeNoneSignatureVersion$inboundSchema: z.ZodType<S3PartitioningSchemeNoneSignatureVersion, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const S3PartitioningSchemeNoneSignatureVersion$outboundSchema: z.ZodType<string, z.ZodTypeDef, S3PartitioningSchemeNoneSignatureVersion>;
+/** @internal */
+export declare const S3PartitioningSchemeNone$inboundSchema: z.ZodType<S3PartitioningSchemeNone, z.ZodTypeDef, unknown>;
+/** @internal */
+export type S3PartitioningSchemeNone$Outbound = {
+    partitioningScheme: string;
+    recurse?: any | undefined;
+    outputName?: string | undefined;
+    bucket: string;
+    parquetChunkSizeMB: number;
+    parquetChunkDownloadTimeout: number;
+    region?: string | undefined;
+    path?: string | undefined;
+    extractors?: Array<S3PartitioningSchemeNoneExtractor$Outbound> | undefined;
+    awsAuthenticationMethod: string;
+    endpoint?: string | undefined;
+    signatureVersion: string;
+    enableAssumeRole: boolean;
+    assumeRoleArn?: string | undefined;
+    assumeRoleExternalId?: string | undefined;
+    durationSeconds: number;
+    maxBatchSize: number;
+    reuseConnections: boolean;
+    rejectUnauthorized: boolean;
+    verifyPermissions: boolean;
+    disableTimeFilter: boolean;
+};
+/** @internal */
+export declare const S3PartitioningSchemeNone$outboundSchema: z.ZodType<S3PartitioningSchemeNone$Outbound, z.ZodTypeDef, S3PartitioningSchemeNone>;
+export declare function s3PartitioningSchemeNoneToJSON(s3PartitioningSchemeNone: S3PartitioningSchemeNone): string;
+export declare function s3PartitioningSchemeNoneFromJSON(jsonString: string): SafeParseResult<S3PartitioningSchemeNone, SDKValidationError>;
+/** @internal */
+export declare const S3PartitioningSchemeDdssPartitioningScheme$inboundSchema: z.ZodType<S3PartitioningSchemeDdssPartitioningScheme, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const S3PartitioningSchemeDdssPartitioningScheme$outboundSchema: z.ZodType<string, z.ZodTypeDef, S3PartitioningSchemeDdssPartitioningScheme>;
+/** @internal */
+export declare const S3PartitioningSchemeDdssExtractor$inboundSchema: z.ZodType<S3PartitioningSchemeDdssExtractor, z.ZodTypeDef, unknown>;
+/** @internal */
+export type S3PartitioningSchemeDdssExtractor$Outbound = {
+    key: string;
+    expression: string;
+};
+/** @internal */
+export declare const S3PartitioningSchemeDdssExtractor$outboundSchema: z.ZodType<S3PartitioningSchemeDdssExtractor$Outbound, z.ZodTypeDef, S3PartitioningSchemeDdssExtractor>;
+export declare function s3PartitioningSchemeDdssExtractorToJSON(s3PartitioningSchemeDdssExtractor: S3PartitioningSchemeDdssExtractor): string;
+export declare function s3PartitioningSchemeDdssExtractorFromJSON(jsonString: string): SafeParseResult<S3PartitioningSchemeDdssExtractor, SDKValidationError>;
+/** @internal */
+export declare const S3PartitioningSchemeDdssAuthenticationMethod$inboundSchema: z.ZodType<S3PartitioningSchemeDdssAuthenticationMethod, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const S3PartitioningSchemeDdssAuthenticationMethod$outboundSchema: z.ZodType<string, z.ZodTypeDef, S3PartitioningSchemeDdssAuthenticationMethod>;
+/** @internal */
+export declare const S3PartitioningSchemeDdssSignatureVersion$inboundSchema: z.ZodType<S3PartitioningSchemeDdssSignatureVersion, z.ZodTypeDef, unknown>;
+/** @internal */
+export declare const S3PartitioningSchemeDdssSignatureVersion$outboundSchema: z.ZodType<string, z.ZodTypeDef, S3PartitioningSchemeDdssSignatureVersion>;
+/** @internal */
+export declare const S3PartitioningSchemeDdss$inboundSchema: z.ZodType<S3PartitioningSchemeDdss, z.ZodTypeDef, unknown>;
+/** @internal */
+export type S3PartitioningSchemeDdss$Outbound = {
+    partitioningScheme: string;
+    outputName?: string | undefined;
+    bucket: string;
+    parquetChunkSizeMB: number;
+    parquetChunkDownloadTimeout: number;
+    region?: string | undefined;
+    path?: string | undefined;
+    extractors?: Array<S3PartitioningSchemeDdssExtractor$Outbound> | undefined;
+    awsAuthenticationMethod: string;
+    endpoint?: string | undefined;
+    signatureVersion: string;
+    enableAssumeRole: boolean;
+    assumeRoleArn?: string | undefined;
+    assumeRoleExternalId?: string | undefined;
+    durationSeconds: number;
+    maxBatchSize: number;
+    recurse?: any | undefined;
+    reuseConnections: boolean;
+    rejectUnauthorized: boolean;
+    verifyPermissions: boolean;
+    disableTimeFilter: boolean;
+};
+/** @internal */
+export declare const S3PartitioningSchemeDdss$outboundSchema: z.ZodType<S3PartitioningSchemeDdss$Outbound, z.ZodTypeDef, S3PartitioningSchemeDdss>;
+export declare function s3PartitioningSchemeDdssToJSON(s3PartitioningSchemeDdss: S3PartitioningSchemeDdss): string;
+export declare function s3PartitioningSchemeDdssFromJSON(jsonString: string): SafeParseResult<S3PartitioningSchemeDdss, SDKValidationError>;
+/** @internal */
+export declare const S3CollectorConf$inboundSchema: z.ZodType<S3CollectorConf, z.ZodTypeDef, unknown>;
+/** @internal */
+export type S3CollectorConf$Outbound = S3AwsAuthenticationMethodAuto$Outbound | S3AwsAuthenticationMethodManual$Outbound | S3AwsAuthenticationMethodSecret$Outbound;
+/** @internal */
+export declare const S3CollectorConf$outboundSchema: z.ZodType<S3CollectorConf$Outbound, z.ZodTypeDef, S3CollectorConf>;
+export declare function s3CollectorConfToJSON(s3CollectorConf: S3CollectorConf): string;
+export declare function s3CollectorConfFromJSON(jsonString: string): SafeParseResult<S3CollectorConf, SDKValidationError>;
+//# sourceMappingURL=s3collectorconf.d.ts.map