aws.pipes.Pipe

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const main = aws.getCallerIdentity({});
const example = new aws.iam.Role("example", {assumeRolePolicy: JSON.stringify({
    Version: "2012-10-17",
    Statement: {
        Effect: "Allow",
        Action: "sts:AssumeRole",
        Principal: {
            Service: "pipes.amazonaws.com",
        },
        Condition: {
            StringEquals: {
                "aws:SourceAccount": main.then(main => main.accountId),
            },
        },
    },
})});
const sourceQueue = new aws.sqs.Queue("source", {});
const source = new aws.iam.RolePolicy("source", {
    role: example.id,
    policy: pulumi.jsonStringify({
        Version: "2012-10-17",
        Statement: [{
            Effect: "Allow",
            Action: [
                "sqs:DeleteMessage",
                "sqs:GetQueueAttributes",
                "sqs:ReceiveMessage",
            ],
            Resource: [sourceQueue.arn],
        }],
    }),
});
const targetQueue = new aws.sqs.Queue("target", {});
const target = new aws.iam.RolePolicy("target", {
    role: example.id,
    policy: pulumi.jsonStringify({
        Version: "2012-10-17",
        Statement: [{
            Effect: "Allow",
            Action: ["sqs:SendMessage"],
            Resource: [targetQueue.arn],
        }],
    }),
});
const examplePipe = new aws.pipes.Pipe("example", {
    name: "example-pipe",
    roleArn: example.arn,
    source: sourceQueue.arn,
    target: targetQueue.arn,
}, {
    dependsOn: [
        source,
        target,
    ],
});

import pulumi
import json
import pulumi_aws as aws

main = aws.get_caller_identity()
example = aws.iam.Role("example", assume_role_policy=json.dumps({
    "Version": "2012-10-17",
    "Statement": {
        "Effect": "Allow",
        "Action": "sts:AssumeRole",
        "Principal": {
            "Service": "pipes.amazonaws.com",
        },
        "Condition": {
            "StringEquals": {
                "aws:SourceAccount": main.account_id,
            },
        },
    },
}))
source_queue = aws.sqs.Queue("source")
source = aws.iam.RolePolicy("source",
    role=example.id,
    policy=pulumi.Output.json_dumps({
        "Version": "2012-10-17",
        "Statement": [{
            "Effect": "Allow",
            "Action": [
                "sqs:DeleteMessage",
                "sqs:GetQueueAttributes",
                "sqs:ReceiveMessage",
            ],
            "Resource": [source_queue.arn],
        }],
    }))
target_queue = aws.sqs.Queue("target")
target = aws.iam.RolePolicy("target",
    role=example.id,
    policy=pulumi.Output.json_dumps({
        "Version": "2012-10-17",
        "Statement": [{
            "Effect": "Allow",
            "Action": ["sqs:SendMessage"],
            "Resource": [target_queue.arn],
        }],
    }))
example_pipe = aws.pipes.Pipe("example",
    name="example-pipe",
    role_arn=example.arn,
    source=source_queue.arn,
    target=target_queue.arn,
    opts = pulumi.ResourceOptions(depends_on=[
            source,
            target,
        ]))

package main

import (
	"encoding/json"

	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws"
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/iam"
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/pipes"
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/sqs"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		main, err := aws.GetCallerIdentity(ctx, nil, nil)
		if err != nil {
			return err
		}
		tmpJSON0, err := json.Marshal(map[string]interface{}{
			"Version": "2012-10-17",
			"Statement": map[string]interface{}{
				"Effect": "Allow",
				"Action": "sts:AssumeRole",
				"Principal": map[string]interface{}{
					"Service": "pipes.amazonaws.com",
				},
				"Condition": map[string]interface{}{
					"StringEquals": map[string]interface{}{
						"aws:SourceAccount": main.AccountId,
					},
				},
			},
		})
		if err != nil {
			return err
		}
		json0 := string(tmpJSON0)
		example, err := iam.NewRole(ctx, "example", &iam.RoleArgs{
			AssumeRolePolicy: pulumi.String(json0),
		})
		if err != nil {
			return err
		}
		sourceQueue, err := sqs.NewQueue(ctx, "source", nil)
		if err != nil {
			return err
		}
		source, err := iam.NewRolePolicy(ctx, "source", &iam.RolePolicyArgs{
			Role: example.ID(),
			Policy: sourceQueue.Arn.ApplyT(func(arn string) (pulumi.String, error) {
				var _zero pulumi.String
				tmpJSON1, err := json.Marshal(map[string]interface{}{
					"Version": "2012-10-17",
					"Statement": []map[string]interface{}{
						map[string]interface{}{
							"Effect": "Allow",
							"Action": []string{
								"sqs:DeleteMessage",
								"sqs:GetQueueAttributes",
								"sqs:ReceiveMessage",
							},
							"Resource": []string{
								arn,
							},
						},
					},
				})
				if err != nil {
					return _zero, err
				}
				json1 := string(tmpJSON1)
				return pulumi.String(json1), nil
			}).(pulumi.StringOutput),
		})
		if err != nil {
			return err
		}
		targetQueue, err := sqs.NewQueue(ctx, "target", nil)
		if err != nil {
			return err
		}
		target, err := iam.NewRolePolicy(ctx, "target", &iam.RolePolicyArgs{
			Role: example.ID(),
			Policy: targetQueue.Arn.ApplyT(func(arn string) (pulumi.String, error) {
				var _zero pulumi.String
				tmpJSON2, err := json.Marshal(map[string]interface{}{
					"Version": "2012-10-17",
					"Statement": []map[string]interface{}{
						map[string]interface{}{
							"Effect": "Allow",
							"Action": []string{
								"sqs:SendMessage",
							},
							"Resource": []string{
								arn,
							},
						},
					},
				})
				if err != nil {
					return _zero, err
				}
				json2 := string(tmpJSON2)
				return pulumi.String(json2), nil
			}).(pulumi.StringOutput),
		})
		if err != nil {
			return err
		}
		_, err = pipes.NewPipe(ctx, "example", &pipes.PipeArgs{
			Name:    pulumi.String("example-pipe"),
			RoleArn: example.Arn,
			Source:  sourceQueue.Arn,
			Target:  targetQueue.Arn,
		}, pulumi.DependsOn([]pulumi.Resource{
			source,
			target,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using System.Text.Json;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() => 
{
    var main = Aws.GetCallerIdentity.Invoke();

    var example = new Aws.Iam.Role("example", new()
    {
        AssumeRolePolicy = JsonSerializer.Serialize(new Dictionary<string, object?>
        {
            ["Version"] = "2012-10-17",
            ["Statement"] = new Dictionary<string, object?>
            {
                ["Effect"] = "Allow",
                ["Action"] = "sts:AssumeRole",
                ["Principal"] = new Dictionary<string, object?>
                {
                    ["Service"] = "pipes.amazonaws.com",
                },
                ["Condition"] = new Dictionary<string, object?>
                {
                    ["StringEquals"] = new Dictionary<string, object?>
                    {
                        ["aws:SourceAccount"] = main.Apply(getCallerIdentityResult => getCallerIdentityResult.AccountId),
                    },
                },
            },
        }),
    });

    var sourceQueue = new Aws.Sqs.Queue("source");

    var source = new Aws.Iam.RolePolicy("source", new()
    {
        Role = example.Id,
        Policy = Output.JsonSerialize(Output.Create(new Dictionary<string, object?>
        {
            ["Version"] = "2012-10-17",
            ["Statement"] = new[]
            {
                new Dictionary<string, object?>
                {
                    ["Effect"] = "Allow",
                    ["Action"] = new[]
                    {
                        "sqs:DeleteMessage",
                        "sqs:GetQueueAttributes",
                        "sqs:ReceiveMessage",
                    },
                    ["Resource"] = new[]
                    {
                        sourceQueue.Arn,
                    },
                },
            },
        })),
    });

    var targetQueue = new Aws.Sqs.Queue("target");

    var target = new Aws.Iam.RolePolicy("target", new()
    {
        Role = example.Id,
        Policy = Output.JsonSerialize(Output.Create(new Dictionary<string, object?>
        {
            ["Version"] = "2012-10-17",
            ["Statement"] = new[]
            {
                new Dictionary<string, object?>
                {
                    ["Effect"] = "Allow",
                    ["Action"] = new[]
                    {
                        "sqs:SendMessage",
                    },
                    ["Resource"] = new[]
                    {
                        targetQueue.Arn,
                    },
                },
            },
        })),
    });

    var examplePipe = new Aws.Pipes.Pipe("example", new()
    {
        Name = "example-pipe",
        RoleArn = example.Arn,
        Source = sourceQueue.Arn,
        Target = targetQueue.Arn,
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            source,
            target,
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.AwsFunctions;
import com.pulumi.aws.inputs.GetCallerIdentityArgs;
import com.pulumi.aws.iam.Role;
import com.pulumi.aws.iam.RoleArgs;
import com.pulumi.aws.sqs.Queue;
import com.pulumi.aws.iam.RolePolicy;
import com.pulumi.aws.iam.RolePolicyArgs;
import com.pulumi.aws.pipes.Pipe;
import com.pulumi.aws.pipes.PipeArgs;
import static com.pulumi.codegen.internal.Serialization.*;
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) {
        final var main = AwsFunctions.getCallerIdentity();

        var example = new Role("example", RoleArgs.builder()
            .assumeRolePolicy(serializeJson(
                jsonObject(
                    jsonProperty("Version", "2012-10-17"),
                    jsonProperty("Statement", jsonObject(
                        jsonProperty("Effect", "Allow"),
                        jsonProperty("Action", "sts:AssumeRole"),
                        jsonProperty("Principal", jsonObject(
                            jsonProperty("Service", "pipes.amazonaws.com")
                        )),
                        jsonProperty("Condition", jsonObject(
                            jsonProperty("StringEquals", jsonObject(
                                jsonProperty("aws:SourceAccount", main.applyValue(getCallerIdentityResult -> getCallerIdentityResult.accountId()))
                            ))
                        ))
                    ))
                )))
            .build());

        var sourceQueue = new Queue("sourceQueue");

        var source = new RolePolicy("source", RolePolicyArgs.builder()
            .role(example.id())
            .policy(sourceQueue.arn().applyValue(arn -> serializeJson(
                jsonObject(
                    jsonProperty("Version", "2012-10-17"),
                    jsonProperty("Statement", jsonArray(jsonObject(
                        jsonProperty("Effect", "Allow"),
                        jsonProperty("Action", jsonArray(
                            "sqs:DeleteMessage", 
                            "sqs:GetQueueAttributes", 
                            "sqs:ReceiveMessage"
                        )),
                        jsonProperty("Resource", jsonArray(arn))
                    )))
                ))))
            .build());

        var targetQueue = new Queue("targetQueue");

        var target = new RolePolicy("target", RolePolicyArgs.builder()
            .role(example.id())
            .policy(targetQueue.arn().applyValue(arn -> serializeJson(
                jsonObject(
                    jsonProperty("Version", "2012-10-17"),
                    jsonProperty("Statement", jsonArray(jsonObject(
                        jsonProperty("Effect", "Allow"),
                        jsonProperty("Action", jsonArray("sqs:SendMessage")),
                        jsonProperty("Resource", jsonArray(arn))
                    )))
                ))))
            .build());

        var examplePipe = new Pipe("examplePipe", PipeArgs.builder()
            .name("example-pipe")
            .roleArn(example.arn())
            .source(sourceQueue.arn())
            .target(targetQueue.arn())
            .build(), CustomResourceOptions.builder()
                .dependsOn(                
                    source,
                    target)
                .build());

    }
}

resources:
  example:
    type: aws:iam:Role
    properties:
      assumeRolePolicy:
        fn::toJSON:
          Version: 2012-10-17
          Statement:
            Effect: Allow
            Action: sts:AssumeRole
            Principal:
              Service: pipes.amazonaws.com
            Condition:
              StringEquals:
                aws:SourceAccount: ${main.accountId}
  source:
    type: aws:iam:RolePolicy
    properties:
      role: ${example.id}
      policy:
        fn::toJSON:
          Version: 2012-10-17
          Statement:
            - Effect: Allow
              Action:
                - sqs:DeleteMessage
                - sqs:GetQueueAttributes
                - sqs:ReceiveMessage
              Resource:
                - ${sourceQueue.arn}
  sourceQueue:
    type: aws:sqs:Queue
    name: source
  target:
    type: aws:iam:RolePolicy
    properties:
      role: ${example.id}
      policy:
        fn::toJSON:
          Version: 2012-10-17
          Statement:
            - Effect: Allow
              Action:
                - sqs:SendMessage
              Resource:
                - ${targetQueue.arn}
  targetQueue:
    type: aws:sqs:Queue
    name: target
  examplePipe:
    type: aws:pipes:Pipe
    name: example
    properties:
      name: example-pipe
      roleArn: ${example.arn}
      source: ${sourceQueue.arn}
      target: ${targetQueue.arn}
    options:
      dependson:
        - ${source}
        - ${target}
variables:
  main:
    fn::invoke:
      Function: aws:getCallerIdentity
      Arguments: {}

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const example = new aws.pipes.Pipe("example", {
    name: "example-pipe",
    roleArn: exampleAwsIamRole.arn,
    source: source.arn,
    target: target.arn,
    enrichment: exampleAwsCloudwatchEventApiDestination.arn,
    enrichmentParameters: {
        httpParameters: {
            pathParameterValues: "example-path-param",
            headerParameters: {
                "example-header": "example-value",
                "second-example-header": "second-example-value",
            },
            queryStringParameters: {
                "example-query-string": "example-value",
                "second-example-query-string": "second-example-value",
            },
        },
    },
});

import pulumi
import pulumi_aws as aws

example = aws.pipes.Pipe("example",
    name="example-pipe",
    role_arn=example_aws_iam_role["arn"],
    source=source["arn"],
    target=target["arn"],
    enrichment=example_aws_cloudwatch_event_api_destination["arn"],
    enrichment_parameters={
        "httpParameters": {
            "pathParameterValues": "example-path-param",
            "headerParameters": {
                "example-header": "example-value",
                "second-example-header": "second-example-value",
            },
            "queryStringParameters": {
                "example-query-string": "example-value",
                "second-example-query-string": "second-example-value",
            },
        },
    })

package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/pipes"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := pipes.NewPipe(ctx, "example", &pipes.PipeArgs{
			Name:       pulumi.String("example-pipe"),
			RoleArn:    pulumi.Any(exampleAwsIamRole.Arn),
			Source:     pulumi.Any(source.Arn),
			Target:     pulumi.Any(target.Arn),
			Enrichment: pulumi.Any(exampleAwsCloudwatchEventApiDestination.Arn),
			EnrichmentParameters: &pipes.PipeEnrichmentParametersArgs{
				HttpParameters: &pipes.PipeEnrichmentParametersHttpParametersArgs{
					PathParameterValues: pulumi.String("example-path-param"),
					HeaderParameters: pulumi.StringMap{
						"example-header":        pulumi.String("example-value"),
						"second-example-header": pulumi.String("second-example-value"),
					},
					QueryStringParameters: pulumi.StringMap{
						"example-query-string":        pulumi.String("example-value"),
						"second-example-query-string": pulumi.String("second-example-value"),
					},
				},
			},
		})
		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 example = new Aws.Pipes.Pipe("example", new()
    {
        Name = "example-pipe",
        RoleArn = exampleAwsIamRole.Arn,
        Source = source.Arn,
        Target = target.Arn,
        Enrichment = exampleAwsCloudwatchEventApiDestination.Arn,
        EnrichmentParameters = new Aws.Pipes.Inputs.PipeEnrichmentParametersArgs
        {
            HttpParameters = new Aws.Pipes.Inputs.PipeEnrichmentParametersHttpParametersArgs
            {
                PathParameterValues = "example-path-param",
                HeaderParameters = 
                {
                    { "example-header", "example-value" },
                    { "second-example-header", "second-example-value" },
                },
                QueryStringParameters = 
                {
                    { "example-query-string", "example-value" },
                    { "second-example-query-string", "second-example-value" },
                },
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.pipes.Pipe;
import com.pulumi.aws.pipes.PipeArgs;
import com.pulumi.aws.pipes.inputs.PipeEnrichmentParametersArgs;
import com.pulumi.aws.pipes.inputs.PipeEnrichmentParametersHttpParametersArgs;
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 example = new Pipe("example", PipeArgs.builder()
            .name("example-pipe")
            .roleArn(exampleAwsIamRole.arn())
            .source(source.arn())
            .target(target.arn())
            .enrichment(exampleAwsCloudwatchEventApiDestination.arn())
            .enrichmentParameters(PipeEnrichmentParametersArgs.builder()
                .httpParameters(PipeEnrichmentParametersHttpParametersArgs.builder()
                    .pathParameterValues("example-path-param")
                    .headerParameters(Map.ofEntries(
                        Map.entry("example-header", "example-value"),
                        Map.entry("second-example-header", "second-example-value")
                    ))
                    .queryStringParameters(Map.ofEntries(
                        Map.entry("example-query-string", "example-value"),
                        Map.entry("second-example-query-string", "second-example-value")
                    ))
                    .build())
                .build())
            .build());

    }
}

resources:
  example:
    type: aws:pipes:Pipe
    properties:
      name: example-pipe
      roleArn: ${exampleAwsIamRole.arn}
      source: ${source.arn}
      target: ${target.arn}
      enrichment: ${exampleAwsCloudwatchEventApiDestination.arn}
      enrichmentParameters:
        httpParameters:
          pathParameterValues: example-path-param
          headerParameters:
            example-header: example-value
            second-example-header: second-example-value
          queryStringParameters:
            example-query-string: example-value
            second-example-query-string: second-example-value

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const example = new aws.pipes.Pipe("example", {
    name: "example-pipe",
    roleArn: exampleAwsIamRole.arn,
    source: source.arn,
    target: target.arn,
    sourceParameters: {
        filterCriteria: {
            filters: [{
                pattern: JSON.stringify({
                    source: ["event-source"],
                }),
            }],
        },
    },
});

import pulumi
import json
import pulumi_aws as aws

example = aws.pipes.Pipe("example",
    name="example-pipe",
    role_arn=example_aws_iam_role["arn"],
    source=source["arn"],
    target=target["arn"],
    source_parameters={
        "filterCriteria": {
            "filters": [{
                "pattern": json.dumps({
                    "source": ["event-source"],
                }),
            }],
        },
    })

package main

import (
	"encoding/json"

	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/pipes"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		tmpJSON0, err := json.Marshal(map[string]interface{}{
			"source": []string{
				"event-source",
			},
		})
		if err != nil {
			return err
		}
		json0 := string(tmpJSON0)
		_, err = pipes.NewPipe(ctx, "example", &pipes.PipeArgs{
			Name:    pulumi.String("example-pipe"),
			RoleArn: pulumi.Any(exampleAwsIamRole.Arn),
			Source:  pulumi.Any(source.Arn),
			Target:  pulumi.Any(target.Arn),
			SourceParameters: &pipes.PipeSourceParametersArgs{
				FilterCriteria: &pipes.PipeSourceParametersFilterCriteriaArgs{
					Filters: pipes.PipeSourceParametersFilterCriteriaFilterArray{
						&pipes.PipeSourceParametersFilterCriteriaFilterArgs{
							Pattern: pulumi.String(json0),
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using System.Text.Json;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() => 
{
    var example = new Aws.Pipes.Pipe("example", new()
    {
        Name = "example-pipe",
        RoleArn = exampleAwsIamRole.Arn,
        Source = source.Arn,
        Target = target.Arn,
        SourceParameters = new Aws.Pipes.Inputs.PipeSourceParametersArgs
        {
            FilterCriteria = new Aws.Pipes.Inputs.PipeSourceParametersFilterCriteriaArgs
            {
                Filters = new[]
                {
                    new Aws.Pipes.Inputs.PipeSourceParametersFilterCriteriaFilterArgs
                    {
                        Pattern = JsonSerializer.Serialize(new Dictionary<string, object?>
                        {
                            ["source"] = new[]
                            {
                                "event-source",
                            },
                        }),
                    },
                },
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.pipes.Pipe;
import com.pulumi.aws.pipes.PipeArgs;
import com.pulumi.aws.pipes.inputs.PipeSourceParametersArgs;
import com.pulumi.aws.pipes.inputs.PipeSourceParametersFilterCriteriaArgs;
import static com.pulumi.codegen.internal.Serialization.*;
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 example = new Pipe("example", PipeArgs.builder()
            .name("example-pipe")
            .roleArn(exampleAwsIamRole.arn())
            .source(source.arn())
            .target(target.arn())
            .sourceParameters(PipeSourceParametersArgs.builder()
                .filterCriteria(PipeSourceParametersFilterCriteriaArgs.builder()
                    .filters(PipeSourceParametersFilterCriteriaFilterArgs.builder()
                        .pattern(serializeJson(
                            jsonObject(
                                jsonProperty("source", jsonArray("event-source"))
                            )))
                        .build())
                    .build())
                .build())
            .build());

    }
}

resources:
  example:
    type: aws:pipes:Pipe
    properties:
      name: example-pipe
      roleArn: ${exampleAwsIamRole.arn}
      source: ${source.arn}
      target: ${target.arn}
      sourceParameters:
        filterCriteria:
          filters:
            - pattern:
                fn::toJSON:
                  source:
                    - event-source

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.pipes.Pipe;
import com.pulumi.aws.pipes.PipeArgs;
import com.pulumi.aws.pipes.inputs.PipeSourceParametersArgs;
import com.pulumi.aws.pipes.inputs.PipeSourceParametersSqsQueueParametersArgs;
import com.pulumi.aws.pipes.inputs.PipeTargetParametersArgs;
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 example = new Pipe("example", PipeArgs.builder()
            .name("example-pipe")
            .roleArn(exampleAwsIamRole.arn())
            .source(source.arn())
            .target(target.arn())
            .sourceParameters(PipeSourceParametersArgs.builder()
                .sqsQueueParameters(PipeSourceParametersSqsQueueParametersArgs.builder()
                    .batchSize(1)
                    .maximumBatchingWindowInSeconds(2)
                    .build())
                .build())
            .targetParameters(PipeTargetParametersArgs.builder()
                .sqsQueue(%!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference))
                .build())
            .build());

    }
}

resources:
  example:
    type: aws:pipes:Pipe
    properties:
      name: example-pipe
      roleArn: ${exampleAwsIamRole.arn}
      source: ${source.arn}
      target: ${target.arn}
      sourceParameters:
        sqsQueueParameters:
          batchSize: 1
          maximumBatchingWindowInSeconds: 2
      targetParameters:
        sqsQueue:
          - messageDeduplicationId: example-dedupe
            messageGroupId: example-group

var pipeResource = new Aws.Pipes.Pipe("pipeResource", new()
{
    RoleArn = "string",
    Target = "string",
    Source = "string",
    NamePrefix = "string",
    LogConfiguration = new Aws.Pipes.Inputs.PipeLogConfigurationArgs
    {
        Level = "string",
        CloudwatchLogsLogDestination = new Aws.Pipes.Inputs.PipeLogConfigurationCloudwatchLogsLogDestinationArgs
        {
            LogGroupArn = "string",
        },
        FirehoseLogDestination = new Aws.Pipes.Inputs.PipeLogConfigurationFirehoseLogDestinationArgs
        {
            DeliveryStreamArn = "string",
        },
        S3LogDestination = new Aws.Pipes.Inputs.PipeLogConfigurationS3LogDestinationArgs
        {
            BucketName = "string",
            BucketOwner = "string",
            OutputFormat = "string",
            Prefix = "string",
        },
    },
    Name = "string",
    Description = "string",
    EnrichmentParameters = new Aws.Pipes.Inputs.PipeEnrichmentParametersArgs
    {
        HttpParameters = new Aws.Pipes.Inputs.PipeEnrichmentParametersHttpParametersArgs
        {
            HeaderParameters = 
            {
                { "string", "string" },
            },
            PathParameterValues = "string",
            QueryStringParameters = 
            {
                { "string", "string" },
            },
        },
        InputTemplate = "string",
    },
    Enrichment = "string",
    SourceParameters = new Aws.Pipes.Inputs.PipeSourceParametersArgs
    {
        ActivemqBrokerParameters = new Aws.Pipes.Inputs.PipeSourceParametersActivemqBrokerParametersArgs
        {
            Credentials = new Aws.Pipes.Inputs.PipeSourceParametersActivemqBrokerParametersCredentialsArgs
            {
                BasicAuth = "string",
            },
            QueueName = "string",
            BatchSize = 0,
            MaximumBatchingWindowInSeconds = 0,
        },
        DynamodbStreamParameters = new Aws.Pipes.Inputs.PipeSourceParametersDynamodbStreamParametersArgs
        {
            StartingPosition = "string",
            BatchSize = 0,
            DeadLetterConfig = new Aws.Pipes.Inputs.PipeSourceParametersDynamodbStreamParametersDeadLetterConfigArgs
            {
                Arn = "string",
            },
            MaximumBatchingWindowInSeconds = 0,
            MaximumRecordAgeInSeconds = 0,
            MaximumRetryAttempts = 0,
            OnPartialBatchItemFailure = "string",
            ParallelizationFactor = 0,
        },
        FilterCriteria = new Aws.Pipes.Inputs.PipeSourceParametersFilterCriteriaArgs
        {
            Filters = new[]
            {
                new Aws.Pipes.Inputs.PipeSourceParametersFilterCriteriaFilterArgs
                {
                    Pattern = "string",
                },
            },
        },
        KinesisStreamParameters = new Aws.Pipes.Inputs.PipeSourceParametersKinesisStreamParametersArgs
        {
            StartingPosition = "string",
            BatchSize = 0,
            DeadLetterConfig = new Aws.Pipes.Inputs.PipeSourceParametersKinesisStreamParametersDeadLetterConfigArgs
            {
                Arn = "string",
            },
            MaximumBatchingWindowInSeconds = 0,
            MaximumRecordAgeInSeconds = 0,
            MaximumRetryAttempts = 0,
            OnPartialBatchItemFailure = "string",
            ParallelizationFactor = 0,
            StartingPositionTimestamp = "string",
        },
        ManagedStreamingKafkaParameters = new Aws.Pipes.Inputs.PipeSourceParametersManagedStreamingKafkaParametersArgs
        {
            TopicName = "string",
            BatchSize = 0,
            ConsumerGroupId = "string",
            Credentials = new Aws.Pipes.Inputs.PipeSourceParametersManagedStreamingKafkaParametersCredentialsArgs
            {
                ClientCertificateTlsAuth = "string",
                SaslScram512Auth = "string",
            },
            MaximumBatchingWindowInSeconds = 0,
            StartingPosition = "string",
        },
        RabbitmqBrokerParameters = new Aws.Pipes.Inputs.PipeSourceParametersRabbitmqBrokerParametersArgs
        {
            Credentials = new Aws.Pipes.Inputs.PipeSourceParametersRabbitmqBrokerParametersCredentialsArgs
            {
                BasicAuth = "string",
            },
            QueueName = "string",
            BatchSize = 0,
            MaximumBatchingWindowInSeconds = 0,
            VirtualHost = "string",
        },
        SelfManagedKafkaParameters = new Aws.Pipes.Inputs.PipeSourceParametersSelfManagedKafkaParametersArgs
        {
            TopicName = "string",
            AdditionalBootstrapServers = new[]
            {
                "string",
            },
            BatchSize = 0,
            ConsumerGroupId = "string",
            Credentials = new Aws.Pipes.Inputs.PipeSourceParametersSelfManagedKafkaParametersCredentialsArgs
            {
                BasicAuth = "string",
                ClientCertificateTlsAuth = "string",
                SaslScram256Auth = "string",
                SaslScram512Auth = "string",
            },
            MaximumBatchingWindowInSeconds = 0,
            ServerRootCaCertificate = "string",
            StartingPosition = "string",
            Vpc = new Aws.Pipes.Inputs.PipeSourceParametersSelfManagedKafkaParametersVpcArgs
            {
                SecurityGroups = new[]
                {
                    "string",
                },
                Subnets = new[]
                {
                    "string",
                },
            },
        },
        SqsQueueParameters = new Aws.Pipes.Inputs.PipeSourceParametersSqsQueueParametersArgs
        {
            BatchSize = 0,
            MaximumBatchingWindowInSeconds = 0,
        },
    },
    Tags = 
    {
        { "string", "string" },
    },
    DesiredState = "string",
    TargetParameters = new Aws.Pipes.Inputs.PipeTargetParametersArgs
    {
        BatchJobParameters = new Aws.Pipes.Inputs.PipeTargetParametersBatchJobParametersArgs
        {
            JobDefinition = "string",
            JobName = "string",
            ArrayProperties = new Aws.Pipes.Inputs.PipeTargetParametersBatchJobParametersArrayPropertiesArgs
            {
                Size = 0,
            },
            ContainerOverrides = new Aws.Pipes.Inputs.PipeTargetParametersBatchJobParametersContainerOverridesArgs
            {
                Commands = new[]
                {
                    "string",
                },
                Environments = new[]
                {
                    new Aws.Pipes.Inputs.PipeTargetParametersBatchJobParametersContainerOverridesEnvironmentArgs
                    {
                        Name = "string",
                        Value = "string",
                    },
                },
                InstanceType = "string",
                ResourceRequirements = new[]
                {
                    new Aws.Pipes.Inputs.PipeTargetParametersBatchJobParametersContainerOverridesResourceRequirementArgs
                    {
                        Type = "string",
                        Value = "string",
                    },
                },
            },
            DependsOns = new[]
            {
                new Aws.Pipes.Inputs.PipeTargetParametersBatchJobParametersDependsOnArgs
                {
                    JobId = "string",
                    Type = "string",
                },
            },
            Parameters = 
            {
                { "string", "string" },
            },
            RetryStrategy = new Aws.Pipes.Inputs.PipeTargetParametersBatchJobParametersRetryStrategyArgs
            {
                Attempts = 0,
            },
        },
        CloudwatchLogsParameters = new Aws.Pipes.Inputs.PipeTargetParametersCloudwatchLogsParametersArgs
        {
            LogStreamName = "string",
            Timestamp = "string",
        },
        EcsTaskParameters = new Aws.Pipes.Inputs.PipeTargetParametersEcsTaskParametersArgs
        {
            TaskDefinitionArn = "string",
            Overrides = new Aws.Pipes.Inputs.PipeTargetParametersEcsTaskParametersOverridesArgs
            {
                ContainerOverrides = new[]
                {
                    new Aws.Pipes.Inputs.PipeTargetParametersEcsTaskParametersOverridesContainerOverrideArgs
                    {
                        Commands = new[]
                        {
                            "string",
                        },
                        Cpu = 0,
                        EnvironmentFiles = new[]
                        {
                            new Aws.Pipes.Inputs.PipeTargetParametersEcsTaskParametersOverridesContainerOverrideEnvironmentFileArgs
                            {
                                Type = "string",
                                Value = "string",
                            },
                        },
                        Environments = new[]
                        {
                            new Aws.Pipes.Inputs.PipeTargetParametersEcsTaskParametersOverridesContainerOverrideEnvironmentArgs
                            {
                                Name = "string",
                                Value = "string",
                            },
                        },
                        Memory = 0,
                        MemoryReservation = 0,
                        Name = "string",
                        ResourceRequirements = new[]
                        {
                            new Aws.Pipes.Inputs.PipeTargetParametersEcsTaskParametersOverridesContainerOverrideResourceRequirementArgs
                            {
                                Type = "string",
                                Value = "string",
                            },
                        },
                    },
                },
                Cpu = "string",
                EphemeralStorage = new Aws.Pipes.Inputs.PipeTargetParametersEcsTaskParametersOverridesEphemeralStorageArgs
                {
                    SizeInGib = 0,
                },
                ExecutionRoleArn = "string",
                InferenceAcceleratorOverrides = new[]
                {
                    new Aws.Pipes.Inputs.PipeTargetParametersEcsTaskParametersOverridesInferenceAcceleratorOverrideArgs
                    {
                        DeviceName = "string",
                        DeviceType = "string",
                    },
                },
                Memory = "string",
                TaskRoleArn = "string",
            },
            PlacementStrategies = new[]
            {
                new Aws.Pipes.Inputs.PipeTargetParametersEcsTaskParametersPlacementStrategyArgs
                {
                    Field = "string",
                    Type = "string",
                },
            },
            Group = "string",
            LaunchType = "string",
            NetworkConfiguration = new Aws.Pipes.Inputs.PipeTargetParametersEcsTaskParametersNetworkConfigurationArgs
            {
                AwsVpcConfiguration = new Aws.Pipes.Inputs.PipeTargetParametersEcsTaskParametersNetworkConfigurationAwsVpcConfigurationArgs
                {
                    AssignPublicIp = "string",
                    SecurityGroups = new[]
                    {
                        "string",
                    },
                    Subnets = new[]
                    {
                        "string",
                    },
                },
            },
            CapacityProviderStrategies = new[]
            {
                new Aws.Pipes.Inputs.PipeTargetParametersEcsTaskParametersCapacityProviderStrategyArgs
                {
                    CapacityProvider = "string",
                    Base = 0,
                    Weight = 0,
                },
            },
            PlacementConstraints = new[]
            {
                new Aws.Pipes.Inputs.PipeTargetParametersEcsTaskParametersPlacementConstraintArgs
                {
                    Expression = "string",
                    Type = "string",
                },
            },
            EnableExecuteCommand = false,
            PlatformVersion = "string",
            PropagateTags = "string",
            ReferenceId = "string",
            Tags = 
            {
                { "string", "string" },
            },
            TaskCount = 0,
            EnableEcsManagedTags = false,
        },
        EventbridgeEventBusParameters = new Aws.Pipes.Inputs.PipeTargetParametersEventbridgeEventBusParametersArgs
        {
            DetailType = "string",
            EndpointId = "string",
            Resources = new[]
            {
                "string",
            },
            Source = "string",
            Time = "string",
        },
        HttpParameters = new Aws.Pipes.Inputs.PipeTargetParametersHttpParametersArgs
        {
            HeaderParameters = 
            {
                { "string", "string" },
            },
            PathParameterValues = "string",
            QueryStringParameters = 
            {
                { "string", "string" },
            },
        },
        InputTemplate = "string",
        KinesisStreamParameters = new Aws.Pipes.Inputs.PipeTargetParametersKinesisStreamParametersArgs
        {
            PartitionKey = "string",
        },
        LambdaFunctionParameters = new Aws.Pipes.Inputs.PipeTargetParametersLambdaFunctionParametersArgs
        {
            InvocationType = "string",
        },
        RedshiftDataParameters = new Aws.Pipes.Inputs.PipeTargetParametersRedshiftDataParametersArgs
        {
            Database = "string",
            Sqls = new[]
            {
                "string",
            },
            DbUser = "string",
            SecretManagerArn = "string",
            StatementName = "string",
            WithEvent = false,
        },
        SagemakerPipelineParameters = new Aws.Pipes.Inputs.PipeTargetParametersSagemakerPipelineParametersArgs
        {
            PipelineParameters = new[]
            {
                new Aws.Pipes.Inputs.PipeTargetParametersSagemakerPipelineParametersPipelineParameterArgs
                {
                    Name = "string",
                    Value = "string",
                },
            },
        },
        SqsQueueParameters = new Aws.Pipes.Inputs.PipeTargetParametersSqsQueueParametersArgs
        {
            MessageDeduplicationId = "string",
            MessageGroupId = "string",
        },
        StepFunctionStateMachineParameters = new Aws.Pipes.Inputs.PipeTargetParametersStepFunctionStateMachineParametersArgs
        {
            InvocationType = "string",
        },
    },
});