1. Packages
  2. AWS Classic
  3. API Docs
  4. kinesis
  5. FirehoseDeliveryStream

Try AWS Native preview for resources not in the classic version.

AWS Classic v6.41.0 published on Tuesday, Jun 18, 2024 by Pulumi

aws.kinesis.FirehoseDeliveryStream

Explore with Pulumi AI

aws logo

Try AWS Native preview for resources not in the classic version.

AWS Classic v6.41.0 published on Tuesday, Jun 18, 2024 by Pulumi

    Provides a Kinesis Firehose Delivery Stream resource. Amazon Kinesis Firehose is a fully managed, elastic service to easily deliver real-time data streams to destinations such as Amazon S3 , Amazon Redshift and Snowflake.

    For more details, see the Amazon Kinesis Firehose Documentation.

    Example Usage

    Extended S3 Destination

    import * as pulumi from "@pulumi/pulumi";
    import * as aws from "@pulumi/aws";
    
    const bucket = new aws.s3.BucketV2("bucket", {bucket: "tf-test-bucket"});
    const firehoseAssumeRole = aws.iam.getPolicyDocument({
        statements: [{
            effect: "Allow",
            principals: [{
                type: "Service",
                identifiers: ["firehose.amazonaws.com"],
            }],
            actions: ["sts:AssumeRole"],
        }],
    });
    const firehoseRole = new aws.iam.Role("firehose_role", {
        name: "firehose_test_role",
        assumeRolePolicy: firehoseAssumeRole.then(firehoseAssumeRole => firehoseAssumeRole.json),
    });
    const lambdaAssumeRole = aws.iam.getPolicyDocument({
        statements: [{
            effect: "Allow",
            principals: [{
                type: "Service",
                identifiers: ["lambda.amazonaws.com"],
            }],
            actions: ["sts:AssumeRole"],
        }],
    });
    const lambdaIam = new aws.iam.Role("lambda_iam", {
        name: "lambda_iam",
        assumeRolePolicy: lambdaAssumeRole.then(lambdaAssumeRole => lambdaAssumeRole.json),
    });
    const lambdaProcessor = new aws.lambda.Function("lambda_processor", {
        code: new pulumi.asset.FileArchive("lambda.zip"),
        name: "firehose_lambda_processor",
        role: lambdaIam.arn,
        handler: "exports.handler",
        runtime: aws.lambda.Runtime.NodeJS16dX,
    });
    const extendedS3Stream = new aws.kinesis.FirehoseDeliveryStream("extended_s3_stream", {
        name: "kinesis-firehose-extended-s3-test-stream",
        destination: "extended_s3",
        extendedS3Configuration: {
            roleArn: firehoseRole.arn,
            bucketArn: bucket.arn,
            processingConfiguration: {
                enabled: true,
                processors: [{
                    type: "Lambda",
                    parameters: [{
                        parameterName: "LambdaArn",
                        parameterValue: pulumi.interpolate`${lambdaProcessor.arn}:$LATEST`,
                    }],
                }],
            },
        },
    });
    const bucketAcl = new aws.s3.BucketAclV2("bucket_acl", {
        bucket: bucket.id,
        acl: "private",
    });
    
    import pulumi
    import pulumi_aws as aws
    
    bucket = aws.s3.BucketV2("bucket", bucket="tf-test-bucket")
    firehose_assume_role = aws.iam.get_policy_document(statements=[aws.iam.GetPolicyDocumentStatementArgs(
        effect="Allow",
        principals=[aws.iam.GetPolicyDocumentStatementPrincipalArgs(
            type="Service",
            identifiers=["firehose.amazonaws.com"],
        )],
        actions=["sts:AssumeRole"],
    )])
    firehose_role = aws.iam.Role("firehose_role",
        name="firehose_test_role",
        assume_role_policy=firehose_assume_role.json)
    lambda_assume_role = aws.iam.get_policy_document(statements=[aws.iam.GetPolicyDocumentStatementArgs(
        effect="Allow",
        principals=[aws.iam.GetPolicyDocumentStatementPrincipalArgs(
            type="Service",
            identifiers=["lambda.amazonaws.com"],
        )],
        actions=["sts:AssumeRole"],
    )])
    lambda_iam = aws.iam.Role("lambda_iam",
        name="lambda_iam",
        assume_role_policy=lambda_assume_role.json)
    lambda_processor = aws.lambda_.Function("lambda_processor",
        code=pulumi.FileArchive("lambda.zip"),
        name="firehose_lambda_processor",
        role=lambda_iam.arn,
        handler="exports.handler",
        runtime=aws.lambda_.Runtime.NODE_JS16D_X)
    extended_s3_stream = aws.kinesis.FirehoseDeliveryStream("extended_s3_stream",
        name="kinesis-firehose-extended-s3-test-stream",
        destination="extended_s3",
        extended_s3_configuration=aws.kinesis.FirehoseDeliveryStreamExtendedS3ConfigurationArgs(
            role_arn=firehose_role.arn,
            bucket_arn=bucket.arn,
            processing_configuration=aws.kinesis.FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationArgs(
                enabled=True,
                processors=[aws.kinesis.FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorArgs(
                    type="Lambda",
                    parameters=[aws.kinesis.FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorParameterArgs(
                        parameter_name="LambdaArn",
                        parameter_value=lambda_processor.arn.apply(lambda arn: f"{arn}:$LATEST"),
                    )],
                )],
            ),
        ))
    bucket_acl = aws.s3.BucketAclV2("bucket_acl",
        bucket=bucket.id,
        acl="private")
    
    package main
    
    import (
    	"fmt"
    
    	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/iam"
    	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/kinesis"
    	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/lambda"
    	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/s3"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		bucket, err := s3.NewBucketV2(ctx, "bucket", &s3.BucketV2Args{
    			Bucket: pulumi.String("tf-test-bucket"),
    		})
    		if err != nil {
    			return err
    		}
    		firehoseAssumeRole, err := iam.GetPolicyDocument(ctx, &iam.GetPolicyDocumentArgs{
    			Statements: []iam.GetPolicyDocumentStatement{
    				{
    					Effect: pulumi.StringRef("Allow"),
    					Principals: []iam.GetPolicyDocumentStatementPrincipal{
    						{
    							Type: "Service",
    							Identifiers: []string{
    								"firehose.amazonaws.com",
    							},
    						},
    					},
    					Actions: []string{
    						"sts:AssumeRole",
    					},
    				},
    			},
    		}, nil)
    		if err != nil {
    			return err
    		}
    		firehoseRole, err := iam.NewRole(ctx, "firehose_role", &iam.RoleArgs{
    			Name:             pulumi.String("firehose_test_role"),
    			AssumeRolePolicy: pulumi.String(firehoseAssumeRole.Json),
    		})
    		if err != nil {
    			return err
    		}
    		lambdaAssumeRole, err := iam.GetPolicyDocument(ctx, &iam.GetPolicyDocumentArgs{
    			Statements: []iam.GetPolicyDocumentStatement{
    				{
    					Effect: pulumi.StringRef("Allow"),
    					Principals: []iam.GetPolicyDocumentStatementPrincipal{
    						{
    							Type: "Service",
    							Identifiers: []string{
    								"lambda.amazonaws.com",
    							},
    						},
    					},
    					Actions: []string{
    						"sts:AssumeRole",
    					},
    				},
    			},
    		}, nil)
    		if err != nil {
    			return err
    		}
    		lambdaIam, err := iam.NewRole(ctx, "lambda_iam", &iam.RoleArgs{
    			Name:             pulumi.String("lambda_iam"),
    			AssumeRolePolicy: pulumi.String(lambdaAssumeRole.Json),
    		})
    		if err != nil {
    			return err
    		}
    		lambdaProcessor, err := lambda.NewFunction(ctx, "lambda_processor", &lambda.FunctionArgs{
    			Code:    pulumi.NewFileArchive("lambda.zip"),
    			Name:    pulumi.String("firehose_lambda_processor"),
    			Role:    lambdaIam.Arn,
    			Handler: pulumi.String("exports.handler"),
    			Runtime: pulumi.String(lambda.RuntimeNodeJS16dX),
    		})
    		if err != nil {
    			return err
    		}
    		_, err = kinesis.NewFirehoseDeliveryStream(ctx, "extended_s3_stream", &kinesis.FirehoseDeliveryStreamArgs{
    			Name:        pulumi.String("kinesis-firehose-extended-s3-test-stream"),
    			Destination: pulumi.String("extended_s3"),
    			ExtendedS3Configuration: &kinesis.FirehoseDeliveryStreamExtendedS3ConfigurationArgs{
    				RoleArn:   firehoseRole.Arn,
    				BucketArn: bucket.Arn,
    				ProcessingConfiguration: &kinesis.FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationArgs{
    					Enabled: pulumi.Bool(true),
    					Processors: kinesis.FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorArray{
    						&kinesis.FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorArgs{
    							Type: pulumi.String("Lambda"),
    							Parameters: kinesis.FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorParameterArray{
    								&kinesis.FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorParameterArgs{
    									ParameterName: pulumi.String("LambdaArn"),
    									ParameterValue: lambdaProcessor.Arn.ApplyT(func(arn string) (string, error) {
    										return fmt.Sprintf("%v:$LATEST", arn), nil
    									}).(pulumi.StringOutput),
    								},
    							},
    						},
    					},
    				},
    			},
    		})
    		if err != nil {
    			return err
    		}
    		_, err = s3.NewBucketAclV2(ctx, "bucket_acl", &s3.BucketAclV2Args{
    			Bucket: bucket.ID(),
    			Acl:    pulumi.String("private"),
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using Aws = Pulumi.Aws;
    
    return await Deployment.RunAsync(() => 
    {
        var bucket = new Aws.S3.BucketV2("bucket", new()
        {
            Bucket = "tf-test-bucket",
        });
    
        var firehoseAssumeRole = Aws.Iam.GetPolicyDocument.Invoke(new()
        {
            Statements = new[]
            {
                new Aws.Iam.Inputs.GetPolicyDocumentStatementInputArgs
                {
                    Effect = "Allow",
                    Principals = new[]
                    {
                        new Aws.Iam.Inputs.GetPolicyDocumentStatementPrincipalInputArgs
                        {
                            Type = "Service",
                            Identifiers = new[]
                            {
                                "firehose.amazonaws.com",
                            },
                        },
                    },
                    Actions = new[]
                    {
                        "sts:AssumeRole",
                    },
                },
            },
        });
    
        var firehoseRole = new Aws.Iam.Role("firehose_role", new()
        {
            Name = "firehose_test_role",
            AssumeRolePolicy = firehoseAssumeRole.Apply(getPolicyDocumentResult => getPolicyDocumentResult.Json),
        });
    
        var lambdaAssumeRole = Aws.Iam.GetPolicyDocument.Invoke(new()
        {
            Statements = new[]
            {
                new Aws.Iam.Inputs.GetPolicyDocumentStatementInputArgs
                {
                    Effect = "Allow",
                    Principals = new[]
                    {
                        new Aws.Iam.Inputs.GetPolicyDocumentStatementPrincipalInputArgs
                        {
                            Type = "Service",
                            Identifiers = new[]
                            {
                                "lambda.amazonaws.com",
                            },
                        },
                    },
                    Actions = new[]
                    {
                        "sts:AssumeRole",
                    },
                },
            },
        });
    
        var lambdaIam = new Aws.Iam.Role("lambda_iam", new()
        {
            Name = "lambda_iam",
            AssumeRolePolicy = lambdaAssumeRole.Apply(getPolicyDocumentResult => getPolicyDocumentResult.Json),
        });
    
        var lambdaProcessor = new Aws.Lambda.Function("lambda_processor", new()
        {
            Code = new FileArchive("lambda.zip"),
            Name = "firehose_lambda_processor",
            Role = lambdaIam.Arn,
            Handler = "exports.handler",
            Runtime = Aws.Lambda.Runtime.NodeJS16dX,
        });
    
        var extendedS3Stream = new Aws.Kinesis.FirehoseDeliveryStream("extended_s3_stream", new()
        {
            Name = "kinesis-firehose-extended-s3-test-stream",
            Destination = "extended_s3",
            ExtendedS3Configuration = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamExtendedS3ConfigurationArgs
            {
                RoleArn = firehoseRole.Arn,
                BucketArn = bucket.Arn,
                ProcessingConfiguration = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationArgs
                {
                    Enabled = true,
                    Processors = new[]
                    {
                        new Aws.Kinesis.Inputs.FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorArgs
                        {
                            Type = "Lambda",
                            Parameters = new[]
                            {
                                new Aws.Kinesis.Inputs.FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorParameterArgs
                                {
                                    ParameterName = "LambdaArn",
                                    ParameterValue = lambdaProcessor.Arn.Apply(arn => $"{arn}:$LATEST"),
                                },
                            },
                        },
                    },
                },
            },
        });
    
        var bucketAcl = new Aws.S3.BucketAclV2("bucket_acl", new()
        {
            Bucket = bucket.Id,
            Acl = "private",
        });
    
    });
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.aws.s3.BucketV2;
    import com.pulumi.aws.s3.BucketV2Args;
    import com.pulumi.aws.iam.IamFunctions;
    import com.pulumi.aws.iam.inputs.GetPolicyDocumentArgs;
    import com.pulumi.aws.iam.Role;
    import com.pulumi.aws.iam.RoleArgs;
    import com.pulumi.aws.lambda.Function;
    import com.pulumi.aws.lambda.FunctionArgs;
    import com.pulumi.aws.kinesis.FirehoseDeliveryStream;
    import com.pulumi.aws.kinesis.FirehoseDeliveryStreamArgs;
    import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamExtendedS3ConfigurationArgs;
    import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationArgs;
    import com.pulumi.aws.s3.BucketAclV2;
    import com.pulumi.aws.s3.BucketAclV2Args;
    import com.pulumi.asset.FileArchive;
    import java.util.List;
    import java.util.ArrayList;
    import java.util.Map;
    import java.io.File;
    import java.nio.file.Files;
    import java.nio.file.Paths;
    
    public class App {
        public static void main(String[] args) {
            Pulumi.run(App::stack);
        }
    
        public static void stack(Context ctx) {
            var bucket = new BucketV2("bucket", BucketV2Args.builder()
                .bucket("tf-test-bucket")
                .build());
    
            final var firehoseAssumeRole = IamFunctions.getPolicyDocument(GetPolicyDocumentArgs.builder()
                .statements(GetPolicyDocumentStatementArgs.builder()
                    .effect("Allow")
                    .principals(GetPolicyDocumentStatementPrincipalArgs.builder()
                        .type("Service")
                        .identifiers("firehose.amazonaws.com")
                        .build())
                    .actions("sts:AssumeRole")
                    .build())
                .build());
    
            var firehoseRole = new Role("firehoseRole", RoleArgs.builder()
                .name("firehose_test_role")
                .assumeRolePolicy(firehoseAssumeRole.applyValue(getPolicyDocumentResult -> getPolicyDocumentResult.json()))
                .build());
    
            final var lambdaAssumeRole = IamFunctions.getPolicyDocument(GetPolicyDocumentArgs.builder()
                .statements(GetPolicyDocumentStatementArgs.builder()
                    .effect("Allow")
                    .principals(GetPolicyDocumentStatementPrincipalArgs.builder()
                        .type("Service")
                        .identifiers("lambda.amazonaws.com")
                        .build())
                    .actions("sts:AssumeRole")
                    .build())
                .build());
    
            var lambdaIam = new Role("lambdaIam", RoleArgs.builder()
                .name("lambda_iam")
                .assumeRolePolicy(lambdaAssumeRole.applyValue(getPolicyDocumentResult -> getPolicyDocumentResult.json()))
                .build());
    
            var lambdaProcessor = new Function("lambdaProcessor", FunctionArgs.builder()
                .code(new FileArchive("lambda.zip"))
                .name("firehose_lambda_processor")
                .role(lambdaIam.arn())
                .handler("exports.handler")
                .runtime("nodejs16.x")
                .build());
    
            var extendedS3Stream = new FirehoseDeliveryStream("extendedS3Stream", FirehoseDeliveryStreamArgs.builder()
                .name("kinesis-firehose-extended-s3-test-stream")
                .destination("extended_s3")
                .extendedS3Configuration(FirehoseDeliveryStreamExtendedS3ConfigurationArgs.builder()
                    .roleArn(firehoseRole.arn())
                    .bucketArn(bucket.arn())
                    .processingConfiguration(FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationArgs.builder()
                        .enabled("true")
                        .processors(FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorArgs.builder()
                            .type("Lambda")
                            .parameters(FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorParameterArgs.builder()
                                .parameterName("LambdaArn")
                                .parameterValue(lambdaProcessor.arn().applyValue(arn -> String.format("%s:$LATEST", arn)))
                                .build())
                            .build())
                        .build())
                    .build())
                .build());
    
            var bucketAcl = new BucketAclV2("bucketAcl", BucketAclV2Args.builder()
                .bucket(bucket.id())
                .acl("private")
                .build());
    
        }
    }
    
    resources:
      extendedS3Stream:
        type: aws:kinesis:FirehoseDeliveryStream
        name: extended_s3_stream
        properties:
          name: kinesis-firehose-extended-s3-test-stream
          destination: extended_s3
          extendedS3Configuration:
            roleArn: ${firehoseRole.arn}
            bucketArn: ${bucket.arn}
            processingConfiguration:
              enabled: 'true'
              processors:
                - type: Lambda
                  parameters:
                    - parameterName: LambdaArn
                      parameterValue: ${lambdaProcessor.arn}:$LATEST
      bucket:
        type: aws:s3:BucketV2
        properties:
          bucket: tf-test-bucket
      bucketAcl:
        type: aws:s3:BucketAclV2
        name: bucket_acl
        properties:
          bucket: ${bucket.id}
          acl: private
      firehoseRole:
        type: aws:iam:Role
        name: firehose_role
        properties:
          name: firehose_test_role
          assumeRolePolicy: ${firehoseAssumeRole.json}
      lambdaIam:
        type: aws:iam:Role
        name: lambda_iam
        properties:
          name: lambda_iam
          assumeRolePolicy: ${lambdaAssumeRole.json}
      lambdaProcessor:
        type: aws:lambda:Function
        name: lambda_processor
        properties:
          code:
            fn::FileArchive: lambda.zip
          name: firehose_lambda_processor
          role: ${lambdaIam.arn}
          handler: exports.handler
          runtime: nodejs16.x
    variables:
      firehoseAssumeRole:
        fn::invoke:
          Function: aws:iam:getPolicyDocument
          Arguments:
            statements:
              - effect: Allow
                principals:
                  - type: Service
                    identifiers:
                      - firehose.amazonaws.com
                actions:
                  - sts:AssumeRole
      lambdaAssumeRole:
        fn::invoke:
          Function: aws:iam:getPolicyDocument
          Arguments:
            statements:
              - effect: Allow
                principals:
                  - type: Service
                    identifiers:
                      - lambda.amazonaws.com
                actions:
                  - sts:AssumeRole
    

    Extended S3 Destination with dynamic partitioning

    These examples use built-in Firehose functionality, rather than requiring a lambda.

    import * as pulumi from "@pulumi/pulumi";
    import * as aws from "@pulumi/aws";
    
    const extendedS3Stream = new aws.kinesis.FirehoseDeliveryStream("extended_s3_stream", {
        name: "kinesis-firehose-extended-s3-test-stream",
        destination: "extended_s3",
        extendedS3Configuration: {
            roleArn: firehoseRole.arn,
            bucketArn: bucket.arn,
            bufferingSize: 64,
            dynamicPartitioningConfiguration: {
                enabled: true,
            },
            prefix: "data/customer_id=!{partitionKeyFromQuery:customer_id}/year=!{timestamp:yyyy}/month=!{timestamp:MM}/day=!{timestamp:dd}/hour=!{timestamp:HH}/",
            errorOutputPrefix: "errors/year=!{timestamp:yyyy}/month=!{timestamp:MM}/day=!{timestamp:dd}/hour=!{timestamp:HH}/!{firehose:error-output-type}/",
            processingConfiguration: {
                enabled: true,
                processors: [
                    {
                        type: "RecordDeAggregation",
                        parameters: [{
                            parameterName: "SubRecordType",
                            parameterValue: "JSON",
                        }],
                    },
                    {
                        type: "AppendDelimiterToRecord",
                    },
                    {
                        type: "MetadataExtraction",
                        parameters: [
                            {
                                parameterName: "JsonParsingEngine",
                                parameterValue: "JQ-1.6",
                            },
                            {
                                parameterName: "MetadataExtractionQuery",
                                parameterValue: "{customer_id:.customer_id}",
                            },
                        ],
                    },
                ],
            },
        },
    });
    
    import pulumi
    import pulumi_aws as aws
    
    extended_s3_stream = aws.kinesis.FirehoseDeliveryStream("extended_s3_stream",
        name="kinesis-firehose-extended-s3-test-stream",
        destination="extended_s3",
        extended_s3_configuration=aws.kinesis.FirehoseDeliveryStreamExtendedS3ConfigurationArgs(
            role_arn=firehose_role["arn"],
            bucket_arn=bucket["arn"],
            buffering_size=64,
            dynamic_partitioning_configuration=aws.kinesis.FirehoseDeliveryStreamExtendedS3ConfigurationDynamicPartitioningConfigurationArgs(
                enabled=True,
            ),
            prefix="data/customer_id=!{partitionKeyFromQuery:customer_id}/year=!{timestamp:yyyy}/month=!{timestamp:MM}/day=!{timestamp:dd}/hour=!{timestamp:HH}/",
            error_output_prefix="errors/year=!{timestamp:yyyy}/month=!{timestamp:MM}/day=!{timestamp:dd}/hour=!{timestamp:HH}/!{firehose:error-output-type}/",
            processing_configuration=aws.kinesis.FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationArgs(
                enabled=True,
                processors=[
                    aws.kinesis.FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorArgs(
                        type="RecordDeAggregation",
                        parameters=[aws.kinesis.FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorParameterArgs(
                            parameter_name="SubRecordType",
                            parameter_value="JSON",
                        )],
                    ),
                    aws.kinesis.FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorArgs(
                        type="AppendDelimiterToRecord",
                    ),
                    aws.kinesis.FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorArgs(
                        type="MetadataExtraction",
                        parameters=[
                            aws.kinesis.FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorParameterArgs(
                                parameter_name="JsonParsingEngine",
                                parameter_value="JQ-1.6",
                            ),
                            aws.kinesis.FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorParameterArgs(
                                parameter_name="MetadataExtractionQuery",
                                parameter_value="{customer_id:.customer_id}",
                            ),
                        ],
                    ),
                ],
            ),
        ))
    
    package main
    
    import (
    	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/kinesis"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		_, err := kinesis.NewFirehoseDeliveryStream(ctx, "extended_s3_stream", &kinesis.FirehoseDeliveryStreamArgs{
    			Name:        pulumi.String("kinesis-firehose-extended-s3-test-stream"),
    			Destination: pulumi.String("extended_s3"),
    			ExtendedS3Configuration: &kinesis.FirehoseDeliveryStreamExtendedS3ConfigurationArgs{
    				RoleArn:       pulumi.Any(firehoseRole.Arn),
    				BucketArn:     pulumi.Any(bucket.Arn),
    				BufferingSize: pulumi.Int(64),
    				DynamicPartitioningConfiguration: &kinesis.FirehoseDeliveryStreamExtendedS3ConfigurationDynamicPartitioningConfigurationArgs{
    					Enabled: pulumi.Bool(true),
    				},
    				Prefix:            pulumi.String("data/customer_id=!{partitionKeyFromQuery:customer_id}/year=!{timestamp:yyyy}/month=!{timestamp:MM}/day=!{timestamp:dd}/hour=!{timestamp:HH}/"),
    				ErrorOutputPrefix: pulumi.String("errors/year=!{timestamp:yyyy}/month=!{timestamp:MM}/day=!{timestamp:dd}/hour=!{timestamp:HH}/!{firehose:error-output-type}/"),
    				ProcessingConfiguration: &kinesis.FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationArgs{
    					Enabled: pulumi.Bool(true),
    					Processors: kinesis.FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorArray{
    						&kinesis.FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorArgs{
    							Type: pulumi.String("RecordDeAggregation"),
    							Parameters: kinesis.FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorParameterArray{
    								&kinesis.FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorParameterArgs{
    									ParameterName:  pulumi.String("SubRecordType"),
    									ParameterValue: pulumi.String("JSON"),
    								},
    							},
    						},
    						&kinesis.FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorArgs{
    							Type: pulumi.String("AppendDelimiterToRecord"),
    						},
    						&kinesis.FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorArgs{
    							Type: pulumi.String("MetadataExtraction"),
    							Parameters: kinesis.FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorParameterArray{
    								&kinesis.FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorParameterArgs{
    									ParameterName:  pulumi.String("JsonParsingEngine"),
    									ParameterValue: pulumi.String("JQ-1.6"),
    								},
    								&kinesis.FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorParameterArgs{
    									ParameterName:  pulumi.String("MetadataExtractionQuery"),
    									ParameterValue: pulumi.String("{customer_id:.customer_id}"),
    								},
    							},
    						},
    					},
    				},
    			},
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using Aws = Pulumi.Aws;
    
    return await Deployment.RunAsync(() => 
    {
        var extendedS3Stream = new Aws.Kinesis.FirehoseDeliveryStream("extended_s3_stream", new()
        {
            Name = "kinesis-firehose-extended-s3-test-stream",
            Destination = "extended_s3",
            ExtendedS3Configuration = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamExtendedS3ConfigurationArgs
            {
                RoleArn = firehoseRole.Arn,
                BucketArn = bucket.Arn,
                BufferingSize = 64,
                DynamicPartitioningConfiguration = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamExtendedS3ConfigurationDynamicPartitioningConfigurationArgs
                {
                    Enabled = true,
                },
                Prefix = "data/customer_id=!{partitionKeyFromQuery:customer_id}/year=!{timestamp:yyyy}/month=!{timestamp:MM}/day=!{timestamp:dd}/hour=!{timestamp:HH}/",
                ErrorOutputPrefix = "errors/year=!{timestamp:yyyy}/month=!{timestamp:MM}/day=!{timestamp:dd}/hour=!{timestamp:HH}/!{firehose:error-output-type}/",
                ProcessingConfiguration = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationArgs
                {
                    Enabled = true,
                    Processors = new[]
                    {
                        new Aws.Kinesis.Inputs.FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorArgs
                        {
                            Type = "RecordDeAggregation",
                            Parameters = new[]
                            {
                                new Aws.Kinesis.Inputs.FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorParameterArgs
                                {
                                    ParameterName = "SubRecordType",
                                    ParameterValue = "JSON",
                                },
                            },
                        },
                        new Aws.Kinesis.Inputs.FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorArgs
                        {
                            Type = "AppendDelimiterToRecord",
                        },
                        new Aws.Kinesis.Inputs.FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorArgs
                        {
                            Type = "MetadataExtraction",
                            Parameters = new[]
                            {
                                new Aws.Kinesis.Inputs.FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorParameterArgs
                                {
                                    ParameterName = "JsonParsingEngine",
                                    ParameterValue = "JQ-1.6",
                                },
                                new Aws.Kinesis.Inputs.FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorParameterArgs
                                {
                                    ParameterName = "MetadataExtractionQuery",
                                    ParameterValue = "{customer_id:.customer_id}",
                                },
                            },
                        },
                    },
                },
            },
        });
    
    });
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.aws.kinesis.FirehoseDeliveryStream;
    import com.pulumi.aws.kinesis.FirehoseDeliveryStreamArgs;
    import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamExtendedS3ConfigurationArgs;
    import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamExtendedS3ConfigurationDynamicPartitioningConfigurationArgs;
    import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationArgs;
    import java.util.List;
    import java.util.ArrayList;
    import java.util.Map;
    import java.io.File;
    import java.nio.file.Files;
    import java.nio.file.Paths;
    
    public class App {
        public static void main(String[] args) {
            Pulumi.run(App::stack);
        }
    
        public static void stack(Context ctx) {
            var extendedS3Stream = new FirehoseDeliveryStream("extendedS3Stream", FirehoseDeliveryStreamArgs.builder()
                .name("kinesis-firehose-extended-s3-test-stream")
                .destination("extended_s3")
                .extendedS3Configuration(FirehoseDeliveryStreamExtendedS3ConfigurationArgs.builder()
                    .roleArn(firehoseRole.arn())
                    .bucketArn(bucket.arn())
                    .bufferingSize(64)
                    .dynamicPartitioningConfiguration(FirehoseDeliveryStreamExtendedS3ConfigurationDynamicPartitioningConfigurationArgs.builder()
                        .enabled("true")
                        .build())
                    .prefix("data/customer_id=!{partitionKeyFromQuery:customer_id}/year=!{timestamp:yyyy}/month=!{timestamp:MM}/day=!{timestamp:dd}/hour=!{timestamp:HH}/")
                    .errorOutputPrefix("errors/year=!{timestamp:yyyy}/month=!{timestamp:MM}/day=!{timestamp:dd}/hour=!{timestamp:HH}/!{firehose:error-output-type}/")
                    .processingConfiguration(FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationArgs.builder()
                        .enabled("true")
                        .processors(                    
                            FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorArgs.builder()
                                .type("RecordDeAggregation")
                                .parameters(FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorParameterArgs.builder()
                                    .parameterName("SubRecordType")
                                    .parameterValue("JSON")
                                    .build())
                                .build(),
                            FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorArgs.builder()
                                .type("AppendDelimiterToRecord")
                                .build(),
                            FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorArgs.builder()
                                .type("MetadataExtraction")
                                .parameters(                            
                                    FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorParameterArgs.builder()
                                        .parameterName("JsonParsingEngine")
                                        .parameterValue("JQ-1.6")
                                        .build(),
                                    FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorParameterArgs.builder()
                                        .parameterName("MetadataExtractionQuery")
                                        .parameterValue("{customer_id:.customer_id}")
                                        .build())
                                .build())
                        .build())
                    .build())
                .build());
    
        }
    }
    
    resources:
      extendedS3Stream:
        type: aws:kinesis:FirehoseDeliveryStream
        name: extended_s3_stream
        properties:
          name: kinesis-firehose-extended-s3-test-stream
          destination: extended_s3
          extendedS3Configuration:
            roleArn: ${firehoseRole.arn}
            bucketArn: ${bucket.arn}
            bufferingSize: 64
            dynamicPartitioningConfiguration:
              enabled: 'true'
            prefix: data/customer_id=!{partitionKeyFromQuery:customer_id}/year=!{timestamp:yyyy}/month=!{timestamp:MM}/day=!{timestamp:dd}/hour=!{timestamp:HH}/
            errorOutputPrefix: errors/year=!{timestamp:yyyy}/month=!{timestamp:MM}/day=!{timestamp:dd}/hour=!{timestamp:HH}/!{firehose:error-output-type}/
            processingConfiguration:
              enabled: 'true'
              processors:
                - type: RecordDeAggregation
                  parameters:
                    - parameterName: SubRecordType
                      parameterValue: JSON
                - type: AppendDelimiterToRecord
                - type: MetadataExtraction
                  parameters:
                    - parameterName: JsonParsingEngine
                      parameterValue: JQ-1.6
                    - parameterName: MetadataExtractionQuery
                      parameterValue: '{customer_id:.customer_id}'
    

    Multiple Dynamic Partitioning Keys (maximum of 50) can be added by comma separating the parameter_value.

    The following example adds the Dynamic Partitioning Keys: store_id and customer_id to the S3 prefix.

    import * as pulumi from "@pulumi/pulumi";
    import * as aws from "@pulumi/aws";
    
    const extendedS3Stream = new aws.kinesis.FirehoseDeliveryStream("extended_s3_stream", {
        name: "kinesis-firehose-extended-s3-test-stream",
        destination: "extended_s3",
        extendedS3Configuration: {
            roleArn: firehoseRole.arn,
            bucketArn: bucket.arn,
            bufferingSize: 64,
            dynamicPartitioningConfiguration: {
                enabled: true,
            },
            prefix: "data/store_id=!{partitionKeyFromQuery:store_id}/customer_id=!{partitionKeyFromQuery:customer_id}/year=!{timestamp:yyyy}/month=!{timestamp:MM}/day=!{timestamp:dd}/hour=!{timestamp:HH}/",
            errorOutputPrefix: "errors/year=!{timestamp:yyyy}/month=!{timestamp:MM}/day=!{timestamp:dd}/hour=!{timestamp:HH}/!{firehose:error-output-type}/",
            processingConfiguration: {
                enabled: true,
                processors: [{
                    type: "MetadataExtraction",
                    parameters: [
                        {
                            parameterName: "JsonParsingEngine",
                            parameterValue: "JQ-1.6",
                        },
                        {
                            parameterName: "MetadataExtractionQuery",
                            parameterValue: "{store_id:.store_id,customer_id:.customer_id}",
                        },
                    ],
                }],
            },
        },
    });
    
    import pulumi
    import pulumi_aws as aws
    
    extended_s3_stream = aws.kinesis.FirehoseDeliveryStream("extended_s3_stream",
        name="kinesis-firehose-extended-s3-test-stream",
        destination="extended_s3",
        extended_s3_configuration=aws.kinesis.FirehoseDeliveryStreamExtendedS3ConfigurationArgs(
            role_arn=firehose_role["arn"],
            bucket_arn=bucket["arn"],
            buffering_size=64,
            dynamic_partitioning_configuration=aws.kinesis.FirehoseDeliveryStreamExtendedS3ConfigurationDynamicPartitioningConfigurationArgs(
                enabled=True,
            ),
            prefix="data/store_id=!{partitionKeyFromQuery:store_id}/customer_id=!{partitionKeyFromQuery:customer_id}/year=!{timestamp:yyyy}/month=!{timestamp:MM}/day=!{timestamp:dd}/hour=!{timestamp:HH}/",
            error_output_prefix="errors/year=!{timestamp:yyyy}/month=!{timestamp:MM}/day=!{timestamp:dd}/hour=!{timestamp:HH}/!{firehose:error-output-type}/",
            processing_configuration=aws.kinesis.FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationArgs(
                enabled=True,
                processors=[aws.kinesis.FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorArgs(
                    type="MetadataExtraction",
                    parameters=[
                        aws.kinesis.FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorParameterArgs(
                            parameter_name="JsonParsingEngine",
                            parameter_value="JQ-1.6",
                        ),
                        aws.kinesis.FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorParameterArgs(
                            parameter_name="MetadataExtractionQuery",
                            parameter_value="{store_id:.store_id,customer_id:.customer_id}",
                        ),
                    ],
                )],
            ),
        ))
    
    package main
    
    import (
    	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/kinesis"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		_, err := kinesis.NewFirehoseDeliveryStream(ctx, "extended_s3_stream", &kinesis.FirehoseDeliveryStreamArgs{
    			Name:        pulumi.String("kinesis-firehose-extended-s3-test-stream"),
    			Destination: pulumi.String("extended_s3"),
    			ExtendedS3Configuration: &kinesis.FirehoseDeliveryStreamExtendedS3ConfigurationArgs{
    				RoleArn:       pulumi.Any(firehoseRole.Arn),
    				BucketArn:     pulumi.Any(bucket.Arn),
    				BufferingSize: pulumi.Int(64),
    				DynamicPartitioningConfiguration: &kinesis.FirehoseDeliveryStreamExtendedS3ConfigurationDynamicPartitioningConfigurationArgs{
    					Enabled: pulumi.Bool(true),
    				},
    				Prefix:            pulumi.String("data/store_id=!{partitionKeyFromQuery:store_id}/customer_id=!{partitionKeyFromQuery:customer_id}/year=!{timestamp:yyyy}/month=!{timestamp:MM}/day=!{timestamp:dd}/hour=!{timestamp:HH}/"),
    				ErrorOutputPrefix: pulumi.String("errors/year=!{timestamp:yyyy}/month=!{timestamp:MM}/day=!{timestamp:dd}/hour=!{timestamp:HH}/!{firehose:error-output-type}/"),
    				ProcessingConfiguration: &kinesis.FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationArgs{
    					Enabled: pulumi.Bool(true),
    					Processors: kinesis.FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorArray{
    						&kinesis.FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorArgs{
    							Type: pulumi.String("MetadataExtraction"),
    							Parameters: kinesis.FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorParameterArray{
    								&kinesis.FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorParameterArgs{
    									ParameterName:  pulumi.String("JsonParsingEngine"),
    									ParameterValue: pulumi.String("JQ-1.6"),
    								},
    								&kinesis.FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorParameterArgs{
    									ParameterName:  pulumi.String("MetadataExtractionQuery"),
    									ParameterValue: pulumi.String("{store_id:.store_id,customer_id:.customer_id}"),
    								},
    							},
    						},
    					},
    				},
    			},
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using Aws = Pulumi.Aws;
    
    return await Deployment.RunAsync(() => 
    {
        var extendedS3Stream = new Aws.Kinesis.FirehoseDeliveryStream("extended_s3_stream", new()
        {
            Name = "kinesis-firehose-extended-s3-test-stream",
            Destination = "extended_s3",
            ExtendedS3Configuration = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamExtendedS3ConfigurationArgs
            {
                RoleArn = firehoseRole.Arn,
                BucketArn = bucket.Arn,
                BufferingSize = 64,
                DynamicPartitioningConfiguration = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamExtendedS3ConfigurationDynamicPartitioningConfigurationArgs
                {
                    Enabled = true,
                },
                Prefix = "data/store_id=!{partitionKeyFromQuery:store_id}/customer_id=!{partitionKeyFromQuery:customer_id}/year=!{timestamp:yyyy}/month=!{timestamp:MM}/day=!{timestamp:dd}/hour=!{timestamp:HH}/",
                ErrorOutputPrefix = "errors/year=!{timestamp:yyyy}/month=!{timestamp:MM}/day=!{timestamp:dd}/hour=!{timestamp:HH}/!{firehose:error-output-type}/",
                ProcessingConfiguration = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationArgs
                {
                    Enabled = true,
                    Processors = new[]
                    {
                        new Aws.Kinesis.Inputs.FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorArgs
                        {
                            Type = "MetadataExtraction",
                            Parameters = new[]
                            {
                                new Aws.Kinesis.Inputs.FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorParameterArgs
                                {
                                    ParameterName = "JsonParsingEngine",
                                    ParameterValue = "JQ-1.6",
                                },
                                new Aws.Kinesis.Inputs.FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorParameterArgs
                                {
                                    ParameterName = "MetadataExtractionQuery",
                                    ParameterValue = "{store_id:.store_id,customer_id:.customer_id}",
                                },
                            },
                        },
                    },
                },
            },
        });
    
    });
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.aws.kinesis.FirehoseDeliveryStream;
    import com.pulumi.aws.kinesis.FirehoseDeliveryStreamArgs;
    import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamExtendedS3ConfigurationArgs;
    import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamExtendedS3ConfigurationDynamicPartitioningConfigurationArgs;
    import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationArgs;
    import java.util.List;
    import java.util.ArrayList;
    import java.util.Map;
    import java.io.File;
    import java.nio.file.Files;
    import java.nio.file.Paths;
    
    public class App {
        public static void main(String[] args) {
            Pulumi.run(App::stack);
        }
    
        public static void stack(Context ctx) {
            var extendedS3Stream = new FirehoseDeliveryStream("extendedS3Stream", FirehoseDeliveryStreamArgs.builder()
                .name("kinesis-firehose-extended-s3-test-stream")
                .destination("extended_s3")
                .extendedS3Configuration(FirehoseDeliveryStreamExtendedS3ConfigurationArgs.builder()
                    .roleArn(firehoseRole.arn())
                    .bucketArn(bucket.arn())
                    .bufferingSize(64)
                    .dynamicPartitioningConfiguration(FirehoseDeliveryStreamExtendedS3ConfigurationDynamicPartitioningConfigurationArgs.builder()
                        .enabled("true")
                        .build())
                    .prefix("data/store_id=!{partitionKeyFromQuery:store_id}/customer_id=!{partitionKeyFromQuery:customer_id}/year=!{timestamp:yyyy}/month=!{timestamp:MM}/day=!{timestamp:dd}/hour=!{timestamp:HH}/")
                    .errorOutputPrefix("errors/year=!{timestamp:yyyy}/month=!{timestamp:MM}/day=!{timestamp:dd}/hour=!{timestamp:HH}/!{firehose:error-output-type}/")
                    .processingConfiguration(FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationArgs.builder()
                        .enabled("true")
                        .processors(FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorArgs.builder()
                            .type("MetadataExtraction")
                            .parameters(                        
                                FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorParameterArgs.builder()
                                    .parameterName("JsonParsingEngine")
                                    .parameterValue("JQ-1.6")
                                    .build(),
                                FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorParameterArgs.builder()
                                    .parameterName("MetadataExtractionQuery")
                                    .parameterValue("{store_id:.store_id,customer_id:.customer_id}")
                                    .build())
                            .build())
                        .build())
                    .build())
                .build());
    
        }
    }
    
    resources:
      extendedS3Stream:
        type: aws:kinesis:FirehoseDeliveryStream
        name: extended_s3_stream
        properties:
          name: kinesis-firehose-extended-s3-test-stream
          destination: extended_s3
          extendedS3Configuration:
            roleArn: ${firehoseRole.arn}
            bucketArn: ${bucket.arn}
            bufferingSize: 64
            dynamicPartitioningConfiguration:
              enabled: 'true'
            prefix: data/store_id=!{partitionKeyFromQuery:store_id}/customer_id=!{partitionKeyFromQuery:customer_id}/year=!{timestamp:yyyy}/month=!{timestamp:MM}/day=!{timestamp:dd}/hour=!{timestamp:HH}/
            errorOutputPrefix: errors/year=!{timestamp:yyyy}/month=!{timestamp:MM}/day=!{timestamp:dd}/hour=!{timestamp:HH}/!{firehose:error-output-type}/
            processingConfiguration:
              enabled: 'true'
              processors:
                - type: MetadataExtraction
                  parameters:
                    - parameterName: JsonParsingEngine
                      parameterValue: JQ-1.6
                    - parameterName: MetadataExtractionQuery
                      parameterValue: '{store_id:.store_id,customer_id:.customer_id}'
    

    Redshift Destination

    import * as pulumi from "@pulumi/pulumi";
    import * as aws from "@pulumi/aws";
    
    const testCluster = new aws.redshift.Cluster("test_cluster", {
        clusterIdentifier: "tf-redshift-cluster",
        databaseName: "test",
        masterUsername: "testuser",
        masterPassword: "T3stPass",
        nodeType: "dc1.large",
        clusterType: "single-node",
    });
    const testStream = new aws.kinesis.FirehoseDeliveryStream("test_stream", {
        name: "kinesis-firehose-test-stream",
        destination: "redshift",
        redshiftConfiguration: {
            roleArn: firehoseRole.arn,
            clusterJdbcurl: pulumi.interpolate`jdbc:redshift://${testCluster.endpoint}/${testCluster.databaseName}`,
            username: "testuser",
            password: "T3stPass",
            dataTableName: "test-table",
            copyOptions: "delimiter '|'",
            dataTableColumns: "test-col",
            s3BackupMode: "Enabled",
            s3Configuration: {
                roleArn: firehoseRole.arn,
                bucketArn: bucket.arn,
                bufferingSize: 10,
                bufferingInterval: 400,
                compressionFormat: "GZIP",
            },
            s3BackupConfiguration: {
                roleArn: firehoseRole.arn,
                bucketArn: bucket.arn,
                bufferingSize: 15,
                bufferingInterval: 300,
                compressionFormat: "GZIP",
            },
        },
    });
    
    import pulumi
    import pulumi_aws as aws
    
    test_cluster = aws.redshift.Cluster("test_cluster",
        cluster_identifier="tf-redshift-cluster",
        database_name="test",
        master_username="testuser",
        master_password="T3stPass",
        node_type="dc1.large",
        cluster_type="single-node")
    test_stream = aws.kinesis.FirehoseDeliveryStream("test_stream",
        name="kinesis-firehose-test-stream",
        destination="redshift",
        redshift_configuration=aws.kinesis.FirehoseDeliveryStreamRedshiftConfigurationArgs(
            role_arn=firehose_role["arn"],
            cluster_jdbcurl=pulumi.Output.all(test_cluster.endpoint, test_cluster.database_name).apply(lambda endpoint, database_name: f"jdbc:redshift://{endpoint}/{database_name}"),
            username="testuser",
            password="T3stPass",
            data_table_name="test-table",
            copy_options="delimiter '|'",
            data_table_columns="test-col",
            s3_backup_mode="Enabled",
            s3_configuration=aws.kinesis.FirehoseDeliveryStreamRedshiftConfigurationS3ConfigurationArgs(
                role_arn=firehose_role["arn"],
                bucket_arn=bucket["arn"],
                buffering_size=10,
                buffering_interval=400,
                compression_format="GZIP",
            ),
            s3_backup_configuration=aws.kinesis.FirehoseDeliveryStreamRedshiftConfigurationS3BackupConfigurationArgs(
                role_arn=firehose_role["arn"],
                bucket_arn=bucket["arn"],
                buffering_size=15,
                buffering_interval=300,
                compression_format="GZIP",
            ),
        ))
    
    package main
    
    import (
    	"fmt"
    
    	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/kinesis"
    	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/redshift"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		testCluster, err := redshift.NewCluster(ctx, "test_cluster", &redshift.ClusterArgs{
    			ClusterIdentifier: pulumi.String("tf-redshift-cluster"),
    			DatabaseName:      pulumi.String("test"),
    			MasterUsername:    pulumi.String("testuser"),
    			MasterPassword:    pulumi.String("T3stPass"),
    			NodeType:          pulumi.String("dc1.large"),
    			ClusterType:       pulumi.String("single-node"),
    		})
    		if err != nil {
    			return err
    		}
    		_, err = kinesis.NewFirehoseDeliveryStream(ctx, "test_stream", &kinesis.FirehoseDeliveryStreamArgs{
    			Name:        pulumi.String("kinesis-firehose-test-stream"),
    			Destination: pulumi.String("redshift"),
    			RedshiftConfiguration: &kinesis.FirehoseDeliveryStreamRedshiftConfigurationArgs{
    				RoleArn: pulumi.Any(firehoseRole.Arn),
    				ClusterJdbcurl: pulumi.All(testCluster.Endpoint, testCluster.DatabaseName).ApplyT(func(_args []interface{}) (string, error) {
    					endpoint := _args[0].(string)
    					databaseName := _args[1].(string)
    					return fmt.Sprintf("jdbc:redshift://%v/%v", endpoint, databaseName), nil
    				}).(pulumi.StringOutput),
    				Username:         pulumi.String("testuser"),
    				Password:         pulumi.String("T3stPass"),
    				DataTableName:    pulumi.String("test-table"),
    				CopyOptions:      pulumi.String("delimiter '|'"),
    				DataTableColumns: pulumi.String("test-col"),
    				S3BackupMode:     pulumi.String("Enabled"),
    				S3Configuration: &kinesis.FirehoseDeliveryStreamRedshiftConfigurationS3ConfigurationArgs{
    					RoleArn:           pulumi.Any(firehoseRole.Arn),
    					BucketArn:         pulumi.Any(bucket.Arn),
    					BufferingSize:     pulumi.Int(10),
    					BufferingInterval: pulumi.Int(400),
    					CompressionFormat: pulumi.String("GZIP"),
    				},
    				S3BackupConfiguration: &kinesis.FirehoseDeliveryStreamRedshiftConfigurationS3BackupConfigurationArgs{
    					RoleArn:           pulumi.Any(firehoseRole.Arn),
    					BucketArn:         pulumi.Any(bucket.Arn),
    					BufferingSize:     pulumi.Int(15),
    					BufferingInterval: pulumi.Int(300),
    					CompressionFormat: pulumi.String("GZIP"),
    				},
    			},
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using Aws = Pulumi.Aws;
    
    return await Deployment.RunAsync(() => 
    {
        var testCluster = new Aws.RedShift.Cluster("test_cluster", new()
        {
            ClusterIdentifier = "tf-redshift-cluster",
            DatabaseName = "test",
            MasterUsername = "testuser",
            MasterPassword = "T3stPass",
            NodeType = "dc1.large",
            ClusterType = "single-node",
        });
    
        var testStream = new Aws.Kinesis.FirehoseDeliveryStream("test_stream", new()
        {
            Name = "kinesis-firehose-test-stream",
            Destination = "redshift",
            RedshiftConfiguration = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamRedshiftConfigurationArgs
            {
                RoleArn = firehoseRole.Arn,
                ClusterJdbcurl = Output.Tuple(testCluster.Endpoint, testCluster.DatabaseName).Apply(values =>
                {
                    var endpoint = values.Item1;
                    var databaseName = values.Item2;
                    return $"jdbc:redshift://{endpoint}/{databaseName}";
                }),
                Username = "testuser",
                Password = "T3stPass",
                DataTableName = "test-table",
                CopyOptions = "delimiter '|'",
                DataTableColumns = "test-col",
                S3BackupMode = "Enabled",
                S3Configuration = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamRedshiftConfigurationS3ConfigurationArgs
                {
                    RoleArn = firehoseRole.Arn,
                    BucketArn = bucket.Arn,
                    BufferingSize = 10,
                    BufferingInterval = 400,
                    CompressionFormat = "GZIP",
                },
                S3BackupConfiguration = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamRedshiftConfigurationS3BackupConfigurationArgs
                {
                    RoleArn = firehoseRole.Arn,
                    BucketArn = bucket.Arn,
                    BufferingSize = 15,
                    BufferingInterval = 300,
                    CompressionFormat = "GZIP",
                },
            },
        });
    
    });
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.aws.redshift.Cluster;
    import com.pulumi.aws.redshift.ClusterArgs;
    import com.pulumi.aws.kinesis.FirehoseDeliveryStream;
    import com.pulumi.aws.kinesis.FirehoseDeliveryStreamArgs;
    import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamRedshiftConfigurationArgs;
    import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamRedshiftConfigurationS3ConfigurationArgs;
    import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamRedshiftConfigurationS3BackupConfigurationArgs;
    import java.util.List;
    import java.util.ArrayList;
    import java.util.Map;
    import java.io.File;
    import java.nio.file.Files;
    import java.nio.file.Paths;
    
    public class App {
        public static void main(String[] args) {
            Pulumi.run(App::stack);
        }
    
        public static void stack(Context ctx) {
            var testCluster = new Cluster("testCluster", ClusterArgs.builder()
                .clusterIdentifier("tf-redshift-cluster")
                .databaseName("test")
                .masterUsername("testuser")
                .masterPassword("T3stPass")
                .nodeType("dc1.large")
                .clusterType("single-node")
                .build());
    
            var testStream = new FirehoseDeliveryStream("testStream", FirehoseDeliveryStreamArgs.builder()
                .name("kinesis-firehose-test-stream")
                .destination("redshift")
                .redshiftConfiguration(FirehoseDeliveryStreamRedshiftConfigurationArgs.builder()
                    .roleArn(firehoseRole.arn())
                    .clusterJdbcurl(Output.tuple(testCluster.endpoint(), testCluster.databaseName()).applyValue(values -> {
                        var endpoint = values.t1;
                        var databaseName = values.t2;
                        return String.format("jdbc:redshift://%s/%s", endpoint,databaseName);
                    }))
                    .username("testuser")
                    .password("T3stPass")
                    .dataTableName("test-table")
                    .copyOptions("delimiter '|'")
                    .dataTableColumns("test-col")
                    .s3BackupMode("Enabled")
                    .s3Configuration(FirehoseDeliveryStreamRedshiftConfigurationS3ConfigurationArgs.builder()
                        .roleArn(firehoseRole.arn())
                        .bucketArn(bucket.arn())
                        .bufferingSize(10)
                        .bufferingInterval(400)
                        .compressionFormat("GZIP")
                        .build())
                    .s3BackupConfiguration(FirehoseDeliveryStreamRedshiftConfigurationS3BackupConfigurationArgs.builder()
                        .roleArn(firehoseRole.arn())
                        .bucketArn(bucket.arn())
                        .bufferingSize(15)
                        .bufferingInterval(300)
                        .compressionFormat("GZIP")
                        .build())
                    .build())
                .build());
    
        }
    }
    
    resources:
      testCluster:
        type: aws:redshift:Cluster
        name: test_cluster
        properties:
          clusterIdentifier: tf-redshift-cluster
          databaseName: test
          masterUsername: testuser
          masterPassword: T3stPass
          nodeType: dc1.large
          clusterType: single-node
      testStream:
        type: aws:kinesis:FirehoseDeliveryStream
        name: test_stream
        properties:
          name: kinesis-firehose-test-stream
          destination: redshift
          redshiftConfiguration:
            roleArn: ${firehoseRole.arn}
            clusterJdbcurl: jdbc:redshift://${testCluster.endpoint}/${testCluster.databaseName}
            username: testuser
            password: T3stPass
            dataTableName: test-table
            copyOptions: delimiter '|'
            dataTableColumns: test-col
            s3BackupMode: Enabled
            s3Configuration:
              roleArn: ${firehoseRole.arn}
              bucketArn: ${bucket.arn}
              bufferingSize: 10
              bufferingInterval: 400
              compressionFormat: GZIP
            s3BackupConfiguration:
              roleArn: ${firehoseRole.arn}
              bucketArn: ${bucket.arn}
              bufferingSize: 15
              bufferingInterval: 300
              compressionFormat: GZIP
    

    Elasticsearch Destination

    import * as pulumi from "@pulumi/pulumi";
    import * as aws from "@pulumi/aws";
    
    const testCluster = new aws.elasticsearch.Domain("test_cluster", {domainName: "firehose-es-test"});
    const testStream = new aws.kinesis.FirehoseDeliveryStream("test_stream", {
        name: "kinesis-firehose-test-stream",
        destination: "elasticsearch",
        elasticsearchConfiguration: {
            domainArn: testCluster.arn,
            roleArn: firehoseRole.arn,
            indexName: "test",
            typeName: "test",
            s3Configuration: {
                roleArn: firehoseRole.arn,
                bucketArn: bucket.arn,
                bufferingSize: 10,
                bufferingInterval: 400,
                compressionFormat: "GZIP",
            },
            processingConfiguration: {
                enabled: true,
                processors: [{
                    type: "Lambda",
                    parameters: [{
                        parameterName: "LambdaArn",
                        parameterValue: `${lambdaProcessor.arn}:$LATEST`,
                    }],
                }],
            },
        },
    });
    
    import pulumi
    import pulumi_aws as aws
    
    test_cluster = aws.elasticsearch.Domain("test_cluster", domain_name="firehose-es-test")
    test_stream = aws.kinesis.FirehoseDeliveryStream("test_stream",
        name="kinesis-firehose-test-stream",
        destination="elasticsearch",
        elasticsearch_configuration=aws.kinesis.FirehoseDeliveryStreamElasticsearchConfigurationArgs(
            domain_arn=test_cluster.arn,
            role_arn=firehose_role["arn"],
            index_name="test",
            type_name="test",
            s3_configuration=aws.kinesis.FirehoseDeliveryStreamElasticsearchConfigurationS3ConfigurationArgs(
                role_arn=firehose_role["arn"],
                bucket_arn=bucket["arn"],
                buffering_size=10,
                buffering_interval=400,
                compression_format="GZIP",
            ),
            processing_configuration=aws.kinesis.FirehoseDeliveryStreamElasticsearchConfigurationProcessingConfigurationArgs(
                enabled=True,
                processors=[aws.kinesis.FirehoseDeliveryStreamElasticsearchConfigurationProcessingConfigurationProcessorArgs(
                    type="Lambda",
                    parameters=[aws.kinesis.FirehoseDeliveryStreamElasticsearchConfigurationProcessingConfigurationProcessorParameterArgs(
                        parameter_name="LambdaArn",
                        parameter_value=f"{lambda_processor['arn']}:$LATEST",
                    )],
                )],
            ),
        ))
    
    package main
    
    import (
    	"fmt"
    
    	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/elasticsearch"
    	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/kinesis"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		testCluster, err := elasticsearch.NewDomain(ctx, "test_cluster", &elasticsearch.DomainArgs{
    			DomainName: pulumi.String("firehose-es-test"),
    		})
    		if err != nil {
    			return err
    		}
    		_, err = kinesis.NewFirehoseDeliveryStream(ctx, "test_stream", &kinesis.FirehoseDeliveryStreamArgs{
    			Name:        pulumi.String("kinesis-firehose-test-stream"),
    			Destination: pulumi.String("elasticsearch"),
    			ElasticsearchConfiguration: &kinesis.FirehoseDeliveryStreamElasticsearchConfigurationArgs{
    				DomainArn: testCluster.Arn,
    				RoleArn:   pulumi.Any(firehoseRole.Arn),
    				IndexName: pulumi.String("test"),
    				TypeName:  pulumi.String("test"),
    				S3Configuration: &kinesis.FirehoseDeliveryStreamElasticsearchConfigurationS3ConfigurationArgs{
    					RoleArn:           pulumi.Any(firehoseRole.Arn),
    					BucketArn:         pulumi.Any(bucket.Arn),
    					BufferingSize:     pulumi.Int(10),
    					BufferingInterval: pulumi.Int(400),
    					CompressionFormat: pulumi.String("GZIP"),
    				},
    				ProcessingConfiguration: &kinesis.FirehoseDeliveryStreamElasticsearchConfigurationProcessingConfigurationArgs{
    					Enabled: pulumi.Bool(true),
    					Processors: kinesis.FirehoseDeliveryStreamElasticsearchConfigurationProcessingConfigurationProcessorArray{
    						&kinesis.FirehoseDeliveryStreamElasticsearchConfigurationProcessingConfigurationProcessorArgs{
    							Type: pulumi.String("Lambda"),
    							Parameters: kinesis.FirehoseDeliveryStreamElasticsearchConfigurationProcessingConfigurationProcessorParameterArray{
    								&kinesis.FirehoseDeliveryStreamElasticsearchConfigurationProcessingConfigurationProcessorParameterArgs{
    									ParameterName:  pulumi.String("LambdaArn"),
    									ParameterValue: pulumi.String(fmt.Sprintf("%v:$LATEST", lambdaProcessor.Arn)),
    								},
    							},
    						},
    					},
    				},
    			},
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using Aws = Pulumi.Aws;
    
    return await Deployment.RunAsync(() => 
    {
        var testCluster = new Aws.ElasticSearch.Domain("test_cluster", new()
        {
            DomainName = "firehose-es-test",
        });
    
        var testStream = new Aws.Kinesis.FirehoseDeliveryStream("test_stream", new()
        {
            Name = "kinesis-firehose-test-stream",
            Destination = "elasticsearch",
            ElasticsearchConfiguration = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamElasticsearchConfigurationArgs
            {
                DomainArn = testCluster.Arn,
                RoleArn = firehoseRole.Arn,
                IndexName = "test",
                TypeName = "test",
                S3Configuration = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamElasticsearchConfigurationS3ConfigurationArgs
                {
                    RoleArn = firehoseRole.Arn,
                    BucketArn = bucket.Arn,
                    BufferingSize = 10,
                    BufferingInterval = 400,
                    CompressionFormat = "GZIP",
                },
                ProcessingConfiguration = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamElasticsearchConfigurationProcessingConfigurationArgs
                {
                    Enabled = true,
                    Processors = new[]
                    {
                        new Aws.Kinesis.Inputs.FirehoseDeliveryStreamElasticsearchConfigurationProcessingConfigurationProcessorArgs
                        {
                            Type = "Lambda",
                            Parameters = new[]
                            {
                                new Aws.Kinesis.Inputs.FirehoseDeliveryStreamElasticsearchConfigurationProcessingConfigurationProcessorParameterArgs
                                {
                                    ParameterName = "LambdaArn",
                                    ParameterValue = $"{lambdaProcessor.Arn}:$LATEST",
                                },
                            },
                        },
                    },
                },
            },
        });
    
    });
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.aws.elasticsearch.Domain;
    import com.pulumi.aws.elasticsearch.DomainArgs;
    import com.pulumi.aws.kinesis.FirehoseDeliveryStream;
    import com.pulumi.aws.kinesis.FirehoseDeliveryStreamArgs;
    import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamElasticsearchConfigurationArgs;
    import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamElasticsearchConfigurationS3ConfigurationArgs;
    import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamElasticsearchConfigurationProcessingConfigurationArgs;
    import java.util.List;
    import java.util.ArrayList;
    import java.util.Map;
    import java.io.File;
    import java.nio.file.Files;
    import java.nio.file.Paths;
    
    public class App {
        public static void main(String[] args) {
            Pulumi.run(App::stack);
        }
    
        public static void stack(Context ctx) {
            var testCluster = new Domain("testCluster", DomainArgs.builder()
                .domainName("firehose-es-test")
                .build());
    
            var testStream = new FirehoseDeliveryStream("testStream", FirehoseDeliveryStreamArgs.builder()
                .name("kinesis-firehose-test-stream")
                .destination("elasticsearch")
                .elasticsearchConfiguration(FirehoseDeliveryStreamElasticsearchConfigurationArgs.builder()
                    .domainArn(testCluster.arn())
                    .roleArn(firehoseRole.arn())
                    .indexName("test")
                    .typeName("test")
                    .s3Configuration(FirehoseDeliveryStreamElasticsearchConfigurationS3ConfigurationArgs.builder()
                        .roleArn(firehoseRole.arn())
                        .bucketArn(bucket.arn())
                        .bufferingSize(10)
                        .bufferingInterval(400)
                        .compressionFormat("GZIP")
                        .build())
                    .processingConfiguration(FirehoseDeliveryStreamElasticsearchConfigurationProcessingConfigurationArgs.builder()
                        .enabled("true")
                        .processors(FirehoseDeliveryStreamElasticsearchConfigurationProcessingConfigurationProcessorArgs.builder()
                            .type("Lambda")
                            .parameters(FirehoseDeliveryStreamElasticsearchConfigurationProcessingConfigurationProcessorParameterArgs.builder()
                                .parameterName("LambdaArn")
                                .parameterValue(String.format("%s:$LATEST", lambdaProcessor.arn()))
                                .build())
                            .build())
                        .build())
                    .build())
                .build());
    
        }
    }
    
    resources:
      testCluster:
        type: aws:elasticsearch:Domain
        name: test_cluster
        properties:
          domainName: firehose-es-test
      testStream:
        type: aws:kinesis:FirehoseDeliveryStream
        name: test_stream
        properties:
          name: kinesis-firehose-test-stream
          destination: elasticsearch
          elasticsearchConfiguration:
            domainArn: ${testCluster.arn}
            roleArn: ${firehoseRole.arn}
            indexName: test
            typeName: test
            s3Configuration:
              roleArn: ${firehoseRole.arn}
              bucketArn: ${bucket.arn}
              bufferingSize: 10
              bufferingInterval: 400
              compressionFormat: GZIP
            processingConfiguration:
              enabled: 'true'
              processors:
                - type: Lambda
                  parameters:
                    - parameterName: LambdaArn
                      parameterValue: ${lambdaProcessor.arn}:$LATEST
    

    Elasticsearch Destination With VPC

    import * as pulumi from "@pulumi/pulumi";
    import * as aws from "@pulumi/aws";
    
    const testCluster = new aws.elasticsearch.Domain("test_cluster", {
        domainName: "es-test",
        clusterConfig: {
            instanceCount: 2,
            zoneAwarenessEnabled: true,
            instanceType: "t2.small.elasticsearch",
        },
        ebsOptions: {
            ebsEnabled: true,
            volumeSize: 10,
        },
        vpcOptions: {
            securityGroupIds: [first.id],
            subnetIds: [
                firstAwsSubnet.id,
                second.id,
            ],
        },
    });
    const firehose-elasticsearch = aws.iam.getPolicyDocumentOutput({
        statements: [
            {
                effect: "Allow",
                actions: ["es:*"],
                resources: [
                    testCluster.arn,
                    pulumi.interpolate`${testCluster.arn}/*`,
                ],
            },
            {
                effect: "Allow",
                actions: [
                    "ec2:DescribeVpcs",
                    "ec2:DescribeVpcAttribute",
                    "ec2:DescribeSubnets",
                    "ec2:DescribeSecurityGroups",
                    "ec2:DescribeNetworkInterfaces",
                    "ec2:CreateNetworkInterface",
                    "ec2:CreateNetworkInterfacePermission",
                    "ec2:DeleteNetworkInterface",
                ],
                resources: ["*"],
            },
        ],
    });
    const firehose_elasticsearchRolePolicy = new aws.iam.RolePolicy("firehose-elasticsearch", {
        name: "elasticsearch",
        role: firehose.id,
        policy: firehose_elasticsearch.apply(firehose_elasticsearch => firehose_elasticsearch.json),
    });
    const test = new aws.kinesis.FirehoseDeliveryStream("test", {
        name: "kinesis-firehose-es",
        destination: "elasticsearch",
        elasticsearchConfiguration: {
            domainArn: testCluster.arn,
            roleArn: firehose.arn,
            indexName: "test",
            typeName: "test",
            s3Configuration: {
                roleArn: firehose.arn,
                bucketArn: bucket.arn,
            },
            vpcConfig: {
                subnetIds: [
                    firstAwsSubnet.id,
                    second.id,
                ],
                securityGroupIds: [first.id],
                roleArn: firehose.arn,
            },
        },
    }, {
        dependsOn: [firehose_elasticsearchRolePolicy],
    });
    
    import pulumi
    import pulumi_aws as aws
    
    test_cluster = aws.elasticsearch.Domain("test_cluster",
        domain_name="es-test",
        cluster_config=aws.elasticsearch.DomainClusterConfigArgs(
            instance_count=2,
            zone_awareness_enabled=True,
            instance_type="t2.small.elasticsearch",
        ),
        ebs_options=aws.elasticsearch.DomainEbsOptionsArgs(
            ebs_enabled=True,
            volume_size=10,
        ),
        vpc_options=aws.elasticsearch.DomainVpcOptionsArgs(
            security_group_ids=[first["id"]],
            subnet_ids=[
                first_aws_subnet["id"],
                second["id"],
            ],
        ))
    firehose_elasticsearch = aws.iam.get_policy_document_output(statements=[
        aws.iam.GetPolicyDocumentStatementArgs(
            effect="Allow",
            actions=["es:*"],
            resources=[
                test_cluster.arn,
                test_cluster.arn.apply(lambda arn: f"{arn}/*"),
            ],
        ),
        aws.iam.GetPolicyDocumentStatementArgs(
            effect="Allow",
            actions=[
                "ec2:DescribeVpcs",
                "ec2:DescribeVpcAttribute",
                "ec2:DescribeSubnets",
                "ec2:DescribeSecurityGroups",
                "ec2:DescribeNetworkInterfaces",
                "ec2:CreateNetworkInterface",
                "ec2:CreateNetworkInterfacePermission",
                "ec2:DeleteNetworkInterface",
            ],
            resources=["*"],
        ),
    ])
    firehose_elasticsearch_role_policy = aws.iam.RolePolicy("firehose-elasticsearch",
        name="elasticsearch",
        role=firehose["id"],
        policy=firehose_elasticsearch.json)
    test = aws.kinesis.FirehoseDeliveryStream("test",
        name="kinesis-firehose-es",
        destination="elasticsearch",
        elasticsearch_configuration=aws.kinesis.FirehoseDeliveryStreamElasticsearchConfigurationArgs(
            domain_arn=test_cluster.arn,
            role_arn=firehose["arn"],
            index_name="test",
            type_name="test",
            s3_configuration=aws.kinesis.FirehoseDeliveryStreamElasticsearchConfigurationS3ConfigurationArgs(
                role_arn=firehose["arn"],
                bucket_arn=bucket["arn"],
            ),
            vpc_config=aws.kinesis.FirehoseDeliveryStreamElasticsearchConfigurationVpcConfigArgs(
                subnet_ids=[
                    first_aws_subnet["id"],
                    second["id"],
                ],
                security_group_ids=[first["id"]],
                role_arn=firehose["arn"],
            ),
        ),
        opts=pulumi.ResourceOptions(depends_on=[firehose_elasticsearch_role_policy]))
    
    package main
    
    import (
    	"fmt"
    
    	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/elasticsearch"
    	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/iam"
    	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/kinesis"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		testCluster, err := elasticsearch.NewDomain(ctx, "test_cluster", &elasticsearch.DomainArgs{
    			DomainName: pulumi.String("es-test"),
    			ClusterConfig: &elasticsearch.DomainClusterConfigArgs{
    				InstanceCount:        pulumi.Int(2),
    				ZoneAwarenessEnabled: pulumi.Bool(true),
    				InstanceType:         pulumi.String("t2.small.elasticsearch"),
    			},
    			EbsOptions: &elasticsearch.DomainEbsOptionsArgs{
    				EbsEnabled: pulumi.Bool(true),
    				VolumeSize: pulumi.Int(10),
    			},
    			VpcOptions: &elasticsearch.DomainVpcOptionsArgs{
    				SecurityGroupIds: pulumi.StringArray{
    					first.Id,
    				},
    				SubnetIds: pulumi.StringArray{
    					firstAwsSubnet.Id,
    					second.Id,
    				},
    			},
    		})
    		if err != nil {
    			return err
    		}
    		firehose_elasticsearch := iam.GetPolicyDocumentOutput(ctx, iam.GetPolicyDocumentOutputArgs{
    			Statements: iam.GetPolicyDocumentStatementArray{
    				&iam.GetPolicyDocumentStatementArgs{
    					Effect: pulumi.String("Allow"),
    					Actions: pulumi.StringArray{
    						pulumi.String("es:*"),
    					},
    					Resources: pulumi.StringArray{
    						testCluster.Arn,
    						testCluster.Arn.ApplyT(func(arn string) (string, error) {
    							return fmt.Sprintf("%v/*", arn), nil
    						}).(pulumi.StringOutput),
    					},
    				},
    				&iam.GetPolicyDocumentStatementArgs{
    					Effect: pulumi.String("Allow"),
    					Actions: pulumi.StringArray{
    						pulumi.String("ec2:DescribeVpcs"),
    						pulumi.String("ec2:DescribeVpcAttribute"),
    						pulumi.String("ec2:DescribeSubnets"),
    						pulumi.String("ec2:DescribeSecurityGroups"),
    						pulumi.String("ec2:DescribeNetworkInterfaces"),
    						pulumi.String("ec2:CreateNetworkInterface"),
    						pulumi.String("ec2:CreateNetworkInterfacePermission"),
    						pulumi.String("ec2:DeleteNetworkInterface"),
    					},
    					Resources: pulumi.StringArray{
    						pulumi.String("*"),
    					},
    				},
    			},
    		}, nil)
    		_, err = iam.NewRolePolicy(ctx, "firehose-elasticsearch", &iam.RolePolicyArgs{
    			Name: pulumi.String("elasticsearch"),
    			Role: pulumi.Any(firehose.Id),
    			Policy: firehose_elasticsearch.ApplyT(func(firehose_elasticsearch iam.GetPolicyDocumentResult) (*string, error) {
    				return &firehose_elasticsearch.Json, nil
    			}).(pulumi.StringPtrOutput),
    		})
    		if err != nil {
    			return err
    		}
    		_, err = kinesis.NewFirehoseDeliveryStream(ctx, "test", &kinesis.FirehoseDeliveryStreamArgs{
    			Name:        pulumi.String("kinesis-firehose-es"),
    			Destination: pulumi.String("elasticsearch"),
    			ElasticsearchConfiguration: &kinesis.FirehoseDeliveryStreamElasticsearchConfigurationArgs{
    				DomainArn: testCluster.Arn,
    				RoleArn:   pulumi.Any(firehose.Arn),
    				IndexName: pulumi.String("test"),
    				TypeName:  pulumi.String("test"),
    				S3Configuration: &kinesis.FirehoseDeliveryStreamElasticsearchConfigurationS3ConfigurationArgs{
    					RoleArn:   pulumi.Any(firehose.Arn),
    					BucketArn: pulumi.Any(bucket.Arn),
    				},
    				VpcConfig: &kinesis.FirehoseDeliveryStreamElasticsearchConfigurationVpcConfigArgs{
    					SubnetIds: pulumi.StringArray{
    						firstAwsSubnet.Id,
    						second.Id,
    					},
    					SecurityGroupIds: pulumi.StringArray{
    						first.Id,
    					},
    					RoleArn: pulumi.Any(firehose.Arn),
    				},
    			},
    		}, pulumi.DependsOn([]pulumi.Resource{
    			firehose_elasticsearchRolePolicy,
    		}))
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using Aws = Pulumi.Aws;
    
    return await Deployment.RunAsync(() => 
    {
        var testCluster = new Aws.ElasticSearch.Domain("test_cluster", new()
        {
            DomainName = "es-test",
            ClusterConfig = new Aws.ElasticSearch.Inputs.DomainClusterConfigArgs
            {
                InstanceCount = 2,
                ZoneAwarenessEnabled = true,
                InstanceType = "t2.small.elasticsearch",
            },
            EbsOptions = new Aws.ElasticSearch.Inputs.DomainEbsOptionsArgs
            {
                EbsEnabled = true,
                VolumeSize = 10,
            },
            VpcOptions = new Aws.ElasticSearch.Inputs.DomainVpcOptionsArgs
            {
                SecurityGroupIds = new[]
                {
                    first.Id,
                },
                SubnetIds = new[]
                {
                    firstAwsSubnet.Id,
                    second.Id,
                },
            },
        });
    
        var firehose_elasticsearch = Aws.Iam.GetPolicyDocument.Invoke(new()
        {
            Statements = new[]
            {
                new Aws.Iam.Inputs.GetPolicyDocumentStatementInputArgs
                {
                    Effect = "Allow",
                    Actions = new[]
                    {
                        "es:*",
                    },
                    Resources = new[]
                    {
                        testCluster.Arn,
                        $"{testCluster.Arn}/*",
                    },
                },
                new Aws.Iam.Inputs.GetPolicyDocumentStatementInputArgs
                {
                    Effect = "Allow",
                    Actions = new[]
                    {
                        "ec2:DescribeVpcs",
                        "ec2:DescribeVpcAttribute",
                        "ec2:DescribeSubnets",
                        "ec2:DescribeSecurityGroups",
                        "ec2:DescribeNetworkInterfaces",
                        "ec2:CreateNetworkInterface",
                        "ec2:CreateNetworkInterfacePermission",
                        "ec2:DeleteNetworkInterface",
                    },
                    Resources = new[]
                    {
                        "*",
                    },
                },
            },
        });
    
        var firehose_elasticsearchRolePolicy = new Aws.Iam.RolePolicy("firehose-elasticsearch", new()
        {
            Name = "elasticsearch",
            Role = firehose.Id,
            Policy = firehose_elasticsearch.Apply(firehose_elasticsearch => firehose_elasticsearch.Apply(getPolicyDocumentResult => getPolicyDocumentResult.Json)),
        });
    
        var test = new Aws.Kinesis.FirehoseDeliveryStream("test", new()
        {
            Name = "kinesis-firehose-es",
            Destination = "elasticsearch",
            ElasticsearchConfiguration = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamElasticsearchConfigurationArgs
            {
                DomainArn = testCluster.Arn,
                RoleArn = firehose.Arn,
                IndexName = "test",
                TypeName = "test",
                S3Configuration = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamElasticsearchConfigurationS3ConfigurationArgs
                {
                    RoleArn = firehose.Arn,
                    BucketArn = bucket.Arn,
                },
                VpcConfig = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamElasticsearchConfigurationVpcConfigArgs
                {
                    SubnetIds = new[]
                    {
                        firstAwsSubnet.Id,
                        second.Id,
                    },
                    SecurityGroupIds = new[]
                    {
                        first.Id,
                    },
                    RoleArn = firehose.Arn,
                },
            },
        }, new CustomResourceOptions
        {
            DependsOn =
            {
                firehose_elasticsearchRolePolicy,
            },
        });
    
    });
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.aws.elasticsearch.Domain;
    import com.pulumi.aws.elasticsearch.DomainArgs;
    import com.pulumi.aws.elasticsearch.inputs.DomainClusterConfigArgs;
    import com.pulumi.aws.elasticsearch.inputs.DomainEbsOptionsArgs;
    import com.pulumi.aws.elasticsearch.inputs.DomainVpcOptionsArgs;
    import com.pulumi.aws.iam.IamFunctions;
    import com.pulumi.aws.iam.inputs.GetPolicyDocumentArgs;
    import com.pulumi.aws.iam.RolePolicy;
    import com.pulumi.aws.iam.RolePolicyArgs;
    import com.pulumi.aws.kinesis.FirehoseDeliveryStream;
    import com.pulumi.aws.kinesis.FirehoseDeliveryStreamArgs;
    import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamElasticsearchConfigurationArgs;
    import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamElasticsearchConfigurationS3ConfigurationArgs;
    import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamElasticsearchConfigurationVpcConfigArgs;
    import com.pulumi.resources.CustomResourceOptions;
    import java.util.List;
    import java.util.ArrayList;
    import java.util.Map;
    import java.io.File;
    import java.nio.file.Files;
    import java.nio.file.Paths;
    
    public class App {
        public static void main(String[] args) {
            Pulumi.run(App::stack);
        }
    
        public static void stack(Context ctx) {
            var testCluster = new Domain("testCluster", DomainArgs.builder()
                .domainName("es-test")
                .clusterConfig(DomainClusterConfigArgs.builder()
                    .instanceCount(2)
                    .zoneAwarenessEnabled(true)
                    .instanceType("t2.small.elasticsearch")
                    .build())
                .ebsOptions(DomainEbsOptionsArgs.builder()
                    .ebsEnabled(true)
                    .volumeSize(10)
                    .build())
                .vpcOptions(DomainVpcOptionsArgs.builder()
                    .securityGroupIds(first.id())
                    .subnetIds(                
                        firstAwsSubnet.id(),
                        second.id())
                    .build())
                .build());
    
            final var firehose-elasticsearch = IamFunctions.getPolicyDocument(GetPolicyDocumentArgs.builder()
                .statements(            
                    GetPolicyDocumentStatementArgs.builder()
                        .effect("Allow")
                        .actions("es:*")
                        .resources(                    
                            testCluster.arn(),
                            testCluster.arn().applyValue(arn -> String.format("%s/*", arn)))
                        .build(),
                    GetPolicyDocumentStatementArgs.builder()
                        .effect("Allow")
                        .actions(                    
                            "ec2:DescribeVpcs",
                            "ec2:DescribeVpcAttribute",
                            "ec2:DescribeSubnets",
                            "ec2:DescribeSecurityGroups",
                            "ec2:DescribeNetworkInterfaces",
                            "ec2:CreateNetworkInterface",
                            "ec2:CreateNetworkInterfacePermission",
                            "ec2:DeleteNetworkInterface")
                        .resources("*")
                        .build())
                .build());
    
            var firehose_elasticsearchRolePolicy = new RolePolicy("firehose-elasticsearchRolePolicy", RolePolicyArgs.builder()
                .name("elasticsearch")
                .role(firehose.id())
                .policy(firehose_elasticsearch.applyValue(firehose_elasticsearch -> firehose_elasticsearch.json()))
                .build());
    
            var test = new FirehoseDeliveryStream("test", FirehoseDeliveryStreamArgs.builder()
                .name("kinesis-firehose-es")
                .destination("elasticsearch")
                .elasticsearchConfiguration(FirehoseDeliveryStreamElasticsearchConfigurationArgs.builder()
                    .domainArn(testCluster.arn())
                    .roleArn(firehose.arn())
                    .indexName("test")
                    .typeName("test")
                    .s3Configuration(FirehoseDeliveryStreamElasticsearchConfigurationS3ConfigurationArgs.builder()
                        .roleArn(firehose.arn())
                        .bucketArn(bucket.arn())
                        .build())
                    .vpcConfig(FirehoseDeliveryStreamElasticsearchConfigurationVpcConfigArgs.builder()
                        .subnetIds(                    
                            firstAwsSubnet.id(),
                            second.id())
                        .securityGroupIds(first.id())
                        .roleArn(firehose.arn())
                        .build())
                    .build())
                .build(), CustomResourceOptions.builder()
                    .dependsOn(firehose_elasticsearchRolePolicy)
                    .build());
    
        }
    }
    
    resources:
      testCluster:
        type: aws:elasticsearch:Domain
        name: test_cluster
        properties:
          domainName: es-test
          clusterConfig:
            instanceCount: 2
            zoneAwarenessEnabled: true
            instanceType: t2.small.elasticsearch
          ebsOptions:
            ebsEnabled: true
            volumeSize: 10
          vpcOptions:
            securityGroupIds:
              - ${first.id}
            subnetIds:
              - ${firstAwsSubnet.id}
              - ${second.id}
      firehose-elasticsearchRolePolicy:
        type: aws:iam:RolePolicy
        name: firehose-elasticsearch
        properties:
          name: elasticsearch
          role: ${firehose.id}
          policy: ${["firehose-elasticsearch"].json}
      test:
        type: aws:kinesis:FirehoseDeliveryStream
        properties:
          name: kinesis-firehose-es
          destination: elasticsearch
          elasticsearchConfiguration:
            domainArn: ${testCluster.arn}
            roleArn: ${firehose.arn}
            indexName: test
            typeName: test
            s3Configuration:
              roleArn: ${firehose.arn}
              bucketArn: ${bucket.arn}
            vpcConfig:
              subnetIds:
                - ${firstAwsSubnet.id}
                - ${second.id}
              securityGroupIds:
                - ${first.id}
              roleArn: ${firehose.arn}
        options:
          dependson:
            - ${["firehose-elasticsearchRolePolicy"]}
    variables:
      firehose-elasticsearch:
        fn::invoke:
          Function: aws:iam:getPolicyDocument
          Arguments:
            statements:
              - effect: Allow
                actions:
                  - es:*
                resources:
                  - ${testCluster.arn}
                  - ${testCluster.arn}/*
              - effect: Allow
                actions:
                  - ec2:DescribeVpcs
                  - ec2:DescribeVpcAttribute
                  - ec2:DescribeSubnets
                  - ec2:DescribeSecurityGroups
                  - ec2:DescribeNetworkInterfaces
                  - ec2:CreateNetworkInterface
                  - ec2:CreateNetworkInterfacePermission
                  - ec2:DeleteNetworkInterface
                resources:
                  - '*'
    

    OpenSearch Destination

    import * as pulumi from "@pulumi/pulumi";
    import * as aws from "@pulumi/aws";
    
    const testCluster = new aws.opensearch.Domain("test_cluster", {domainName: "firehose-os-test"});
    const testStream = new aws.kinesis.FirehoseDeliveryStream("test_stream", {
        name: "kinesis-firehose-test-stream",
        destination: "opensearch",
        opensearchConfiguration: {
            domainArn: testCluster.arn,
            roleArn: firehoseRole.arn,
            indexName: "test",
            s3Configuration: {
                roleArn: firehoseRole.arn,
                bucketArn: bucket.arn,
                bufferingSize: 10,
                bufferingInterval: 400,
                compressionFormat: "GZIP",
            },
            processingConfiguration: {
                enabled: true,
                processors: [{
                    type: "Lambda",
                    parameters: [{
                        parameterName: "LambdaArn",
                        parameterValue: `${lambdaProcessor.arn}:$LATEST`,
                    }],
                }],
            },
        },
    });
    
    import pulumi
    import pulumi_aws as aws
    
    test_cluster = aws.opensearch.Domain("test_cluster", domain_name="firehose-os-test")
    test_stream = aws.kinesis.FirehoseDeliveryStream("test_stream",
        name="kinesis-firehose-test-stream",
        destination="opensearch",
        opensearch_configuration=aws.kinesis.FirehoseDeliveryStreamOpensearchConfigurationArgs(
            domain_arn=test_cluster.arn,
            role_arn=firehose_role["arn"],
            index_name="test",
            s3_configuration=aws.kinesis.FirehoseDeliveryStreamOpensearchConfigurationS3ConfigurationArgs(
                role_arn=firehose_role["arn"],
                bucket_arn=bucket["arn"],
                buffering_size=10,
                buffering_interval=400,
                compression_format="GZIP",
            ),
            processing_configuration=aws.kinesis.FirehoseDeliveryStreamOpensearchConfigurationProcessingConfigurationArgs(
                enabled=True,
                processors=[aws.kinesis.FirehoseDeliveryStreamOpensearchConfigurationProcessingConfigurationProcessorArgs(
                    type="Lambda",
                    parameters=[aws.kinesis.FirehoseDeliveryStreamOpensearchConfigurationProcessingConfigurationProcessorParameterArgs(
                        parameter_name="LambdaArn",
                        parameter_value=f"{lambda_processor['arn']}:$LATEST",
                    )],
                )],
            ),
        ))
    
    package main
    
    import (
    	"fmt"
    
    	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/kinesis"
    	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/opensearch"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		testCluster, err := opensearch.NewDomain(ctx, "test_cluster", &opensearch.DomainArgs{
    			DomainName: pulumi.String("firehose-os-test"),
    		})
    		if err != nil {
    			return err
    		}
    		_, err = kinesis.NewFirehoseDeliveryStream(ctx, "test_stream", &kinesis.FirehoseDeliveryStreamArgs{
    			Name:        pulumi.String("kinesis-firehose-test-stream"),
    			Destination: pulumi.String("opensearch"),
    			OpensearchConfiguration: &kinesis.FirehoseDeliveryStreamOpensearchConfigurationArgs{
    				DomainArn: testCluster.Arn,
    				RoleArn:   pulumi.Any(firehoseRole.Arn),
    				IndexName: pulumi.String("test"),
    				S3Configuration: &kinesis.FirehoseDeliveryStreamOpensearchConfigurationS3ConfigurationArgs{
    					RoleArn:           pulumi.Any(firehoseRole.Arn),
    					BucketArn:         pulumi.Any(bucket.Arn),
    					BufferingSize:     pulumi.Int(10),
    					BufferingInterval: pulumi.Int(400),
    					CompressionFormat: pulumi.String("GZIP"),
    				},
    				ProcessingConfiguration: &kinesis.FirehoseDeliveryStreamOpensearchConfigurationProcessingConfigurationArgs{
    					Enabled: pulumi.Bool(true),
    					Processors: kinesis.FirehoseDeliveryStreamOpensearchConfigurationProcessingConfigurationProcessorArray{
    						&kinesis.FirehoseDeliveryStreamOpensearchConfigurationProcessingConfigurationProcessorArgs{
    							Type: pulumi.String("Lambda"),
    							Parameters: kinesis.FirehoseDeliveryStreamOpensearchConfigurationProcessingConfigurationProcessorParameterArray{
    								&kinesis.FirehoseDeliveryStreamOpensearchConfigurationProcessingConfigurationProcessorParameterArgs{
    									ParameterName:  pulumi.String("LambdaArn"),
    									ParameterValue: pulumi.String(fmt.Sprintf("%v:$LATEST", lambdaProcessor.Arn)),
    								},
    							},
    						},
    					},
    				},
    			},
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using Aws = Pulumi.Aws;
    
    return await Deployment.RunAsync(() => 
    {
        var testCluster = new Aws.OpenSearch.Domain("test_cluster", new()
        {
            DomainName = "firehose-os-test",
        });
    
        var testStream = new Aws.Kinesis.FirehoseDeliveryStream("test_stream", new()
        {
            Name = "kinesis-firehose-test-stream",
            Destination = "opensearch",
            OpensearchConfiguration = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamOpensearchConfigurationArgs
            {
                DomainArn = testCluster.Arn,
                RoleArn = firehoseRole.Arn,
                IndexName = "test",
                S3Configuration = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamOpensearchConfigurationS3ConfigurationArgs
                {
                    RoleArn = firehoseRole.Arn,
                    BucketArn = bucket.Arn,
                    BufferingSize = 10,
                    BufferingInterval = 400,
                    CompressionFormat = "GZIP",
                },
                ProcessingConfiguration = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamOpensearchConfigurationProcessingConfigurationArgs
                {
                    Enabled = true,
                    Processors = new[]
                    {
                        new Aws.Kinesis.Inputs.FirehoseDeliveryStreamOpensearchConfigurationProcessingConfigurationProcessorArgs
                        {
                            Type = "Lambda",
                            Parameters = new[]
                            {
                                new Aws.Kinesis.Inputs.FirehoseDeliveryStreamOpensearchConfigurationProcessingConfigurationProcessorParameterArgs
                                {
                                    ParameterName = "LambdaArn",
                                    ParameterValue = $"{lambdaProcessor.Arn}:$LATEST",
                                },
                            },
                        },
                    },
                },
            },
        });
    
    });
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.aws.opensearch.Domain;
    import com.pulumi.aws.opensearch.DomainArgs;
    import com.pulumi.aws.kinesis.FirehoseDeliveryStream;
    import com.pulumi.aws.kinesis.FirehoseDeliveryStreamArgs;
    import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamOpensearchConfigurationArgs;
    import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamOpensearchConfigurationS3ConfigurationArgs;
    import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamOpensearchConfigurationProcessingConfigurationArgs;
    import java.util.List;
    import java.util.ArrayList;
    import java.util.Map;
    import java.io.File;
    import java.nio.file.Files;
    import java.nio.file.Paths;
    
    public class App {
        public static void main(String[] args) {
            Pulumi.run(App::stack);
        }
    
        public static void stack(Context ctx) {
            var testCluster = new Domain("testCluster", DomainArgs.builder()
                .domainName("firehose-os-test")
                .build());
    
            var testStream = new FirehoseDeliveryStream("testStream", FirehoseDeliveryStreamArgs.builder()
                .name("kinesis-firehose-test-stream")
                .destination("opensearch")
                .opensearchConfiguration(FirehoseDeliveryStreamOpensearchConfigurationArgs.builder()
                    .domainArn(testCluster.arn())
                    .roleArn(firehoseRole.arn())
                    .indexName("test")
                    .s3Configuration(FirehoseDeliveryStreamOpensearchConfigurationS3ConfigurationArgs.builder()
                        .roleArn(firehoseRole.arn())
                        .bucketArn(bucket.arn())
                        .bufferingSize(10)
                        .bufferingInterval(400)
                        .compressionFormat("GZIP")
                        .build())
                    .processingConfiguration(FirehoseDeliveryStreamOpensearchConfigurationProcessingConfigurationArgs.builder()
                        .enabled("true")
                        .processors(FirehoseDeliveryStreamOpensearchConfigurationProcessingConfigurationProcessorArgs.builder()
                            .type("Lambda")
                            .parameters(FirehoseDeliveryStreamOpensearchConfigurationProcessingConfigurationProcessorParameterArgs.builder()
                                .parameterName("LambdaArn")
                                .parameterValue(String.format("%s:$LATEST", lambdaProcessor.arn()))
                                .build())
                            .build())
                        .build())
                    .build())
                .build());
    
        }
    }
    
    resources:
      testCluster:
        type: aws:opensearch:Domain
        name: test_cluster
        properties:
          domainName: firehose-os-test
      testStream:
        type: aws:kinesis:FirehoseDeliveryStream
        name: test_stream
        properties:
          name: kinesis-firehose-test-stream
          destination: opensearch
          opensearchConfiguration:
            domainArn: ${testCluster.arn}
            roleArn: ${firehoseRole.arn}
            indexName: test
            s3Configuration:
              roleArn: ${firehoseRole.arn}
              bucketArn: ${bucket.arn}
              bufferingSize: 10
              bufferingInterval: 400
              compressionFormat: GZIP
            processingConfiguration:
              enabled: 'true'
              processors:
                - type: Lambda
                  parameters:
                    - parameterName: LambdaArn
                      parameterValue: ${lambdaProcessor.arn}:$LATEST
    

    OpenSearch Destination With VPC

    import * as pulumi from "@pulumi/pulumi";
    import * as aws from "@pulumi/aws";
    
    const testCluster = new aws.opensearch.Domain("test_cluster", {
        domainName: "es-test",
        clusterConfig: {
            instanceCount: 2,
            zoneAwarenessEnabled: true,
            instanceType: "m4.large.search",
        },
        ebsOptions: {
            ebsEnabled: true,
            volumeSize: 10,
        },
        vpcOptions: {
            securityGroupIds: [first.id],
            subnetIds: [
                firstAwsSubnet.id,
                second.id,
            ],
        },
    });
    const firehose_opensearch = new aws.iam.RolePolicy("firehose-opensearch", {
        name: "opensearch",
        role: firehose.id,
        policy: pulumi.interpolate`{
      "Version": "2012-10-17",
      "Statement": [
        {
          "Effect": "Allow",
          "Action": [
            "es:*"
          ],
          "Resource": [
            "${testCluster.arn}",
            "${testCluster.arn}/*"
          ]
            },
            {
              "Effect": "Allow",
              "Action": [
                "ec2:DescribeVpcs",
                "ec2:DescribeVpcAttribute",
                "ec2:DescribeSubnets",
                "ec2:DescribeSecurityGroups",
                "ec2:DescribeNetworkInterfaces",
                "ec2:CreateNetworkInterface",
                "ec2:CreateNetworkInterfacePermission",
                "ec2:DeleteNetworkInterface"
              ],
              "Resource": [
                "*"
              ]
            }
      ]
    }
    `,
    });
    const test = new aws.kinesis.FirehoseDeliveryStream("test", {
        name: "pulumi-kinesis-firehose-os",
        destination: "opensearch",
        opensearchConfiguration: {
            domainArn: testCluster.arn,
            roleArn: firehose.arn,
            indexName: "test",
            s3Configuration: {
                roleArn: firehose.arn,
                bucketArn: bucket.arn,
            },
            vpcConfig: {
                subnetIds: [
                    firstAwsSubnet.id,
                    second.id,
                ],
                securityGroupIds: [first.id],
                roleArn: firehose.arn,
            },
        },
    }, {
        dependsOn: [firehose_opensearch],
    });
    
    import pulumi
    import pulumi_aws as aws
    
    test_cluster = aws.opensearch.Domain("test_cluster",
        domain_name="es-test",
        cluster_config=aws.opensearch.DomainClusterConfigArgs(
            instance_count=2,
            zone_awareness_enabled=True,
            instance_type="m4.large.search",
        ),
        ebs_options=aws.opensearch.DomainEbsOptionsArgs(
            ebs_enabled=True,
            volume_size=10,
        ),
        vpc_options=aws.opensearch.DomainVpcOptionsArgs(
            security_group_ids=[first["id"]],
            subnet_ids=[
                first_aws_subnet["id"],
                second["id"],
            ],
        ))
    firehose_opensearch = aws.iam.RolePolicy("firehose-opensearch",
        name="opensearch",
        role=firehose["id"],
        policy=pulumi.Output.all(test_cluster.arn, test_cluster.arn).apply(lambda testClusterArn, testClusterArn1: f"""{{
      "Version": "2012-10-17",
      "Statement": [
        {{
          "Effect": "Allow",
          "Action": [
            "es:*"
          ],
          "Resource": [
            "{test_cluster_arn}",
            "{test_cluster_arn1}/*"
          ]
            }},
            {{
              "Effect": "Allow",
              "Action": [
                "ec2:DescribeVpcs",
                "ec2:DescribeVpcAttribute",
                "ec2:DescribeSubnets",
                "ec2:DescribeSecurityGroups",
                "ec2:DescribeNetworkInterfaces",
                "ec2:CreateNetworkInterface",
                "ec2:CreateNetworkInterfacePermission",
                "ec2:DeleteNetworkInterface"
              ],
              "Resource": [
                "*"
              ]
            }}
      ]
    }}
    """))
    test = aws.kinesis.FirehoseDeliveryStream("test",
        name="pulumi-kinesis-firehose-os",
        destination="opensearch",
        opensearch_configuration=aws.kinesis.FirehoseDeliveryStreamOpensearchConfigurationArgs(
            domain_arn=test_cluster.arn,
            role_arn=firehose["arn"],
            index_name="test",
            s3_configuration=aws.kinesis.FirehoseDeliveryStreamOpensearchConfigurationS3ConfigurationArgs(
                role_arn=firehose["arn"],
                bucket_arn=bucket["arn"],
            ),
            vpc_config=aws.kinesis.FirehoseDeliveryStreamOpensearchConfigurationVpcConfigArgs(
                subnet_ids=[
                    first_aws_subnet["id"],
                    second["id"],
                ],
                security_group_ids=[first["id"]],
                role_arn=firehose["arn"],
            ),
        ),
        opts=pulumi.ResourceOptions(depends_on=[firehose_opensearch]))
    
    package main
    
    import (
    	"fmt"
    
    	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/iam"
    	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/kinesis"
    	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/opensearch"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		testCluster, err := opensearch.NewDomain(ctx, "test_cluster", &opensearch.DomainArgs{
    			DomainName: pulumi.String("es-test"),
    			ClusterConfig: &opensearch.DomainClusterConfigArgs{
    				InstanceCount:        pulumi.Int(2),
    				ZoneAwarenessEnabled: pulumi.Bool(true),
    				InstanceType:         pulumi.String("m4.large.search"),
    			},
    			EbsOptions: &opensearch.DomainEbsOptionsArgs{
    				EbsEnabled: pulumi.Bool(true),
    				VolumeSize: pulumi.Int(10),
    			},
    			VpcOptions: &opensearch.DomainVpcOptionsArgs{
    				SecurityGroupIds: pulumi.StringArray{
    					first.Id,
    				},
    				SubnetIds: pulumi.StringArray{
    					firstAwsSubnet.Id,
    					second.Id,
    				},
    			},
    		})
    		if err != nil {
    			return err
    		}
    		_, err = iam.NewRolePolicy(ctx, "firehose-opensearch", &iam.RolePolicyArgs{
    			Name: pulumi.String("opensearch"),
    			Role: pulumi.Any(firehose.Id),
    			Policy: pulumi.All(testCluster.Arn, testCluster.Arn).ApplyT(func(_args []interface{}) (string, error) {
    				testClusterArn := _args[0].(string)
    				testClusterArn1 := _args[1].(string)
    				return fmt.Sprintf(`{
      "Version": "2012-10-17",
      "Statement": [
        {
          "Effect": "Allow",
          "Action": [
            "es:*"
          ],
          "Resource": [
            "%v",
            "%v/*"
          ]
            },
            {
              "Effect": "Allow",
              "Action": [
                "ec2:DescribeVpcs",
                "ec2:DescribeVpcAttribute",
                "ec2:DescribeSubnets",
                "ec2:DescribeSecurityGroups",
                "ec2:DescribeNetworkInterfaces",
                "ec2:CreateNetworkInterface",
                "ec2:CreateNetworkInterfacePermission",
                "ec2:DeleteNetworkInterface"
              ],
              "Resource": [
                "*"
              ]
            }
      ]
    }
    `, testClusterArn, testClusterArn1), nil
    			}).(pulumi.StringOutput),
    		})
    		if err != nil {
    			return err
    		}
    		_, err = kinesis.NewFirehoseDeliveryStream(ctx, "test", &kinesis.FirehoseDeliveryStreamArgs{
    			Name:        pulumi.String("pulumi-kinesis-firehose-os"),
    			Destination: pulumi.String("opensearch"),
    			OpensearchConfiguration: &kinesis.FirehoseDeliveryStreamOpensearchConfigurationArgs{
    				DomainArn: testCluster.Arn,
    				RoleArn:   pulumi.Any(firehose.Arn),
    				IndexName: pulumi.String("test"),
    				S3Configuration: &kinesis.FirehoseDeliveryStreamOpensearchConfigurationS3ConfigurationArgs{
    					RoleArn:   pulumi.Any(firehose.Arn),
    					BucketArn: pulumi.Any(bucket.Arn),
    				},
    				VpcConfig: &kinesis.FirehoseDeliveryStreamOpensearchConfigurationVpcConfigArgs{
    					SubnetIds: pulumi.StringArray{
    						firstAwsSubnet.Id,
    						second.Id,
    					},
    					SecurityGroupIds: pulumi.StringArray{
    						first.Id,
    					},
    					RoleArn: pulumi.Any(firehose.Arn),
    				},
    			},
    		}, pulumi.DependsOn([]pulumi.Resource{
    			firehose_opensearch,
    		}))
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using Aws = Pulumi.Aws;
    
    return await Deployment.RunAsync(() => 
    {
        var testCluster = new Aws.OpenSearch.Domain("test_cluster", new()
        {
            DomainName = "es-test",
            ClusterConfig = new Aws.OpenSearch.Inputs.DomainClusterConfigArgs
            {
                InstanceCount = 2,
                ZoneAwarenessEnabled = true,
                InstanceType = "m4.large.search",
            },
            EbsOptions = new Aws.OpenSearch.Inputs.DomainEbsOptionsArgs
            {
                EbsEnabled = true,
                VolumeSize = 10,
            },
            VpcOptions = new Aws.OpenSearch.Inputs.DomainVpcOptionsArgs
            {
                SecurityGroupIds = new[]
                {
                    first.Id,
                },
                SubnetIds = new[]
                {
                    firstAwsSubnet.Id,
                    second.Id,
                },
            },
        });
    
        var firehose_opensearch = new Aws.Iam.RolePolicy("firehose-opensearch", new()
        {
            Name = "opensearch",
            Role = firehose.Id,
            Policy = Output.Tuple(testCluster.Arn, testCluster.Arn).Apply(values =>
            {
                var testClusterArn = values.Item1;
                var testClusterArn1 = values.Item2;
                return @$"{{
      ""Version"": ""2012-10-17"",
      ""Statement"": [
        {{
          ""Effect"": ""Allow"",
          ""Action"": [
            ""es:*""
          ],
          ""Resource"": [
            ""{testClusterArn}"",
            ""{testClusterArn1}/*""
          ]
            }},
            {{
              ""Effect"": ""Allow"",
              ""Action"": [
                ""ec2:DescribeVpcs"",
                ""ec2:DescribeVpcAttribute"",
                ""ec2:DescribeSubnets"",
                ""ec2:DescribeSecurityGroups"",
                ""ec2:DescribeNetworkInterfaces"",
                ""ec2:CreateNetworkInterface"",
                ""ec2:CreateNetworkInterfacePermission"",
                ""ec2:DeleteNetworkInterface""
              ],
              ""Resource"": [
                ""*""
              ]
            }}
      ]
    }}
    ";
            }),
        });
    
        var test = new Aws.Kinesis.FirehoseDeliveryStream("test", new()
        {
            Name = "pulumi-kinesis-firehose-os",
            Destination = "opensearch",
            OpensearchConfiguration = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamOpensearchConfigurationArgs
            {
                DomainArn = testCluster.Arn,
                RoleArn = firehose.Arn,
                IndexName = "test",
                S3Configuration = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamOpensearchConfigurationS3ConfigurationArgs
                {
                    RoleArn = firehose.Arn,
                    BucketArn = bucket.Arn,
                },
                VpcConfig = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamOpensearchConfigurationVpcConfigArgs
                {
                    SubnetIds = new[]
                    {
                        firstAwsSubnet.Id,
                        second.Id,
                    },
                    SecurityGroupIds = new[]
                    {
                        first.Id,
                    },
                    RoleArn = firehose.Arn,
                },
            },
        }, new CustomResourceOptions
        {
            DependsOn =
            {
                firehose_opensearch,
            },
        });
    
    });
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.aws.opensearch.Domain;
    import com.pulumi.aws.opensearch.DomainArgs;
    import com.pulumi.aws.opensearch.inputs.DomainClusterConfigArgs;
    import com.pulumi.aws.opensearch.inputs.DomainEbsOptionsArgs;
    import com.pulumi.aws.opensearch.inputs.DomainVpcOptionsArgs;
    import com.pulumi.aws.iam.RolePolicy;
    import com.pulumi.aws.iam.RolePolicyArgs;
    import com.pulumi.aws.kinesis.FirehoseDeliveryStream;
    import com.pulumi.aws.kinesis.FirehoseDeliveryStreamArgs;
    import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamOpensearchConfigurationArgs;
    import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamOpensearchConfigurationS3ConfigurationArgs;
    import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamOpensearchConfigurationVpcConfigArgs;
    import com.pulumi.resources.CustomResourceOptions;
    import java.util.List;
    import java.util.ArrayList;
    import java.util.Map;
    import java.io.File;
    import java.nio.file.Files;
    import java.nio.file.Paths;
    
    public class App {
        public static void main(String[] args) {
            Pulumi.run(App::stack);
        }
    
        public static void stack(Context ctx) {
            var testCluster = new Domain("testCluster", DomainArgs.builder()
                .domainName("es-test")
                .clusterConfig(DomainClusterConfigArgs.builder()
                    .instanceCount(2)
                    .zoneAwarenessEnabled(true)
                    .instanceType("m4.large.search")
                    .build())
                .ebsOptions(DomainEbsOptionsArgs.builder()
                    .ebsEnabled(true)
                    .volumeSize(10)
                    .build())
                .vpcOptions(DomainVpcOptionsArgs.builder()
                    .securityGroupIds(first.id())
                    .subnetIds(                
                        firstAwsSubnet.id(),
                        second.id())
                    .build())
                .build());
    
            var firehose_opensearch = new RolePolicy("firehose-opensearch", RolePolicyArgs.builder()
                .name("opensearch")
                .role(firehose.id())
                .policy(Output.tuple(testCluster.arn(), testCluster.arn()).applyValue(values -> {
                    var testClusterArn = values.t1;
                    var testClusterArn1 = values.t2;
                    return """
    {
      "Version": "2012-10-17",
      "Statement": [
        {
          "Effect": "Allow",
          "Action": [
            "es:*"
          ],
          "Resource": [
            "%s",
            "%s/*"
          ]
            },
            {
              "Effect": "Allow",
              "Action": [
                "ec2:DescribeVpcs",
                "ec2:DescribeVpcAttribute",
                "ec2:DescribeSubnets",
                "ec2:DescribeSecurityGroups",
                "ec2:DescribeNetworkInterfaces",
                "ec2:CreateNetworkInterface",
                "ec2:CreateNetworkInterfacePermission",
                "ec2:DeleteNetworkInterface"
              ],
              "Resource": [
                "*"
              ]
            }
      ]
    }
    ", testClusterArn,testClusterArn1);
                }))
                .build());
    
            var test = new FirehoseDeliveryStream("test", FirehoseDeliveryStreamArgs.builder()
                .name("pulumi-kinesis-firehose-os")
                .destination("opensearch")
                .opensearchConfiguration(FirehoseDeliveryStreamOpensearchConfigurationArgs.builder()
                    .domainArn(testCluster.arn())
                    .roleArn(firehose.arn())
                    .indexName("test")
                    .s3Configuration(FirehoseDeliveryStreamOpensearchConfigurationS3ConfigurationArgs.builder()
                        .roleArn(firehose.arn())
                        .bucketArn(bucket.arn())
                        .build())
                    .vpcConfig(FirehoseDeliveryStreamOpensearchConfigurationVpcConfigArgs.builder()
                        .subnetIds(                    
                            firstAwsSubnet.id(),
                            second.id())
                        .securityGroupIds(first.id())
                        .roleArn(firehose.arn())
                        .build())
                    .build())
                .build(), CustomResourceOptions.builder()
                    .dependsOn(firehose_opensearch)
                    .build());
    
        }
    }
    
    resources:
      testCluster:
        type: aws:opensearch:Domain
        name: test_cluster
        properties:
          domainName: es-test
          clusterConfig:
            instanceCount: 2
            zoneAwarenessEnabled: true
            instanceType: m4.large.search
          ebsOptions:
            ebsEnabled: true
            volumeSize: 10
          vpcOptions:
            securityGroupIds:
              - ${first.id}
            subnetIds:
              - ${firstAwsSubnet.id}
              - ${second.id}
      firehose-opensearch:
        type: aws:iam:RolePolicy
        properties:
          name: opensearch
          role: ${firehose.id}
          policy: |
            {
              "Version": "2012-10-17",
              "Statement": [
                {
                  "Effect": "Allow",
                  "Action": [
                    "es:*"
                  ],
                  "Resource": [
                    "${testCluster.arn}",
                    "${testCluster.arn}/*"
                  ]
                    },
                    {
                      "Effect": "Allow",
                      "Action": [
                        "ec2:DescribeVpcs",
                        "ec2:DescribeVpcAttribute",
                        "ec2:DescribeSubnets",
                        "ec2:DescribeSecurityGroups",
                        "ec2:DescribeNetworkInterfaces",
                        "ec2:CreateNetworkInterface",
                        "ec2:CreateNetworkInterfacePermission",
                        "ec2:DeleteNetworkInterface"
                      ],
                      "Resource": [
                        "*"
                      ]
                    }
              ]
            }        
      test:
        type: aws:kinesis:FirehoseDeliveryStream
        properties:
          name: pulumi-kinesis-firehose-os
          destination: opensearch
          opensearchConfiguration:
            domainArn: ${testCluster.arn}
            roleArn: ${firehose.arn}
            indexName: test
            s3Configuration:
              roleArn: ${firehose.arn}
              bucketArn: ${bucket.arn}
            vpcConfig:
              subnetIds:
                - ${firstAwsSubnet.id}
                - ${second.id}
              securityGroupIds:
                - ${first.id}
              roleArn: ${firehose.arn}
        options:
          dependson:
            - ${["firehose-opensearch"]}
    

    OpenSearch Serverless Destination

    import * as pulumi from "@pulumi/pulumi";
    import * as aws from "@pulumi/aws";
    
    const testCollection = new aws.opensearch.ServerlessCollection("test_collection", {name: "firehose-osserverless-test"});
    const testStream = new aws.kinesis.FirehoseDeliveryStream("test_stream", {
        name: "kinesis-firehose-test-stream",
        destination: "opensearchserverless",
        opensearchserverlessConfiguration: {
            collectionEndpoint: testCollection.collectionEndpoint,
            roleArn: firehoseRole.arn,
            indexName: "test",
            s3Configuration: {
                roleArn: firehoseRole.arn,
                bucketArn: bucket.arn,
                bufferingSize: 10,
                bufferingInterval: 400,
                compressionFormat: "GZIP",
            },
            processingConfiguration: {
                enabled: true,
                processors: [{
                    type: "Lambda",
                    parameters: [{
                        parameterName: "LambdaArn",
                        parameterValue: `${lambdaProcessor.arn}:$LATEST`,
                    }],
                }],
            },
        },
    });
    
    import pulumi
    import pulumi_aws as aws
    
    test_collection = aws.opensearch.ServerlessCollection("test_collection", name="firehose-osserverless-test")
    test_stream = aws.kinesis.FirehoseDeliveryStream("test_stream",
        name="kinesis-firehose-test-stream",
        destination="opensearchserverless",
        opensearchserverless_configuration=aws.kinesis.FirehoseDeliveryStreamOpensearchserverlessConfigurationArgs(
            collection_endpoint=test_collection.collection_endpoint,
            role_arn=firehose_role["arn"],
            index_name="test",
            s3_configuration=aws.kinesis.FirehoseDeliveryStreamOpensearchserverlessConfigurationS3ConfigurationArgs(
                role_arn=firehose_role["arn"],
                bucket_arn=bucket["arn"],
                buffering_size=10,
                buffering_interval=400,
                compression_format="GZIP",
            ),
            processing_configuration=aws.kinesis.FirehoseDeliveryStreamOpensearchserverlessConfigurationProcessingConfigurationArgs(
                enabled=True,
                processors=[aws.kinesis.FirehoseDeliveryStreamOpensearchserverlessConfigurationProcessingConfigurationProcessorArgs(
                    type="Lambda",
                    parameters=[aws.kinesis.FirehoseDeliveryStreamOpensearchserverlessConfigurationProcessingConfigurationProcessorParameterArgs(
                        parameter_name="LambdaArn",
                        parameter_value=f"{lambda_processor['arn']}:$LATEST",
                    )],
                )],
            ),
        ))
    
    package main
    
    import (
    	"fmt"
    
    	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/kinesis"
    	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/opensearch"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		testCollection, err := opensearch.NewServerlessCollection(ctx, "test_collection", &opensearch.ServerlessCollectionArgs{
    			Name: pulumi.String("firehose-osserverless-test"),
    		})
    		if err != nil {
    			return err
    		}
    		_, err = kinesis.NewFirehoseDeliveryStream(ctx, "test_stream", &kinesis.FirehoseDeliveryStreamArgs{
    			Name:        pulumi.String("kinesis-firehose-test-stream"),
    			Destination: pulumi.String("opensearchserverless"),
    			OpensearchserverlessConfiguration: &kinesis.FirehoseDeliveryStreamOpensearchserverlessConfigurationArgs{
    				CollectionEndpoint: testCollection.CollectionEndpoint,
    				RoleArn:            pulumi.Any(firehoseRole.Arn),
    				IndexName:          pulumi.String("test"),
    				S3Configuration: &kinesis.FirehoseDeliveryStreamOpensearchserverlessConfigurationS3ConfigurationArgs{
    					RoleArn:           pulumi.Any(firehoseRole.Arn),
    					BucketArn:         pulumi.Any(bucket.Arn),
    					BufferingSize:     pulumi.Int(10),
    					BufferingInterval: pulumi.Int(400),
    					CompressionFormat: pulumi.String("GZIP"),
    				},
    				ProcessingConfiguration: &kinesis.FirehoseDeliveryStreamOpensearchserverlessConfigurationProcessingConfigurationArgs{
    					Enabled: pulumi.Bool(true),
    					Processors: kinesis.FirehoseDeliveryStreamOpensearchserverlessConfigurationProcessingConfigurationProcessorArray{
    						&kinesis.FirehoseDeliveryStreamOpensearchserverlessConfigurationProcessingConfigurationProcessorArgs{
    							Type: pulumi.String("Lambda"),
    							Parameters: kinesis.FirehoseDeliveryStreamOpensearchserverlessConfigurationProcessingConfigurationProcessorParameterArray{
    								&kinesis.FirehoseDeliveryStreamOpensearchserverlessConfigurationProcessingConfigurationProcessorParameterArgs{
    									ParameterName:  pulumi.String("LambdaArn"),
    									ParameterValue: pulumi.String(fmt.Sprintf("%v:$LATEST", lambdaProcessor.Arn)),
    								},
    							},
    						},
    					},
    				},
    			},
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using Aws = Pulumi.Aws;
    
    return await Deployment.RunAsync(() => 
    {
        var testCollection = new Aws.OpenSearch.ServerlessCollection("test_collection", new()
        {
            Name = "firehose-osserverless-test",
        });
    
        var testStream = new Aws.Kinesis.FirehoseDeliveryStream("test_stream", new()
        {
            Name = "kinesis-firehose-test-stream",
            Destination = "opensearchserverless",
            OpensearchserverlessConfiguration = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamOpensearchserverlessConfigurationArgs
            {
                CollectionEndpoint = testCollection.CollectionEndpoint,
                RoleArn = firehoseRole.Arn,
                IndexName = "test",
                S3Configuration = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamOpensearchserverlessConfigurationS3ConfigurationArgs
                {
                    RoleArn = firehoseRole.Arn,
                    BucketArn = bucket.Arn,
                    BufferingSize = 10,
                    BufferingInterval = 400,
                    CompressionFormat = "GZIP",
                },
                ProcessingConfiguration = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamOpensearchserverlessConfigurationProcessingConfigurationArgs
                {
                    Enabled = true,
                    Processors = new[]
                    {
                        new Aws.Kinesis.Inputs.FirehoseDeliveryStreamOpensearchserverlessConfigurationProcessingConfigurationProcessorArgs
                        {
                            Type = "Lambda",
                            Parameters = new[]
                            {
                                new Aws.Kinesis.Inputs.FirehoseDeliveryStreamOpensearchserverlessConfigurationProcessingConfigurationProcessorParameterArgs
                                {
                                    ParameterName = "LambdaArn",
                                    ParameterValue = $"{lambdaProcessor.Arn}:$LATEST",
                                },
                            },
                        },
                    },
                },
            },
        });
    
    });
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.aws.opensearch.ServerlessCollection;
    import com.pulumi.aws.opensearch.ServerlessCollectionArgs;
    import com.pulumi.aws.kinesis.FirehoseDeliveryStream;
    import com.pulumi.aws.kinesis.FirehoseDeliveryStreamArgs;
    import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamOpensearchserverlessConfigurationArgs;
    import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamOpensearchserverlessConfigurationS3ConfigurationArgs;
    import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamOpensearchserverlessConfigurationProcessingConfigurationArgs;
    import java.util.List;
    import java.util.ArrayList;
    import java.util.Map;
    import java.io.File;
    import java.nio.file.Files;
    import java.nio.file.Paths;
    
    public class App {
        public static void main(String[] args) {
            Pulumi.run(App::stack);
        }
    
        public static void stack(Context ctx) {
            var testCollection = new ServerlessCollection("testCollection", ServerlessCollectionArgs.builder()
                .name("firehose-osserverless-test")
                .build());
    
            var testStream = new FirehoseDeliveryStream("testStream", FirehoseDeliveryStreamArgs.builder()
                .name("kinesis-firehose-test-stream")
                .destination("opensearchserverless")
                .opensearchserverlessConfiguration(FirehoseDeliveryStreamOpensearchserverlessConfigurationArgs.builder()
                    .collectionEndpoint(testCollection.collectionEndpoint())
                    .roleArn(firehoseRole.arn())
                    .indexName("test")
                    .s3Configuration(FirehoseDeliveryStreamOpensearchserverlessConfigurationS3ConfigurationArgs.builder()
                        .roleArn(firehoseRole.arn())
                        .bucketArn(bucket.arn())
                        .bufferingSize(10)
                        .bufferingInterval(400)
                        .compressionFormat("GZIP")
                        .build())
                    .processingConfiguration(FirehoseDeliveryStreamOpensearchserverlessConfigurationProcessingConfigurationArgs.builder()
                        .enabled("true")
                        .processors(FirehoseDeliveryStreamOpensearchserverlessConfigurationProcessingConfigurationProcessorArgs.builder()
                            .type("Lambda")
                            .parameters(FirehoseDeliveryStreamOpensearchserverlessConfigurationProcessingConfigurationProcessorParameterArgs.builder()
                                .parameterName("LambdaArn")
                                .parameterValue(String.format("%s:$LATEST", lambdaProcessor.arn()))
                                .build())
                            .build())
                        .build())
                    .build())
                .build());
    
        }
    }
    
    resources:
      testCollection:
        type: aws:opensearch:ServerlessCollection
        name: test_collection
        properties:
          name: firehose-osserverless-test
      testStream:
        type: aws:kinesis:FirehoseDeliveryStream
        name: test_stream
        properties:
          name: kinesis-firehose-test-stream
          destination: opensearchserverless
          opensearchserverlessConfiguration:
            collectionEndpoint: ${testCollection.collectionEndpoint}
            roleArn: ${firehoseRole.arn}
            indexName: test
            s3Configuration:
              roleArn: ${firehoseRole.arn}
              bucketArn: ${bucket.arn}
              bufferingSize: 10
              bufferingInterval: 400
              compressionFormat: GZIP
            processingConfiguration:
              enabled: 'true'
              processors:
                - type: Lambda
                  parameters:
                    - parameterName: LambdaArn
                      parameterValue: ${lambdaProcessor.arn}:$LATEST
    

    Splunk Destination

    import * as pulumi from "@pulumi/pulumi";
    import * as aws from "@pulumi/aws";
    
    const testStream = new aws.kinesis.FirehoseDeliveryStream("test_stream", {
        name: "kinesis-firehose-test-stream",
        destination: "splunk",
        splunkConfiguration: {
            hecEndpoint: "https://http-inputs-mydomain.splunkcloud.com:443",
            hecToken: "51D4DA16-C61B-4F5F-8EC7-ED4301342A4A",
            hecAcknowledgmentTimeout: 600,
            hecEndpointType: "Event",
            s3BackupMode: "FailedEventsOnly",
            s3Configuration: {
                roleArn: firehose.arn,
                bucketArn: bucket.arn,
                bufferingSize: 10,
                bufferingInterval: 400,
                compressionFormat: "GZIP",
            },
        },
    });
    
    import pulumi
    import pulumi_aws as aws
    
    test_stream = aws.kinesis.FirehoseDeliveryStream("test_stream",
        name="kinesis-firehose-test-stream",
        destination="splunk",
        splunk_configuration=aws.kinesis.FirehoseDeliveryStreamSplunkConfigurationArgs(
            hec_endpoint="https://http-inputs-mydomain.splunkcloud.com:443",
            hec_token="51D4DA16-C61B-4F5F-8EC7-ED4301342A4A",
            hec_acknowledgment_timeout=600,
            hec_endpoint_type="Event",
            s3_backup_mode="FailedEventsOnly",
            s3_configuration=aws.kinesis.FirehoseDeliveryStreamSplunkConfigurationS3ConfigurationArgs(
                role_arn=firehose["arn"],
                bucket_arn=bucket["arn"],
                buffering_size=10,
                buffering_interval=400,
                compression_format="GZIP",
            ),
        ))
    
    package main
    
    import (
    	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/kinesis"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		_, err := kinesis.NewFirehoseDeliveryStream(ctx, "test_stream", &kinesis.FirehoseDeliveryStreamArgs{
    			Name:        pulumi.String("kinesis-firehose-test-stream"),
    			Destination: pulumi.String("splunk"),
    			SplunkConfiguration: &kinesis.FirehoseDeliveryStreamSplunkConfigurationArgs{
    				HecEndpoint:              pulumi.String("https://http-inputs-mydomain.splunkcloud.com:443"),
    				HecToken:                 pulumi.String("51D4DA16-C61B-4F5F-8EC7-ED4301342A4A"),
    				HecAcknowledgmentTimeout: pulumi.Int(600),
    				HecEndpointType:          pulumi.String("Event"),
    				S3BackupMode:             pulumi.String("FailedEventsOnly"),
    				S3Configuration: &kinesis.FirehoseDeliveryStreamSplunkConfigurationS3ConfigurationArgs{
    					RoleArn:           pulumi.Any(firehose.Arn),
    					BucketArn:         pulumi.Any(bucket.Arn),
    					BufferingSize:     pulumi.Int(10),
    					BufferingInterval: pulumi.Int(400),
    					CompressionFormat: pulumi.String("GZIP"),
    				},
    			},
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using Aws = Pulumi.Aws;
    
    return await Deployment.RunAsync(() => 
    {
        var testStream = new Aws.Kinesis.FirehoseDeliveryStream("test_stream", new()
        {
            Name = "kinesis-firehose-test-stream",
            Destination = "splunk",
            SplunkConfiguration = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamSplunkConfigurationArgs
            {
                HecEndpoint = "https://http-inputs-mydomain.splunkcloud.com:443",
                HecToken = "51D4DA16-C61B-4F5F-8EC7-ED4301342A4A",
                HecAcknowledgmentTimeout = 600,
                HecEndpointType = "Event",
                S3BackupMode = "FailedEventsOnly",
                S3Configuration = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamSplunkConfigurationS3ConfigurationArgs
                {
                    RoleArn = firehose.Arn,
                    BucketArn = bucket.Arn,
                    BufferingSize = 10,
                    BufferingInterval = 400,
                    CompressionFormat = "GZIP",
                },
            },
        });
    
    });
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.aws.kinesis.FirehoseDeliveryStream;
    import com.pulumi.aws.kinesis.FirehoseDeliveryStreamArgs;
    import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamSplunkConfigurationArgs;
    import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamSplunkConfigurationS3ConfigurationArgs;
    import java.util.List;
    import java.util.ArrayList;
    import java.util.Map;
    import java.io.File;
    import java.nio.file.Files;
    import java.nio.file.Paths;
    
    public class App {
        public static void main(String[] args) {
            Pulumi.run(App::stack);
        }
    
        public static void stack(Context ctx) {
            var testStream = new FirehoseDeliveryStream("testStream", FirehoseDeliveryStreamArgs.builder()
                .name("kinesis-firehose-test-stream")
                .destination("splunk")
                .splunkConfiguration(FirehoseDeliveryStreamSplunkConfigurationArgs.builder()
                    .hecEndpoint("https://http-inputs-mydomain.splunkcloud.com:443")
                    .hecToken("51D4DA16-C61B-4F5F-8EC7-ED4301342A4A")
                    .hecAcknowledgmentTimeout(600)
                    .hecEndpointType("Event")
                    .s3BackupMode("FailedEventsOnly")
                    .s3Configuration(FirehoseDeliveryStreamSplunkConfigurationS3ConfigurationArgs.builder()
                        .roleArn(firehose.arn())
                        .bucketArn(bucket.arn())
                        .bufferingSize(10)
                        .bufferingInterval(400)
                        .compressionFormat("GZIP")
                        .build())
                    .build())
                .build());
    
        }
    }
    
    resources:
      testStream:
        type: aws:kinesis:FirehoseDeliveryStream
        name: test_stream
        properties:
          name: kinesis-firehose-test-stream
          destination: splunk
          splunkConfiguration:
            hecEndpoint: https://http-inputs-mydomain.splunkcloud.com:443
            hecToken: 51D4DA16-C61B-4F5F-8EC7-ED4301342A4A
            hecAcknowledgmentTimeout: 600
            hecEndpointType: Event
            s3BackupMode: FailedEventsOnly
            s3Configuration:
              roleArn: ${firehose.arn}
              bucketArn: ${bucket.arn}
              bufferingSize: 10
              bufferingInterval: 400
              compressionFormat: GZIP
    

    HTTP Endpoint (e.g., New Relic) Destination

    import * as pulumi from "@pulumi/pulumi";
    import * as aws from "@pulumi/aws";
    
    const testStream = new aws.kinesis.FirehoseDeliveryStream("test_stream", {
        name: "kinesis-firehose-test-stream",
        destination: "http_endpoint",
        httpEndpointConfiguration: {
            url: "https://aws-api.newrelic.com/firehose/v1",
            name: "New Relic",
            accessKey: "my-key",
            bufferingSize: 15,
            bufferingInterval: 600,
            roleArn: firehose.arn,
            s3BackupMode: "FailedDataOnly",
            s3Configuration: {
                roleArn: firehose.arn,
                bucketArn: bucket.arn,
                bufferingSize: 10,
                bufferingInterval: 400,
                compressionFormat: "GZIP",
            },
            requestConfiguration: {
                contentEncoding: "GZIP",
                commonAttributes: [
                    {
                        name: "testname",
                        value: "testvalue",
                    },
                    {
                        name: "testname2",
                        value: "testvalue2",
                    },
                ],
            },
        },
    });
    
    import pulumi
    import pulumi_aws as aws
    
    test_stream = aws.kinesis.FirehoseDeliveryStream("test_stream",
        name="kinesis-firehose-test-stream",
        destination="http_endpoint",
        http_endpoint_configuration=aws.kinesis.FirehoseDeliveryStreamHttpEndpointConfigurationArgs(
            url="https://aws-api.newrelic.com/firehose/v1",
            name="New Relic",
            access_key="my-key",
            buffering_size=15,
            buffering_interval=600,
            role_arn=firehose["arn"],
            s3_backup_mode="FailedDataOnly",
            s3_configuration=aws.kinesis.FirehoseDeliveryStreamHttpEndpointConfigurationS3ConfigurationArgs(
                role_arn=firehose["arn"],
                bucket_arn=bucket["arn"],
                buffering_size=10,
                buffering_interval=400,
                compression_format="GZIP",
            ),
            request_configuration=aws.kinesis.FirehoseDeliveryStreamHttpEndpointConfigurationRequestConfigurationArgs(
                content_encoding="GZIP",
                common_attributes=[
                    aws.kinesis.FirehoseDeliveryStreamHttpEndpointConfigurationRequestConfigurationCommonAttributeArgs(
                        name="testname",
                        value="testvalue",
                    ),
                    aws.kinesis.FirehoseDeliveryStreamHttpEndpointConfigurationRequestConfigurationCommonAttributeArgs(
                        name="testname2",
                        value="testvalue2",
                    ),
                ],
            ),
        ))
    
    package main
    
    import (
    	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/kinesis"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		_, err := kinesis.NewFirehoseDeliveryStream(ctx, "test_stream", &kinesis.FirehoseDeliveryStreamArgs{
    			Name:        pulumi.String("kinesis-firehose-test-stream"),
    			Destination: pulumi.String("http_endpoint"),
    			HttpEndpointConfiguration: &kinesis.FirehoseDeliveryStreamHttpEndpointConfigurationArgs{
    				Url:               pulumi.String("https://aws-api.newrelic.com/firehose/v1"),
    				Name:              pulumi.String("New Relic"),
    				AccessKey:         pulumi.String("my-key"),
    				BufferingSize:     pulumi.Int(15),
    				BufferingInterval: pulumi.Int(600),
    				RoleArn:           pulumi.Any(firehose.Arn),
    				S3BackupMode:      pulumi.String("FailedDataOnly"),
    				S3Configuration: &kinesis.FirehoseDeliveryStreamHttpEndpointConfigurationS3ConfigurationArgs{
    					RoleArn:           pulumi.Any(firehose.Arn),
    					BucketArn:         pulumi.Any(bucket.Arn),
    					BufferingSize:     pulumi.Int(10),
    					BufferingInterval: pulumi.Int(400),
    					CompressionFormat: pulumi.String("GZIP"),
    				},
    				RequestConfiguration: &kinesis.FirehoseDeliveryStreamHttpEndpointConfigurationRequestConfigurationArgs{
    					ContentEncoding: pulumi.String("GZIP"),
    					CommonAttributes: kinesis.FirehoseDeliveryStreamHttpEndpointConfigurationRequestConfigurationCommonAttributeArray{
    						&kinesis.FirehoseDeliveryStreamHttpEndpointConfigurationRequestConfigurationCommonAttributeArgs{
    							Name:  pulumi.String("testname"),
    							Value: pulumi.String("testvalue"),
    						},
    						&kinesis.FirehoseDeliveryStreamHttpEndpointConfigurationRequestConfigurationCommonAttributeArgs{
    							Name:  pulumi.String("testname2"),
    							Value: pulumi.String("testvalue2"),
    						},
    					},
    				},
    			},
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using Aws = Pulumi.Aws;
    
    return await Deployment.RunAsync(() => 
    {
        var testStream = new Aws.Kinesis.FirehoseDeliveryStream("test_stream", new()
        {
            Name = "kinesis-firehose-test-stream",
            Destination = "http_endpoint",
            HttpEndpointConfiguration = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamHttpEndpointConfigurationArgs
            {
                Url = "https://aws-api.newrelic.com/firehose/v1",
                Name = "New Relic",
                AccessKey = "my-key",
                BufferingSize = 15,
                BufferingInterval = 600,
                RoleArn = firehose.Arn,
                S3BackupMode = "FailedDataOnly",
                S3Configuration = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamHttpEndpointConfigurationS3ConfigurationArgs
                {
                    RoleArn = firehose.Arn,
                    BucketArn = bucket.Arn,
                    BufferingSize = 10,
                    BufferingInterval = 400,
                    CompressionFormat = "GZIP",
                },
                RequestConfiguration = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamHttpEndpointConfigurationRequestConfigurationArgs
                {
                    ContentEncoding = "GZIP",
                    CommonAttributes = new[]
                    {
                        new Aws.Kinesis.Inputs.FirehoseDeliveryStreamHttpEndpointConfigurationRequestConfigurationCommonAttributeArgs
                        {
                            Name = "testname",
                            Value = "testvalue",
                        },
                        new Aws.Kinesis.Inputs.FirehoseDeliveryStreamHttpEndpointConfigurationRequestConfigurationCommonAttributeArgs
                        {
                            Name = "testname2",
                            Value = "testvalue2",
                        },
                    },
                },
            },
        });
    
    });
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.aws.kinesis.FirehoseDeliveryStream;
    import com.pulumi.aws.kinesis.FirehoseDeliveryStreamArgs;
    import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamHttpEndpointConfigurationArgs;
    import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamHttpEndpointConfigurationS3ConfigurationArgs;
    import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamHttpEndpointConfigurationRequestConfigurationArgs;
    import java.util.List;
    import java.util.ArrayList;
    import java.util.Map;
    import java.io.File;
    import java.nio.file.Files;
    import java.nio.file.Paths;
    
    public class App {
        public static void main(String[] args) {
            Pulumi.run(App::stack);
        }
    
        public static void stack(Context ctx) {
            var testStream = new FirehoseDeliveryStream("testStream", FirehoseDeliveryStreamArgs.builder()
                .name("kinesis-firehose-test-stream")
                .destination("http_endpoint")
                .httpEndpointConfiguration(FirehoseDeliveryStreamHttpEndpointConfigurationArgs.builder()
                    .url("https://aws-api.newrelic.com/firehose/v1")
                    .name("New Relic")
                    .accessKey("my-key")
                    .bufferingSize(15)
                    .bufferingInterval(600)
                    .roleArn(firehose.arn())
                    .s3BackupMode("FailedDataOnly")
                    .s3Configuration(FirehoseDeliveryStreamHttpEndpointConfigurationS3ConfigurationArgs.builder()
                        .roleArn(firehose.arn())
                        .bucketArn(bucket.arn())
                        .bufferingSize(10)
                        .bufferingInterval(400)
                        .compressionFormat("GZIP")
                        .build())
                    .requestConfiguration(FirehoseDeliveryStreamHttpEndpointConfigurationRequestConfigurationArgs.builder()
                        .contentEncoding("GZIP")
                        .commonAttributes(                    
                            FirehoseDeliveryStreamHttpEndpointConfigurationRequestConfigurationCommonAttributeArgs.builder()
                                .name("testname")
                                .value("testvalue")
                                .build(),
                            FirehoseDeliveryStreamHttpEndpointConfigurationRequestConfigurationCommonAttributeArgs.builder()
                                .name("testname2")
                                .value("testvalue2")
                                .build())
                        .build())
                    .build())
                .build());
    
        }
    }
    
    resources:
      testStream:
        type: aws:kinesis:FirehoseDeliveryStream
        name: test_stream
        properties:
          name: kinesis-firehose-test-stream
          destination: http_endpoint
          httpEndpointConfiguration:
            url: https://aws-api.newrelic.com/firehose/v1
            name: New Relic
            accessKey: my-key
            bufferingSize: 15
            bufferingInterval: 600
            roleArn: ${firehose.arn}
            s3BackupMode: FailedDataOnly
            s3Configuration:
              roleArn: ${firehose.arn}
              bucketArn: ${bucket.arn}
              bufferingSize: 10
              bufferingInterval: 400
              compressionFormat: GZIP
            requestConfiguration:
              contentEncoding: GZIP
              commonAttributes:
                - name: testname
                  value: testvalue
                - name: testname2
                  value: testvalue2
    

    Snowflake Destination

    import * as pulumi from "@pulumi/pulumi";
    import * as aws from "@pulumi/aws";
    
    const exampleSnowflakeDestination = new aws.kinesis.FirehoseDeliveryStream("example_snowflake_destination", {
        name: "example-snowflake-destination",
        destination: "snowflake",
        snowflakeConfiguration: {
            accountUrl: "https://example.snowflakecomputing.com",
            database: "example-db",
            privateKey: "...",
            roleArn: firehose.arn,
            schema: "example-schema",
            table: "example-table",
            user: "example-usr",
            s3Configuration: {
                roleArn: firehose.arn,
                bucketArn: bucket.arn,
                bufferingSize: 10,
                bufferingInterval: 400,
                compressionFormat: "GZIP",
            },
        },
    });
    
    import pulumi
    import pulumi_aws as aws
    
    example_snowflake_destination = aws.kinesis.FirehoseDeliveryStream("example_snowflake_destination",
        name="example-snowflake-destination",
        destination="snowflake",
        snowflake_configuration=aws.kinesis.FirehoseDeliveryStreamSnowflakeConfigurationArgs(
            account_url="https://example.snowflakecomputing.com",
            database="example-db",
            private_key="...",
            role_arn=firehose["arn"],
            schema="example-schema",
            table="example-table",
            user="example-usr",
            s3_configuration=aws.kinesis.FirehoseDeliveryStreamSnowflakeConfigurationS3ConfigurationArgs(
                role_arn=firehose["arn"],
                bucket_arn=bucket["arn"],
                buffering_size=10,
                buffering_interval=400,
                compression_format="GZIP",
            ),
        ))
    
    package main
    
    import (
    	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/kinesis"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		_, err := kinesis.NewFirehoseDeliveryStream(ctx, "example_snowflake_destination", &kinesis.FirehoseDeliveryStreamArgs{
    			Name:        pulumi.String("example-snowflake-destination"),
    			Destination: pulumi.String("snowflake"),
    			SnowflakeConfiguration: &kinesis.FirehoseDeliveryStreamSnowflakeConfigurationArgs{
    				AccountUrl: pulumi.String("https://example.snowflakecomputing.com"),
    				Database:   pulumi.String("example-db"),
    				PrivateKey: pulumi.String("..."),
    				RoleArn:    pulumi.Any(firehose.Arn),
    				Schema:     pulumi.String("example-schema"),
    				Table:      pulumi.String("example-table"),
    				User:       pulumi.String("example-usr"),
    				S3Configuration: &kinesis.FirehoseDeliveryStreamSnowflakeConfigurationS3ConfigurationArgs{
    					RoleArn:           pulumi.Any(firehose.Arn),
    					BucketArn:         pulumi.Any(bucket.Arn),
    					BufferingSize:     pulumi.Int(10),
    					BufferingInterval: pulumi.Int(400),
    					CompressionFormat: pulumi.String("GZIP"),
    				},
    			},
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using Aws = Pulumi.Aws;
    
    return await Deployment.RunAsync(() => 
    {
        var exampleSnowflakeDestination = new Aws.Kinesis.FirehoseDeliveryStream("example_snowflake_destination", new()
        {
            Name = "example-snowflake-destination",
            Destination = "snowflake",
            SnowflakeConfiguration = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamSnowflakeConfigurationArgs
            {
                AccountUrl = "https://example.snowflakecomputing.com",
                Database = "example-db",
                PrivateKey = "...",
                RoleArn = firehose.Arn,
                Schema = "example-schema",
                Table = "example-table",
                User = "example-usr",
                S3Configuration = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamSnowflakeConfigurationS3ConfigurationArgs
                {
                    RoleArn = firehose.Arn,
                    BucketArn = bucket.Arn,
                    BufferingSize = 10,
                    BufferingInterval = 400,
                    CompressionFormat = "GZIP",
                },
            },
        });
    
    });
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.aws.kinesis.FirehoseDeliveryStream;
    import com.pulumi.aws.kinesis.FirehoseDeliveryStreamArgs;
    import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamSnowflakeConfigurationArgs;
    import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamSnowflakeConfigurationS3ConfigurationArgs;
    import java.util.List;
    import java.util.ArrayList;
    import java.util.Map;
    import java.io.File;
    import java.nio.file.Files;
    import java.nio.file.Paths;
    
    public class App {
        public static void main(String[] args) {
            Pulumi.run(App::stack);
        }
    
        public static void stack(Context ctx) {
            var exampleSnowflakeDestination = new FirehoseDeliveryStream("exampleSnowflakeDestination", FirehoseDeliveryStreamArgs.builder()
                .name("example-snowflake-destination")
                .destination("snowflake")
                .snowflakeConfiguration(FirehoseDeliveryStreamSnowflakeConfigurationArgs.builder()
                    .accountUrl("https://example.snowflakecomputing.com")
                    .database("example-db")
                    .privateKey("...")
                    .roleArn(firehose.arn())
                    .schema("example-schema")
                    .table("example-table")
                    .user("example-usr")
                    .s3Configuration(FirehoseDeliveryStreamSnowflakeConfigurationS3ConfigurationArgs.builder()
                        .roleArn(firehose.arn())
                        .bucketArn(bucket.arn())
                        .bufferingSize(10)
                        .bufferingInterval(400)
                        .compressionFormat("GZIP")
                        .build())
                    .build())
                .build());
    
        }
    }
    
    resources:
      exampleSnowflakeDestination:
        type: aws:kinesis:FirehoseDeliveryStream
        name: example_snowflake_destination
        properties:
          name: example-snowflake-destination
          destination: snowflake
          snowflakeConfiguration:
            accountUrl: https://example.snowflakecomputing.com
            database: example-db
            privateKey: '...'
            roleArn: ${firehose.arn}
            schema: example-schema
            table: example-table
            user: example-usr
            s3Configuration:
              roleArn: ${firehose.arn}
              bucketArn: ${bucket.arn}
              bufferingSize: 10
              bufferingInterval: 400
              compressionFormat: GZIP
    

    Create FirehoseDeliveryStream Resource

    Resources are created with functions called constructors. To learn more about declaring and configuring resources, see Resources.

    Constructor syntax

    new FirehoseDeliveryStream(name: string, args: FirehoseDeliveryStreamArgs, opts?: CustomResourceOptions);
    @overload
    def FirehoseDeliveryStream(resource_name: str,
                               args: FirehoseDeliveryStreamArgs,
                               opts: Optional[ResourceOptions] = None)
    
    @overload
    def FirehoseDeliveryStream(resource_name: str,
                               opts: Optional[ResourceOptions] = None,
                               destination: Optional[str] = None,
                               name: Optional[str] = None,
                               msk_source_configuration: Optional[FirehoseDeliveryStreamMskSourceConfigurationArgs] = None,
                               elasticsearch_configuration: Optional[FirehoseDeliveryStreamElasticsearchConfigurationArgs] = None,
                               extended_s3_configuration: Optional[FirehoseDeliveryStreamExtendedS3ConfigurationArgs] = None,
                               opensearch_configuration: Optional[FirehoseDeliveryStreamOpensearchConfigurationArgs] = None,
                               kinesis_source_configuration: Optional[FirehoseDeliveryStreamKinesisSourceConfigurationArgs] = None,
                               destination_id: Optional[str] = None,
                               arn: Optional[str] = None,
                               http_endpoint_configuration: Optional[FirehoseDeliveryStreamHttpEndpointConfigurationArgs] = None,
                               opensearchserverless_configuration: Optional[FirehoseDeliveryStreamOpensearchserverlessConfigurationArgs] = None,
                               redshift_configuration: Optional[FirehoseDeliveryStreamRedshiftConfigurationArgs] = None,
                               server_side_encryption: Optional[FirehoseDeliveryStreamServerSideEncryptionArgs] = None,
                               snowflake_configuration: Optional[FirehoseDeliveryStreamSnowflakeConfigurationArgs] = None,
                               splunk_configuration: Optional[FirehoseDeliveryStreamSplunkConfigurationArgs] = None,
                               tags: Optional[Mapping[str, str]] = None,
                               version_id: Optional[str] = None)
    func NewFirehoseDeliveryStream(ctx *Context, name string, args FirehoseDeliveryStreamArgs, opts ...ResourceOption) (*FirehoseDeliveryStream, error)
    public FirehoseDeliveryStream(string name, FirehoseDeliveryStreamArgs args, CustomResourceOptions? opts = null)
    public FirehoseDeliveryStream(String name, FirehoseDeliveryStreamArgs args)
    public FirehoseDeliveryStream(String name, FirehoseDeliveryStreamArgs args, CustomResourceOptions options)
    
    type: aws:kinesis:FirehoseDeliveryStream
    properties: # The arguments to resource properties.
    options: # Bag of options to control resource's behavior.
    
    

    Parameters

    name string
    The unique name of the resource.
    args FirehoseDeliveryStreamArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    resource_name str
    The unique name of the resource.
    args FirehoseDeliveryStreamArgs
    The arguments to resource properties.
    opts ResourceOptions
    Bag of options to control resource's behavior.
    ctx Context
    Context object for the current deployment.
    name string
    The unique name of the resource.
    args FirehoseDeliveryStreamArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args FirehoseDeliveryStreamArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args FirehoseDeliveryStreamArgs
    The arguments to resource properties.
    options CustomResourceOptions
    Bag of options to control resource's behavior.

    Example

    The following reference example uses placeholder values for all input properties.

    var firehoseDeliveryStreamResource = new Aws.Kinesis.FirehoseDeliveryStream("firehoseDeliveryStreamResource", new()
    {
        Destination = "string",
        Name = "string",
        MskSourceConfiguration = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamMskSourceConfigurationArgs
        {
            AuthenticationConfiguration = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamMskSourceConfigurationAuthenticationConfigurationArgs
            {
                Connectivity = "string",
                RoleArn = "string",
            },
            MskClusterArn = "string",
            TopicName = "string",
        },
        ElasticsearchConfiguration = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamElasticsearchConfigurationArgs
        {
            IndexName = "string",
            S3Configuration = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamElasticsearchConfigurationS3ConfigurationArgs
            {
                BucketArn = "string",
                RoleArn = "string",
                BufferingInterval = 0,
                BufferingSize = 0,
                CloudwatchLoggingOptions = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamElasticsearchConfigurationS3ConfigurationCloudwatchLoggingOptionsArgs
                {
                    Enabled = false,
                    LogGroupName = "string",
                    LogStreamName = "string",
                },
                CompressionFormat = "string",
                ErrorOutputPrefix = "string",
                KmsKeyArn = "string",
                Prefix = "string",
            },
            RoleArn = "string",
            ClusterEndpoint = "string",
            DomainArn = "string",
            BufferingInterval = 0,
            IndexRotationPeriod = "string",
            ProcessingConfiguration = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamElasticsearchConfigurationProcessingConfigurationArgs
            {
                Enabled = false,
                Processors = new[]
                {
                    new Aws.Kinesis.Inputs.FirehoseDeliveryStreamElasticsearchConfigurationProcessingConfigurationProcessorArgs
                    {
                        Type = "string",
                        Parameters = new[]
                        {
                            new Aws.Kinesis.Inputs.FirehoseDeliveryStreamElasticsearchConfigurationProcessingConfigurationProcessorParameterArgs
                            {
                                ParameterName = "string",
                                ParameterValue = "string",
                            },
                        },
                    },
                },
            },
            RetryDuration = 0,
            CloudwatchLoggingOptions = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamElasticsearchConfigurationCloudwatchLoggingOptionsArgs
            {
                Enabled = false,
                LogGroupName = "string",
                LogStreamName = "string",
            },
            S3BackupMode = "string",
            BufferingSize = 0,
            TypeName = "string",
            VpcConfig = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamElasticsearchConfigurationVpcConfigArgs
            {
                RoleArn = "string",
                SecurityGroupIds = new[]
                {
                    "string",
                },
                SubnetIds = new[]
                {
                    "string",
                },
                VpcId = "string",
            },
        },
        ExtendedS3Configuration = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamExtendedS3ConfigurationArgs
        {
            BucketArn = "string",
            RoleArn = "string",
            ErrorOutputPrefix = "string",
            FileExtension = "string",
            CompressionFormat = "string",
            CustomTimeZone = "string",
            DataFormatConversionConfiguration = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamExtendedS3ConfigurationDataFormatConversionConfigurationArgs
            {
                InputFormatConfiguration = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamExtendedS3ConfigurationDataFormatConversionConfigurationInputFormatConfigurationArgs
                {
                    Deserializer = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamExtendedS3ConfigurationDataFormatConversionConfigurationInputFormatConfigurationDeserializerArgs
                    {
                        HiveJsonSerDe = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamExtendedS3ConfigurationDataFormatConversionConfigurationInputFormatConfigurationDeserializerHiveJsonSerDeArgs
                        {
                            TimestampFormats = new[]
                            {
                                "string",
                            },
                        },
                        OpenXJsonSerDe = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamExtendedS3ConfigurationDataFormatConversionConfigurationInputFormatConfigurationDeserializerOpenXJsonSerDeArgs
                        {
                            CaseInsensitive = false,
                            ColumnToJsonKeyMappings = 
                            {
                                { "string", "string" },
                            },
                            ConvertDotsInJsonKeysToUnderscores = false,
                        },
                    },
                },
                OutputFormatConfiguration = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamExtendedS3ConfigurationDataFormatConversionConfigurationOutputFormatConfigurationArgs
                {
                    Serializer = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamExtendedS3ConfigurationDataFormatConversionConfigurationOutputFormatConfigurationSerializerArgs
                    {
                        OrcSerDe = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamExtendedS3ConfigurationDataFormatConversionConfigurationOutputFormatConfigurationSerializerOrcSerDeArgs
                        {
                            BlockSizeBytes = 0,
                            BloomFilterColumns = new[]
                            {
                                "string",
                            },
                            BloomFilterFalsePositiveProbability = 0,
                            Compression = "string",
                            DictionaryKeyThreshold = 0,
                            EnablePadding = false,
                            FormatVersion = "string",
                            PaddingTolerance = 0,
                            RowIndexStride = 0,
                            StripeSizeBytes = 0,
                        },
                        ParquetSerDe = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamExtendedS3ConfigurationDataFormatConversionConfigurationOutputFormatConfigurationSerializerParquetSerDeArgs
                        {
                            BlockSizeBytes = 0,
                            Compression = "string",
                            EnableDictionaryCompression = false,
                            MaxPaddingBytes = 0,
                            PageSizeBytes = 0,
                            WriterVersion = "string",
                        },
                    },
                },
                SchemaConfiguration = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamExtendedS3ConfigurationDataFormatConversionConfigurationSchemaConfigurationArgs
                {
                    DatabaseName = "string",
                    RoleArn = "string",
                    TableName = "string",
                    CatalogId = "string",
                    Region = "string",
                    VersionId = "string",
                },
                Enabled = false,
            },
            DynamicPartitioningConfiguration = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamExtendedS3ConfigurationDynamicPartitioningConfigurationArgs
            {
                Enabled = false,
                RetryDuration = 0,
            },
            BufferingSize = 0,
            CloudwatchLoggingOptions = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamExtendedS3ConfigurationCloudwatchLoggingOptionsArgs
            {
                Enabled = false,
                LogGroupName = "string",
                LogStreamName = "string",
            },
            KmsKeyArn = "string",
            Prefix = "string",
            ProcessingConfiguration = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationArgs
            {
                Enabled = false,
                Processors = new[]
                {
                    new Aws.Kinesis.Inputs.FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorArgs
                    {
                        Type = "string",
                        Parameters = new[]
                        {
                            new Aws.Kinesis.Inputs.FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorParameterArgs
                            {
                                ParameterName = "string",
                                ParameterValue = "string",
                            },
                        },
                    },
                },
            },
            BufferingInterval = 0,
            S3BackupConfiguration = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamExtendedS3ConfigurationS3BackupConfigurationArgs
            {
                BucketArn = "string",
                RoleArn = "string",
                BufferingInterval = 0,
                BufferingSize = 0,
                CloudwatchLoggingOptions = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamExtendedS3ConfigurationS3BackupConfigurationCloudwatchLoggingOptionsArgs
                {
                    Enabled = false,
                    LogGroupName = "string",
                    LogStreamName = "string",
                },
                CompressionFormat = "string",
                ErrorOutputPrefix = "string",
                KmsKeyArn = "string",
                Prefix = "string",
            },
            S3BackupMode = "string",
        },
        OpensearchConfiguration = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamOpensearchConfigurationArgs
        {
            IndexName = "string",
            S3Configuration = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamOpensearchConfigurationS3ConfigurationArgs
            {
                BucketArn = "string",
                RoleArn = "string",
                BufferingInterval = 0,
                BufferingSize = 0,
                CloudwatchLoggingOptions = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamOpensearchConfigurationS3ConfigurationCloudwatchLoggingOptionsArgs
                {
                    Enabled = false,
                    LogGroupName = "string",
                    LogStreamName = "string",
                },
                CompressionFormat = "string",
                ErrorOutputPrefix = "string",
                KmsKeyArn = "string",
                Prefix = "string",
            },
            RoleArn = "string",
            ClusterEndpoint = "string",
            DocumentIdOptions = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamOpensearchConfigurationDocumentIdOptionsArgs
            {
                DefaultDocumentIdFormat = "string",
            },
            DomainArn = "string",
            BufferingInterval = 0,
            IndexRotationPeriod = "string",
            ProcessingConfiguration = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamOpensearchConfigurationProcessingConfigurationArgs
            {
                Enabled = false,
                Processors = new[]
                {
                    new Aws.Kinesis.Inputs.FirehoseDeliveryStreamOpensearchConfigurationProcessingConfigurationProcessorArgs
                    {
                        Type = "string",
                        Parameters = new[]
                        {
                            new Aws.Kinesis.Inputs.FirehoseDeliveryStreamOpensearchConfigurationProcessingConfigurationProcessorParameterArgs
                            {
                                ParameterName = "string",
                                ParameterValue = "string",
                            },
                        },
                    },
                },
            },
            RetryDuration = 0,
            CloudwatchLoggingOptions = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamOpensearchConfigurationCloudwatchLoggingOptionsArgs
            {
                Enabled = false,
                LogGroupName = "string",
                LogStreamName = "string",
            },
            S3BackupMode = "string",
            BufferingSize = 0,
            TypeName = "string",
            VpcConfig = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamOpensearchConfigurationVpcConfigArgs
            {
                RoleArn = "string",
                SecurityGroupIds = new[]
                {
                    "string",
                },
                SubnetIds = new[]
                {
                    "string",
                },
                VpcId = "string",
            },
        },
        KinesisSourceConfiguration = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamKinesisSourceConfigurationArgs
        {
            KinesisStreamArn = "string",
            RoleArn = "string",
        },
        DestinationId = "string",
        Arn = "string",
        HttpEndpointConfiguration = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamHttpEndpointConfigurationArgs
        {
            S3Configuration = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamHttpEndpointConfigurationS3ConfigurationArgs
            {
                BucketArn = "string",
                RoleArn = "string",
                BufferingInterval = 0,
                BufferingSize = 0,
                CloudwatchLoggingOptions = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamHttpEndpointConfigurationS3ConfigurationCloudwatchLoggingOptionsArgs
                {
                    Enabled = false,
                    LogGroupName = "string",
                    LogStreamName = "string",
                },
                CompressionFormat = "string",
                ErrorOutputPrefix = "string",
                KmsKeyArn = "string",
                Prefix = "string",
            },
            Url = "string",
            AccessKey = "string",
            BufferingInterval = 0,
            BufferingSize = 0,
            CloudwatchLoggingOptions = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamHttpEndpointConfigurationCloudwatchLoggingOptionsArgs
            {
                Enabled = false,
                LogGroupName = "string",
                LogStreamName = "string",
            },
            Name = "string",
            ProcessingConfiguration = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamHttpEndpointConfigurationProcessingConfigurationArgs
            {
                Enabled = false,
                Processors = new[]
                {
                    new Aws.Kinesis.Inputs.FirehoseDeliveryStreamHttpEndpointConfigurationProcessingConfigurationProcessorArgs
                    {
                        Type = "string",
                        Parameters = new[]
                        {
                            new Aws.Kinesis.Inputs.FirehoseDeliveryStreamHttpEndpointConfigurationProcessingConfigurationProcessorParameterArgs
                            {
                                ParameterName = "string",
                                ParameterValue = "string",
                            },
                        },
                    },
                },
            },
            RequestConfiguration = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamHttpEndpointConfigurationRequestConfigurationArgs
            {
                CommonAttributes = new[]
                {
                    new Aws.Kinesis.Inputs.FirehoseDeliveryStreamHttpEndpointConfigurationRequestConfigurationCommonAttributeArgs
                    {
                        Name = "string",
                        Value = "string",
                    },
                },
                ContentEncoding = "string",
            },
            RetryDuration = 0,
            RoleArn = "string",
            S3BackupMode = "string",
        },
        OpensearchserverlessConfiguration = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamOpensearchserverlessConfigurationArgs
        {
            CollectionEndpoint = "string",
            IndexName = "string",
            RoleArn = "string",
            S3Configuration = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamOpensearchserverlessConfigurationS3ConfigurationArgs
            {
                BucketArn = "string",
                RoleArn = "string",
                BufferingInterval = 0,
                BufferingSize = 0,
                CloudwatchLoggingOptions = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamOpensearchserverlessConfigurationS3ConfigurationCloudwatchLoggingOptionsArgs
                {
                    Enabled = false,
                    LogGroupName = "string",
                    LogStreamName = "string",
                },
                CompressionFormat = "string",
                ErrorOutputPrefix = "string",
                KmsKeyArn = "string",
                Prefix = "string",
            },
            BufferingInterval = 0,
            BufferingSize = 0,
            CloudwatchLoggingOptions = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamOpensearchserverlessConfigurationCloudwatchLoggingOptionsArgs
            {
                Enabled = false,
                LogGroupName = "string",
                LogStreamName = "string",
            },
            ProcessingConfiguration = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamOpensearchserverlessConfigurationProcessingConfigurationArgs
            {
                Enabled = false,
                Processors = new[]
                {
                    new Aws.Kinesis.Inputs.FirehoseDeliveryStreamOpensearchserverlessConfigurationProcessingConfigurationProcessorArgs
                    {
                        Type = "string",
                        Parameters = new[]
                        {
                            new Aws.Kinesis.Inputs.FirehoseDeliveryStreamOpensearchserverlessConfigurationProcessingConfigurationProcessorParameterArgs
                            {
                                ParameterName = "string",
                                ParameterValue = "string",
                            },
                        },
                    },
                },
            },
            RetryDuration = 0,
            S3BackupMode = "string",
            VpcConfig = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamOpensearchserverlessConfigurationVpcConfigArgs
            {
                RoleArn = "string",
                SecurityGroupIds = new[]
                {
                    "string",
                },
                SubnetIds = new[]
                {
                    "string",
                },
                VpcId = "string",
            },
        },
        RedshiftConfiguration = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamRedshiftConfigurationArgs
        {
            RoleArn = "string",
            ClusterJdbcurl = "string",
            Username = "string",
            S3Configuration = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamRedshiftConfigurationS3ConfigurationArgs
            {
                BucketArn = "string",
                RoleArn = "string",
                BufferingInterval = 0,
                BufferingSize = 0,
                CloudwatchLoggingOptions = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamRedshiftConfigurationS3ConfigurationCloudwatchLoggingOptionsArgs
                {
                    Enabled = false,
                    LogGroupName = "string",
                    LogStreamName = "string",
                },
                CompressionFormat = "string",
                ErrorOutputPrefix = "string",
                KmsKeyArn = "string",
                Prefix = "string",
            },
            DataTableName = "string",
            Password = "string",
            ProcessingConfiguration = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamRedshiftConfigurationProcessingConfigurationArgs
            {
                Enabled = false,
                Processors = new[]
                {
                    new Aws.Kinesis.Inputs.FirehoseDeliveryStreamRedshiftConfigurationProcessingConfigurationProcessorArgs
                    {
                        Type = "string",
                        Parameters = new[]
                        {
                            new Aws.Kinesis.Inputs.FirehoseDeliveryStreamRedshiftConfigurationProcessingConfigurationProcessorParameterArgs
                            {
                                ParameterName = "string",
                                ParameterValue = "string",
                            },
                        },
                    },
                },
            },
            RetryDuration = 0,
            CloudwatchLoggingOptions = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamRedshiftConfigurationCloudwatchLoggingOptionsArgs
            {
                Enabled = false,
                LogGroupName = "string",
                LogStreamName = "string",
            },
            S3BackupConfiguration = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamRedshiftConfigurationS3BackupConfigurationArgs
            {
                BucketArn = "string",
                RoleArn = "string",
                BufferingInterval = 0,
                BufferingSize = 0,
                CloudwatchLoggingOptions = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamRedshiftConfigurationS3BackupConfigurationCloudwatchLoggingOptionsArgs
                {
                    Enabled = false,
                    LogGroupName = "string",
                    LogStreamName = "string",
                },
                CompressionFormat = "string",
                ErrorOutputPrefix = "string",
                KmsKeyArn = "string",
                Prefix = "string",
            },
            S3BackupMode = "string",
            DataTableColumns = "string",
            CopyOptions = "string",
        },
        ServerSideEncryption = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamServerSideEncryptionArgs
        {
            Enabled = false,
            KeyArn = "string",
            KeyType = "string",
        },
        SnowflakeConfiguration = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamSnowflakeConfigurationArgs
        {
            S3Configuration = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamSnowflakeConfigurationS3ConfigurationArgs
            {
                BucketArn = "string",
                RoleArn = "string",
                BufferingInterval = 0,
                BufferingSize = 0,
                CloudwatchLoggingOptions = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamSnowflakeConfigurationS3ConfigurationCloudwatchLoggingOptionsArgs
                {
                    Enabled = false,
                    LogGroupName = "string",
                    LogStreamName = "string",
                },
                CompressionFormat = "string",
                ErrorOutputPrefix = "string",
                KmsKeyArn = "string",
                Prefix = "string",
            },
            User = "string",
            Table = "string",
            RoleArn = "string",
            Database = "string",
            Schema = "string",
            AccountUrl = "string",
            PrivateKey = "string",
            KeyPassphrase = "string",
            ContentColumnName = "string",
            DataLoadingOption = "string",
            S3BackupMode = "string",
            MetadataColumnName = "string",
            CloudwatchLoggingOptions = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamSnowflakeConfigurationCloudwatchLoggingOptionsArgs
            {
                Enabled = false,
                LogGroupName = "string",
                LogStreamName = "string",
            },
            SnowflakeRoleConfiguration = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamSnowflakeConfigurationSnowflakeRoleConfigurationArgs
            {
                Enabled = false,
                SnowflakeRole = "string",
            },
            SnowflakeVpcConfiguration = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamSnowflakeConfigurationSnowflakeVpcConfigurationArgs
            {
                PrivateLinkVpceId = "string",
            },
            RetryDuration = 0,
            ProcessingConfiguration = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamSnowflakeConfigurationProcessingConfigurationArgs
            {
                Enabled = false,
                Processors = new[]
                {
                    new Aws.Kinesis.Inputs.FirehoseDeliveryStreamSnowflakeConfigurationProcessingConfigurationProcessorArgs
                    {
                        Type = "string",
                        Parameters = new[]
                        {
                            new Aws.Kinesis.Inputs.FirehoseDeliveryStreamSnowflakeConfigurationProcessingConfigurationProcessorParameterArgs
                            {
                                ParameterName = "string",
                                ParameterValue = "string",
                            },
                        },
                    },
                },
            },
        },
        SplunkConfiguration = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamSplunkConfigurationArgs
        {
            HecEndpoint = "string",
            HecToken = "string",
            S3Configuration = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamSplunkConfigurationS3ConfigurationArgs
            {
                BucketArn = "string",
                RoleArn = "string",
                BufferingInterval = 0,
                BufferingSize = 0,
                CloudwatchLoggingOptions = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamSplunkConfigurationS3ConfigurationCloudwatchLoggingOptionsArgs
                {
                    Enabled = false,
                    LogGroupName = "string",
                    LogStreamName = "string",
                },
                CompressionFormat = "string",
                ErrorOutputPrefix = "string",
                KmsKeyArn = "string",
                Prefix = "string",
            },
            BufferingInterval = 0,
            BufferingSize = 0,
            CloudwatchLoggingOptions = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamSplunkConfigurationCloudwatchLoggingOptionsArgs
            {
                Enabled = false,
                LogGroupName = "string",
                LogStreamName = "string",
            },
            HecAcknowledgmentTimeout = 0,
            HecEndpointType = "string",
            ProcessingConfiguration = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamSplunkConfigurationProcessingConfigurationArgs
            {
                Enabled = false,
                Processors = new[]
                {
                    new Aws.Kinesis.Inputs.FirehoseDeliveryStreamSplunkConfigurationProcessingConfigurationProcessorArgs
                    {
                        Type = "string",
                        Parameters = new[]
                        {
                            new Aws.Kinesis.Inputs.FirehoseDeliveryStreamSplunkConfigurationProcessingConfigurationProcessorParameterArgs
                            {
                                ParameterName = "string",
                                ParameterValue = "string",
                            },
                        },
                    },
                },
            },
            RetryDuration = 0,
            S3BackupMode = "string",
        },
        Tags = 
        {
            { "string", "string" },
        },
        VersionId = "string",
    });
    
    example, err := kinesis.NewFirehoseDeliveryStream(ctx, "firehoseDeliveryStreamResource", &kinesis.FirehoseDeliveryStreamArgs{
    	Destination: pulumi.String("string"),
    	Name:        pulumi.String("string"),
    	MskSourceConfiguration: &kinesis.FirehoseDeliveryStreamMskSourceConfigurationArgs{
    		AuthenticationConfiguration: &kinesis.FirehoseDeliveryStreamMskSourceConfigurationAuthenticationConfigurationArgs{
    			Connectivity: pulumi.String("string"),
    			RoleArn:      pulumi.String("string"),
    		},
    		MskClusterArn: pulumi.String("string"),
    		TopicName:     pulumi.String("string"),
    	},
    	ElasticsearchConfiguration: &kinesis.FirehoseDeliveryStreamElasticsearchConfigurationArgs{
    		IndexName: pulumi.String("string"),
    		S3Configuration: &kinesis.FirehoseDeliveryStreamElasticsearchConfigurationS3ConfigurationArgs{
    			BucketArn:         pulumi.String("string"),
    			RoleArn:           pulumi.String("string"),
    			BufferingInterval: pulumi.Int(0),
    			BufferingSize:     pulumi.Int(0),
    			CloudwatchLoggingOptions: &kinesis.FirehoseDeliveryStreamElasticsearchConfigurationS3ConfigurationCloudwatchLoggingOptionsArgs{
    				Enabled:       pulumi.Bool(false),
    				LogGroupName:  pulumi.String("string"),
    				LogStreamName: pulumi.String("string"),
    			},
    			CompressionFormat: pulumi.String("string"),
    			ErrorOutputPrefix: pulumi.String("string"),
    			KmsKeyArn:         pulumi.String("string"),
    			Prefix:            pulumi.String("string"),
    		},
    		RoleArn:             pulumi.String("string"),
    		ClusterEndpoint:     pulumi.String("string"),
    		DomainArn:           pulumi.String("string"),
    		BufferingInterval:   pulumi.Int(0),
    		IndexRotationPeriod: pulumi.String("string"),
    		ProcessingConfiguration: &kinesis.FirehoseDeliveryStreamElasticsearchConfigurationProcessingConfigurationArgs{
    			Enabled: pulumi.Bool(false),
    			Processors: kinesis.FirehoseDeliveryStreamElasticsearchConfigurationProcessingConfigurationProcessorArray{
    				&kinesis.FirehoseDeliveryStreamElasticsearchConfigurationProcessingConfigurationProcessorArgs{
    					Type: pulumi.String("string"),
    					Parameters: kinesis.FirehoseDeliveryStreamElasticsearchConfigurationProcessingConfigurationProcessorParameterArray{
    						&kinesis.FirehoseDeliveryStreamElasticsearchConfigurationProcessingConfigurationProcessorParameterArgs{
    							ParameterName:  pulumi.String("string"),
    							ParameterValue: pulumi.String("string"),
    						},
    					},
    				},
    			},
    		},
    		RetryDuration: pulumi.Int(0),
    		CloudwatchLoggingOptions: &kinesis.FirehoseDeliveryStreamElasticsearchConfigurationCloudwatchLoggingOptionsArgs{
    			Enabled:       pulumi.Bool(false),
    			LogGroupName:  pulumi.String("string"),
    			LogStreamName: pulumi.String("string"),
    		},
    		S3BackupMode:  pulumi.String("string"),
    		BufferingSize: pulumi.Int(0),
    		TypeName:      pulumi.String("string"),
    		VpcConfig: &kinesis.FirehoseDeliveryStreamElasticsearchConfigurationVpcConfigArgs{
    			RoleArn: pulumi.String("string"),
    			SecurityGroupIds: pulumi.StringArray{
    				pulumi.String("string"),
    			},
    			SubnetIds: pulumi.StringArray{
    				pulumi.String("string"),
    			},
    			VpcId: pulumi.String("string"),
    		},
    	},
    	ExtendedS3Configuration: &kinesis.FirehoseDeliveryStreamExtendedS3ConfigurationArgs{
    		BucketArn:         pulumi.String("string"),
    		RoleArn:           pulumi.String("string"),
    		ErrorOutputPrefix: pulumi.String("string"),
    		FileExtension:     pulumi.String("string"),
    		CompressionFormat: pulumi.String("string"),
    		CustomTimeZone:    pulumi.String("string"),
    		DataFormatConversionConfiguration: &kinesis.FirehoseDeliveryStreamExtendedS3ConfigurationDataFormatConversionConfigurationArgs{
    			InputFormatConfiguration: &kinesis.FirehoseDeliveryStreamExtendedS3ConfigurationDataFormatConversionConfigurationInputFormatConfigurationArgs{
    				Deserializer: &kinesis.FirehoseDeliveryStreamExtendedS3ConfigurationDataFormatConversionConfigurationInputFormatConfigurationDeserializerArgs{
    					HiveJsonSerDe: &kinesis.FirehoseDeliveryStreamExtendedS3ConfigurationDataFormatConversionConfigurationInputFormatConfigurationDeserializerHiveJsonSerDeArgs{
    						TimestampFormats: pulumi.StringArray{
    							pulumi.String("string"),
    						},
    					},
    					OpenXJsonSerDe: &kinesis.FirehoseDeliveryStreamExtendedS3ConfigurationDataFormatConversionConfigurationInputFormatConfigurationDeserializerOpenXJsonSerDeArgs{
    						CaseInsensitive: pulumi.Bool(false),
    						ColumnToJsonKeyMappings: pulumi.StringMap{
    							"string": pulumi.String("string"),
    						},
    						ConvertDotsInJsonKeysToUnderscores: pulumi.Bool(false),
    					},
    				},
    			},
    			OutputFormatConfiguration: &kinesis.FirehoseDeliveryStreamExtendedS3ConfigurationDataFormatConversionConfigurationOutputFormatConfigurationArgs{
    				Serializer: &kinesis.FirehoseDeliveryStreamExtendedS3ConfigurationDataFormatConversionConfigurationOutputFormatConfigurationSerializerArgs{
    					OrcSerDe: &kinesis.FirehoseDeliveryStreamExtendedS3ConfigurationDataFormatConversionConfigurationOutputFormatConfigurationSerializerOrcSerDeArgs{
    						BlockSizeBytes: pulumi.Int(0),
    						BloomFilterColumns: pulumi.StringArray{
    							pulumi.String("string"),
    						},
    						BloomFilterFalsePositiveProbability: pulumi.Float64(0),
    						Compression:                         pulumi.String("string"),
    						DictionaryKeyThreshold:              pulumi.Float64(0),
    						EnablePadding:                       pulumi.Bool(false),
    						FormatVersion:                       pulumi.String("string"),
    						PaddingTolerance:                    pulumi.Float64(0),
    						RowIndexStride:                      pulumi.Int(0),
    						StripeSizeBytes:                     pulumi.Int(0),
    					},
    					ParquetSerDe: &kinesis.FirehoseDeliveryStreamExtendedS3ConfigurationDataFormatConversionConfigurationOutputFormatConfigurationSerializerParquetSerDeArgs{
    						BlockSizeBytes:              pulumi.Int(0),
    						Compression:                 pulumi.String("string"),
    						EnableDictionaryCompression: pulumi.Bool(false),
    						MaxPaddingBytes:             pulumi.Int(0),
    						PageSizeBytes:               pulumi.Int(0),
    						WriterVersion:               pulumi.String("string"),
    					},
    				},
    			},
    			SchemaConfiguration: &kinesis.FirehoseDeliveryStreamExtendedS3ConfigurationDataFormatConversionConfigurationSchemaConfigurationArgs{
    				DatabaseName: pulumi.String("string"),
    				RoleArn:      pulumi.String("string"),
    				TableName:    pulumi.String("string"),
    				CatalogId:    pulumi.String("string"),
    				Region:       pulumi.String("string"),
    				VersionId:    pulumi.String("string"),
    			},
    			Enabled: pulumi.Bool(false),
    		},
    		DynamicPartitioningConfiguration: &kinesis.FirehoseDeliveryStreamExtendedS3ConfigurationDynamicPartitioningConfigurationArgs{
    			Enabled:       pulumi.Bool(false),
    			RetryDuration: pulumi.Int(0),
    		},
    		BufferingSize: pulumi.Int(0),
    		CloudwatchLoggingOptions: &kinesis.FirehoseDeliveryStreamExtendedS3ConfigurationCloudwatchLoggingOptionsArgs{
    			Enabled:       pulumi.Bool(false),
    			LogGroupName:  pulumi.String("string"),
    			LogStreamName: pulumi.String("string"),
    		},
    		KmsKeyArn: pulumi.String("string"),
    		Prefix:    pulumi.String("string"),
    		ProcessingConfiguration: &kinesis.FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationArgs{
    			Enabled: pulumi.Bool(false),
    			Processors: kinesis.FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorArray{
    				&kinesis.FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorArgs{
    					Type: pulumi.String("string"),
    					Parameters: kinesis.FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorParameterArray{
    						&kinesis.FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorParameterArgs{
    							ParameterName:  pulumi.String("string"),
    							ParameterValue: pulumi.String("string"),
    						},
    					},
    				},
    			},
    		},
    		BufferingInterval: pulumi.Int(0),
    		S3BackupConfiguration: &kinesis.FirehoseDeliveryStreamExtendedS3ConfigurationS3BackupConfigurationArgs{
    			BucketArn:         pulumi.String("string"),
    			RoleArn:           pulumi.String("string"),
    			BufferingInterval: pulumi.Int(0),
    			BufferingSize:     pulumi.Int(0),
    			CloudwatchLoggingOptions: &kinesis.FirehoseDeliveryStreamExtendedS3ConfigurationS3BackupConfigurationCloudwatchLoggingOptionsArgs{
    				Enabled:       pulumi.Bool(false),
    				LogGroupName:  pulumi.String("string"),
    				LogStreamName: pulumi.String("string"),
    			},
    			CompressionFormat: pulumi.String("string"),
    			ErrorOutputPrefix: pulumi.String("string"),
    			KmsKeyArn:         pulumi.String("string"),
    			Prefix:            pulumi.String("string"),
    		},
    		S3BackupMode: pulumi.String("string"),
    	},
    	OpensearchConfiguration: &kinesis.FirehoseDeliveryStreamOpensearchConfigurationArgs{
    		IndexName: pulumi.String("string"),
    		S3Configuration: &kinesis.FirehoseDeliveryStreamOpensearchConfigurationS3ConfigurationArgs{
    			BucketArn:         pulumi.String("string"),
    			RoleArn:           pulumi.String("string"),
    			BufferingInterval: pulumi.Int(0),
    			BufferingSize:     pulumi.Int(0),
    			CloudwatchLoggingOptions: &kinesis.FirehoseDeliveryStreamOpensearchConfigurationS3ConfigurationCloudwatchLoggingOptionsArgs{
    				Enabled:       pulumi.Bool(false),
    				LogGroupName:  pulumi.String("string"),
    				LogStreamName: pulumi.String("string"),
    			},
    			CompressionFormat: pulumi.String("string"),
    			ErrorOutputPrefix: pulumi.String("string"),
    			KmsKeyArn:         pulumi.String("string"),
    			Prefix:            pulumi.String("string"),
    		},
    		RoleArn:         pulumi.String("string"),
    		ClusterEndpoint: pulumi.String("string"),
    		DocumentIdOptions: &kinesis.FirehoseDeliveryStreamOpensearchConfigurationDocumentIdOptionsArgs{
    			DefaultDocumentIdFormat: pulumi.String("string"),
    		},
    		DomainArn:           pulumi.String("string"),
    		BufferingInterval:   pulumi.Int(0),
    		IndexRotationPeriod: pulumi.String("string"),
    		ProcessingConfiguration: &kinesis.FirehoseDeliveryStreamOpensearchConfigurationProcessingConfigurationArgs{
    			Enabled: pulumi.Bool(false),
    			Processors: kinesis.FirehoseDeliveryStreamOpensearchConfigurationProcessingConfigurationProcessorArray{
    				&kinesis.FirehoseDeliveryStreamOpensearchConfigurationProcessingConfigurationProcessorArgs{
    					Type: pulumi.String("string"),
    					Parameters: kinesis.FirehoseDeliveryStreamOpensearchConfigurationProcessingConfigurationProcessorParameterArray{
    						&kinesis.FirehoseDeliveryStreamOpensearchConfigurationProcessingConfigurationProcessorParameterArgs{
    							ParameterName:  pulumi.String("string"),
    							ParameterValue: pulumi.String("string"),
    						},
    					},
    				},
    			},
    		},
    		RetryDuration: pulumi.Int(0),
    		CloudwatchLoggingOptions: &kinesis.FirehoseDeliveryStreamOpensearchConfigurationCloudwatchLoggingOptionsArgs{
    			Enabled:       pulumi.Bool(false),
    			LogGroupName:  pulumi.String("string"),
    			LogStreamName: pulumi.String("string"),
    		},
    		S3BackupMode:  pulumi.String("string"),
    		BufferingSize: pulumi.Int(0),
    		TypeName:      pulumi.String("string"),
    		VpcConfig: &kinesis.FirehoseDeliveryStreamOpensearchConfigurationVpcConfigArgs{
    			RoleArn: pulumi.String("string"),
    			SecurityGroupIds: pulumi.StringArray{
    				pulumi.String("string"),
    			},
    			SubnetIds: pulumi.StringArray{
    				pulumi.String("string"),
    			},
    			VpcId: pulumi.String("string"),
    		},
    	},
    	KinesisSourceConfiguration: &kinesis.FirehoseDeliveryStreamKinesisSourceConfigurationArgs{
    		KinesisStreamArn: pulumi.String("string"),
    		RoleArn:          pulumi.String("string"),
    	},
    	DestinationId: pulumi.String("string"),
    	Arn:           pulumi.String("string"),
    	HttpEndpointConfiguration: &kinesis.FirehoseDeliveryStreamHttpEndpointConfigurationArgs{
    		S3Configuration: &kinesis.FirehoseDeliveryStreamHttpEndpointConfigurationS3ConfigurationArgs{
    			BucketArn:         pulumi.String("string"),
    			RoleArn:           pulumi.String("string"),
    			BufferingInterval: pulumi.Int(0),
    			BufferingSize:     pulumi.Int(0),
    			CloudwatchLoggingOptions: &kinesis.FirehoseDeliveryStreamHttpEndpointConfigurationS3ConfigurationCloudwatchLoggingOptionsArgs{
    				Enabled:       pulumi.Bool(false),
    				LogGroupName:  pulumi.String("string"),
    				LogStreamName: pulumi.String("string"),
    			},
    			CompressionFormat: pulumi.String("string"),
    			ErrorOutputPrefix: pulumi.String("string"),
    			KmsKeyArn:         pulumi.String("string"),
    			Prefix:            pulumi.String("string"),
    		},
    		Url:               pulumi.String("string"),
    		AccessKey:         pulumi.String("string"),
    		BufferingInterval: pulumi.Int(0),
    		BufferingSize:     pulumi.Int(0),
    		CloudwatchLoggingOptions: &kinesis.FirehoseDeliveryStreamHttpEndpointConfigurationCloudwatchLoggingOptionsArgs{
    			Enabled:       pulumi.Bool(false),
    			LogGroupName:  pulumi.String("string"),
    			LogStreamName: pulumi.String("string"),
    		},
    		Name: pulumi.String("string"),
    		ProcessingConfiguration: &kinesis.FirehoseDeliveryStreamHttpEndpointConfigurationProcessingConfigurationArgs{
    			Enabled: pulumi.Bool(false),
    			Processors: kinesis.FirehoseDeliveryStreamHttpEndpointConfigurationProcessingConfigurationProcessorArray{
    				&kinesis.FirehoseDeliveryStreamHttpEndpointConfigurationProcessingConfigurationProcessorArgs{
    					Type: pulumi.String("string"),
    					Parameters: kinesis.FirehoseDeliveryStreamHttpEndpointConfigurationProcessingConfigurationProcessorParameterArray{
    						&kinesis.FirehoseDeliveryStreamHttpEndpointConfigurationProcessingConfigurationProcessorParameterArgs{
    							ParameterName:  pulumi.String("string"),
    							ParameterValue: pulumi.String("string"),
    						},
    					},
    				},
    			},
    		},
    		RequestConfiguration: &kinesis.FirehoseDeliveryStreamHttpEndpointConfigurationRequestConfigurationArgs{
    			CommonAttributes: kinesis.FirehoseDeliveryStreamHttpEndpointConfigurationRequestConfigurationCommonAttributeArray{
    				&kinesis.FirehoseDeliveryStreamHttpEndpointConfigurationRequestConfigurationCommonAttributeArgs{
    					Name:  pulumi.String("string"),
    					Value: pulumi.String("string"),
    				},
    			},
    			ContentEncoding: pulumi.String("string"),
    		},
    		RetryDuration: pulumi.Int(0),
    		RoleArn:       pulumi.String("string"),
    		S3BackupMode:  pulumi.String("string"),
    	},
    	OpensearchserverlessConfiguration: &kinesis.FirehoseDeliveryStreamOpensearchserverlessConfigurationArgs{
    		CollectionEndpoint: pulumi.String("string"),
    		IndexName:          pulumi.String("string"),
    		RoleArn:            pulumi.String("string"),
    		S3Configuration: &kinesis.FirehoseDeliveryStreamOpensearchserverlessConfigurationS3ConfigurationArgs{
    			BucketArn:         pulumi.String("string"),
    			RoleArn:           pulumi.String("string"),
    			BufferingInterval: pulumi.Int(0),
    			BufferingSize:     pulumi.Int(0),
    			CloudwatchLoggingOptions: &kinesis.FirehoseDeliveryStreamOpensearchserverlessConfigurationS3ConfigurationCloudwatchLoggingOptionsArgs{
    				Enabled:       pulumi.Bool(false),
    				LogGroupName:  pulumi.String("string"),
    				LogStreamName: pulumi.String("string"),
    			},
    			CompressionFormat: pulumi.String("string"),
    			ErrorOutputPrefix: pulumi.String("string"),
    			KmsKeyArn:         pulumi.String("string"),
    			Prefix:            pulumi.String("string"),
    		},
    		BufferingInterval: pulumi.Int(0),
    		BufferingSize:     pulumi.Int(0),
    		CloudwatchLoggingOptions: &kinesis.FirehoseDeliveryStreamOpensearchserverlessConfigurationCloudwatchLoggingOptionsArgs{
    			Enabled:       pulumi.Bool(false),
    			LogGroupName:  pulumi.String("string"),
    			LogStreamName: pulumi.String("string"),
    		},
    		ProcessingConfiguration: &kinesis.FirehoseDeliveryStreamOpensearchserverlessConfigurationProcessingConfigurationArgs{
    			Enabled: pulumi.Bool(false),
    			Processors: kinesis.FirehoseDeliveryStreamOpensearchserverlessConfigurationProcessingConfigurationProcessorArray{
    				&kinesis.FirehoseDeliveryStreamOpensearchserverlessConfigurationProcessingConfigurationProcessorArgs{
    					Type: pulumi.String("string"),
    					Parameters: kinesis.FirehoseDeliveryStreamOpensearchserverlessConfigurationProcessingConfigurationProcessorParameterArray{
    						&kinesis.FirehoseDeliveryStreamOpensearchserverlessConfigurationProcessingConfigurationProcessorParameterArgs{
    							ParameterName:  pulumi.String("string"),
    							ParameterValue: pulumi.String("string"),
    						},
    					},
    				},
    			},
    		},
    		RetryDuration: pulumi.Int(0),
    		S3BackupMode:  pulumi.String("string"),
    		VpcConfig: &kinesis.FirehoseDeliveryStreamOpensearchserverlessConfigurationVpcConfigArgs{
    			RoleArn: pulumi.String("string"),
    			SecurityGroupIds: pulumi.StringArray{
    				pulumi.String("string"),
    			},
    			SubnetIds: pulumi.StringArray{
    				pulumi.String("string"),
    			},
    			VpcId: pulumi.String("string"),
    		},
    	},
    	RedshiftConfiguration: &kinesis.FirehoseDeliveryStreamRedshiftConfigurationArgs{
    		RoleArn:        pulumi.String("string"),
    		ClusterJdbcurl: pulumi.String("string"),
    		Username:       pulumi.String("string"),
    		S3Configuration: &kinesis.FirehoseDeliveryStreamRedshiftConfigurationS3ConfigurationArgs{
    			BucketArn:         pulumi.String("string"),
    			RoleArn:           pulumi.String("string"),
    			BufferingInterval: pulumi.Int(0),
    			BufferingSize:     pulumi.Int(0),
    			CloudwatchLoggingOptions: &kinesis.FirehoseDeliveryStreamRedshiftConfigurationS3ConfigurationCloudwatchLoggingOptionsArgs{
    				Enabled:       pulumi.Bool(false),
    				LogGroupName:  pulumi.String("string"),
    				LogStreamName: pulumi.String("string"),
    			},
    			CompressionFormat: pulumi.String("string"),
    			ErrorOutputPrefix: pulumi.String("string"),
    			KmsKeyArn:         pulumi.String("string"),
    			Prefix:            pulumi.String("string"),
    		},
    		DataTableName: pulumi.String("string"),
    		Password:      pulumi.String("string"),
    		ProcessingConfiguration: &kinesis.FirehoseDeliveryStreamRedshiftConfigurationProcessingConfigurationArgs{
    			Enabled: pulumi.Bool(false),
    			Processors: kinesis.FirehoseDeliveryStreamRedshiftConfigurationProcessingConfigurationProcessorArray{
    				&kinesis.FirehoseDeliveryStreamRedshiftConfigurationProcessingConfigurationProcessorArgs{
    					Type: pulumi.String("string"),
    					Parameters: kinesis.FirehoseDeliveryStreamRedshiftConfigurationProcessingConfigurationProcessorParameterArray{
    						&kinesis.FirehoseDeliveryStreamRedshiftConfigurationProcessingConfigurationProcessorParameterArgs{
    							ParameterName:  pulumi.String("string"),
    							ParameterValue: pulumi.String("string"),
    						},
    					},
    				},
    			},
    		},
    		RetryDuration: pulumi.Int(0),
    		CloudwatchLoggingOptions: &kinesis.FirehoseDeliveryStreamRedshiftConfigurationCloudwatchLoggingOptionsArgs{
    			Enabled:       pulumi.Bool(false),
    			LogGroupName:  pulumi.String("string"),
    			LogStreamName: pulumi.String("string"),
    		},
    		S3BackupConfiguration: &kinesis.FirehoseDeliveryStreamRedshiftConfigurationS3BackupConfigurationArgs{
    			BucketArn:         pulumi.String("string"),
    			RoleArn:           pulumi.String("string"),
    			BufferingInterval: pulumi.Int(0),
    			BufferingSize:     pulumi.Int(0),
    			CloudwatchLoggingOptions: &kinesis.FirehoseDeliveryStreamRedshiftConfigurationS3BackupConfigurationCloudwatchLoggingOptionsArgs{
    				Enabled:       pulumi.Bool(false),
    				LogGroupName:  pulumi.String("string"),
    				LogStreamName: pulumi.String("string"),
    			},
    			CompressionFormat: pulumi.String("string"),
    			ErrorOutputPrefix: pulumi.String("string"),
    			KmsKeyArn:         pulumi.String("string"),
    			Prefix:            pulumi.String("string"),
    		},
    		S3BackupMode:     pulumi.String("string"),
    		DataTableColumns: pulumi.String("string"),
    		CopyOptions:      pulumi.String("string"),
    	},
    	ServerSideEncryption: &kinesis.FirehoseDeliveryStreamServerSideEncryptionArgs{
    		Enabled: pulumi.Bool(false),
    		KeyArn:  pulumi.String("string"),
    		KeyType: pulumi.String("string"),
    	},
    	SnowflakeConfiguration: &kinesis.FirehoseDeliveryStreamSnowflakeConfigurationArgs{
    		S3Configuration: &kinesis.FirehoseDeliveryStreamSnowflakeConfigurationS3ConfigurationArgs{
    			BucketArn:         pulumi.String("string"),
    			RoleArn:           pulumi.String("string"),
    			BufferingInterval: pulumi.Int(0),
    			BufferingSize:     pulumi.Int(0),
    			CloudwatchLoggingOptions: &kinesis.FirehoseDeliveryStreamSnowflakeConfigurationS3ConfigurationCloudwatchLoggingOptionsArgs{
    				Enabled:       pulumi.Bool(false),
    				LogGroupName:  pulumi.String("string"),
    				LogStreamName: pulumi.String("string"),
    			},
    			CompressionFormat: pulumi.String("string"),
    			ErrorOutputPrefix: pulumi.String("string"),
    			KmsKeyArn:         pulumi.String("string"),
    			Prefix:            pulumi.String("string"),
    		},
    		User:               pulumi.String("string"),
    		Table:              pulumi.String("string"),
    		RoleArn:            pulumi.String("string"),
    		Database:           pulumi.String("string"),
    		Schema:             pulumi.String("string"),
    		AccountUrl:         pulumi.String("string"),
    		PrivateKey:         pulumi.String("string"),
    		KeyPassphrase:      pulumi.String("string"),
    		ContentColumnName:  pulumi.String("string"),
    		DataLoadingOption:  pulumi.String("string"),
    		S3BackupMode:       pulumi.String("string"),
    		MetadataColumnName: pulumi.String("string"),
    		CloudwatchLoggingOptions: &kinesis.FirehoseDeliveryStreamSnowflakeConfigurationCloudwatchLoggingOptionsArgs{
    			Enabled:       pulumi.Bool(false),
    			LogGroupName:  pulumi.String("string"),
    			LogStreamName: pulumi.String("string"),
    		},
    		SnowflakeRoleConfiguration: &kinesis.FirehoseDeliveryStreamSnowflakeConfigurationSnowflakeRoleConfigurationArgs{
    			Enabled:       pulumi.Bool(false),
    			SnowflakeRole: pulumi.String("string"),
    		},
    		SnowflakeVpcConfiguration: &kinesis.FirehoseDeliveryStreamSnowflakeConfigurationSnowflakeVpcConfigurationArgs{
    			PrivateLinkVpceId: pulumi.String("string"),
    		},
    		RetryDuration: pulumi.Int(0),
    		ProcessingConfiguration: &kinesis.FirehoseDeliveryStreamSnowflakeConfigurationProcessingConfigurationArgs{
    			Enabled: pulumi.Bool(false),
    			Processors: kinesis.FirehoseDeliveryStreamSnowflakeConfigurationProcessingConfigurationProcessorArray{
    				&kinesis.FirehoseDeliveryStreamSnowflakeConfigurationProcessingConfigurationProcessorArgs{
    					Type: pulumi.String("string"),
    					Parameters: kinesis.FirehoseDeliveryStreamSnowflakeConfigurationProcessingConfigurationProcessorParameterArray{
    						&kinesis.FirehoseDeliveryStreamSnowflakeConfigurationProcessingConfigurationProcessorParameterArgs{
    							ParameterName:  pulumi.String("string"),
    							ParameterValue: pulumi.String("string"),
    						},
    					},
    				},
    			},
    		},
    	},
    	SplunkConfiguration: &kinesis.FirehoseDeliveryStreamSplunkConfigurationArgs{
    		HecEndpoint: pulumi.String("string"),
    		HecToken:    pulumi.String("string"),
    		S3Configuration: &kinesis.FirehoseDeliveryStreamSplunkConfigurationS3ConfigurationArgs{
    			BucketArn:         pulumi.String("string"),
    			RoleArn:           pulumi.String("string"),
    			BufferingInterval: pulumi.Int(0),
    			BufferingSize:     pulumi.Int(0),
    			CloudwatchLoggingOptions: &kinesis.FirehoseDeliveryStreamSplunkConfigurationS3ConfigurationCloudwatchLoggingOptionsArgs{
    				Enabled:       pulumi.Bool(false),
    				LogGroupName:  pulumi.String("string"),
    				LogStreamName: pulumi.String("string"),
    			},
    			CompressionFormat: pulumi.String("string"),
    			ErrorOutputPrefix: pulumi.String("string"),
    			KmsKeyArn:         pulumi.String("string"),
    			Prefix:            pulumi.String("string"),
    		},
    		BufferingInterval: pulumi.Int(0),
    		BufferingSize:     pulumi.Int(0),
    		CloudwatchLoggingOptions: &kinesis.FirehoseDeliveryStreamSplunkConfigurationCloudwatchLoggingOptionsArgs{
    			Enabled:       pulumi.Bool(false),
    			LogGroupName:  pulumi.String("string"),
    			LogStreamName: pulumi.String("string"),
    		},
    		HecAcknowledgmentTimeout: pulumi.Int(0),
    		HecEndpointType:          pulumi.String("string"),
    		ProcessingConfiguration: &kinesis.FirehoseDeliveryStreamSplunkConfigurationProcessingConfigurationArgs{
    			Enabled: pulumi.Bool(false),
    			Processors: kinesis.FirehoseDeliveryStreamSplunkConfigurationProcessingConfigurationProcessorArray{
    				&kinesis.FirehoseDeliveryStreamSplunkConfigurationProcessingConfigurationProcessorArgs{
    					Type: pulumi.String("string"),
    					Parameters: kinesis.FirehoseDeliveryStreamSplunkConfigurationProcessingConfigurationProcessorParameterArray{
    						&kinesis.FirehoseDeliveryStreamSplunkConfigurationProcessingConfigurationProcessorParameterArgs{
    							ParameterName:  pulumi.String("string"),
    							ParameterValue: pulumi.String("string"),
    						},
    					},
    				},
    			},
    		},
    		RetryDuration: pulumi.Int(0),
    		S3BackupMode:  pulumi.String("string"),
    	},
    	Tags: pulumi.StringMap{
    		"string": pulumi.String("string"),
    	},
    	VersionId: pulumi.String("string"),
    })
    
    var firehoseDeliveryStreamResource = new FirehoseDeliveryStream("firehoseDeliveryStreamResource", FirehoseDeliveryStreamArgs.builder()
        .destination("string")
        .name("string")
        .mskSourceConfiguration(FirehoseDeliveryStreamMskSourceConfigurationArgs.builder()
            .authenticationConfiguration(FirehoseDeliveryStreamMskSourceConfigurationAuthenticationConfigurationArgs.builder()
                .connectivity("string")
                .roleArn("string")
                .build())
            .mskClusterArn("string")
            .topicName("string")
            .build())
        .elasticsearchConfiguration(FirehoseDeliveryStreamElasticsearchConfigurationArgs.builder()
            .indexName("string")
            .s3Configuration(FirehoseDeliveryStreamElasticsearchConfigurationS3ConfigurationArgs.builder()
                .bucketArn("string")
                .roleArn("string")
                .bufferingInterval(0)
                .bufferingSize(0)
                .cloudwatchLoggingOptions(FirehoseDeliveryStreamElasticsearchConfigurationS3ConfigurationCloudwatchLoggingOptionsArgs.builder()
                    .enabled(false)
                    .logGroupName("string")
                    .logStreamName("string")
                    .build())
                .compressionFormat("string")
                .errorOutputPrefix("string")
                .kmsKeyArn("string")
                .prefix("string")
                .build())
            .roleArn("string")
            .clusterEndpoint("string")
            .domainArn("string")
            .bufferingInterval(0)
            .indexRotationPeriod("string")
            .processingConfiguration(FirehoseDeliveryStreamElasticsearchConfigurationProcessingConfigurationArgs.builder()
                .enabled(false)
                .processors(FirehoseDeliveryStreamElasticsearchConfigurationProcessingConfigurationProcessorArgs.builder()
                    .type("string")
                    .parameters(FirehoseDeliveryStreamElasticsearchConfigurationProcessingConfigurationProcessorParameterArgs.builder()
                        .parameterName("string")
                        .parameterValue("string")
                        .build())
                    .build())
                .build())
            .retryDuration(0)
            .cloudwatchLoggingOptions(FirehoseDeliveryStreamElasticsearchConfigurationCloudwatchLoggingOptionsArgs.builder()
                .enabled(false)
                .logGroupName("string")
                .logStreamName("string")
                .build())
            .s3BackupMode("string")
            .bufferingSize(0)
            .typeName("string")
            .vpcConfig(FirehoseDeliveryStreamElasticsearchConfigurationVpcConfigArgs.builder()
                .roleArn("string")
                .securityGroupIds("string")
                .subnetIds("string")
                .vpcId("string")
                .build())
            .build())
        .extendedS3Configuration(FirehoseDeliveryStreamExtendedS3ConfigurationArgs.builder()
            .bucketArn("string")
            .roleArn("string")
            .errorOutputPrefix("string")
            .fileExtension("string")
            .compressionFormat("string")
            .customTimeZone("string")
            .dataFormatConversionConfiguration(FirehoseDeliveryStreamExtendedS3ConfigurationDataFormatConversionConfigurationArgs.builder()
                .inputFormatConfiguration(FirehoseDeliveryStreamExtendedS3ConfigurationDataFormatConversionConfigurationInputFormatConfigurationArgs.builder()
                    .deserializer(FirehoseDeliveryStreamExtendedS3ConfigurationDataFormatConversionConfigurationInputFormatConfigurationDeserializerArgs.builder()
                        .hiveJsonSerDe(FirehoseDeliveryStreamExtendedS3ConfigurationDataFormatConversionConfigurationInputFormatConfigurationDeserializerHiveJsonSerDeArgs.builder()
                            .timestampFormats("string")
                            .build())
                        .openXJsonSerDe(FirehoseDeliveryStreamExtendedS3ConfigurationDataFormatConversionConfigurationInputFormatConfigurationDeserializerOpenXJsonSerDeArgs.builder()
                            .caseInsensitive(false)
                            .columnToJsonKeyMappings(Map.of("string", "string"))
                            .convertDotsInJsonKeysToUnderscores(false)
                            .build())
                        .build())
                    .build())
                .outputFormatConfiguration(FirehoseDeliveryStreamExtendedS3ConfigurationDataFormatConversionConfigurationOutputFormatConfigurationArgs.builder()
                    .serializer(FirehoseDeliveryStreamExtendedS3ConfigurationDataFormatConversionConfigurationOutputFormatConfigurationSerializerArgs.builder()
                        .orcSerDe(FirehoseDeliveryStreamExtendedS3ConfigurationDataFormatConversionConfigurationOutputFormatConfigurationSerializerOrcSerDeArgs.builder()
                            .blockSizeBytes(0)
                            .bloomFilterColumns("string")
                            .bloomFilterFalsePositiveProbability(0)
                            .compression("string")
                            .dictionaryKeyThreshold(0)
                            .enablePadding(false)
                            .formatVersion("string")
                            .paddingTolerance(0)
                            .rowIndexStride(0)
                            .stripeSizeBytes(0)
                            .build())
                        .parquetSerDe(FirehoseDeliveryStreamExtendedS3ConfigurationDataFormatConversionConfigurationOutputFormatConfigurationSerializerParquetSerDeArgs.builder()
                            .blockSizeBytes(0)
                            .compression("string")
                            .enableDictionaryCompression(false)
                            .maxPaddingBytes(0)
                            .pageSizeBytes(0)
                            .writerVersion("string")
                            .build())
                        .build())
                    .build())
                .schemaConfiguration(FirehoseDeliveryStreamExtendedS3ConfigurationDataFormatConversionConfigurationSchemaConfigurationArgs.builder()
                    .databaseName("string")
                    .roleArn("string")
                    .tableName("string")
                    .catalogId("string")
                    .region("string")
                    .versionId("string")
                    .build())
                .enabled(false)
                .build())
            .dynamicPartitioningConfiguration(FirehoseDeliveryStreamExtendedS3ConfigurationDynamicPartitioningConfigurationArgs.builder()
                .enabled(false)
                .retryDuration(0)
                .build())
            .bufferingSize(0)
            .cloudwatchLoggingOptions(FirehoseDeliveryStreamExtendedS3ConfigurationCloudwatchLoggingOptionsArgs.builder()
                .enabled(false)
                .logGroupName("string")
                .logStreamName("string")
                .build())
            .kmsKeyArn("string")
            .prefix("string")
            .processingConfiguration(FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationArgs.builder()
                .enabled(false)
                .processors(FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorArgs.builder()
                    .type("string")
                    .parameters(FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorParameterArgs.builder()
                        .parameterName("string")
                        .parameterValue("string")
                        .build())
                    .build())
                .build())
            .bufferingInterval(0)
            .s3BackupConfiguration(FirehoseDeliveryStreamExtendedS3ConfigurationS3BackupConfigurationArgs.builder()
                .bucketArn("string")
                .roleArn("string")
                .bufferingInterval(0)
                .bufferingSize(0)
                .cloudwatchLoggingOptions(FirehoseDeliveryStreamExtendedS3ConfigurationS3BackupConfigurationCloudwatchLoggingOptionsArgs.builder()
                    .enabled(false)
                    .logGroupName("string")
                    .logStreamName("string")
                    .build())
                .compressionFormat("string")
                .errorOutputPrefix("string")
                .kmsKeyArn("string")
                .prefix("string")
                .build())
            .s3BackupMode("string")
            .build())
        .opensearchConfiguration(FirehoseDeliveryStreamOpensearchConfigurationArgs.builder()
            .indexName("string")
            .s3Configuration(FirehoseDeliveryStreamOpensearchConfigurationS3ConfigurationArgs.builder()
                .bucketArn("string")
                .roleArn("string")
                .bufferingInterval(0)
                .bufferingSize(0)
                .cloudwatchLoggingOptions(FirehoseDeliveryStreamOpensearchConfigurationS3ConfigurationCloudwatchLoggingOptionsArgs.builder()
                    .enabled(false)
                    .logGroupName("string")
                    .logStreamName("string")
                    .build())
                .compressionFormat("string")
                .errorOutputPrefix("string")
                .kmsKeyArn("string")
                .prefix("string")
                .build())
            .roleArn("string")
            .clusterEndpoint("string")
            .documentIdOptions(FirehoseDeliveryStreamOpensearchConfigurationDocumentIdOptionsArgs.builder()
                .defaultDocumentIdFormat("string")
                .build())
            .domainArn("string")
            .bufferingInterval(0)
            .indexRotationPeriod("string")
            .processingConfiguration(FirehoseDeliveryStreamOpensearchConfigurationProcessingConfigurationArgs.builder()
                .enabled(false)
                .processors(FirehoseDeliveryStreamOpensearchConfigurationProcessingConfigurationProcessorArgs.builder()
                    .type("string")
                    .parameters(FirehoseDeliveryStreamOpensearchConfigurationProcessingConfigurationProcessorParameterArgs.builder()
                        .parameterName("string")
                        .parameterValue("string")
                        .build())
                    .build())
                .build())
            .retryDuration(0)
            .cloudwatchLoggingOptions(FirehoseDeliveryStreamOpensearchConfigurationCloudwatchLoggingOptionsArgs.builder()
                .enabled(false)
                .logGroupName("string")
                .logStreamName("string")
                .build())
            .s3BackupMode("string")
            .bufferingSize(0)
            .typeName("string")
            .vpcConfig(FirehoseDeliveryStreamOpensearchConfigurationVpcConfigArgs.builder()
                .roleArn("string")
                .securityGroupIds("string")
                .subnetIds("string")
                .vpcId("string")
                .build())
            .build())
        .kinesisSourceConfiguration(FirehoseDeliveryStreamKinesisSourceConfigurationArgs.builder()
            .kinesisStreamArn("string")
            .roleArn("string")
            .build())
        .destinationId("string")
        .arn("string")
        .httpEndpointConfiguration(FirehoseDeliveryStreamHttpEndpointConfigurationArgs.builder()
            .s3Configuration(FirehoseDeliveryStreamHttpEndpointConfigurationS3ConfigurationArgs.builder()
                .bucketArn("string")
                .roleArn("string")
                .bufferingInterval(0)
                .bufferingSize(0)
                .cloudwatchLoggingOptions(FirehoseDeliveryStreamHttpEndpointConfigurationS3ConfigurationCloudwatchLoggingOptionsArgs.builder()
                    .enabled(false)
                    .logGroupName("string")
                    .logStreamName("string")
                    .build())
                .compressionFormat("string")
                .errorOutputPrefix("string")
                .kmsKeyArn("string")
                .prefix("string")
                .build())
            .url("string")
            .accessKey("string")
            .bufferingInterval(0)
            .bufferingSize(0)
            .cloudwatchLoggingOptions(FirehoseDeliveryStreamHttpEndpointConfigurationCloudwatchLoggingOptionsArgs.builder()
                .enabled(false)
                .logGroupName("string")
                .logStreamName("string")
                .build())
            .name("string")
            .processingConfiguration(FirehoseDeliveryStreamHttpEndpointConfigurationProcessingConfigurationArgs.builder()
                .enabled(false)
                .processors(FirehoseDeliveryStreamHttpEndpointConfigurationProcessingConfigurationProcessorArgs.builder()
                    .type("string")
                    .parameters(FirehoseDeliveryStreamHttpEndpointConfigurationProcessingConfigurationProcessorParameterArgs.builder()
                        .parameterName("string")
                        .parameterValue("string")
                        .build())
                    .build())
                .build())
            .requestConfiguration(FirehoseDeliveryStreamHttpEndpointConfigurationRequestConfigurationArgs.builder()
                .commonAttributes(FirehoseDeliveryStreamHttpEndpointConfigurationRequestConfigurationCommonAttributeArgs.builder()
                    .name("string")
                    .value("string")
                    .build())
                .contentEncoding("string")
                .build())
            .retryDuration(0)
            .roleArn("string")
            .s3BackupMode("string")
            .build())
        .opensearchserverlessConfiguration(FirehoseDeliveryStreamOpensearchserverlessConfigurationArgs.builder()
            .collectionEndpoint("string")
            .indexName("string")
            .roleArn("string")
            .s3Configuration(FirehoseDeliveryStreamOpensearchserverlessConfigurationS3ConfigurationArgs.builder()
                .bucketArn("string")
                .roleArn("string")
                .bufferingInterval(0)
                .bufferingSize(0)
                .cloudwatchLoggingOptions(FirehoseDeliveryStreamOpensearchserverlessConfigurationS3ConfigurationCloudwatchLoggingOptionsArgs.builder()
                    .enabled(false)
                    .logGroupName("string")
                    .logStreamName("string")
                    .build())
                .compressionFormat("string")
                .errorOutputPrefix("string")
                .kmsKeyArn("string")
                .prefix("string")
                .build())
            .bufferingInterval(0)
            .bufferingSize(0)
            .cloudwatchLoggingOptions(FirehoseDeliveryStreamOpensearchserverlessConfigurationCloudwatchLoggingOptionsArgs.builder()
                .enabled(false)
                .logGroupName("string")
                .logStreamName("string")
                .build())
            .processingConfiguration(FirehoseDeliveryStreamOpensearchserverlessConfigurationProcessingConfigurationArgs.builder()
                .enabled(false)
                .processors(FirehoseDeliveryStreamOpensearchserverlessConfigurationProcessingConfigurationProcessorArgs.builder()
                    .type("string")
                    .parameters(FirehoseDeliveryStreamOpensearchserverlessConfigurationProcessingConfigurationProcessorParameterArgs.builder()
                        .parameterName("string")
                        .parameterValue("string")
                        .build())
                    .build())
                .build())
            .retryDuration(0)
            .s3BackupMode("string")
            .vpcConfig(FirehoseDeliveryStreamOpensearchserverlessConfigurationVpcConfigArgs.builder()
                .roleArn("string")
                .securityGroupIds("string")
                .subnetIds("string")
                .vpcId("string")
                .build())
            .build())
        .redshiftConfiguration(FirehoseDeliveryStreamRedshiftConfigurationArgs.builder()
            .roleArn("string")
            .clusterJdbcurl("string")
            .username("string")
            .s3Configuration(FirehoseDeliveryStreamRedshiftConfigurationS3ConfigurationArgs.builder()
                .bucketArn("string")
                .roleArn("string")
                .bufferingInterval(0)
                .bufferingSize(0)
                .cloudwatchLoggingOptions(FirehoseDeliveryStreamRedshiftConfigurationS3ConfigurationCloudwatchLoggingOptionsArgs.builder()
                    .enabled(false)
                    .logGroupName("string")
                    .logStreamName("string")
                    .build())
                .compressionFormat("string")
                .errorOutputPrefix("string")
                .kmsKeyArn("string")
                .prefix("string")
                .build())
            .dataTableName("string")
            .password("string")
            .processingConfiguration(FirehoseDeliveryStreamRedshiftConfigurationProcessingConfigurationArgs.builder()
                .enabled(false)
                .processors(FirehoseDeliveryStreamRedshiftConfigurationProcessingConfigurationProcessorArgs.builder()
                    .type("string")
                    .parameters(FirehoseDeliveryStreamRedshiftConfigurationProcessingConfigurationProcessorParameterArgs.builder()
                        .parameterName("string")
                        .parameterValue("string")
                        .build())
                    .build())
                .build())
            .retryDuration(0)
            .cloudwatchLoggingOptions(FirehoseDeliveryStreamRedshiftConfigurationCloudwatchLoggingOptionsArgs.builder()
                .enabled(false)
                .logGroupName("string")
                .logStreamName("string")
                .build())
            .s3BackupConfiguration(FirehoseDeliveryStreamRedshiftConfigurationS3BackupConfigurationArgs.builder()
                .bucketArn("string")
                .roleArn("string")
                .bufferingInterval(0)
                .bufferingSize(0)
                .cloudwatchLoggingOptions(FirehoseDeliveryStreamRedshiftConfigurationS3BackupConfigurationCloudwatchLoggingOptionsArgs.builder()
                    .enabled(false)
                    .logGroupName("string")
                    .logStreamName("string")
                    .build())
                .compressionFormat("string")
                .errorOutputPrefix("string")
                .kmsKeyArn("string")
                .prefix("string")
                .build())
            .s3BackupMode("string")
            .dataTableColumns("string")
            .copyOptions("string")
            .build())
        .serverSideEncryption(FirehoseDeliveryStreamServerSideEncryptionArgs.builder()
            .enabled(false)
            .keyArn("string")
            .keyType("string")
            .build())
        .snowflakeConfiguration(FirehoseDeliveryStreamSnowflakeConfigurationArgs.builder()
            .s3Configuration(FirehoseDeliveryStreamSnowflakeConfigurationS3ConfigurationArgs.builder()
                .bucketArn("string")
                .roleArn("string")
                .bufferingInterval(0)
                .bufferingSize(0)
                .cloudwatchLoggingOptions(FirehoseDeliveryStreamSnowflakeConfigurationS3ConfigurationCloudwatchLoggingOptionsArgs.builder()
                    .enabled(false)
                    .logGroupName("string")
                    .logStreamName("string")
                    .build())
                .compressionFormat("string")
                .errorOutputPrefix("string")
                .kmsKeyArn("string")
                .prefix("string")
                .build())
            .user("string")
            .table("string")
            .roleArn("string")
            .database("string")
            .schema("string")
            .accountUrl("string")
            .privateKey("string")
            .keyPassphrase("string")
            .contentColumnName("string")
            .dataLoadingOption("string")
            .s3BackupMode("string")
            .metadataColumnName("string")
            .cloudwatchLoggingOptions(FirehoseDeliveryStreamSnowflakeConfigurationCloudwatchLoggingOptionsArgs.builder()
                .enabled(false)
                .logGroupName("string")
                .logStreamName("string")
                .build())
            .snowflakeRoleConfiguration(FirehoseDeliveryStreamSnowflakeConfigurationSnowflakeRoleConfigurationArgs.builder()
                .enabled(false)
                .snowflakeRole("string")
                .build())
            .snowflakeVpcConfiguration(FirehoseDeliveryStreamSnowflakeConfigurationSnowflakeVpcConfigurationArgs.builder()
                .privateLinkVpceId("string")
                .build())
            .retryDuration(0)
            .processingConfiguration(FirehoseDeliveryStreamSnowflakeConfigurationProcessingConfigurationArgs.builder()
                .enabled(false)
                .processors(FirehoseDeliveryStreamSnowflakeConfigurationProcessingConfigurationProcessorArgs.builder()
                    .type("string")
                    .parameters(FirehoseDeliveryStreamSnowflakeConfigurationProcessingConfigurationProcessorParameterArgs.builder()
                        .parameterName("string")
                        .parameterValue("string")
                        .build())
                    .build())
                .build())
            .build())
        .splunkConfiguration(FirehoseDeliveryStreamSplunkConfigurationArgs.builder()
            .hecEndpoint("string")
            .hecToken("string")
            .s3Configuration(FirehoseDeliveryStreamSplunkConfigurationS3ConfigurationArgs.builder()
                .bucketArn("string")
                .roleArn("string")
                .bufferingInterval(0)
                .bufferingSize(0)
                .cloudwatchLoggingOptions(FirehoseDeliveryStreamSplunkConfigurationS3ConfigurationCloudwatchLoggingOptionsArgs.builder()
                    .enabled(false)
                    .logGroupName("string")
                    .logStreamName("string")
                    .build())
                .compressionFormat("string")
                .errorOutputPrefix("string")
                .kmsKeyArn("string")
                .prefix("string")
                .build())
            .bufferingInterval(0)
            .bufferingSize(0)
            .cloudwatchLoggingOptions(FirehoseDeliveryStreamSplunkConfigurationCloudwatchLoggingOptionsArgs.builder()
                .enabled(false)
                .logGroupName("string")