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

package/src/models/s3collectorconf.ts

@@ -12,7 +12,7 @@ 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 PartitioningScheme = {
+export const S3AwsAuthenticationMethodSecretPartitioningScheme = {
   /**
    * Defined in Path
    */
@@ -25,157 +25,1520 @@ export const PartitioningScheme = {
 /**
  * Partitioning scheme used for this dataset. Using a known scheme like DDSS enables more efficient data reading and retrieval.
  */
-export type PartitioningScheme = OpenEnum<typeof PartitioningScheme>;
+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 type S3CollectorConfExtractor = {
-  /**
-   * A token from the template path, such as epoch
-   */
+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;
-  /**
-   * 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 S3CollectorConfAuthenticationMethod = {
-  /**
-   * Auto
-   */
-  Auto: "auto",
-  /**
-   * Manual
-   */
-  Manual: "manual",
-  /**
-   * Secret Key pair
-   */
-  Secret: "secret",
-} as const;
-/**
- * AWS authentication method. Choose Auto to use IAM roles.
- */
-export type S3CollectorConfAuthenticationMethod = OpenEnum<
-  typeof S3CollectorConfAuthenticationMethod
->;
+/** @internal */
+export const S3PartitioningSchemeNoneExtractor$outboundSchema: z.ZodType<
+  S3PartitioningSchemeNoneExtractor$Outbound,
+  z.ZodTypeDef,
+  S3PartitioningSchemeNoneExtractor
+> = z.object({
+  key: z.string(),
+  expression: z.string(),
+});
 
-/**
- * Signature version to use for signing S3 requests
- */
-export const S3CollectorConfSignatureVersion = {
-  V2: "v2",
-  V4: "v4",
-} as const;
-/**
- * Signature version to use for signing S3 requests
- */
-export type S3CollectorConfSignatureVersion = OpenEnum<
-  typeof S3CollectorConfSignatureVersion
->;
+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`,
+  );
+}
 
-export type S3CollectorConf = {
-  /**
-   * Name of the predefined Destination that will be used to auto-populate Collector settings
-   */
+/** @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;
-  /**
-   * 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
-   */
+  parquetChunkSizeMB: number;
+  parquetChunkDownloadTimeout: number;
   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?: PartitioningScheme | 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<S3CollectorConfExtractor> | undefined;
-  /**
-   * AWS authentication method. Choose Auto to use IAM roles.
-   */
-  awsAuthenticationMethod?: S3CollectorConfAuthenticationMethod | undefined;
-  /**
-   * Must point to an S3-compatible endpoint. If empty, defaults to an AWS region-specific endpoint.
-   */
+  extractors?: Array<S3PartitioningSchemeNoneExtractor$Outbound> | undefined;
+  awsAuthenticationMethod: string;
   endpoint?: string | undefined;
-  /**
-   * Signature version to use for signing S3 requests
-   */
-  signatureVersion?: S3CollectorConfSignatureVersion | undefined;
-  /**
-   * Use AssumeRole credentials
-   */
-  enableAssumeRole?: boolean | undefined;
-  /**
-   * Amazon Resource Name (ARN) of the role to assume
-   */
+  signatureVersion: string;
+  enableAssumeRole: boolean;
   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;
+  durationSeconds: number;
+  maxBatchSize: number;
+  reuseConnections: boolean;
+  rejectUnauthorized: boolean;
+  verifyPermissions: boolean;
+  disableTimeFilter: boolean;
 };
 
 /** @internal */
-export const PartitioningScheme$inboundSchema: z.ZodType<
-  PartitioningScheme,
+export const S3PartitioningSchemeNone$outboundSchema: z.ZodType<
+  S3PartitioningSchemeNone$Outbound,
   z.ZodTypeDef,
-  unknown
-> = openEnums.inboundSchema(PartitioningScheme);
+  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 PartitioningScheme$outboundSchema: z.ZodType<
-  string,
-  z.ZodTypeDef,
-  PartitioningScheme
-> = openEnums.outboundSchema(PartitioningScheme);
+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 S3CollectorConfExtractor$inboundSchema: z.ZodType<
-  S3CollectorConfExtractor,
+export const S3PartitioningSchemeDdssExtractor$inboundSchema: z.ZodType<
+  S3PartitioningSchemeDdssExtractor,
   z.ZodTypeDef,
   unknown
 > = z.object({
@@ -183,83 +1546,90 @@ export const S3CollectorConfExtractor$inboundSchema: z.ZodType<
   expression: z.string(),
 });
 /** @internal */
-export type S3CollectorConfExtractor$Outbound = {
+export type S3PartitioningSchemeDdssExtractor$Outbound = {
   key: string;
   expression: string;
 };
 
 /** @internal */
-export const S3CollectorConfExtractor$outboundSchema: z.ZodType<
-  S3CollectorConfExtractor$Outbound,
+export const S3PartitioningSchemeDdssExtractor$outboundSchema: z.ZodType<
+  S3PartitioningSchemeDdssExtractor$Outbound,
   z.ZodTypeDef,
-  S3CollectorConfExtractor
+  S3PartitioningSchemeDdssExtractor
 > = z.object({
   key: z.string(),
   expression: z.string(),
 });
 
-export function s3CollectorConfExtractorToJSON(
-  s3CollectorConfExtractor: S3CollectorConfExtractor,
+export function s3PartitioningSchemeDdssExtractorToJSON(
+  s3PartitioningSchemeDdssExtractor: S3PartitioningSchemeDdssExtractor,
 ): string {
   return JSON.stringify(
-    S3CollectorConfExtractor$outboundSchema.parse(s3CollectorConfExtractor),
+    S3PartitioningSchemeDdssExtractor$outboundSchema.parse(
+      s3PartitioningSchemeDdssExtractor,
+    ),
   );
 }
-export function s3CollectorConfExtractorFromJSON(
+export function s3PartitioningSchemeDdssExtractorFromJSON(
   jsonString: string,
-): SafeParseResult<S3CollectorConfExtractor, SDKValidationError> {
+): SafeParseResult<S3PartitioningSchemeDdssExtractor, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => S3CollectorConfExtractor$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'S3CollectorConfExtractor' from JSON`,
+    (x) => S3PartitioningSchemeDdssExtractor$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'S3PartitioningSchemeDdssExtractor' from JSON`,
   );
 }
 
 /** @internal */
-export const S3CollectorConfAuthenticationMethod$inboundSchema: z.ZodType<
-  S3CollectorConfAuthenticationMethod,
-  z.ZodTypeDef,
-  unknown
-> = openEnums.inboundSchema(S3CollectorConfAuthenticationMethod);
+export const S3PartitioningSchemeDdssAuthenticationMethod$inboundSchema:
+  z.ZodType<
+    S3PartitioningSchemeDdssAuthenticationMethod,
+    z.ZodTypeDef,
+    unknown
+  > = openEnums.inboundSchema(S3PartitioningSchemeDdssAuthenticationMethod);
 /** @internal */
-export const S3CollectorConfAuthenticationMethod$outboundSchema: z.ZodType<
-  string,
-  z.ZodTypeDef,
-  S3CollectorConfAuthenticationMethod
-> = openEnums.outboundSchema(S3CollectorConfAuthenticationMethod);
+export const S3PartitioningSchemeDdssAuthenticationMethod$outboundSchema:
+  z.ZodType<
+    string,
+    z.ZodTypeDef,
+    S3PartitioningSchemeDdssAuthenticationMethod
+  > = openEnums.outboundSchema(S3PartitioningSchemeDdssAuthenticationMethod);
 
 /** @internal */
-export const S3CollectorConfSignatureVersion$inboundSchema: z.ZodType<
-  S3CollectorConfSignatureVersion,
+export const S3PartitioningSchemeDdssSignatureVersion$inboundSchema: z.ZodType<
+  S3PartitioningSchemeDdssSignatureVersion,
   z.ZodTypeDef,
   unknown
-> = openEnums.inboundSchema(S3CollectorConfSignatureVersion);
+> = openEnums.inboundSchema(S3PartitioningSchemeDdssSignatureVersion);
 /** @internal */
-export const S3CollectorConfSignatureVersion$outboundSchema: z.ZodType<
+export const S3PartitioningSchemeDdssSignatureVersion$outboundSchema: z.ZodType<
   string,
   z.ZodTypeDef,
-  S3CollectorConfSignatureVersion
-> = openEnums.outboundSchema(S3CollectorConfSignatureVersion);
+  S3PartitioningSchemeDdssSignatureVersion
+> = openEnums.outboundSchema(S3PartitioningSchemeDdssSignatureVersion);
 
 /** @internal */
-export const S3CollectorConf$inboundSchema: z.ZodType<
-  S3CollectorConf,
+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(),
-  partitioningScheme: PartitioningScheme$inboundSchema.default("none"),
-  extractors: z.array(z.lazy(() => S3CollectorConfExtractor$inboundSchema))
-    .optional(),
-  awsAuthenticationMethod: S3CollectorConfAuthenticationMethod$inboundSchema
-    .default("auto"),
+  extractors: z.array(
+    z.lazy(() => S3PartitioningSchemeDdssExtractor$inboundSchema),
+  ).optional(),
+  awsAuthenticationMethod:
+    S3PartitioningSchemeDdssAuthenticationMethod$inboundSchema.default("auto"),
   endpoint: z.string().optional(),
-  signatureVersion: S3CollectorConfSignatureVersion$inboundSchema.default("v4"),
+  signatureVersion: S3PartitioningSchemeDdssSignatureVersion$inboundSchema
+    .default("v4"),
   enableAssumeRole: z.boolean().default(false),
   assumeRoleArn: z.string().optional(),
   assumeRoleExternalId: z.string().optional(),
@@ -272,15 +1642,15 @@ export const S3CollectorConf$inboundSchema: z.ZodType<
   disableTimeFilter: z.boolean().default(false),
 });
 /** @internal */
-export type S3CollectorConf$Outbound = {
+export type S3PartitioningSchemeDdss$Outbound = {
+  partitioningScheme: string;
   outputName?: string | undefined;
   bucket: string;
   parquetChunkSizeMB: number;
   parquetChunkDownloadTimeout: number;
   region?: string | undefined;
   path?: string | undefined;
-  partitioningScheme: string;
-  extractors?: Array<S3CollectorConfExtractor$Outbound> | undefined;
+  extractors?: Array<S3PartitioningSchemeDdssExtractor$Outbound> | undefined;
   awsAuthenticationMethod: string;
   endpoint?: string | undefined;
   signatureVersion: string;
@@ -297,26 +1667,27 @@ export type S3CollectorConf$Outbound = {
 };
 
 /** @internal */
-export const S3CollectorConf$outboundSchema: z.ZodType<
-  S3CollectorConf$Outbound,
+export const S3PartitioningSchemeDdss$outboundSchema: z.ZodType<
+  S3PartitioningSchemeDdss$Outbound,
   z.ZodTypeDef,
-  S3CollectorConf
+  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(),
-  partitioningScheme: PartitioningScheme$outboundSchema.default("none"),
-  extractors: z.array(z.lazy(() => S3CollectorConfExtractor$outboundSchema))
-    .optional(),
-  awsAuthenticationMethod: S3CollectorConfAuthenticationMethod$outboundSchema
-    .default("auto"),
+  extractors: z.array(
+    z.lazy(() => S3PartitioningSchemeDdssExtractor$outboundSchema),
+  ).optional(),
+  awsAuthenticationMethod:
+    S3PartitioningSchemeDdssAuthenticationMethod$outboundSchema.default("auto"),
   endpoint: z.string().optional(),
-  signatureVersion: S3CollectorConfSignatureVersion$outboundSchema.default(
-    "v4",
-  ),
+  signatureVersion: S3PartitioningSchemeDdssSignatureVersion$outboundSchema
+    .default("v4"),
   enableAssumeRole: z.boolean().default(false),
   assumeRoleArn: z.string().optional(),
   assumeRoleExternalId: z.string().optional(),
@@ -329,6 +1700,50 @@ export const S3CollectorConf$outboundSchema: z.ZodType<
   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 {