github.com/pulumi/pulumi-aws/sdk/v6@v6.32.0/go/aws/cfg/recorderStatus.go

// Code generated by the Pulumi Terraform Bridge (tfgen) Tool DO NOT EDIT.
// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! ***

package cfg

import (
	"context"
	"reflect"

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

// Manages status (recording / stopped) of an AWS Config Configuration Recorder.
//
// > **Note:** Starting Configuration Recorder requires a Delivery Channel to be present. Use of `dependsOn` (as shown below) is recommended to avoid race conditions.
//
// ## Example Usage
//
// <!--Start PulumiCodeChooser -->
// ```go
// package main
//
// import (
//
//	"fmt"
//
//	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/cfg"
//	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/iam"
//	"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 {
//			b, err := s3.NewBucketV2(ctx, "b", &s3.BucketV2Args{
//				Bucket: pulumi.String("awsconfig-example"),
//			})
//			if err != nil {
//				return err
//			}
//			fooDeliveryChannel, err := cfg.NewDeliveryChannel(ctx, "foo", &cfg.DeliveryChannelArgs{
//				Name:         pulumi.String("example"),
//				S3BucketName: b.Bucket,
//			})
//			if err != nil {
//				return err
//			}
//			assumeRole, err := iam.GetPolicyDocument(ctx, &iam.GetPolicyDocumentArgs{
//				Statements: []iam.GetPolicyDocumentStatement{
//					{
//						Effect: pulumi.StringRef("Allow"),
//						Principals: []iam.GetPolicyDocumentStatementPrincipal{
//							{
//								Type: "Service",
//								Identifiers: []string{
//									"config.amazonaws.com",
//								},
//							},
//						},
//						Actions: []string{
//							"sts:AssumeRole",
//						},
//					},
//				},
//			}, nil)
//			if err != nil {
//				return err
//			}
//			r, err := iam.NewRole(ctx, "r", &iam.RoleArgs{
//				Name:             pulumi.String("example-awsconfig"),
//				AssumeRolePolicy: pulumi.String(assumeRole.Json),
//			})
//			if err != nil {
//				return err
//			}
//			fooRecorder, err := cfg.NewRecorder(ctx, "foo", &cfg.RecorderArgs{
//				Name:    pulumi.String("example"),
//				RoleArn: r.Arn,
//			})
//			if err != nil {
//				return err
//			}
//			_, err = cfg.NewRecorderStatus(ctx, "foo", &cfg.RecorderStatusArgs{
//				Name:      fooRecorder.Name,
//				IsEnabled: pulumi.Bool(true),
//			}, pulumi.DependsOn([]pulumi.Resource{
//				fooDeliveryChannel,
//			}))
//			if err != nil {
//				return err
//			}
//			_, err = iam.NewRolePolicyAttachment(ctx, "a", &iam.RolePolicyAttachmentArgs{
//				Role:      r.Name,
//				PolicyArn: pulumi.String("arn:aws:iam::aws:policy/service-role/AWS_ConfigRole"),
//			})
//			if err != nil {
//				return err
//			}
//			p := iam.GetPolicyDocumentOutput(ctx, iam.GetPolicyDocumentOutputArgs{
//				Statements: iam.GetPolicyDocumentStatementArray{
//					&iam.GetPolicyDocumentStatementArgs{
//						Effect: pulumi.String("Allow"),
//						Actions: pulumi.StringArray{
//							pulumi.String("s3:*"),
//						},
//						Resources: pulumi.StringArray{
//							b.Arn,
//							b.Arn.ApplyT(func(arn string) (string, error) {
//								return fmt.Sprintf("%v/*", arn), nil
//							}).(pulumi.StringOutput),
//						},
//					},
//				},
//			}, nil)
//			_, err = iam.NewRolePolicy(ctx, "p", &iam.RolePolicyArgs{
//				Name: pulumi.String("awsconfig-example"),
//				Role: r.ID(),
//				Policy: p.ApplyT(func(p iam.GetPolicyDocumentResult) (*string, error) {
//					return &p.Json, nil
//				}).(pulumi.StringPtrOutput),
//			})
//			if err != nil {
//				return err
//			}
//			return nil
//		})
//	}
//
// ```
// <!--End PulumiCodeChooser -->
//
// ## Import
//
// Using `pulumi import`, import Configuration Recorder Status using the name of the Configuration Recorder. For example:
//
// ```sh
// $ pulumi import aws:cfg/recorderStatus:RecorderStatus foo example
// ```
type RecorderStatus struct {
	pulumi.CustomResourceState

	// Whether the configuration recorder should be enabled or disabled.
	IsEnabled pulumi.BoolOutput `pulumi:"isEnabled"`
	// The name of the recorder
	Name pulumi.StringOutput `pulumi:"name"`
}

// NewRecorderStatus registers a new resource with the given unique name, arguments, and options.
func NewRecorderStatus(ctx *pulumi.Context,
	name string, args *RecorderStatusArgs, opts ...pulumi.ResourceOption) (*RecorderStatus, error) {
	if args == nil {
		return nil, errors.New("missing one or more required arguments")
	}

	if args.IsEnabled == nil {
		return nil, errors.New("invalid value for required argument 'IsEnabled'")
	}
	opts = internal.PkgResourceDefaultOpts(opts)
	var resource RecorderStatus
	err := ctx.RegisterResource("aws:cfg/recorderStatus:RecorderStatus", name, args, &resource, opts...)
	if err != nil {
		return nil, err
	}
	return &resource, nil
}

// GetRecorderStatus gets an existing RecorderStatus resource's state with the given name, ID, and optional
// state properties that are used to uniquely qualify the lookup (nil if not required).
func GetRecorderStatus(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *RecorderStatusState, opts ...pulumi.ResourceOption) (*RecorderStatus, error) {
	var resource RecorderStatus
	err := ctx.ReadResource("aws:cfg/recorderStatus:RecorderStatus", name, id, state, &resource, opts...)
	if err != nil {
		return nil, err
	}
	return &resource, nil
}

// Input properties used for looking up and filtering RecorderStatus resources.
type recorderStatusState struct {
	// Whether the configuration recorder should be enabled or disabled.
	IsEnabled *bool `pulumi:"isEnabled"`
	// The name of the recorder
	Name *string `pulumi:"name"`
}

type RecorderStatusState struct {
	// Whether the configuration recorder should be enabled or disabled.
	IsEnabled pulumi.BoolPtrInput
	// The name of the recorder
	Name pulumi.StringPtrInput
}

func (RecorderStatusState) ElementType() reflect.Type {
	return reflect.TypeOf((*recorderStatusState)(nil)).Elem()
}

type recorderStatusArgs struct {
	// Whether the configuration recorder should be enabled or disabled.
	IsEnabled bool `pulumi:"isEnabled"`
	// The name of the recorder
	Name *string `pulumi:"name"`
}

// The set of arguments for constructing a RecorderStatus resource.
type RecorderStatusArgs struct {
	// Whether the configuration recorder should be enabled or disabled.
	IsEnabled pulumi.BoolInput
	// The name of the recorder
	Name pulumi.StringPtrInput
}

func (RecorderStatusArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*recorderStatusArgs)(nil)).Elem()
}

type RecorderStatusInput interface {
	pulumi.Input

	ToRecorderStatusOutput() RecorderStatusOutput
	ToRecorderStatusOutputWithContext(ctx context.Context) RecorderStatusOutput
}

func (*RecorderStatus) ElementType() reflect.Type {
	return reflect.TypeOf((**RecorderStatus)(nil)).Elem()
}

func (i *RecorderStatus) ToRecorderStatusOutput() RecorderStatusOutput {
	return i.ToRecorderStatusOutputWithContext(context.Background())
}

func (i *RecorderStatus) ToRecorderStatusOutputWithContext(ctx context.Context) RecorderStatusOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RecorderStatusOutput)
}

// RecorderStatusArrayInput is an input type that accepts RecorderStatusArray and RecorderStatusArrayOutput values.
// You can construct a concrete instance of `RecorderStatusArrayInput` via:
//
//	RecorderStatusArray{ RecorderStatusArgs{...} }
type RecorderStatusArrayInput interface {
	pulumi.Input

	ToRecorderStatusArrayOutput() RecorderStatusArrayOutput
	ToRecorderStatusArrayOutputWithContext(context.Context) RecorderStatusArrayOutput
}

type RecorderStatusArray []RecorderStatusInput

func (RecorderStatusArray) ElementType() reflect.Type {
	return reflect.TypeOf((*[]*RecorderStatus)(nil)).Elem()
}

func (i RecorderStatusArray) ToRecorderStatusArrayOutput() RecorderStatusArrayOutput {
	return i.ToRecorderStatusArrayOutputWithContext(context.Background())
}

func (i RecorderStatusArray) ToRecorderStatusArrayOutputWithContext(ctx context.Context) RecorderStatusArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RecorderStatusArrayOutput)
}

// RecorderStatusMapInput is an input type that accepts RecorderStatusMap and RecorderStatusMapOutput values.
// You can construct a concrete instance of `RecorderStatusMapInput` via:
//
//	RecorderStatusMap{ "key": RecorderStatusArgs{...} }
type RecorderStatusMapInput interface {
	pulumi.Input

	ToRecorderStatusMapOutput() RecorderStatusMapOutput
	ToRecorderStatusMapOutputWithContext(context.Context) RecorderStatusMapOutput
}

type RecorderStatusMap map[string]RecorderStatusInput

func (RecorderStatusMap) ElementType() reflect.Type {
	return reflect.TypeOf((*map[string]*RecorderStatus)(nil)).Elem()
}

func (i RecorderStatusMap) ToRecorderStatusMapOutput() RecorderStatusMapOutput {
	return i.ToRecorderStatusMapOutputWithContext(context.Background())
}

func (i RecorderStatusMap) ToRecorderStatusMapOutputWithContext(ctx context.Context) RecorderStatusMapOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RecorderStatusMapOutput)
}

type RecorderStatusOutput struct{ *pulumi.OutputState }

func (RecorderStatusOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**RecorderStatus)(nil)).Elem()
}

func (o RecorderStatusOutput) ToRecorderStatusOutput() RecorderStatusOutput {
	return o
}

func (o RecorderStatusOutput) ToRecorderStatusOutputWithContext(ctx context.Context) RecorderStatusOutput {
	return o
}

// Whether the configuration recorder should be enabled or disabled.
func (o RecorderStatusOutput) IsEnabled() pulumi.BoolOutput {
	return o.ApplyT(func(v *RecorderStatus) pulumi.BoolOutput { return v.IsEnabled }).(pulumi.BoolOutput)
}

// The name of the recorder
func (o RecorderStatusOutput) Name() pulumi.StringOutput {
	return o.ApplyT(func(v *RecorderStatus) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput)
}

type RecorderStatusArrayOutput struct{ *pulumi.OutputState }

func (RecorderStatusArrayOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*[]*RecorderStatus)(nil)).Elem()
}

func (o RecorderStatusArrayOutput) ToRecorderStatusArrayOutput() RecorderStatusArrayOutput {
	return o
}

func (o RecorderStatusArrayOutput) ToRecorderStatusArrayOutputWithContext(ctx context.Context) RecorderStatusArrayOutput {
	return o
}

func (o RecorderStatusArrayOutput) Index(i pulumi.IntInput) RecorderStatusOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) *RecorderStatus {
		return vs[0].([]*RecorderStatus)[vs[1].(int)]
	}).(RecorderStatusOutput)
}

type RecorderStatusMapOutput struct{ *pulumi.OutputState }

func (RecorderStatusMapOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*map[string]*RecorderStatus)(nil)).Elem()
}

func (o RecorderStatusMapOutput) ToRecorderStatusMapOutput() RecorderStatusMapOutput {
	return o
}

func (o RecorderStatusMapOutput) ToRecorderStatusMapOutputWithContext(ctx context.Context) RecorderStatusMapOutput {
	return o
}

func (o RecorderStatusMapOutput) MapIndex(k pulumi.StringInput) RecorderStatusOutput {
	return pulumi.All(o, k).ApplyT(func(vs []interface{}) *RecorderStatus {
		return vs[0].(map[string]*RecorderStatus)[vs[1].(string)]
	}).(RecorderStatusOutput)
}

func init() {
	pulumi.RegisterInputType(reflect.TypeOf((*RecorderStatusInput)(nil)).Elem(), &RecorderStatus{})
	pulumi.RegisterInputType(reflect.TypeOf((*RecorderStatusArrayInput)(nil)).Elem(), RecorderStatusArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*RecorderStatusMapInput)(nil)).Elem(), RecorderStatusMap{})
	pulumi.RegisterOutputType(RecorderStatusOutput{})
	pulumi.RegisterOutputType(RecorderStatusArrayOutput{})
	pulumi.RegisterOutputType(RecorderStatusMapOutput{})
}