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

package/src/models/s3collectorconf.ts

@@ -0,0 +1,1760 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../lib/schemas.js";
+import * as openEnums from "../types/enums.js";
+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 const S3AwsAuthenticationMethodSecretPartitioningScheme = {
+  /**
+   * Defined in Path
+   */
+  None: "none",
+  /**
+   * DDSS
+   */
+  Ddss: "ddss",
+} as const;
+/**
+ * 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 const S3AwsAuthenticationMethodSecretSignatureVersion = {
+  V2: "v2",
+  V4: "v4",
+} as const;
+/**
+ * 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 const S3AwsAuthenticationMethodManualPartitioningScheme = {
+  /**
+   * Defined in Path
+   */
+  None: "none",
+  /**
+   * DDSS
+   */
+  Ddss: "ddss",
+} as const;
+/**
+ * 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 const S3AwsAuthenticationMethodManualSignatureVersion = {
+  V2: "v2",
+  V4: "v4",
+} as const;
+/**
+ * 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 const S3AwsAuthenticationMethodAutoPartitioningScheme = {
+  /**
+   * Defined in Path
+   */
+  None: "none",
+  /**
+   * DDSS
+   */
+  Ddss: "ddss",
+} as const;
+/**
+ * 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 const S3AwsAuthenticationMethodAutoSignatureVersion = {
+  V2: "v2",
+  V4: "v4",
+} as const;
+/**
+ * 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 const S3PartitioningSchemeNonePartitioningScheme = {
+  /**
+   * Defined in Path
+   */
+  None: "none",
+  /**
+   * DDSS
+   */
+  Ddss: "ddss",
+} as const;
+/**
+ * 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 const S3PartitioningSchemeNoneAuthenticationMethod = {
+  /**
+   * Auto
+   */
+  Auto: "auto",
+  /**
+   * Manual
+   */
+  Manual: "manual",
+  /**
+   * Secret Key pair
+   */
+  Secret: "secret",
+} as const;
+/**
+ * AWS authentication method. Choose Auto to use IAM roles.
+ */
+export type S3PartitioningSchemeNoneAuthenticationMethod = OpenEnum<
+  typeof S3PartitioningSchemeNoneAuthenticationMethod
+>;
+
+/**
+ * Signature version to use for signing S3 requests
+ */
+export const S3PartitioningSchemeNoneSignatureVersion = {
+  V2: "v2",
+  V4: "v4",
+} as const;
+/**
+ * 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 const S3PartitioningSchemeDdssPartitioningScheme = {
+  /**
+   * Defined in Path
+   */
+  None: "none",
+  /**
+   * DDSS
+   */
+  Ddss: "ddss",
+} as const;
+/**
+ * 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 const S3PartitioningSchemeDdssAuthenticationMethod = {
+  /**
+   * Auto
+   */
+  Auto: "auto",
+  /**
+   * Manual
+   */
+  Manual: "manual",
+  /**
+   * Secret Key pair
+   */
+  Secret: "secret",
+} as const;
+/**
+ * AWS authentication method. Choose Auto to use IAM roles.
+ */
+export type S3PartitioningSchemeDdssAuthenticationMethod = OpenEnum<
+  typeof S3PartitioningSchemeDdssAuthenticationMethod
+>;
+
+/**
+ * Signature version to use for signing S3 requests
+ */
+export const S3PartitioningSchemeDdssSignatureVersion = {
+  V2: "v2",
+  V4: "v4",
+} as const;
+/**
+ * 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 const S3AwsAuthenticationMethodSecretPartitioningScheme$inboundSchema:
+  z.ZodType<
+    S3AwsAuthenticationMethodSecretPartitioningScheme,
+    z.ZodTypeDef,
+    unknown
+  > = openEnums.inboundSchema(
+    S3AwsAuthenticationMethodSecretPartitioningScheme,
+  );
+/** @internal */
+export const S3AwsAuthenticationMethodSecretPartitioningScheme$outboundSchema:
+  z.ZodType<
+    string,
+    z.ZodTypeDef,
+    S3AwsAuthenticationMethodSecretPartitioningScheme
+  > = openEnums.outboundSchema(
+    S3AwsAuthenticationMethodSecretPartitioningScheme,
+  );
+
+/** @internal */
+export const S3AwsAuthenticationMethodSecretExtractor$inboundSchema: z.ZodType<
+  S3AwsAuthenticationMethodSecretExtractor,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  key: z.string(),
+  expression: z.string(),
+});
+/** @internal */
+export type S3AwsAuthenticationMethodSecretExtractor$Outbound = {
+  key: string;
+  expression: string;
+};
+
+/** @internal */
+export const S3AwsAuthenticationMethodSecretExtractor$outboundSchema: z.ZodType<
+  S3AwsAuthenticationMethodSecretExtractor$Outbound,
+  z.ZodTypeDef,
+  S3AwsAuthenticationMethodSecretExtractor
+> = z.object({
+  key: z.string(),
+  expression: z.string(),
+});
+
+export function s3AwsAuthenticationMethodSecretExtractorToJSON(
+  s3AwsAuthenticationMethodSecretExtractor:
+    S3AwsAuthenticationMethodSecretExtractor,
+): string {
+  return JSON.stringify(
+    S3AwsAuthenticationMethodSecretExtractor$outboundSchema.parse(
+      s3AwsAuthenticationMethodSecretExtractor,
+    ),
+  );
+}
+export function s3AwsAuthenticationMethodSecretExtractorFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  S3AwsAuthenticationMethodSecretExtractor,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      S3AwsAuthenticationMethodSecretExtractor$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'S3AwsAuthenticationMethodSecretExtractor' from JSON`,
+  );
+}
+
+/** @internal */
+export const S3AwsAuthenticationMethodSecretSignatureVersion$inboundSchema:
+  z.ZodType<
+    S3AwsAuthenticationMethodSecretSignatureVersion,
+    z.ZodTypeDef,
+    unknown
+  > = openEnums.inboundSchema(S3AwsAuthenticationMethodSecretSignatureVersion);
+/** @internal */
+export const S3AwsAuthenticationMethodSecretSignatureVersion$outboundSchema:
+  z.ZodType<
+    string,
+    z.ZodTypeDef,
+    S3AwsAuthenticationMethodSecretSignatureVersion
+  > = openEnums.outboundSchema(S3AwsAuthenticationMethodSecretSignatureVersion);
+
+/** @internal */
+export const S3AwsAuthenticationMethodSecret$inboundSchema: z.ZodType<
+  S3AwsAuthenticationMethodSecret,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  awsAuthenticationMethod: z.literal("secret"),
+  awsSecret: z.string().optional(),
+  outputName: z.string().optional(),
+  bucket: z.string(),
+  parquetChunkSizeMB: z.number().default(5),
+  parquetChunkDownloadTimeout: z.number().default(600),
+  region: z.string().optional(),
+  path: z.string().optional(),
+  partitioningScheme:
+    S3AwsAuthenticationMethodSecretPartitioningScheme$inboundSchema.default(
+      "none",
+    ),
+  extractors: z.array(
+    z.lazy(() => S3AwsAuthenticationMethodSecretExtractor$inboundSchema),
+  ).optional(),
+  endpoint: z.string().optional(),
+  signatureVersion:
+    S3AwsAuthenticationMethodSecretSignatureVersion$inboundSchema.default("v4"),
+  enableAssumeRole: z.boolean().default(false),
+  assumeRoleArn: z.string().optional(),
+  assumeRoleExternalId: z.string().optional(),
+  durationSeconds: z.number().default(3600),
+  maxBatchSize: z.number().default(10),
+  recurse: z.any().optional(),
+  reuseConnections: z.boolean().default(true),
+  rejectUnauthorized: z.boolean().default(true),
+  verifyPermissions: z.boolean().default(true),
+  disableTimeFilter: z.boolean().default(false),
+});
+/** @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 const S3AwsAuthenticationMethodSecret$outboundSchema: z.ZodType<
+  S3AwsAuthenticationMethodSecret$Outbound,
+  z.ZodTypeDef,
+  S3AwsAuthenticationMethodSecret
+> = z.object({
+  awsAuthenticationMethod: z.literal("secret"),
+  awsSecret: z.string().optional(),
+  outputName: z.string().optional(),
+  bucket: z.string(),
+  parquetChunkSizeMB: z.number().default(5),
+  parquetChunkDownloadTimeout: z.number().default(600),
+  region: z.string().optional(),
+  path: z.string().optional(),
+  partitioningScheme:
+    S3AwsAuthenticationMethodSecretPartitioningScheme$outboundSchema.default(
+      "none",
+    ),
+  extractors: z.array(
+    z.lazy(() => S3AwsAuthenticationMethodSecretExtractor$outboundSchema),
+  ).optional(),
+  endpoint: z.string().optional(),
+  signatureVersion:
+    S3AwsAuthenticationMethodSecretSignatureVersion$outboundSchema.default(
+      "v4",
+    ),
+  enableAssumeRole: z.boolean().default(false),
+  assumeRoleArn: z.string().optional(),
+  assumeRoleExternalId: z.string().optional(),
+  durationSeconds: z.number().default(3600),
+  maxBatchSize: z.number().default(10),
+  recurse: z.any().optional(),
+  reuseConnections: z.boolean().default(true),
+  rejectUnauthorized: z.boolean().default(true),
+  verifyPermissions: z.boolean().default(true),
+  disableTimeFilter: z.boolean().default(false),
+});
+
+export function s3AwsAuthenticationMethodSecretToJSON(
+  s3AwsAuthenticationMethodSecret: S3AwsAuthenticationMethodSecret,
+): string {
+  return JSON.stringify(
+    S3AwsAuthenticationMethodSecret$outboundSchema.parse(
+      s3AwsAuthenticationMethodSecret,
+    ),
+  );
+}
+export function s3AwsAuthenticationMethodSecretFromJSON(
+  jsonString: string,
+): SafeParseResult<S3AwsAuthenticationMethodSecret, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => S3AwsAuthenticationMethodSecret$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'S3AwsAuthenticationMethodSecret' from JSON`,
+  );
+}
+
+/** @internal */
+export const S3AwsAuthenticationMethodManualPartitioningScheme$inboundSchema:
+  z.ZodType<
+    S3AwsAuthenticationMethodManualPartitioningScheme,
+    z.ZodTypeDef,
+    unknown
+  > = openEnums.inboundSchema(
+    S3AwsAuthenticationMethodManualPartitioningScheme,
+  );
+/** @internal */
+export const S3AwsAuthenticationMethodManualPartitioningScheme$outboundSchema:
+  z.ZodType<
+    string,
+    z.ZodTypeDef,
+    S3AwsAuthenticationMethodManualPartitioningScheme
+  > = openEnums.outboundSchema(
+    S3AwsAuthenticationMethodManualPartitioningScheme,
+  );
+
+/** @internal */
+export const S3AwsAuthenticationMethodManualExtractor$inboundSchema: z.ZodType<
+  S3AwsAuthenticationMethodManualExtractor,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  key: z.string(),
+  expression: z.string(),
+});
+/** @internal */
+export type S3AwsAuthenticationMethodManualExtractor$Outbound = {
+  key: string;
+  expression: string;
+};
+
+/** @internal */
+export const S3AwsAuthenticationMethodManualExtractor$outboundSchema: z.ZodType<
+  S3AwsAuthenticationMethodManualExtractor$Outbound,
+  z.ZodTypeDef,
+  S3AwsAuthenticationMethodManualExtractor
+> = z.object({
+  key: z.string(),
+  expression: z.string(),
+});
+
+export function s3AwsAuthenticationMethodManualExtractorToJSON(
+  s3AwsAuthenticationMethodManualExtractor:
+    S3AwsAuthenticationMethodManualExtractor,
+): string {
+  return JSON.stringify(
+    S3AwsAuthenticationMethodManualExtractor$outboundSchema.parse(
+      s3AwsAuthenticationMethodManualExtractor,
+    ),
+  );
+}
+export function s3AwsAuthenticationMethodManualExtractorFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  S3AwsAuthenticationMethodManualExtractor,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      S3AwsAuthenticationMethodManualExtractor$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'S3AwsAuthenticationMethodManualExtractor' from JSON`,
+  );
+}
+
+/** @internal */
+export const S3AwsAuthenticationMethodManualSignatureVersion$inboundSchema:
+  z.ZodType<
+    S3AwsAuthenticationMethodManualSignatureVersion,
+    z.ZodTypeDef,
+    unknown
+  > = openEnums.inboundSchema(S3AwsAuthenticationMethodManualSignatureVersion);
+/** @internal */
+export const S3AwsAuthenticationMethodManualSignatureVersion$outboundSchema:
+  z.ZodType<
+    string,
+    z.ZodTypeDef,
+    S3AwsAuthenticationMethodManualSignatureVersion
+  > = openEnums.outboundSchema(S3AwsAuthenticationMethodManualSignatureVersion);
+
+/** @internal */
+export const S3AwsAuthenticationMethodManual$inboundSchema: z.ZodType<
+  S3AwsAuthenticationMethodManual,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  awsAuthenticationMethod: z.literal("manual"),
+  awsApiKey: z.string().optional(),
+  awsSecretKey: z.string().optional(),
+  outputName: z.string().optional(),
+  bucket: z.string(),
+  parquetChunkSizeMB: z.number().default(5),
+  parquetChunkDownloadTimeout: z.number().default(600),
+  region: z.string().optional(),
+  path: z.string().optional(),
+  partitioningScheme:
+    S3AwsAuthenticationMethodManualPartitioningScheme$inboundSchema.default(
+      "none",
+    ),
+  extractors: z.array(
+    z.lazy(() => S3AwsAuthenticationMethodManualExtractor$inboundSchema),
+  ).optional(),
+  endpoint: z.string().optional(),
+  signatureVersion:
+    S3AwsAuthenticationMethodManualSignatureVersion$inboundSchema.default("v4"),
+  enableAssumeRole: z.boolean().default(false),
+  assumeRoleArn: z.string().optional(),
+  assumeRoleExternalId: z.string().optional(),
+  durationSeconds: z.number().default(3600),
+  maxBatchSize: z.number().default(10),
+  recurse: z.any().optional(),
+  reuseConnections: z.boolean().default(true),
+  rejectUnauthorized: z.boolean().default(true),
+  verifyPermissions: z.boolean().default(true),
+  disableTimeFilter: z.boolean().default(false),
+});
+/** @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 const S3AwsAuthenticationMethodManual$outboundSchema: z.ZodType<
+  S3AwsAuthenticationMethodManual$Outbound,
+  z.ZodTypeDef,
+  S3AwsAuthenticationMethodManual
+> = z.object({
+  awsAuthenticationMethod: z.literal("manual"),
+  awsApiKey: z.string().optional(),
+  awsSecretKey: z.string().optional(),
+  outputName: z.string().optional(),
+  bucket: z.string(),
+  parquetChunkSizeMB: z.number().default(5),
+  parquetChunkDownloadTimeout: z.number().default(600),
+  region: z.string().optional(),
+  path: z.string().optional(),
+  partitioningScheme:
+    S3AwsAuthenticationMethodManualPartitioningScheme$outboundSchema.default(
+      "none",
+    ),
+  extractors: z.array(
+    z.lazy(() => S3AwsAuthenticationMethodManualExtractor$outboundSchema),
+  ).optional(),
+  endpoint: z.string().optional(),
+  signatureVersion:
+    S3AwsAuthenticationMethodManualSignatureVersion$outboundSchema.default(
+      "v4",
+    ),
+  enableAssumeRole: z.boolean().default(false),
+  assumeRoleArn: z.string().optional(),
+  assumeRoleExternalId: z.string().optional(),
+  durationSeconds: z.number().default(3600),
+  maxBatchSize: z.number().default(10),
+  recurse: z.any().optional(),
+  reuseConnections: z.boolean().default(true),
+  rejectUnauthorized: z.boolean().default(true),
+  verifyPermissions: z.boolean().default(true),
+  disableTimeFilter: z.boolean().default(false),
+});
+
+export function s3AwsAuthenticationMethodManualToJSON(
+  s3AwsAuthenticationMethodManual: S3AwsAuthenticationMethodManual,
+): string {
+  return JSON.stringify(
+    S3AwsAuthenticationMethodManual$outboundSchema.parse(
+      s3AwsAuthenticationMethodManual,
+    ),
+  );
+}
+export function s3AwsAuthenticationMethodManualFromJSON(
+  jsonString: string,
+): SafeParseResult<S3AwsAuthenticationMethodManual, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => S3AwsAuthenticationMethodManual$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'S3AwsAuthenticationMethodManual' from JSON`,
+  );
+}
+
+/** @internal */
+export const S3AwsAuthenticationMethodAutoPartitioningScheme$inboundSchema:
+  z.ZodType<
+    S3AwsAuthenticationMethodAutoPartitioningScheme,
+    z.ZodTypeDef,
+    unknown
+  > = openEnums.inboundSchema(S3AwsAuthenticationMethodAutoPartitioningScheme);
+/** @internal */
+export const S3AwsAuthenticationMethodAutoPartitioningScheme$outboundSchema:
+  z.ZodType<
+    string,
+    z.ZodTypeDef,
+    S3AwsAuthenticationMethodAutoPartitioningScheme
+  > = openEnums.outboundSchema(S3AwsAuthenticationMethodAutoPartitioningScheme);
+
+/** @internal */
+export const S3AwsAuthenticationMethodAutoExtractor$inboundSchema: z.ZodType<
+  S3AwsAuthenticationMethodAutoExtractor,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  key: z.string(),
+  expression: z.string(),
+});
+/** @internal */
+export type S3AwsAuthenticationMethodAutoExtractor$Outbound = {
+  key: string;
+  expression: string;
+};
+
+/** @internal */
+export const S3AwsAuthenticationMethodAutoExtractor$outboundSchema: z.ZodType<
+  S3AwsAuthenticationMethodAutoExtractor$Outbound,
+  z.ZodTypeDef,
+  S3AwsAuthenticationMethodAutoExtractor
+> = z.object({
+  key: z.string(),
+  expression: z.string(),
+});
+
+export function s3AwsAuthenticationMethodAutoExtractorToJSON(
+  s3AwsAuthenticationMethodAutoExtractor:
+    S3AwsAuthenticationMethodAutoExtractor,
+): string {
+  return JSON.stringify(
+    S3AwsAuthenticationMethodAutoExtractor$outboundSchema.parse(
+      s3AwsAuthenticationMethodAutoExtractor,
+    ),
+  );
+}
+export function s3AwsAuthenticationMethodAutoExtractorFromJSON(
+  jsonString: string,
+): SafeParseResult<S3AwsAuthenticationMethodAutoExtractor, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      S3AwsAuthenticationMethodAutoExtractor$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'S3AwsAuthenticationMethodAutoExtractor' from JSON`,
+  );
+}
+
+/** @internal */
+export const S3AwsAuthenticationMethodAutoSignatureVersion$inboundSchema:
+  z.ZodType<
+    S3AwsAuthenticationMethodAutoSignatureVersion,
+    z.ZodTypeDef,
+    unknown
+  > = openEnums.inboundSchema(S3AwsAuthenticationMethodAutoSignatureVersion);
+/** @internal */
+export const S3AwsAuthenticationMethodAutoSignatureVersion$outboundSchema:
+  z.ZodType<
+    string,
+    z.ZodTypeDef,
+    S3AwsAuthenticationMethodAutoSignatureVersion
+  > = openEnums.outboundSchema(S3AwsAuthenticationMethodAutoSignatureVersion);
+
+/** @internal */
+export const S3AwsAuthenticationMethodAuto$inboundSchema: z.ZodType<
+  S3AwsAuthenticationMethodAuto,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  awsAuthenticationMethod: z.literal("auto"),
+  outputName: z.string().optional(),
+  bucket: z.string(),
+  parquetChunkSizeMB: z.number().default(5),
+  parquetChunkDownloadTimeout: z.number().default(600),
+  region: z.string().optional(),
+  path: z.string().optional(),
+  partitioningScheme:
+    S3AwsAuthenticationMethodAutoPartitioningScheme$inboundSchema.default(
+      "none",
+    ),
+  extractors: z.array(
+    z.lazy(() => S3AwsAuthenticationMethodAutoExtractor$inboundSchema),
+  ).optional(),
+  endpoint: z.string().optional(),
+  signatureVersion: S3AwsAuthenticationMethodAutoSignatureVersion$inboundSchema
+    .default("v4"),
+  enableAssumeRole: z.boolean().default(false),
+  assumeRoleArn: z.string().optional(),
+  assumeRoleExternalId: z.string().optional(),
+  durationSeconds: z.number().default(3600),
+  maxBatchSize: z.number().default(10),
+  recurse: z.any().optional(),
+  reuseConnections: z.boolean().default(true),
+  rejectUnauthorized: z.boolean().default(true),
+  verifyPermissions: z.boolean().default(true),
+  disableTimeFilter: z.boolean().default(false),
+});
+/** @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 const S3AwsAuthenticationMethodAuto$outboundSchema: z.ZodType<
+  S3AwsAuthenticationMethodAuto$Outbound,
+  z.ZodTypeDef,
+  S3AwsAuthenticationMethodAuto
+> = z.object({
+  awsAuthenticationMethod: z.literal("auto"),
+  outputName: z.string().optional(),
+  bucket: z.string(),
+  parquetChunkSizeMB: z.number().default(5),
+  parquetChunkDownloadTimeout: z.number().default(600),
+  region: z.string().optional(),
+  path: z.string().optional(),
+  partitioningScheme:
+    S3AwsAuthenticationMethodAutoPartitioningScheme$outboundSchema.default(
+      "none",
+    ),
+  extractors: z.array(
+    z.lazy(() => S3AwsAuthenticationMethodAutoExtractor$outboundSchema),
+  ).optional(),
+  endpoint: z.string().optional(),
+  signatureVersion: S3AwsAuthenticationMethodAutoSignatureVersion$outboundSchema
+    .default("v4"),
+  enableAssumeRole: z.boolean().default(false),
+  assumeRoleArn: z.string().optional(),
+  assumeRoleExternalId: z.string().optional(),
+  durationSeconds: z.number().default(3600),
+  maxBatchSize: z.number().default(10),
+  recurse: z.any().optional(),
+  reuseConnections: z.boolean().default(true),
+  rejectUnauthorized: z.boolean().default(true),
+  verifyPermissions: z.boolean().default(true),
+  disableTimeFilter: z.boolean().default(false),
+});
+
+export function s3AwsAuthenticationMethodAutoToJSON(
+  s3AwsAuthenticationMethodAuto: S3AwsAuthenticationMethodAuto,
+): string {
+  return JSON.stringify(
+    S3AwsAuthenticationMethodAuto$outboundSchema.parse(
+      s3AwsAuthenticationMethodAuto,
+    ),
+  );
+}
+export function s3AwsAuthenticationMethodAutoFromJSON(
+  jsonString: string,
+): SafeParseResult<S3AwsAuthenticationMethodAuto, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => S3AwsAuthenticationMethodAuto$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'S3AwsAuthenticationMethodAuto' from JSON`,
+  );
+}
+
+/** @internal */
+export const S3PartitioningSchemeNonePartitioningScheme$inboundSchema:
+  z.ZodType<S3PartitioningSchemeNonePartitioningScheme, z.ZodTypeDef, unknown> =
+    openEnums.inboundSchema(S3PartitioningSchemeNonePartitioningScheme);
+/** @internal */
+export const S3PartitioningSchemeNonePartitioningScheme$outboundSchema:
+  z.ZodType<string, z.ZodTypeDef, S3PartitioningSchemeNonePartitioningScheme> =
+    openEnums.outboundSchema(S3PartitioningSchemeNonePartitioningScheme);
+
+/** @internal */
+export const S3PartitioningSchemeNoneExtractor$inboundSchema: z.ZodType<
+  S3PartitioningSchemeNoneExtractor,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  key: z.string(),
+  expression: z.string(),
+});
+/** @internal */
+export type S3PartitioningSchemeNoneExtractor$Outbound = {
+  key: string;
+  expression: string;
+};
+
+/** @internal */
+export const S3PartitioningSchemeNoneExtractor$outboundSchema: z.ZodType<
+  S3PartitioningSchemeNoneExtractor$Outbound,
+  z.ZodTypeDef,
+  S3PartitioningSchemeNoneExtractor
+> = z.object({
+  key: z.string(),
+  expression: z.string(),
+});
+
+export function s3PartitioningSchemeNoneExtractorToJSON(
+  s3PartitioningSchemeNoneExtractor: S3PartitioningSchemeNoneExtractor,
+): string {
+  return JSON.stringify(
+    S3PartitioningSchemeNoneExtractor$outboundSchema.parse(
+      s3PartitioningSchemeNoneExtractor,
+    ),
+  );
+}
+export function s3PartitioningSchemeNoneExtractorFromJSON(
+  jsonString: string,
+): SafeParseResult<S3PartitioningSchemeNoneExtractor, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => S3PartitioningSchemeNoneExtractor$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'S3PartitioningSchemeNoneExtractor' from JSON`,
+  );
+}
+
+/** @internal */
+export const S3PartitioningSchemeNoneAuthenticationMethod$inboundSchema:
+  z.ZodType<
+    S3PartitioningSchemeNoneAuthenticationMethod,
+    z.ZodTypeDef,
+    unknown
+  > = openEnums.inboundSchema(S3PartitioningSchemeNoneAuthenticationMethod);
+/** @internal */
+export const S3PartitioningSchemeNoneAuthenticationMethod$outboundSchema:
+  z.ZodType<
+    string,
+    z.ZodTypeDef,
+    S3PartitioningSchemeNoneAuthenticationMethod
+  > = openEnums.outboundSchema(S3PartitioningSchemeNoneAuthenticationMethod);
+
+/** @internal */
+export const S3PartitioningSchemeNoneSignatureVersion$inboundSchema: z.ZodType<
+  S3PartitioningSchemeNoneSignatureVersion,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(S3PartitioningSchemeNoneSignatureVersion);
+/** @internal */
+export const S3PartitioningSchemeNoneSignatureVersion$outboundSchema: z.ZodType<
+  string,
+  z.ZodTypeDef,
+  S3PartitioningSchemeNoneSignatureVersion
+> = openEnums.outboundSchema(S3PartitioningSchemeNoneSignatureVersion);
+
+/** @internal */
+export const S3PartitioningSchemeNone$inboundSchema: z.ZodType<
+  S3PartitioningSchemeNone,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  partitioningScheme: S3PartitioningSchemeNonePartitioningScheme$inboundSchema
+    .default("none"),
+  recurse: z.any().optional(),
+  outputName: z.string().optional(),
+  bucket: z.string(),
+  parquetChunkSizeMB: z.number().default(5),
+  parquetChunkDownloadTimeout: z.number().default(600),
+  region: z.string().optional(),
+  path: z.string().optional(),
+  extractors: z.array(
+    z.lazy(() => S3PartitioningSchemeNoneExtractor$inboundSchema),
+  ).optional(),
+  awsAuthenticationMethod:
+    S3PartitioningSchemeNoneAuthenticationMethod$inboundSchema.default("auto"),
+  endpoint: z.string().optional(),
+  signatureVersion: S3PartitioningSchemeNoneSignatureVersion$inboundSchema
+    .default("v4"),
+  enableAssumeRole: z.boolean().default(false),
+  assumeRoleArn: z.string().optional(),
+  assumeRoleExternalId: z.string().optional(),
+  durationSeconds: z.number().default(3600),
+  maxBatchSize: z.number().default(10),
+  reuseConnections: z.boolean().default(true),
+  rejectUnauthorized: z.boolean().default(true),
+  verifyPermissions: z.boolean().default(true),
+  disableTimeFilter: z.boolean().default(false),
+});
+/** @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 const S3PartitioningSchemeNone$outboundSchema: z.ZodType<
+  S3PartitioningSchemeNone$Outbound,
+  z.ZodTypeDef,
+  S3PartitioningSchemeNone
+> = z.object({
+  partitioningScheme: S3PartitioningSchemeNonePartitioningScheme$outboundSchema
+    .default("none"),
+  recurse: z.any().optional(),
+  outputName: z.string().optional(),
+  bucket: z.string(),
+  parquetChunkSizeMB: z.number().default(5),
+  parquetChunkDownloadTimeout: z.number().default(600),
+  region: z.string().optional(),
+  path: z.string().optional(),
+  extractors: z.array(
+    z.lazy(() => S3PartitioningSchemeNoneExtractor$outboundSchema),
+  ).optional(),
+  awsAuthenticationMethod:
+    S3PartitioningSchemeNoneAuthenticationMethod$outboundSchema.default("auto"),
+  endpoint: z.string().optional(),
+  signatureVersion: S3PartitioningSchemeNoneSignatureVersion$outboundSchema
+    .default("v4"),
+  enableAssumeRole: z.boolean().default(false),
+  assumeRoleArn: z.string().optional(),
+  assumeRoleExternalId: z.string().optional(),
+  durationSeconds: z.number().default(3600),
+  maxBatchSize: z.number().default(10),
+  reuseConnections: z.boolean().default(true),
+  rejectUnauthorized: z.boolean().default(true),
+  verifyPermissions: z.boolean().default(true),
+  disableTimeFilter: z.boolean().default(false),
+});
+
+export function s3PartitioningSchemeNoneToJSON(
+  s3PartitioningSchemeNone: S3PartitioningSchemeNone,
+): string {
+  return JSON.stringify(
+    S3PartitioningSchemeNone$outboundSchema.parse(s3PartitioningSchemeNone),
+  );
+}
+export function s3PartitioningSchemeNoneFromJSON(
+  jsonString: string,
+): SafeParseResult<S3PartitioningSchemeNone, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => S3PartitioningSchemeNone$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'S3PartitioningSchemeNone' from JSON`,
+  );
+}
+
+/** @internal */
+export const S3PartitioningSchemeDdssPartitioningScheme$inboundSchema:
+  z.ZodType<S3PartitioningSchemeDdssPartitioningScheme, z.ZodTypeDef, unknown> =
+    openEnums.inboundSchema(S3PartitioningSchemeDdssPartitioningScheme);
+/** @internal */
+export const S3PartitioningSchemeDdssPartitioningScheme$outboundSchema:
+  z.ZodType<string, z.ZodTypeDef, S3PartitioningSchemeDdssPartitioningScheme> =
+    openEnums.outboundSchema(S3PartitioningSchemeDdssPartitioningScheme);
+
+/** @internal */
+export const S3PartitioningSchemeDdssExtractor$inboundSchema: z.ZodType<
+  S3PartitioningSchemeDdssExtractor,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  key: z.string(),
+  expression: z.string(),
+});
+/** @internal */
+export type S3PartitioningSchemeDdssExtractor$Outbound = {
+  key: string;
+  expression: string;
+};
+
+/** @internal */
+export const S3PartitioningSchemeDdssExtractor$outboundSchema: z.ZodType<
+  S3PartitioningSchemeDdssExtractor$Outbound,
+  z.ZodTypeDef,
+  S3PartitioningSchemeDdssExtractor
+> = z.object({
+  key: z.string(),
+  expression: z.string(),
+});
+
+export function s3PartitioningSchemeDdssExtractorToJSON(
+  s3PartitioningSchemeDdssExtractor: S3PartitioningSchemeDdssExtractor,
+): string {
+  return JSON.stringify(
+    S3PartitioningSchemeDdssExtractor$outboundSchema.parse(
+      s3PartitioningSchemeDdssExtractor,
+    ),
+  );
+}
+export function s3PartitioningSchemeDdssExtractorFromJSON(
+  jsonString: string,
+): SafeParseResult<S3PartitioningSchemeDdssExtractor, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => S3PartitioningSchemeDdssExtractor$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'S3PartitioningSchemeDdssExtractor' from JSON`,
+  );
+}
+
+/** @internal */
+export const S3PartitioningSchemeDdssAuthenticationMethod$inboundSchema:
+  z.ZodType<
+    S3PartitioningSchemeDdssAuthenticationMethod,
+    z.ZodTypeDef,
+    unknown
+  > = openEnums.inboundSchema(S3PartitioningSchemeDdssAuthenticationMethod);
+/** @internal */
+export const S3PartitioningSchemeDdssAuthenticationMethod$outboundSchema:
+  z.ZodType<
+    string,
+    z.ZodTypeDef,
+    S3PartitioningSchemeDdssAuthenticationMethod
+  > = openEnums.outboundSchema(S3PartitioningSchemeDdssAuthenticationMethod);
+
+/** @internal */
+export const S3PartitioningSchemeDdssSignatureVersion$inboundSchema: z.ZodType<
+  S3PartitioningSchemeDdssSignatureVersion,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(S3PartitioningSchemeDdssSignatureVersion);
+/** @internal */
+export const S3PartitioningSchemeDdssSignatureVersion$outboundSchema: z.ZodType<
+  string,
+  z.ZodTypeDef,
+  S3PartitioningSchemeDdssSignatureVersion
+> = openEnums.outboundSchema(S3PartitioningSchemeDdssSignatureVersion);
+
+/** @internal */
+export const S3PartitioningSchemeDdss$inboundSchema: z.ZodType<
+  S3PartitioningSchemeDdss,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  partitioningScheme: S3PartitioningSchemeDdssPartitioningScheme$inboundSchema
+    .default("none"),
+  outputName: z.string().optional(),
+  bucket: z.string(),
+  parquetChunkSizeMB: z.number().default(5),
+  parquetChunkDownloadTimeout: z.number().default(600),
+  region: z.string().optional(),
+  path: z.string().optional(),
+  extractors: z.array(
+    z.lazy(() => S3PartitioningSchemeDdssExtractor$inboundSchema),
+  ).optional(),
+  awsAuthenticationMethod:
+    S3PartitioningSchemeDdssAuthenticationMethod$inboundSchema.default("auto"),
+  endpoint: z.string().optional(),
+  signatureVersion: S3PartitioningSchemeDdssSignatureVersion$inboundSchema
+    .default("v4"),
+  enableAssumeRole: z.boolean().default(false),
+  assumeRoleArn: z.string().optional(),
+  assumeRoleExternalId: z.string().optional(),
+  durationSeconds: z.number().default(3600),
+  maxBatchSize: z.number().default(10),
+  recurse: z.any().optional(),
+  reuseConnections: z.boolean().default(true),
+  rejectUnauthorized: z.boolean().default(true),
+  verifyPermissions: z.boolean().default(true),
+  disableTimeFilter: z.boolean().default(false),
+});
+/** @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 const S3PartitioningSchemeDdss$outboundSchema: z.ZodType<
+  S3PartitioningSchemeDdss$Outbound,
+  z.ZodTypeDef,
+  S3PartitioningSchemeDdss
+> = z.object({
+  partitioningScheme: S3PartitioningSchemeDdssPartitioningScheme$outboundSchema
+    .default("none"),
+  outputName: z.string().optional(),
+  bucket: z.string(),
+  parquetChunkSizeMB: z.number().default(5),
+  parquetChunkDownloadTimeout: z.number().default(600),
+  region: z.string().optional(),
+  path: z.string().optional(),
+  extractors: z.array(
+    z.lazy(() => S3PartitioningSchemeDdssExtractor$outboundSchema),
+  ).optional(),
+  awsAuthenticationMethod:
+    S3PartitioningSchemeDdssAuthenticationMethod$outboundSchema.default("auto"),
+  endpoint: z.string().optional(),
+  signatureVersion: S3PartitioningSchemeDdssSignatureVersion$outboundSchema
+    .default("v4"),
+  enableAssumeRole: z.boolean().default(false),
+  assumeRoleArn: z.string().optional(),
+  assumeRoleExternalId: z.string().optional(),
+  durationSeconds: z.number().default(3600),
+  maxBatchSize: z.number().default(10),
+  recurse: z.any().optional(),
+  reuseConnections: z.boolean().default(true),
+  rejectUnauthorized: z.boolean().default(true),
+  verifyPermissions: z.boolean().default(true),
+  disableTimeFilter: z.boolean().default(false),
+});
+
+export function s3PartitioningSchemeDdssToJSON(
+  s3PartitioningSchemeDdss: S3PartitioningSchemeDdss,
+): string {
+  return JSON.stringify(
+    S3PartitioningSchemeDdss$outboundSchema.parse(s3PartitioningSchemeDdss),
+  );
+}
+export function s3PartitioningSchemeDdssFromJSON(
+  jsonString: string,
+): SafeParseResult<S3PartitioningSchemeDdss, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => S3PartitioningSchemeDdss$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'S3PartitioningSchemeDdss' from JSON`,
+  );
+}
+
+/** @internal */
+export const S3CollectorConf$inboundSchema: z.ZodType<
+  S3CollectorConf,
+  z.ZodTypeDef,
+  unknown
+> = z.union([
+  z.lazy(() => S3AwsAuthenticationMethodAuto$inboundSchema),
+  z.lazy(() => S3AwsAuthenticationMethodManual$inboundSchema),
+  z.lazy(() => S3AwsAuthenticationMethodSecret$inboundSchema),
+]);
+/** @internal */
+export type S3CollectorConf$Outbound =
+  | S3AwsAuthenticationMethodAuto$Outbound
+  | S3AwsAuthenticationMethodManual$Outbound
+  | S3AwsAuthenticationMethodSecret$Outbound;
+
+/** @internal */
+export const S3CollectorConf$outboundSchema: z.ZodType<
+  S3CollectorConf$Outbound,
+  z.ZodTypeDef,
+  S3CollectorConf
+> = z.union([
+  z.lazy(() => S3AwsAuthenticationMethodAuto$outboundSchema),
+  z.lazy(() => S3AwsAuthenticationMethodManual$outboundSchema),
+  z.lazy(() => S3AwsAuthenticationMethodSecret$outboundSchema),
+]);
+
+export function s3CollectorConfToJSON(
+  s3CollectorConf: S3CollectorConf,
+): string {
+  return JSON.stringify(S3CollectorConf$outboundSchema.parse(s3CollectorConf));
+}
+export function s3CollectorConfFromJSON(
+  jsonString: string,
+): SafeParseResult<S3CollectorConf, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => S3CollectorConf$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'S3CollectorConf' from JSON`,
+  );
+}