import * as pulumi from "@pulumi/pulumi";
import * as inputs from "../types/input";
import * as outputs from "../types/output";
/**
 * 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](https://aws.amazon.com/documentation/firehose/).
 *
 * ## Example Usage
 *
 * ### Extended S3 Destination
 *
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as aws from "@pulumi/aws";
 *
 * const bucket = new aws.s3.Bucket("bucket", {bucket: "tf-test-bucket"});
 * const firehoseAssumeRole = aws.iam.getPolicyDocument({
 *     statements: [{
 *         principals: [{
 *             type: "Service",
 *             identifiers: ["firehose.amazonaws.com"],
 *         }],
 *         effect: "Allow",
 *         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: [{
 *         principals: [{
 *             type: "Service",
 *             identifiers: ["lambda.amazonaws.com"],
 *         }],
 *         effect: "Allow",
 *         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.NodeJS24dX,
 * });
 * const extendedS3Stream = new aws.kinesis.FirehoseDeliveryStream("extended_s3_stream", {
 *     extendedS3Configuration: {
 *         processingConfiguration: {
 *             processors: [{
 *                 parameters: [{
 *                     parameterName: "LambdaArn",
 *                     parameterValue: pulumi.interpolate`${lambdaProcessor.arn}:$LATEST`,
 *                 }],
 *                 type: "Lambda",
 *             }],
 *             enabled: true,
 *         },
 *         roleArn: firehoseRole.arn,
 *         bucketArn: bucket.arn,
 *     },
 *     name: "kinesis-firehose-extended-s3-test-stream",
 *     destination: "extended_s3",
 * });
 * const bucketAcl = new aws.s3.BucketAcl("bucket_acl", {
 *     bucket: bucket.id,
 *     acl: "private",
 * });
 * ```
 *
 * ### Extended S3 Destination with dynamic partitioning
 *
 * These examples use built-in Firehose functionality, rather than requiring a lambda.
 *
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as aws from "@pulumi/aws";
 *
 * const extendedS3Stream = new aws.kinesis.FirehoseDeliveryStream("extended_s3_stream", {
 *     extendedS3Configuration: {
 *         dynamicPartitioningConfiguration: {
 *             enabled: true,
 *         },
 *         processingConfiguration: {
 *             processors: [
 *                 {
 *                     parameters: [{
 *                         parameterName: "SubRecordType",
 *                         parameterValue: "JSON",
 *                     }],
 *                     type: "RecordDeAggregation",
 *                 },
 *                 {
 *                     type: "AppendDelimiterToRecord",
 *                 },
 *                 {
 *                     parameters: [
 *                         {
 *                             parameterName: "JsonParsingEngine",
 *                             parameterValue: "JQ-1.6",
 *                         },
 *                         {
 *                             parameterName: "MetadataExtractionQuery",
 *                             parameterValue: "{customer_id:.customer_id}",
 *                         },
 *                     ],
 *                     type: "MetadataExtraction",
 *                 },
 *             ],
 *             enabled: true,
 *         },
 *         roleArn: firehoseRole.arn,
 *         bucketArn: bucket.arn,
 *         bufferingSize: 64,
 *         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}/",
 *     },
 *     name: "kinesis-firehose-extended-s3-test-stream",
 *     destination: "extended_s3",
 * });
 * ```
 *
 * Multiple Dynamic Partitioning Keys (maximum of 50) can be added by comma separating the `parameterValue`.
 *
 * The following example adds the Dynamic Partitioning Keys: `storeId` and `customerId` to the S3 prefix.
 *
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as aws from "@pulumi/aws";
 *
 * const extendedS3Stream = new aws.kinesis.FirehoseDeliveryStream("extended_s3_stream", {
 *     extendedS3Configuration: {
 *         dynamicPartitioningConfiguration: {
 *             enabled: true,
 *         },
 *         processingConfiguration: {
 *             processors: [{
 *                 parameters: [
 *                     {
 *                         parameterName: "JsonParsingEngine",
 *                         parameterValue: "JQ-1.6",
 *                     },
 *                     {
 *                         parameterName: "MetadataExtractionQuery",
 *                         parameterValue: "{store_id:.store_id,customer_id:.customer_id}",
 *                     },
 *                 ],
 *                 type: "MetadataExtraction",
 *             }],
 *             enabled: true,
 *         },
 *         roleArn: firehoseRole.arn,
 *         bucketArn: bucket.arn,
 *         bufferingSize: 64,
 *         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}/",
 *     },
 *     name: "kinesis-firehose-extended-s3-test-stream",
 *     destination: "extended_s3",
 * });
 * ```
 *
 * ### Redshift Destination
 *
 * ```typescript
 * 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", {
 *     redshiftConfiguration: {
 *         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",
 *         },
 *         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",
 *     },
 *     name: "kinesis-firehose-test-stream",
 *     destination: "redshift",
 * });
 * ```
 *
 * ### Elasticsearch Destination
 *
 * ```typescript
 * 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", {
 *     elasticsearchConfiguration: {
 *         s3Configuration: {
 *             roleArn: firehoseRole.arn,
 *             bucketArn: bucket.arn,
 *             bufferingSize: 10,
 *             bufferingInterval: 400,
 *             compressionFormat: "GZIP",
 *         },
 *         processingConfiguration: {
 *             processors: [{
 *                 parameters: [{
 *                     parameterName: "LambdaArn",
 *                     parameterValue: `${lambdaProcessor.arn}:$LATEST`,
 *                 }],
 *                 type: "Lambda",
 *             }],
 *             enabled: true,
 *         },
 *         domainArn: testCluster.arn,
 *         roleArn: firehoseRole.arn,
 *         indexName: "test",
 *         typeName: "test",
 *     },
 *     name: "kinesis-firehose-test-stream",
 *     destination: "elasticsearch",
 * });
 * ```
 *
 * ### Elasticsearch Destination With VPC
 *
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as aws from "@pulumi/aws";
 *
 * const testCluster = new aws.elasticsearch.Domain("test_cluster", {
 *     clusterConfig: {
 *         instanceCount: 2,
 *         zoneAwarenessEnabled: true,
 *         instanceType: "t2.small.elasticsearch",
 *     },
 *     ebsOptions: {
 *         ebsEnabled: true,
 *         volumeSize: 10,
 *     },
 *     vpcOptions: {
 *         securityGroupIds: [first.id],
 *         subnetIds: [
 *             firstAwsSubnet.id,
 *             second.id,
 *         ],
 *     },
 *     domainName: "es-test",
 * });
 * 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.json,
 * });
 * const test = new aws.kinesis.FirehoseDeliveryStream("test", {
 *     elasticsearchConfiguration: {
 *         s3Configuration: {
 *             roleArn: firehose.arn,
 *             bucketArn: bucket.arn,
 *         },
 *         vpcConfig: {
 *             subnetIds: [
 *                 firstAwsSubnet.id,
 *                 second.id,
 *             ],
 *             securityGroupIds: [first.id],
 *             roleArn: firehose.arn,
 *         },
 *         domainArn: testCluster.arn,
 *         roleArn: firehose.arn,
 *         indexName: "test",
 *         typeName: "test",
 *     },
 *     name: "kinesis-firehose-es",
 *     destination: "elasticsearch",
 * }, {
 *     dependsOn: [firehose_elasticsearchRolePolicy],
 * });
 * ```
 *
 * ### OpenSearch Destination
 *
 * ```typescript
 * 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", {
 *     opensearchConfiguration: {
 *         s3Configuration: {
 *             roleArn: firehoseRole.arn,
 *             bucketArn: bucket.arn,
 *             bufferingSize: 10,
 *             bufferingInterval: 400,
 *             compressionFormat: "GZIP",
 *         },
 *         processingConfiguration: {
 *             processors: [{
 *                 parameters: [{
 *                     parameterName: "LambdaArn",
 *                     parameterValue: `${lambdaProcessor.arn}:$LATEST`,
 *                 }],
 *                 type: "Lambda",
 *             }],
 *             enabled: true,
 *         },
 *         domainArn: testCluster.arn,
 *         roleArn: firehoseRole.arn,
 *         indexName: "test",
 *     },
 *     name: "kinesis-firehose-test-stream",
 *     destination: "opensearch",
 * });
 * ```
 *
 * ### OpenSearch Destination With VPC
 *
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as aws from "@pulumi/aws";
 *
 * const testCluster = new aws.opensearch.Domain("test_cluster", {
 *     clusterConfig: {
 *         instanceCount: 2,
 *         zoneAwarenessEnabled: true,
 *         instanceType: "m4.large.search",
 *     },
 *     ebsOptions: {
 *         ebsEnabled: true,
 *         volumeSize: 10,
 *     },
 *     vpcOptions: {
 *         securityGroupIds: [first.id],
 *         subnetIds: [
 *             firstAwsSubnet.id,
 *             second.id,
 *         ],
 *     },
 *     domainName: "es-test",
 * });
 * 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", {
 *     opensearchConfiguration: {
 *         s3Configuration: {
 *             roleArn: firehose.arn,
 *             bucketArn: bucket.arn,
 *         },
 *         vpcConfig: {
 *             subnetIds: [
 *                 firstAwsSubnet.id,
 *                 second.id,
 *             ],
 *             securityGroupIds: [first.id],
 *             roleArn: firehose.arn,
 *         },
 *         domainArn: testCluster.arn,
 *         roleArn: firehose.arn,
 *         indexName: "test",
 *     },
 *     name: "pulumi-kinesis-firehose-os",
 *     destination: "opensearch",
 * }, {
 *     dependsOn: [firehose_opensearch],
 * });
 * ```
 *
 * ### OpenSearch Serverless Destination
 *
 * ```typescript
 * 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", {
 *     opensearchserverlessConfiguration: {
 *         s3Configuration: {
 *             roleArn: firehoseRole.arn,
 *             bucketArn: bucket.arn,
 *             bufferingSize: 10,
 *             bufferingInterval: 400,
 *             compressionFormat: "GZIP",
 *         },
 *         processingConfiguration: {
 *             processors: [{
 *                 parameters: [{
 *                     parameterName: "LambdaArn",
 *                     parameterValue: `${lambdaProcessor.arn}:$LATEST`,
 *                 }],
 *                 type: "Lambda",
 *             }],
 *             enabled: true,
 *         },
 *         collectionEndpoint: testCollection.collectionEndpoint,
 *         roleArn: firehoseRole.arn,
 *         indexName: "test",
 *     },
 *     name: "kinesis-firehose-test-stream",
 *     destination: "opensearchserverless",
 * });
 * ```
 *
 * ### Iceberg Destination
 *
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as aws from "@pulumi/aws";
 *
 * const current = aws.getCallerIdentity({});
 * const currentGetPartition = aws.getPartition({});
 * const currentGetRegion = aws.getRegion({});
 * const bucket = new aws.s3.Bucket("bucket", {
 *     bucket: "test-bucket",
 *     forceDestroy: true,
 * });
 * const test = new aws.glue.CatalogDatabase("test", {name: "test"});
 * const testCatalogTable = new aws.glue.CatalogTable("test", {
 *     openTableFormatInput: {
 *         icebergInput: {
 *             metadataOperation: "CREATE",
 *             version: "2",
 *         },
 *     },
 *     storageDescriptor: {
 *         columns: [{
 *             name: "my_column_1",
 *             type: "int",
 *         }],
 *         location: pulumi.interpolate`s3://${bucket.id}`,
 *     },
 *     name: "test",
 *     databaseName: test.name,
 *     parameters: {
 *         format: "parquet",
 *     },
 *     tableType: "EXTERNAL_TABLE",
 * });
 * const testStream = new aws.kinesis.FirehoseDeliveryStream("test_stream", {
 *     icebergConfiguration: {
 *         s3Configuration: {
 *             roleArn: firehoseRole.arn,
 *             bucketArn: bucket.arn,
 *         },
 *         processingConfiguration: {
 *             processors: [{
 *                 parameters: [{
 *                     parameterName: "LambdaArn",
 *                     parameterValue: `${lambdaProcessor.arn}:$LATEST`,
 *                 }],
 *                 type: "Lambda",
 *             }],
 *             enabled: true,
 *         },
 *         destinationTableConfigurations: [{
 *             databaseName: test.name,
 *             tableName: testCatalogTable.name,
 *         }],
 *         roleArn: firehoseRole.arn,
 *         catalogArn: Promise.all([currentGetPartition, currentGetRegion, current]).then(([currentGetPartition, currentGetRegion, current]) => `arn:${currentGetPartition.partition}:glue:${currentGetRegion.region}:${current.accountId}:catalog`),
 *         bufferingSize: 10,
 *         bufferingInterval: 400,
 *     },
 *     name: "kinesis-firehose-test-stream",
 *     destination: "iceberg",
 * });
 * ```
 *
 * ### Splunk Destination
 *
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as aws from "@pulumi/aws";
 *
 * const testStream = new aws.kinesis.FirehoseDeliveryStream("test_stream", {
 *     splunkConfiguration: {
 *         s3Configuration: {
 *             roleArn: firehose.arn,
 *             bucketArn: bucket.arn,
 *             bufferingSize: 10,
 *             bufferingInterval: 400,
 *             compressionFormat: "GZIP",
 *         },
 *         hecEndpoint: "https://http-inputs-mydomain.splunkcloud.com:443",
 *         hecToken: "51D4DA16-C61B-4F5F-8EC7-ED4301342A4A",
 *         hecAcknowledgmentTimeout: 600,
 *         hecEndpointType: "Event",
 *         s3BackupMode: "FailedEventsOnly",
 *     },
 *     name: "kinesis-firehose-test-stream",
 *     destination: "splunk",
 * });
 * ```
 *
 * ### HTTP Endpoint (e.g., New Relic, Datadog) Destination
 *
 * The HTTP endpoint destination can be used with any vendor that exposes a compatible HTTP intake, including [New Relic](https://docs.newrelic.com/docs/infrastructure/amazon-integrations/connect/aws-firehose/) and [Datadog](https://docs.datadoghq.com/integrations/amazon_kinesis_data_firehose/). Refer to each vendor's documentation for the correct intake URL and authentication requirements.
 *
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as aws from "@pulumi/aws";
 *
 * const testStream = new aws.kinesis.FirehoseDeliveryStream("test_stream", {
 *     httpEndpointConfiguration: {
 *         s3Configuration: {
 *             roleArn: firehose.arn,
 *             bucketArn: bucket.arn,
 *             bufferingSize: 10,
 *             bufferingInterval: 400,
 *             compressionFormat: "GZIP",
 *         },
 *         requestConfiguration: {
 *             commonAttributes: [
 *                 {
 *                     name: "testname",
 *                     value: "testvalue",
 *                 },
 *                 {
 *                     name: "testname2",
 *                     value: "testvalue2",
 *                 },
 *             ],
 *             contentEncoding: "GZIP",
 *         },
 *         url: "https://aws-api.newrelic.com/firehose/v1",
 *         name: "New Relic",
 *         accessKey: "my-key",
 *         bufferingSize: 15,
 *         bufferingInterval: 600,
 *         roleArn: firehose.arn,
 *         s3BackupMode: "FailedDataOnly",
 *     },
 *     name: "kinesis-firehose-test-stream",
 *     destination: "http_endpoint",
 * });
 * ```
 *
 * ### Snowflake Destination
 *
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as aws from "@pulumi/aws";
 *
 * const exampleSnowflakeDestination = new aws.kinesis.FirehoseDeliveryStream("example_snowflake_destination", {
 *     snowflakeConfiguration: {
 *         s3Configuration: {
 *             roleArn: firehose.arn,
 *             bucketArn: bucket.arn,
 *             bufferingSize: 10,
 *             bufferingInterval: 400,
 *             compressionFormat: "GZIP",
 *         },
 *         accountUrl: "https://example.snowflakecomputing.com",
 *         bufferingSize: 15,
 *         bufferingInterval: 600,
 *         database: "example-db",
 *         privateKey: "...",
 *         roleArn: firehose.arn,
 *         schema: "example-schema",
 *         table: "example-table",
 *         user: "example-usr",
 *     },
 *     name: "example-snowflake-destination",
 *     destination: "snowflake",
 * });
 * ```
 *
 * ## Import
 *
 * ### Identity Schema
 *
 * #### Required
 *
 * - `arn` (String) ARN of the delivery stream.
 *
 * Using `pulumi import`, import Kinesis Firehose Delivery Streams using `arn`. For example:
 *
 * ```sh
 * $ pulumi import aws:kinesis/firehoseDeliveryStream:FirehoseDeliveryStream example arn:aws:firehose:us-east-1:123456789012:deliverystream/example-delivery-stream
 * ```
 *
 * Note: Import does not work for stream destination `s3`. Consider using `extendedS3` since `s3` destination is deprecated.
 */
export declare class FirehoseDeliveryStream extends pulumi.CustomResource {
    /**
     * Get an existing FirehoseDeliveryStream resource's state with the given name, ID, and optional extra
     * properties used to qualify the lookup.
     *
     * @param name The _unique_ name of the resulting resource.
     * @param id The _unique_ provider ID of the resource to lookup.
     * @param state Any extra arguments used during the lookup.
     * @param opts Optional settings to control the behavior of the CustomResource.
     */
    static get(name: string, id: pulumi.Input<pulumi.ID>, state?: FirehoseDeliveryStreamState, opts?: pulumi.CustomResourceOptions): FirehoseDeliveryStream;
    /**
     * Returns true if the given object is an instance of FirehoseDeliveryStream.  This is designed to work even
     * when multiple copies of the Pulumi SDK have been loaded into the same process.
     */
    static isInstance(obj: any): obj is FirehoseDeliveryStream;
    /**
     * ARN specifying the Stream
     */
    readonly arn: pulumi.Output<string>;
    /**
     * This is the destination to where the data is delivered. The only options are `s3` (Deprecated, use `extendedS3` instead), `extendedS3`, `redshift`, `elasticsearch`, `splunk`, `httpEndpoint`, `opensearch`, `opensearchserverless` and `snowflake`.
     */
    readonly destination: pulumi.Output<string>;
    readonly destinationId: pulumi.Output<string>;
    /**
     * Configuration options when `destination` is `elasticsearch`. See `elasticsearchConfiguration` block below for details.
     */
    readonly elasticsearchConfiguration: pulumi.Output<outputs.kinesis.FirehoseDeliveryStreamElasticsearchConfiguration | undefined>;
    /**
     * Enhanced configuration options for the s3 destination. See `extendedS3Configuration` block below for details.
     */
    readonly extendedS3Configuration: pulumi.Output<outputs.kinesis.FirehoseDeliveryStreamExtendedS3Configuration | undefined>;
    /**
     * Configuration options when `destination` is `httpEndpoint`. Requires the user to also specify an `s3Configuration` block.  See `httpEndpointConfiguration` block below for details.
     */
    readonly httpEndpointConfiguration: pulumi.Output<outputs.kinesis.FirehoseDeliveryStreamHttpEndpointConfiguration | undefined>;
    /**
     * Configuration options when `destination` is `iceberg`. See `icebergConfiguration` block below for details.
     */
    readonly icebergConfiguration: pulumi.Output<outputs.kinesis.FirehoseDeliveryStreamIcebergConfiguration | undefined>;
    /**
     * Stream and role ARNs for a Kinesis data stream used as the source for a delivery stream. See `kinesisSourceConfiguration` block below for details.
     */
    readonly kinesisSourceConfiguration: pulumi.Output<outputs.kinesis.FirehoseDeliveryStreamKinesisSourceConfiguration | undefined>;
    /**
     * The configuration for the Amazon MSK cluster to be used as the source for a delivery stream. See `mskSourceConfiguration` block below for details.
     */
    readonly mskSourceConfiguration: pulumi.Output<outputs.kinesis.FirehoseDeliveryStreamMskSourceConfiguration | undefined>;
    /**
     * A name to identify the stream. This is unique to the AWS account and region the Stream is created in. When using for WAF logging, name must be prefixed with `aws-waf-logs-`. See [AWS Documentation](https://docs.aws.amazon.com/waf/latest/developerguide/waf-policies.html#waf-policies-logging-config) for more details.
     */
    readonly name: pulumi.Output<string>;
    /**
     * Configuration options when `destination` is `opensearch`. See `opensearchConfiguration` block below for details.
     */
    readonly opensearchConfiguration: pulumi.Output<outputs.kinesis.FirehoseDeliveryStreamOpensearchConfiguration | undefined>;
    /**
     * Configuration options when `destination` is `opensearchserverless`. See `opensearchserverlessConfiguration` block below for details.
     */
    readonly opensearchserverlessConfiguration: pulumi.Output<outputs.kinesis.FirehoseDeliveryStreamOpensearchserverlessConfiguration | undefined>;
    /**
     * Configuration options when `destination` is `redshift`. Requires the user to also specify an `s3Configuration` block. See `redshiftConfiguration` block below for details.
     */
    readonly redshiftConfiguration: pulumi.Output<outputs.kinesis.FirehoseDeliveryStreamRedshiftConfiguration | undefined>;
    /**
     * Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.
     */
    readonly region: pulumi.Output<string>;
    /**
     * Encrypt at rest options. See `serverSideEncryption` block below for details.
     */
    readonly serverSideEncryption: pulumi.Output<outputs.kinesis.FirehoseDeliveryStreamServerSideEncryption | undefined>;
    /**
     * Configuration options when `destination` is `snowflake`. See `snowflakeConfiguration` block below for details.
     */
    readonly snowflakeConfiguration: pulumi.Output<outputs.kinesis.FirehoseDeliveryStreamSnowflakeConfiguration | undefined>;
    /**
     * Configuration options when `destination` is `splunk`. See `splunkConfiguration` block below for details.
     *
     * **NOTE:** Server-side encryption should not be enabled when a kinesis stream is configured as the source of the firehose delivery stream.
     */
    readonly splunkConfiguration: pulumi.Output<outputs.kinesis.FirehoseDeliveryStreamSplunkConfiguration | undefined>;
    /**
     * A map of tags to assign to the resource. If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
     */
    readonly tags: pulumi.Output<{
        [key: string]: string;
    } | undefined>;
    /**
     * A map of tags assigned to the resource, including those inherited from the provider `defaultTags` configuration block.
     */
    readonly tagsAll: pulumi.Output<{
        [key: string]: string;
    }>;
    readonly versionId: pulumi.Output<string>;
    /**
     * Create a FirehoseDeliveryStream resource with the given unique name, arguments, and options.
     *
     * @param name The _unique_ name of the resource.
     * @param args The arguments to use to populate this resource's properties.
     * @param opts A bag of options that control this resource's behavior.
     */
    constructor(name: string, args: FirehoseDeliveryStreamArgs, opts?: pulumi.CustomResourceOptions);
}
/**
 * Input properties used for looking up and filtering FirehoseDeliveryStream resources.
 */
export interface FirehoseDeliveryStreamState {
    /**
     * ARN specifying the Stream
     */
    arn?: pulumi.Input<string | undefined>;
    /**
     * This is the destination to where the data is delivered. The only options are `s3` (Deprecated, use `extendedS3` instead), `extendedS3`, `redshift`, `elasticsearch`, `splunk`, `httpEndpoint`, `opensearch`, `opensearchserverless` and `snowflake`.
     */
    destination?: pulumi.Input<string | undefined>;
    destinationId?: pulumi.Input<string | undefined>;
    /**
     * Configuration options when `destination` is `elasticsearch`. See `elasticsearchConfiguration` block below for details.
     */
    elasticsearchConfiguration?: pulumi.Input<inputs.kinesis.FirehoseDeliveryStreamElasticsearchConfiguration | undefined>;
    /**
     * Enhanced configuration options for the s3 destination. See `extendedS3Configuration` block below for details.
     */
    extendedS3Configuration?: pulumi.Input<inputs.kinesis.FirehoseDeliveryStreamExtendedS3Configuration | undefined>;
    /**
     * Configuration options when `destination` is `httpEndpoint`. Requires the user to also specify an `s3Configuration` block.  See `httpEndpointConfiguration` block below for details.
     */
    httpEndpointConfiguration?: pulumi.Input<inputs.kinesis.FirehoseDeliveryStreamHttpEndpointConfiguration | undefined>;
    /**
     * Configuration options when `destination` is `iceberg`. See `icebergConfiguration` block below for details.
     */
    icebergConfiguration?: pulumi.Input<inputs.kinesis.FirehoseDeliveryStreamIcebergConfiguration | undefined>;
    /**
     * Stream and role ARNs for a Kinesis data stream used as the source for a delivery stream. See `kinesisSourceConfiguration` block below for details.
     */
    kinesisSourceConfiguration?: pulumi.Input<inputs.kinesis.FirehoseDeliveryStreamKinesisSourceConfiguration | undefined>;
    /**
     * The configuration for the Amazon MSK cluster to be used as the source for a delivery stream. See `mskSourceConfiguration` block below for details.
     */
    mskSourceConfiguration?: pulumi.Input<inputs.kinesis.FirehoseDeliveryStreamMskSourceConfiguration | undefined>;
    /**
     * A name to identify the stream. This is unique to the AWS account and region the Stream is created in. When using for WAF logging, name must be prefixed with `aws-waf-logs-`. See [AWS Documentation](https://docs.aws.amazon.com/waf/latest/developerguide/waf-policies.html#waf-policies-logging-config) for more details.
     */
    name?: pulumi.Input<string | undefined>;
    /**
     * Configuration options when `destination` is `opensearch`. See `opensearchConfiguration` block below for details.
     */
    opensearchConfiguration?: pulumi.Input<inputs.kinesis.FirehoseDeliveryStreamOpensearchConfiguration | undefined>;
    /**
     * Configuration options when `destination` is `opensearchserverless`. See `opensearchserverlessConfiguration` block below for details.
     */
    opensearchserverlessConfiguration?: pulumi.Input<inputs.kinesis.FirehoseDeliveryStreamOpensearchserverlessConfiguration | undefined>;
    /**
     * Configuration options when `destination` is `redshift`. Requires the user to also specify an `s3Configuration` block. See `redshiftConfiguration` block below for details.
     */
    redshiftConfiguration?: pulumi.Input<inputs.kinesis.FirehoseDeliveryStreamRedshiftConfiguration | undefined>;
    /**
     * Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.
     */
    region?: pulumi.Input<string | undefined>;
    /**
     * Encrypt at rest options. See `serverSideEncryption` block below for details.
     */
    serverSideEncryption?: pulumi.Input<inputs.kinesis.FirehoseDeliveryStreamServerSideEncryption | undefined>;
    /**
     * Configuration options when `destination` is `snowflake`. See `snowflakeConfiguration` block below for details.
     */
    snowflakeConfiguration?: pulumi.Input<inputs.kinesis.FirehoseDeliveryStreamSnowflakeConfiguration | undefined>;
    /**
     * Configuration options when `destination` is `splunk`. See `splunkConfiguration` block below for details.
     *
     * **NOTE:** Server-side encryption should not be enabled when a kinesis stream is configured as the source of the firehose delivery stream.
     */
    splunkConfiguration?: pulumi.Input<inputs.kinesis.FirehoseDeliveryStreamSplunkConfiguration | undefined>;
    /**
     * A map of tags to assign to the resource. If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
     */
    tags?: pulumi.Input<{
        [key: string]: pulumi.Input<string>;
    } | undefined>;
    /**
     * A map of tags assigned to the resource, including those inherited from the provider `defaultTags` configuration block.
     */
    tagsAll?: pulumi.Input<{
        [key: string]: pulumi.Input<string>;
    } | undefined>;
    versionId?: pulumi.Input<string | undefined>;
}
/**
 * The set of arguments for constructing a FirehoseDeliveryStream resource.
 */
export interface FirehoseDeliveryStreamArgs {
    /**
     * ARN specifying the Stream
     */
    arn?: pulumi.Input<string | undefined>;
    /**
     * This is the destination to where the data is delivered. The only options are `s3` (Deprecated, use `extendedS3` instead), `extendedS3`, `redshift`, `elasticsearch`, `splunk`, `httpEndpoint`, `opensearch`, `opensearchserverless` and `snowflake`.
     */
    destination: pulumi.Input<string>;
    destinationId?: pulumi.Input<string | undefined>;
    /**
     * Configuration options when `destination` is `elasticsearch`. See `elasticsearchConfiguration` block below for details.
     */
    elasticsearchConfiguration?: pulumi.Input<inputs.kinesis.FirehoseDeliveryStreamElasticsearchConfiguration | undefined>;
    /**
     * Enhanced configuration options for the s3 destination. See `extendedS3Configuration` block below for details.
     */
    extendedS3Configuration?: pulumi.Input<inputs.kinesis.FirehoseDeliveryStreamExtendedS3Configuration | undefined>;
    /**
     * Configuration options when `destination` is `httpEndpoint`. Requires the user to also specify an `s3Configuration` block.  See `httpEndpointConfiguration` block below for details.
     */
    httpEndpointConfiguration?: pulumi.Input<inputs.kinesis.FirehoseDeliveryStreamHttpEndpointConfiguration | undefined>;
    /**
     * Configuration options when `destination` is `iceberg`. See `icebergConfiguration` block below for details.
     */
    icebergConfiguration?: pulumi.Input<inputs.kinesis.FirehoseDeliveryStreamIcebergConfiguration | undefined>;
    /**
     * Stream and role ARNs for a Kinesis data stream used as the source for a delivery stream. See `kinesisSourceConfiguration` block below for details.
     */
    kinesisSourceConfiguration?: pulumi.Input<inputs.kinesis.FirehoseDeliveryStreamKinesisSourceConfiguration | undefined>;
    /**
     * The configuration for the Amazon MSK cluster to be used as the source for a delivery stream. See `mskSourceConfiguration` block below for details.
     */
    mskSourceConfiguration?: pulumi.Input<inputs.kinesis.FirehoseDeliveryStreamMskSourceConfiguration | undefined>;
    /**
     * A name to identify the stream. This is unique to the AWS account and region the Stream is created in. When using for WAF logging, name must be prefixed with `aws-waf-logs-`. See [AWS Documentation](https://docs.aws.amazon.com/waf/latest/developerguide/waf-policies.html#waf-policies-logging-config) for more details.
     */
    name?: pulumi.Input<string | undefined>;
    /**
     * Configuration options when `destination` is `opensearch`. See `opensearchConfiguration` block below for details.
     */
    opensearchConfiguration?: pulumi.Input<inputs.kinesis.FirehoseDeliveryStreamOpensearchConfiguration | undefined>;
    /**
     * Configuration options when `destination` is `opensearchserverless`. See `opensearchserverlessConfiguration` block below for details.
     */
    opensearchserverlessConfiguration?: pulumi.Input<inputs.kinesis.FirehoseDeliveryStreamOpensearchserverlessConfiguration | undefined>;
    /**
     * Configuration options when `destination` is `redshift`. Requires the user to also specify an `s3Configuration` block. See `redshiftConfiguration` block below for details.
     */
    redshiftConfiguration?: pulumi.Input<inputs.kinesis.FirehoseDeliveryStreamRedshiftConfiguration | undefined>;
    /**
     * Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.
     */
    region?: pulumi.Input<string | undefined>;
    /**
     * Encrypt at rest options. See `serverSideEncryption` block below for details.
     */
    serverSideEncryption?: pulumi.Input<inputs.kinesis.FirehoseDeliveryStreamServerSideEncryption | undefined>;
    /**
     * Configuration options when `destination` is `snowflake`. See `snowflakeConfiguration` block below for details.
     */
    snowflakeConfiguration?: pulumi.Input<inputs.kinesis.FirehoseDeliveryStreamSnowflakeConfiguration | undefined>;
    /**
     * Configuration options when `destination` is `splunk`. See `splunkConfiguration` block below for details.
     *
     * **NOTE:** Server-side encryption should not be enabled when a kinesis stream is configured as the source of the firehose delivery stream.
     */
    splunkConfiguration?: pulumi.Input<inputs.kinesis.FirehoseDeliveryStreamSplunkConfiguration | undefined>;
    /**
     * A map of tags to assign to the resource. If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
     */
    tags?: pulumi.Input<{
        [key: string]: pulumi.Input<string>;
    } | undefined>;
    versionId?: pulumi.Input<string | undefined>;
}
//# sourceMappingURL=firehoseDeliveryStream.d.ts.map