cribl-control-plane 0.5.0-beta.4 → 0.5.0-beta.5

package/dist/esm/models/collectors3.js

@@ -4,10 +4,76 @@
 import * as z from "zod/v3";
 import { safeParse } from "../lib/schemas.js";
 import * as openEnums from "../types/enums.js";
+/**
+ * AWS authentication method. Choose Auto to use IAM roles.
+ */
+export const CollectorS3AuthenticationMethod5 = {
+    /**
+     * Auto
+     */
+    Auto: "auto",
+    /**
+     * Manual
+     */
+    Manual: "manual",
+    /**
+     * Secret Key pair
+     */
+    Secret: "secret",
+};
+/**
+ * Collector type: s3
+ */
+export const CollectorS3Type5 = {
+    S3: "s3",
+};
+/**
+ * Partitioning scheme used for this dataset. Using a known scheme like DDSS enables more efficient data reading and retrieval.
+ */
+export const PartitioningScheme5 = {
+    /**
+     * Defined in Path
+     */
+    None: "none",
+    /**
+     * DDSS
+     */
+    Ddss: "ddss",
+};
+/**
+ * Signature version to use for signing S3 requests
+ */
+export const CollectorS3SignatureVersion5 = {
+    V2: "v2",
+    V4: "v4",
+};
+/**
+ * AWS authentication method. Choose Auto to use IAM roles.
+ */
+export const CollectorS3AuthenticationMethod4 = {
+    /**
+     * Auto
+     */
+    Auto: "auto",
+    /**
+     * Manual
+     */
+    Manual: "manual",
+    /**
+     * Secret Key pair
+     */
+    Secret: "secret",
+};
+/**
+ * Collector type: s3
+ */
+export const CollectorS3Type4 = {
+    S3: "s3",
+};
 /**
  * Partitioning scheme used for this dataset. Using a known scheme like DDSS enables more efficient data reading and retrieval.
  */
-export const PartitioningScheme = {
+export const PartitioningScheme4 = {
     /**
      * Defined in Path
      */
@@ -17,10 +83,17 @@ export const PartitioningScheme = {
      */
     Ddss: "ddss",
 };
+/**
+ * Signature version to use for signing S3 requests
+ */
+export const CollectorS3SignatureVersion4 = {
+    V2: "v2",
+    V4: "v4",
+};
 /**
  * AWS authentication method. Choose Auto to use IAM roles.
  */
-export const CollectorS3AuthenticationMethod = {
+export const CollectorS3AuthenticationMethod3 = {
     /**
      * Auto
      */
@@ -34,95 +107,624 @@ export const CollectorS3AuthenticationMethod = {
      */
     Secret: "secret",
 };
+/**
+ * Collector type: s3
+ */
+export const CollectorS3Type3 = {
+    S3: "s3",
+};
+/**
+ * Partitioning scheme used for this dataset. Using a known scheme like DDSS enables more efficient data reading and retrieval.
+ */
+export const PartitioningScheme3 = {
+    /**
+     * Defined in Path
+     */
+    None: "none",
+    /**
+     * DDSS
+     */
+    Ddss: "ddss",
+};
 /**
  * Signature version to use for signing S3 requests
  */
-export const CollectorS3SignatureVersion = {
+export const CollectorS3SignatureVersion3 = {
     V2: "v2",
     V4: "v4",
 };
+/**
+ * Partitioning scheme used for this dataset. Using a known scheme like DDSS enables more efficient data reading and retrieval.
+ */
+export const PartitioningScheme2 = {
+    /**
+     * Defined in Path
+     */
+    None: "none",
+    /**
+     * DDSS
+     */
+    Ddss: "ddss",
+};
+/**
+ * Collector type: s3
+ */
+export const CollectorS3Type2 = {
+    S3: "s3",
+};
+/**
+ * AWS authentication method. Choose Auto to use IAM roles.
+ */
+export const CollectorS3AuthenticationMethod2 = {
+    /**
+     * Auto
+     */
+    Auto: "auto",
+    /**
+     * Manual
+     */
+    Manual: "manual",
+    /**
+     * Secret Key pair
+     */
+    Secret: "secret",
+};
+/**
+ * Signature version to use for signing S3 requests
+ */
+export const CollectorS3SignatureVersion2 = {
+    V2: "v2",
+    V4: "v4",
+};
+/**
+ * Partitioning scheme used for this dataset. Using a known scheme like DDSS enables more efficient data reading and retrieval.
+ */
+export const PartitioningScheme1 = {
+    /**
+     * Defined in Path
+     */
+    None: "none",
+    /**
+     * DDSS
+     */
+    Ddss: "ddss",
+};
+/**
+ * Collector type: s3
+ */
+export const CollectorS3Type1 = {
+    S3: "s3",
+};
+/**
+ * AWS authentication method. Choose Auto to use IAM roles.
+ */
+export const CollectorS3AuthenticationMethod1 = {
+    /**
+     * Auto
+     */
+    Auto: "auto",
+    /**
+     * Manual
+     */
+    Manual: "manual",
+    /**
+     * Secret Key pair
+     */
+    Secret: "secret",
+};
+/**
+ * Signature version to use for signing S3 requests
+ */
+export const CollectorS3SignatureVersion1 = {
+    V2: "v2",
+    V4: "v4",
+};
+/** @internal */
+export const CollectorS3AuthenticationMethod5$inboundSchema = openEnums.inboundSchema(CollectorS3AuthenticationMethod5);
+/** @internal */
+export const CollectorS3AuthenticationMethod5$outboundSchema = openEnums.outboundSchema(CollectorS3AuthenticationMethod5);
+/** @internal */
+export const CollectorS3Type5$inboundSchema = z.nativeEnum(CollectorS3Type5);
 /** @internal */
-export const PartitioningScheme$inboundSchema = openEnums.inboundSchema(PartitioningScheme);
+export const CollectorS3Type5$outboundSchema = CollectorS3Type5$inboundSchema;
 /** @internal */
-export const PartitioningScheme$outboundSchema = openEnums.outboundSchema(PartitioningScheme);
+export const PartitioningScheme5$inboundSchema = openEnums.inboundSchema(PartitioningScheme5);
 /** @internal */
-export const CollectorS3Extractor$inboundSchema = z.object({
+export const PartitioningScheme5$outboundSchema = openEnums.outboundSchema(PartitioningScheme5);
+/** @internal */
+export const CollectorS3Extractor5$inboundSchema = z.object({
     key: z.string(),
     expression: z.string(),
 });
 /** @internal */
-export const CollectorS3Extractor$outboundSchema = z.object({
+export const CollectorS3Extractor5$outboundSchema = z.object({
     key: z.string(),
     expression: z.string(),
 });
-export function collectorS3ExtractorToJSON(collectorS3Extractor) {
-    return JSON.stringify(CollectorS3Extractor$outboundSchema.parse(collectorS3Extractor));
+export function collectorS3Extractor5ToJSON(collectorS3Extractor5) {
+    return JSON.stringify(CollectorS3Extractor5$outboundSchema.parse(collectorS3Extractor5));
+}
+export function collectorS3Extractor5FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorS3Extractor5$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorS3Extractor5' from JSON`);
+}
+/** @internal */
+export const CollectorS3SignatureVersion5$inboundSchema = openEnums.inboundSchema(CollectorS3SignatureVersion5);
+/** @internal */
+export const CollectorS3SignatureVersion5$outboundSchema = openEnums.outboundSchema(CollectorS3SignatureVersion5);
+/** @internal */
+export const CollectorS3S35$inboundSchema = z.object({
+    awsAuthenticationMethod: CollectorS3AuthenticationMethod5$inboundSchema
+        .default("auto"),
+    awsSecret: z.string().optional(),
+    type: CollectorS3Type5$inboundSchema,
+    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: PartitioningScheme5$inboundSchema.default("none"),
+    extractors: z.array(z.lazy(() => CollectorS3Extractor5$inboundSchema))
+        .optional(),
+    endpoint: z.string().optional(),
+    signatureVersion: CollectorS3SignatureVersion5$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.boolean().default(true),
+    reuseConnections: z.boolean().default(true),
+    rejectUnauthorized: z.boolean().default(true),
+    verifyPermissions: z.boolean().default(true),
+    disableTimeFilter: z.boolean().default(false),
+    awsApiKey: z.string().optional(),
+    awsSecretKey: z.string().optional(),
+});
+/** @internal */
+export const CollectorS3S35$outboundSchema = z.object({
+    awsAuthenticationMethod: CollectorS3AuthenticationMethod5$outboundSchema
+        .default("auto"),
+    awsSecret: z.string().optional(),
+    type: CollectorS3Type5$outboundSchema,
+    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: PartitioningScheme5$outboundSchema.default("none"),
+    extractors: z.array(z.lazy(() => CollectorS3Extractor5$outboundSchema))
+        .optional(),
+    endpoint: z.string().optional(),
+    signatureVersion: CollectorS3SignatureVersion5$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.boolean().default(true),
+    reuseConnections: z.boolean().default(true),
+    rejectUnauthorized: z.boolean().default(true),
+    verifyPermissions: z.boolean().default(true),
+    disableTimeFilter: z.boolean().default(false),
+    awsApiKey: z.string().optional(),
+    awsSecretKey: z.string().optional(),
+});
+export function collectorS3S35ToJSON(collectorS3S35) {
+    return JSON.stringify(CollectorS3S35$outboundSchema.parse(collectorS3S35));
 }
-export function collectorS3ExtractorFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => CollectorS3Extractor$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorS3Extractor' from JSON`);
+export function collectorS3S35FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorS3S35$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorS3S35' from JSON`);
 }
 /** @internal */
-export const CollectorS3AuthenticationMethod$inboundSchema = openEnums.inboundSchema(CollectorS3AuthenticationMethod);
+export const CollectorS3AuthenticationMethod4$inboundSchema = openEnums.inboundSchema(CollectorS3AuthenticationMethod4);
 /** @internal */
-export const CollectorS3AuthenticationMethod$outboundSchema = openEnums.outboundSchema(CollectorS3AuthenticationMethod);
+export const CollectorS3AuthenticationMethod4$outboundSchema = openEnums.outboundSchema(CollectorS3AuthenticationMethod4);
 /** @internal */
-export const CollectorS3SignatureVersion$inboundSchema = openEnums.inboundSchema(CollectorS3SignatureVersion);
+export const CollectorS3Type4$inboundSchema = z.nativeEnum(CollectorS3Type4);
 /** @internal */
-export const CollectorS3SignatureVersion$outboundSchema = openEnums.outboundSchema(CollectorS3SignatureVersion);
+export const CollectorS3Type4$outboundSchema = CollectorS3Type4$inboundSchema;
 /** @internal */
-export const CollectorS3$inboundSchema = z.object({
-    type: z.literal("s3"),
+export const PartitioningScheme4$inboundSchema = openEnums.inboundSchema(PartitioningScheme4);
+/** @internal */
+export const PartitioningScheme4$outboundSchema = openEnums.outboundSchema(PartitioningScheme4);
+/** @internal */
+export const CollectorS3Extractor4$inboundSchema = z.object({
+    key: z.string(),
+    expression: z.string(),
+});
+/** @internal */
+export const CollectorS3Extractor4$outboundSchema = z.object({
+    key: z.string(),
+    expression: z.string(),
+});
+export function collectorS3Extractor4ToJSON(collectorS3Extractor4) {
+    return JSON.stringify(CollectorS3Extractor4$outboundSchema.parse(collectorS3Extractor4));
+}
+export function collectorS3Extractor4FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorS3Extractor4$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorS3Extractor4' from JSON`);
+}
+/** @internal */
+export const CollectorS3SignatureVersion4$inboundSchema = openEnums.inboundSchema(CollectorS3SignatureVersion4);
+/** @internal */
+export const CollectorS3SignatureVersion4$outboundSchema = openEnums.outboundSchema(CollectorS3SignatureVersion4);
+/** @internal */
+export const CollectorS3S34$inboundSchema = z.object({
+    awsAuthenticationMethod: CollectorS3AuthenticationMethod4$inboundSchema
+        .default("auto"),
+    awsApiKey: z.string().optional(),
+    awsSecretKey: z.string().optional(),
+    type: CollectorS3Type4$inboundSchema,
+    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: PartitioningScheme4$inboundSchema.default("none"),
+    extractors: z.array(z.lazy(() => CollectorS3Extractor4$inboundSchema))
+        .optional(),
+    endpoint: z.string().optional(),
+    signatureVersion: CollectorS3SignatureVersion4$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.boolean().default(true),
+    reuseConnections: z.boolean().default(true),
+    rejectUnauthorized: z.boolean().default(true),
+    verifyPermissions: z.boolean().default(true),
+    disableTimeFilter: z.boolean().default(false),
+    awsSecret: z.string().optional(),
+});
+/** @internal */
+export const CollectorS3S34$outboundSchema = z.object({
+    awsAuthenticationMethod: CollectorS3AuthenticationMethod4$outboundSchema
+        .default("auto"),
+    awsApiKey: z.string().optional(),
+    awsSecretKey: z.string().optional(),
+    type: CollectorS3Type4$outboundSchema,
+    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: PartitioningScheme4$outboundSchema.default("none"),
+    extractors: z.array(z.lazy(() => CollectorS3Extractor4$outboundSchema))
+        .optional(),
+    endpoint: z.string().optional(),
+    signatureVersion: CollectorS3SignatureVersion4$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.boolean().default(true),
+    reuseConnections: z.boolean().default(true),
+    rejectUnauthorized: z.boolean().default(true),
+    verifyPermissions: z.boolean().default(true),
+    disableTimeFilter: z.boolean().default(false),
+    awsSecret: z.string().optional(),
+});
+export function collectorS3S34ToJSON(collectorS3S34) {
+    return JSON.stringify(CollectorS3S34$outboundSchema.parse(collectorS3S34));
+}
+export function collectorS3S34FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorS3S34$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorS3S34' from JSON`);
+}
+/** @internal */
+export const CollectorS3AuthenticationMethod3$inboundSchema = openEnums.inboundSchema(CollectorS3AuthenticationMethod3);
+/** @internal */
+export const CollectorS3AuthenticationMethod3$outboundSchema = openEnums.outboundSchema(CollectorS3AuthenticationMethod3);
+/** @internal */
+export const CollectorS3Type3$inboundSchema = z.nativeEnum(CollectorS3Type3);
+/** @internal */
+export const CollectorS3Type3$outboundSchema = CollectorS3Type3$inboundSchema;
+/** @internal */
+export const PartitioningScheme3$inboundSchema = openEnums.inboundSchema(PartitioningScheme3);
+/** @internal */
+export const PartitioningScheme3$outboundSchema = openEnums.outboundSchema(PartitioningScheme3);
+/** @internal */
+export const CollectorS3Extractor3$inboundSchema = z.object({
+    key: z.string(),
+    expression: z.string(),
+});
+/** @internal */
+export const CollectorS3Extractor3$outboundSchema = z.object({
+    key: z.string(),
+    expression: z.string(),
+});
+export function collectorS3Extractor3ToJSON(collectorS3Extractor3) {
+    return JSON.stringify(CollectorS3Extractor3$outboundSchema.parse(collectorS3Extractor3));
+}
+export function collectorS3Extractor3FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorS3Extractor3$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorS3Extractor3' from JSON`);
+}
+/** @internal */
+export const CollectorS3SignatureVersion3$inboundSchema = openEnums.inboundSchema(CollectorS3SignatureVersion3);
+/** @internal */
+export const CollectorS3SignatureVersion3$outboundSchema = openEnums.outboundSchema(CollectorS3SignatureVersion3);
+/** @internal */
+export const CollectorS3S33$inboundSchema = z.object({
+    awsAuthenticationMethod: CollectorS3AuthenticationMethod3$inboundSchema
+        .default("auto"),
+    type: CollectorS3Type3$inboundSchema,
+    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: PartitioningScheme3$inboundSchema.default("none"),
+    extractors: z.array(z.lazy(() => CollectorS3Extractor3$inboundSchema))
+        .optional(),
+    endpoint: z.string().optional(),
+    signatureVersion: CollectorS3SignatureVersion3$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.boolean().default(true),
+    reuseConnections: z.boolean().default(true),
+    rejectUnauthorized: z.boolean().default(true),
+    verifyPermissions: z.boolean().default(true),
+    disableTimeFilter: z.boolean().default(false),
+    awsApiKey: z.string().optional(),
+    awsSecretKey: z.string().optional(),
+    awsSecret: z.string().optional(),
+});
+/** @internal */
+export const CollectorS3S33$outboundSchema = z.object({
+    awsAuthenticationMethod: CollectorS3AuthenticationMethod3$outboundSchema
+        .default("auto"),
+    type: CollectorS3Type3$outboundSchema,
+    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: PartitioningScheme3$outboundSchema.default("none"),
+    extractors: z.array(z.lazy(() => CollectorS3Extractor3$outboundSchema))
+        .optional(),
+    endpoint: z.string().optional(),
+    signatureVersion: CollectorS3SignatureVersion3$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.boolean().default(true),
+    reuseConnections: z.boolean().default(true),
+    rejectUnauthorized: z.boolean().default(true),
+    verifyPermissions: z.boolean().default(true),
+    disableTimeFilter: z.boolean().default(false),
+    awsApiKey: z.string().optional(),
+    awsSecretKey: z.string().optional(),
+    awsSecret: z.string().optional(),
+});
+export function collectorS3S33ToJSON(collectorS3S33) {
+    return JSON.stringify(CollectorS3S33$outboundSchema.parse(collectorS3S33));
+}
+export function collectorS3S33FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorS3S33$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorS3S33' from JSON`);
+}
+/** @internal */
+export const PartitioningScheme2$inboundSchema = openEnums.inboundSchema(PartitioningScheme2);
+/** @internal */
+export const PartitioningScheme2$outboundSchema = openEnums.outboundSchema(PartitioningScheme2);
+/** @internal */
+export const CollectorS3Type2$inboundSchema = z.nativeEnum(CollectorS3Type2);
+/** @internal */
+export const CollectorS3Type2$outboundSchema = CollectorS3Type2$inboundSchema;
+/** @internal */
+export const CollectorS3Extractor2$inboundSchema = z.object({
+    key: z.string(),
+    expression: z.string(),
+});
+/** @internal */
+export const CollectorS3Extractor2$outboundSchema = z.object({
+    key: z.string(),
+    expression: z.string(),
+});
+export function collectorS3Extractor2ToJSON(collectorS3Extractor2) {
+    return JSON.stringify(CollectorS3Extractor2$outboundSchema.parse(collectorS3Extractor2));
+}
+export function collectorS3Extractor2FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorS3Extractor2$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorS3Extractor2' from JSON`);
+}
+/** @internal */
+export const CollectorS3AuthenticationMethod2$inboundSchema = openEnums.inboundSchema(CollectorS3AuthenticationMethod2);
+/** @internal */
+export const CollectorS3AuthenticationMethod2$outboundSchema = openEnums.outboundSchema(CollectorS3AuthenticationMethod2);
+/** @internal */
+export const CollectorS3SignatureVersion2$inboundSchema = openEnums.inboundSchema(CollectorS3SignatureVersion2);
+/** @internal */
+export const CollectorS3SignatureVersion2$outboundSchema = openEnums.outboundSchema(CollectorS3SignatureVersion2);
+/** @internal */
+export const CollectorS3S32$inboundSchema = z.object({
+    partitioningScheme: PartitioningScheme2$inboundSchema.default("none"),
+    recurse: z.boolean().default(true),
+    type: CollectorS3Type2$inboundSchema,
     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(() => CollectorS3Extractor$inboundSchema))
+    extractors: z.array(z.lazy(() => CollectorS3Extractor2$inboundSchema))
         .optional(),
-    awsAuthenticationMethod: CollectorS3AuthenticationMethod$inboundSchema
+    awsAuthenticationMethod: CollectorS3AuthenticationMethod2$inboundSchema
         .default("auto"),
     endpoint: z.string().optional(),
-    signatureVersion: CollectorS3SignatureVersion$inboundSchema.default("v4"),
+    signatureVersion: CollectorS3SignatureVersion2$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),
+    awsApiKey: z.string().optional(),
+    awsSecretKey: z.string().optional(),
+    awsSecret: z.string().optional(),
 });
 /** @internal */
-export const CollectorS3$outboundSchema = z.object({
-    type: z.literal("s3"),
+export const CollectorS3S32$outboundSchema = z.object({
+    partitioningScheme: PartitioningScheme2$outboundSchema.default("none"),
+    recurse: z.boolean().default(true),
+    type: CollectorS3Type2$outboundSchema,
     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(() => CollectorS3Extractor$outboundSchema))
+    extractors: z.array(z.lazy(() => CollectorS3Extractor2$outboundSchema))
         .optional(),
-    awsAuthenticationMethod: CollectorS3AuthenticationMethod$outboundSchema
+    awsAuthenticationMethod: CollectorS3AuthenticationMethod2$outboundSchema
         .default("auto"),
     endpoint: z.string().optional(),
-    signatureVersion: CollectorS3SignatureVersion$outboundSchema.default("v4"),
+    signatureVersion: CollectorS3SignatureVersion2$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),
+    awsApiKey: z.string().optional(),
+    awsSecretKey: z.string().optional(),
+    awsSecret: z.string().optional(),
 });
+export function collectorS3S32ToJSON(collectorS3S32) {
+    return JSON.stringify(CollectorS3S32$outboundSchema.parse(collectorS3S32));
+}
+export function collectorS3S32FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorS3S32$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorS3S32' from JSON`);
+}
+/** @internal */
+export const PartitioningScheme1$inboundSchema = openEnums.inboundSchema(PartitioningScheme1);
+/** @internal */
+export const PartitioningScheme1$outboundSchema = openEnums.outboundSchema(PartitioningScheme1);
+/** @internal */
+export const CollectorS3Type1$inboundSchema = z.nativeEnum(CollectorS3Type1);
+/** @internal */
+export const CollectorS3Type1$outboundSchema = CollectorS3Type1$inboundSchema;
+/** @internal */
+export const CollectorS3Extractor1$inboundSchema = z.object({
+    key: z.string(),
+    expression: z.string(),
+});
+/** @internal */
+export const CollectorS3Extractor1$outboundSchema = z.object({
+    key: z.string(),
+    expression: z.string(),
+});
+export function collectorS3Extractor1ToJSON(collectorS3Extractor1) {
+    return JSON.stringify(CollectorS3Extractor1$outboundSchema.parse(collectorS3Extractor1));
+}
+export function collectorS3Extractor1FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorS3Extractor1$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorS3Extractor1' from JSON`);
+}
+/** @internal */
+export const CollectorS3AuthenticationMethod1$inboundSchema = openEnums.inboundSchema(CollectorS3AuthenticationMethod1);
+/** @internal */
+export const CollectorS3AuthenticationMethod1$outboundSchema = openEnums.outboundSchema(CollectorS3AuthenticationMethod1);
+/** @internal */
+export const CollectorS3SignatureVersion1$inboundSchema = openEnums.inboundSchema(CollectorS3SignatureVersion1);
+/** @internal */
+export const CollectorS3SignatureVersion1$outboundSchema = openEnums.outboundSchema(CollectorS3SignatureVersion1);
+/** @internal */
+export const CollectorS3S31$inboundSchema = z.object({
+    partitioningScheme: PartitioningScheme1$inboundSchema.default("none"),
+    type: CollectorS3Type1$inboundSchema,
+    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(() => CollectorS3Extractor1$inboundSchema))
+        .optional(),
+    awsAuthenticationMethod: CollectorS3AuthenticationMethod1$inboundSchema
+        .default("auto"),
+    endpoint: z.string().optional(),
+    signatureVersion: CollectorS3SignatureVersion1$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.boolean().default(true),
+    reuseConnections: z.boolean().default(true),
+    rejectUnauthorized: z.boolean().default(true),
+    verifyPermissions: z.boolean().default(true),
+    disableTimeFilter: z.boolean().default(false),
+    awsApiKey: z.string().optional(),
+    awsSecretKey: z.string().optional(),
+    awsSecret: z.string().optional(),
+});
+/** @internal */
+export const CollectorS3S31$outboundSchema = z.object({
+    partitioningScheme: PartitioningScheme1$outboundSchema.default("none"),
+    type: CollectorS3Type1$outboundSchema,
+    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(() => CollectorS3Extractor1$outboundSchema))
+        .optional(),
+    awsAuthenticationMethod: CollectorS3AuthenticationMethod1$outboundSchema
+        .default("auto"),
+    endpoint: z.string().optional(),
+    signatureVersion: CollectorS3SignatureVersion1$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.boolean().default(true),
+    reuseConnections: z.boolean().default(true),
+    rejectUnauthorized: z.boolean().default(true),
+    verifyPermissions: z.boolean().default(true),
+    disableTimeFilter: z.boolean().default(false),
+    awsApiKey: z.string().optional(),
+    awsSecretKey: z.string().optional(),
+    awsSecret: z.string().optional(),
+});
+export function collectorS3S31ToJSON(collectorS3S31) {
+    return JSON.stringify(CollectorS3S31$outboundSchema.parse(collectorS3S31));
+}
+export function collectorS3S31FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CollectorS3S31$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CollectorS3S31' from JSON`);
+}
+/** @internal */
+export const CollectorS3$inboundSchema = z.union([
+    z.lazy(() => CollectorS3S31$inboundSchema),
+    z.lazy(() => CollectorS3S32$inboundSchema),
+    z.lazy(() => CollectorS3S33$inboundSchema),
+    z.lazy(() => CollectorS3S34$inboundSchema),
+    z.lazy(() => CollectorS3S35$inboundSchema),
+]);
+/** @internal */
+export const CollectorS3$outboundSchema = z.union([
+    z.lazy(() => CollectorS3S31$outboundSchema),
+    z.lazy(() => CollectorS3S32$outboundSchema),
+    z.lazy(() => CollectorS3S33$outboundSchema),
+    z.lazy(() => CollectorS3S34$outboundSchema),
+    z.lazy(() => CollectorS3S35$outboundSchema),
+]);
 export function collectorS3ToJSON(collectorS3) {
     return JSON.stringify(CollectorS3$outboundSchema.parse(collectorS3));
 }