archiveRule.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 accessanalyzer

import (
	"context"
	"reflect"

	"errors"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

// Resource for managing an AWS AccessAnalyzer Archive Rule.
//
// ## Example Usage
// ### Basic Usage
//
// ```go
// package main
//
// import (
//
//	"github.com/pulumi/pulumi-aws/sdk/v5/go/aws/accessanalyzer"
//	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
//
// )
//
//	func main() {
//		pulumi.Run(func(ctx *pulumi.Context) error {
//			_, err := accessanalyzer.NewArchiveRule(ctx, "example", &accessanalyzer.ArchiveRuleArgs{
//				AnalyzerName: pulumi.String("example-analyzer"),
//				Filters: accessanalyzer.ArchiveRuleFilterArray{
//					&accessanalyzer.ArchiveRuleFilterArgs{
//						Criteria: pulumi.String("condition.aws:UserId"),
//						Eqs: pulumi.StringArray{
//							pulumi.String("userid"),
//						},
//					},
//					&accessanalyzer.ArchiveRuleFilterArgs{
//						Criteria: pulumi.String("error"),
//						Exists:   pulumi.String("true"),
//					},
//					&accessanalyzer.ArchiveRuleFilterArgs{
//						Criteria: pulumi.String("isPublic"),
//						Eqs: pulumi.StringArray{
//							pulumi.String("false"),
//						},
//					},
//				},
//				RuleName: pulumi.String("example-rule"),
//			})
//			if err != nil {
//				return err
//			}
//			return nil
//		})
//	}
//
// ```
//
// ## Import
//
// AccessAnalyzer ArchiveRule can be imported using the `analyzer_name/rule_name`, e.g.,
//
// ```sh
//
//	$ pulumi import aws:accessanalyzer/archiveRule:ArchiveRule example example-analyzer/example-rule
//
// ```
type ArchiveRule struct {
	pulumi.CustomResourceState

	// Analyzer name.
	AnalyzerName pulumi.StringOutput `pulumi:"analyzerName"`
	// Filter criteria for the archive rule. See Filter for more details.
	Filters ArchiveRuleFilterArrayOutput `pulumi:"filters"`
	// Rule name.
	RuleName pulumi.StringOutput `pulumi:"ruleName"`
}

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

	if args.AnalyzerName == nil {
		return nil, errors.New("invalid value for required argument 'AnalyzerName'")
	}
	if args.Filters == nil {
		return nil, errors.New("invalid value for required argument 'Filters'")
	}
	if args.RuleName == nil {
		return nil, errors.New("invalid value for required argument 'RuleName'")
	}
	var resource ArchiveRule
	err := ctx.RegisterResource("aws:accessanalyzer/archiveRule:ArchiveRule", name, args, &resource, opts...)
	if err != nil {
		return nil, err
	}
	return &resource, nil
}

// GetArchiveRule gets an existing ArchiveRule 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 GetArchiveRule(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ArchiveRuleState, opts ...pulumi.ResourceOption) (*ArchiveRule, error) {
	var resource ArchiveRule
	err := ctx.ReadResource("aws:accessanalyzer/archiveRule:ArchiveRule", name, id, state, &resource, opts...)
	if err != nil {
		return nil, err
	}
	return &resource, nil
}

// Input properties used for looking up and filtering ArchiveRule resources.
type archiveRuleState struct {
	// Analyzer name.
	AnalyzerName *string `pulumi:"analyzerName"`
	// Filter criteria for the archive rule. See Filter for more details.
	Filters []ArchiveRuleFilter `pulumi:"filters"`
	// Rule name.
	RuleName *string `pulumi:"ruleName"`
}

type ArchiveRuleState struct {
	// Analyzer name.
	AnalyzerName pulumi.StringPtrInput
	// Filter criteria for the archive rule. See Filter for more details.
	Filters ArchiveRuleFilterArrayInput
	// Rule name.
	RuleName pulumi.StringPtrInput
}

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

type archiveRuleArgs struct {
	// Analyzer name.
	AnalyzerName string `pulumi:"analyzerName"`
	// Filter criteria for the archive rule. See Filter for more details.
	Filters []ArchiveRuleFilter `pulumi:"filters"`
	// Rule name.
	RuleName string `pulumi:"ruleName"`
}

// The set of arguments for constructing a ArchiveRule resource.
type ArchiveRuleArgs struct {
	// Analyzer name.
	AnalyzerName pulumi.StringInput
	// Filter criteria for the archive rule. See Filter for more details.
	Filters ArchiveRuleFilterArrayInput
	// Rule name.
	RuleName pulumi.StringInput
}

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

type ArchiveRuleInput interface {
	pulumi.Input

	ToArchiveRuleOutput() ArchiveRuleOutput
	ToArchiveRuleOutputWithContext(ctx context.Context) ArchiveRuleOutput
}

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

func (i *ArchiveRule) ToArchiveRuleOutput() ArchiveRuleOutput {
	return i.ToArchiveRuleOutputWithContext(context.Background())
}

func (i *ArchiveRule) ToArchiveRuleOutputWithContext(ctx context.Context) ArchiveRuleOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ArchiveRuleOutput)
}

// ArchiveRuleArrayInput is an input type that accepts ArchiveRuleArray and ArchiveRuleArrayOutput values.
// You can construct a concrete instance of `ArchiveRuleArrayInput` via:
//
//	ArchiveRuleArray{ ArchiveRuleArgs{...} }
type ArchiveRuleArrayInput interface {
	pulumi.Input

	ToArchiveRuleArrayOutput() ArchiveRuleArrayOutput
	ToArchiveRuleArrayOutputWithContext(context.Context) ArchiveRuleArrayOutput
}

type ArchiveRuleArray []ArchiveRuleInput

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

func (i ArchiveRuleArray) ToArchiveRuleArrayOutput() ArchiveRuleArrayOutput {
	return i.ToArchiveRuleArrayOutputWithContext(context.Background())
}

func (i ArchiveRuleArray) ToArchiveRuleArrayOutputWithContext(ctx context.Context) ArchiveRuleArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ArchiveRuleArrayOutput)
}

// ArchiveRuleMapInput is an input type that accepts ArchiveRuleMap and ArchiveRuleMapOutput values.
// You can construct a concrete instance of `ArchiveRuleMapInput` via:
//
//	ArchiveRuleMap{ "key": ArchiveRuleArgs{...} }
type ArchiveRuleMapInput interface {
	pulumi.Input

	ToArchiveRuleMapOutput() ArchiveRuleMapOutput
	ToArchiveRuleMapOutputWithContext(context.Context) ArchiveRuleMapOutput
}

type ArchiveRuleMap map[string]ArchiveRuleInput

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

func (i ArchiveRuleMap) ToArchiveRuleMapOutput() ArchiveRuleMapOutput {
	return i.ToArchiveRuleMapOutputWithContext(context.Background())
}

func (i ArchiveRuleMap) ToArchiveRuleMapOutputWithContext(ctx context.Context) ArchiveRuleMapOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ArchiveRuleMapOutput)
}

type ArchiveRuleOutput struct{ *pulumi.OutputState }

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

func (o ArchiveRuleOutput) ToArchiveRuleOutput() ArchiveRuleOutput {
	return o
}

func (o ArchiveRuleOutput) ToArchiveRuleOutputWithContext(ctx context.Context) ArchiveRuleOutput {
	return o
}

// Analyzer name.
func (o ArchiveRuleOutput) AnalyzerName() pulumi.StringOutput {
	return o.ApplyT(func(v *ArchiveRule) pulumi.StringOutput { return v.AnalyzerName }).(pulumi.StringOutput)
}

// Filter criteria for the archive rule. See Filter for more details.
func (o ArchiveRuleOutput) Filters() ArchiveRuleFilterArrayOutput {
	return o.ApplyT(func(v *ArchiveRule) ArchiveRuleFilterArrayOutput { return v.Filters }).(ArchiveRuleFilterArrayOutput)
}

// Rule name.
func (o ArchiveRuleOutput) RuleName() pulumi.StringOutput {
	return o.ApplyT(func(v *ArchiveRule) pulumi.StringOutput { return v.RuleName }).(pulumi.StringOutput)
}

type ArchiveRuleArrayOutput struct{ *pulumi.OutputState }

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

func (o ArchiveRuleArrayOutput) ToArchiveRuleArrayOutput() ArchiveRuleArrayOutput {
	return o
}

func (o ArchiveRuleArrayOutput) ToArchiveRuleArrayOutputWithContext(ctx context.Context) ArchiveRuleArrayOutput {
	return o
}

func (o ArchiveRuleArrayOutput) Index(i pulumi.IntInput) ArchiveRuleOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ArchiveRule {
		return vs[0].([]*ArchiveRule)[vs[1].(int)]
	}).(ArchiveRuleOutput)
}

type ArchiveRuleMapOutput struct{ *pulumi.OutputState }

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

func (o ArchiveRuleMapOutput) ToArchiveRuleMapOutput() ArchiveRuleMapOutput {
	return o
}

func (o ArchiveRuleMapOutput) ToArchiveRuleMapOutputWithContext(ctx context.Context) ArchiveRuleMapOutput {
	return o
}

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

func init() {
	pulumi.RegisterInputType(reflect.TypeOf((*ArchiveRuleInput)(nil)).Elem(), &ArchiveRule{})
	pulumi.RegisterInputType(reflect.TypeOf((*ArchiveRuleArrayInput)(nil)).Elem(), ArchiveRuleArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*ArchiveRuleMapInput)(nil)).Elem(), ArchiveRuleMap{})
	pulumi.RegisterOutputType(ArchiveRuleOutput{})
	pulumi.RegisterOutputType(ArchiveRuleArrayOutput{})
	pulumi.RegisterOutputType(ArchiveRuleMapOutput{})
}