accessanalyzer

package
v7.11.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Nov 5, 2025 License: Apache-2.0 Imports: 7 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type Analyzer 

type Analyzer struct {
	pulumi.CustomResourceState

	// Name of the Analyzer.
	//
	// The following arguments are optional:
	AnalyzerName pulumi.StringOutput `pulumi:"analyzerName"`
	// ARN of the Analyzer.
	Arn pulumi.StringOutput `pulumi:"arn"`
	// A block that specifies the configuration of the analyzer. See `configuration` Block for details.
	Configuration AnalyzerConfigurationPtrOutput `pulumi:"configuration"`
	// 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.StringOutput `pulumi:"region"`
	// Key-value map of resource tags. If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapOutput `pulumi:"tags"`
	// Map of tags assigned to the resource, including those inherited from the provider `defaultTags` configuration block.
	TagsAll pulumi.StringMapOutput `pulumi:"tagsAll"`
	// Type that represents the zone of trust or scope for the analyzer. Valid values are `ACCOUNT`, `ACCOUNT_INTERNAL_ACCESS`, `ACCOUNT_UNUSED_ACCESS`, `ORGANIZATION`, `ORGANIZATION_INTERNAL_ACCESS`, `ORGANIZATION_UNUSED_ACCESS`. Defaults to `ACCOUNT`.
	Type pulumi.StringPtrOutput `pulumi:"type"`
}

Manages an Access Analyzer Analyzer. More information can be found in the [Access Analyzer User Guide](https://docs.aws.amazon.com/IAM/latest/UserGuide/what-is-access-analyzer.html).

## Example Usage

### Account Analyzer

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/accessanalyzer"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := accessanalyzer.NewAnalyzer(ctx, "example", &accessanalyzer.AnalyzerArgs{
			AnalyzerName: pulumi.String("example"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

### Organization Analyzer

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/accessanalyzer"
"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/organizations"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := organizations.NewOrganization(ctx, "example", &organizations.OrganizationArgs{
			AwsServiceAccessPrincipals: pulumi.StringArray{
				pulumi.String("access-analyzer.amazonaws.com"),
			},
		})
		if err != nil {
			return err
		}
		_, err = accessanalyzer.NewAnalyzer(ctx, "example", &accessanalyzer.AnalyzerArgs{
			AnalyzerName: pulumi.String("example"),
			Type:         pulumi.String("ORGANIZATION"),
		}, pulumi.DependsOn([]pulumi.Resource{
			example,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}

```

### Organization Unused Access Analyzer With Analysis Rule

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/accessanalyzer"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := accessanalyzer.NewAnalyzer(ctx, "example", &accessanalyzer.AnalyzerArgs{
			AnalyzerName: pulumi.String("example"),
			Type:         pulumi.String("ORGANIZATION_UNUSED_ACCESS"),
			Configuration: &accessanalyzer.AnalyzerConfigurationArgs{
				UnusedAccess: &accessanalyzer.AnalyzerConfigurationUnusedAccessArgs{
					UnusedAccessAge: pulumi.Int(180),
					AnalysisRule: &accessanalyzer.AnalyzerConfigurationUnusedAccessAnalysisRuleArgs{
						Exclusions: accessanalyzer.AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionArray{
							&accessanalyzer.AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionArgs{
								AccountIds: pulumi.StringArray{
									pulumi.String("123456789012"),
									pulumi.String("234567890123"),
								},
							},
							&accessanalyzer.AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionArgs{
								ResourceTags: pulumi.StringMapArray{
									pulumi.StringMap{
										"key1": pulumi.String("value1"),
									},
									pulumi.StringMap{
										"key2": pulumi.String("value2"),
									},
								},
							},
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

### Account Internal Access Analyzer by Resource Types

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/accessanalyzer"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := accessanalyzer.NewAnalyzer(ctx, "test", &accessanalyzer.AnalyzerArgs{
			AnalyzerName: pulumi.String("example"),
			Type:         pulumi.String("ORGANIZATION_INTERNAL_ACCESS"),
			Configuration: &accessanalyzer.AnalyzerConfigurationArgs{
				InternalAccess: &accessanalyzer.AnalyzerConfigurationInternalAccessArgs{
					AnalysisRule: &accessanalyzer.AnalyzerConfigurationInternalAccessAnalysisRuleArgs{
						Inclusions: accessanalyzer.AnalyzerConfigurationInternalAccessAnalysisRuleInclusionArray{
							&accessanalyzer.AnalyzerConfigurationInternalAccessAnalysisRuleInclusionArgs{
								ResourceTypes: pulumi.StringArray{
									pulumi.String("AWS::S3::Bucket"),
									pulumi.String("AWS::RDS::DBSnapshot"),
									pulumi.String("AWS::DynamoDB::Table"),
								},
							},
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

### Organization Internal Access Analyzer by Account ID and Resource ARN

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/accessanalyzer"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := accessanalyzer.NewAnalyzer(ctx, "test", &accessanalyzer.AnalyzerArgs{
			AnalyzerName: pulumi.String("example"),
			Type:         pulumi.String("ORGANIZATION_INTERNAL_ACCESS"),
			Configuration: &accessanalyzer.AnalyzerConfigurationArgs{
				InternalAccess: &accessanalyzer.AnalyzerConfigurationInternalAccessArgs{
					AnalysisRule: &accessanalyzer.AnalyzerConfigurationInternalAccessAnalysisRuleArgs{
						Inclusions: accessanalyzer.AnalyzerConfigurationInternalAccessAnalysisRuleInclusionArray{
							&accessanalyzer.AnalyzerConfigurationInternalAccessAnalysisRuleInclusionArgs{
								AccountIds: pulumi.StringArray{
									pulumi.String("123456789012"),
								},
								ResourceArns: pulumi.StringArray{
									pulumi.String("arn:aws:s3:::my-example-bucket"),
								},
							},
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Using `pulumi import`, import Access Analyzer Analyzers using the `analyzer_name`. For example:

```sh $ pulumi import aws:accessanalyzer/analyzer:Analyzer example example ```

func GetAnalyzer 

func GetAnalyzer(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *AnalyzerState, opts ...pulumi.ResourceOption) (*Analyzer, error)

GetAnalyzer gets an existing Analyzer 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 NewAnalyzer 

func NewAnalyzer(ctx *pulumi.Context,
	name string, args *AnalyzerArgs, opts ...pulumi.ResourceOption) (*Analyzer, error)

NewAnalyzer registers a new resource with the given unique name, arguments, and options.

func (*Analyzer) ElementType 

func (*Analyzer) ElementType() reflect.Type

func (*Analyzer) ToAnalyzerOutput 

func (i *Analyzer) ToAnalyzerOutput() AnalyzerOutput

func (*Analyzer) ToAnalyzerOutputWithContext 

func (i *Analyzer) ToAnalyzerOutputWithContext(ctx context.Context) AnalyzerOutput

type AnalyzerArgs 

type AnalyzerArgs struct {
	// Name of the Analyzer.
	//
	// The following arguments are optional:
	AnalyzerName pulumi.StringInput
	// A block that specifies the configuration of the analyzer. See `configuration` Block for details.
	Configuration AnalyzerConfigurationPtrInput
	// 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.StringPtrInput
	// Key-value map of resource tags. If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapInput
	// Type that represents the zone of trust or scope for the analyzer. Valid values are `ACCOUNT`, `ACCOUNT_INTERNAL_ACCESS`, `ACCOUNT_UNUSED_ACCESS`, `ORGANIZATION`, `ORGANIZATION_INTERNAL_ACCESS`, `ORGANIZATION_UNUSED_ACCESS`. Defaults to `ACCOUNT`.
	Type pulumi.StringPtrInput
}

The set of arguments for constructing a Analyzer resource.

func (AnalyzerArgs) ElementType 

func (AnalyzerArgs) ElementType() reflect.Type

type AnalyzerArray 

type AnalyzerArray []AnalyzerInput

func (AnalyzerArray) ElementType 

func (AnalyzerArray) ElementType() reflect.Type

func (AnalyzerArray) ToAnalyzerArrayOutput 

func (i AnalyzerArray) ToAnalyzerArrayOutput() AnalyzerArrayOutput

func (AnalyzerArray) ToAnalyzerArrayOutputWithContext 

func (i AnalyzerArray) ToAnalyzerArrayOutputWithContext(ctx context.Context) AnalyzerArrayOutput

type AnalyzerArrayInput 

type AnalyzerArrayInput interface {
	pulumi.Input

	ToAnalyzerArrayOutput() AnalyzerArrayOutput
	ToAnalyzerArrayOutputWithContext(context.Context) AnalyzerArrayOutput
}

AnalyzerArrayInput is an input type that accepts AnalyzerArray and AnalyzerArrayOutput values. You can construct a concrete instance of `AnalyzerArrayInput` via: 

AnalyzerArray{ AnalyzerArgs{...} }

type AnalyzerArrayOutput 

type AnalyzerArrayOutput struct{ *pulumi.OutputState }

func (AnalyzerArrayOutput) ElementType 

func (AnalyzerArrayOutput) ElementType() reflect.Type

func (AnalyzerArrayOutput) Index 

func (o AnalyzerArrayOutput) Index(i pulumi.IntInput) AnalyzerOutput

func (AnalyzerArrayOutput) ToAnalyzerArrayOutput 

func (o AnalyzerArrayOutput) ToAnalyzerArrayOutput() AnalyzerArrayOutput

func (AnalyzerArrayOutput) ToAnalyzerArrayOutputWithContext 

func (o AnalyzerArrayOutput) ToAnalyzerArrayOutputWithContext(ctx context.Context) AnalyzerArrayOutput

type AnalyzerConfiguration 

type AnalyzerConfiguration struct {
	// Specifies the configuration of an internal access analyzer for an AWS organization or account. This configuration determines how the analyzer evaluates access within your AWS environment. See `internalAccess` Block for details.
	InternalAccess *AnalyzerConfigurationInternalAccess `pulumi:"internalAccess"`
	// Specifies the configuration of an unused access analyzer for an AWS organization or account. See `unusedAccess` Block for details.
	UnusedAccess *AnalyzerConfigurationUnusedAccess `pulumi:"unusedAccess"`
}

type AnalyzerConfigurationArgs 

type AnalyzerConfigurationArgs struct {
	// Specifies the configuration of an internal access analyzer for an AWS organization or account. This configuration determines how the analyzer evaluates access within your AWS environment. See `internalAccess` Block for details.
	InternalAccess AnalyzerConfigurationInternalAccessPtrInput `pulumi:"internalAccess"`
	// Specifies the configuration of an unused access analyzer for an AWS organization or account. See `unusedAccess` Block for details.
	UnusedAccess AnalyzerConfigurationUnusedAccessPtrInput `pulumi:"unusedAccess"`
}

func (AnalyzerConfigurationArgs) ElementType 

func (AnalyzerConfigurationArgs) ElementType() reflect.Type

func (AnalyzerConfigurationArgs) ToAnalyzerConfigurationOutput 

func (i AnalyzerConfigurationArgs) ToAnalyzerConfigurationOutput() AnalyzerConfigurationOutput

func (AnalyzerConfigurationArgs) ToAnalyzerConfigurationOutputWithContext 

func (i AnalyzerConfigurationArgs) ToAnalyzerConfigurationOutputWithContext(ctx context.Context) AnalyzerConfigurationOutput

func (AnalyzerConfigurationArgs) ToAnalyzerConfigurationPtrOutput 

func (i AnalyzerConfigurationArgs) ToAnalyzerConfigurationPtrOutput() AnalyzerConfigurationPtrOutput

func (AnalyzerConfigurationArgs) ToAnalyzerConfigurationPtrOutputWithContext 

func (i AnalyzerConfigurationArgs) ToAnalyzerConfigurationPtrOutputWithContext(ctx context.Context) AnalyzerConfigurationPtrOutput

type AnalyzerConfigurationInput 

type AnalyzerConfigurationInput interface {
	pulumi.Input

	ToAnalyzerConfigurationOutput() AnalyzerConfigurationOutput
	ToAnalyzerConfigurationOutputWithContext(context.Context) AnalyzerConfigurationOutput
}

AnalyzerConfigurationInput is an input type that accepts AnalyzerConfigurationArgs and AnalyzerConfigurationOutput values. You can construct a concrete instance of `AnalyzerConfigurationInput` via: 

AnalyzerConfigurationArgs{...}

type AnalyzerConfigurationInternalAccess 

type AnalyzerConfigurationInternalAccess struct {
	// Information about analysis rules for the internal access analyzer. These rules determine which resources and access patterns will be analyzed. See `analysisRule` Block for Internal Access Analyzer for details.
	AnalysisRule *AnalyzerConfigurationInternalAccessAnalysisRule `pulumi:"analysisRule"`
}

type AnalyzerConfigurationInternalAccessAnalysisRule 

type AnalyzerConfigurationInternalAccessAnalysisRule struct {
	// List of rules for the internal access analyzer containing criteria to include in analysis. Only resources that meet the rule criteria will generate findings. See `inclusion` Block for details.
	Inclusions []AnalyzerConfigurationInternalAccessAnalysisRuleInclusion `pulumi:"inclusions"`
}

type AnalyzerConfigurationInternalAccessAnalysisRuleArgs 

type AnalyzerConfigurationInternalAccessAnalysisRuleArgs struct {
	// List of rules for the internal access analyzer containing criteria to include in analysis. Only resources that meet the rule criteria will generate findings. See `inclusion` Block for details.
	Inclusions AnalyzerConfigurationInternalAccessAnalysisRuleInclusionArrayInput `pulumi:"inclusions"`
}

func (AnalyzerConfigurationInternalAccessAnalysisRuleArgs) ElementType 

func (AnalyzerConfigurationInternalAccessAnalysisRuleArgs) ElementType() reflect.Type

func (AnalyzerConfigurationInternalAccessAnalysisRuleArgs) ToAnalyzerConfigurationInternalAccessAnalysisRuleOutput 

func (i AnalyzerConfigurationInternalAccessAnalysisRuleArgs) ToAnalyzerConfigurationInternalAccessAnalysisRuleOutput() AnalyzerConfigurationInternalAccessAnalysisRuleOutput

func (AnalyzerConfigurationInternalAccessAnalysisRuleArgs) ToAnalyzerConfigurationInternalAccessAnalysisRuleOutputWithContext 

func (i AnalyzerConfigurationInternalAccessAnalysisRuleArgs) ToAnalyzerConfigurationInternalAccessAnalysisRuleOutputWithContext(ctx context.Context) AnalyzerConfigurationInternalAccessAnalysisRuleOutput

func (AnalyzerConfigurationInternalAccessAnalysisRuleArgs) ToAnalyzerConfigurationInternalAccessAnalysisRulePtrOutput 

func (i AnalyzerConfigurationInternalAccessAnalysisRuleArgs) ToAnalyzerConfigurationInternalAccessAnalysisRulePtrOutput() AnalyzerConfigurationInternalAccessAnalysisRulePtrOutput

func (AnalyzerConfigurationInternalAccessAnalysisRuleArgs) ToAnalyzerConfigurationInternalAccessAnalysisRulePtrOutputWithContext 

func (i AnalyzerConfigurationInternalAccessAnalysisRuleArgs) ToAnalyzerConfigurationInternalAccessAnalysisRulePtrOutputWithContext(ctx context.Context) AnalyzerConfigurationInternalAccessAnalysisRulePtrOutput

type AnalyzerConfigurationInternalAccessAnalysisRuleInclusion 

type AnalyzerConfigurationInternalAccessAnalysisRuleInclusion struct {
	// List of AWS account IDs to apply to the internal access analysis rule criteria. Account IDs can only be applied to the analysis rule criteria for organization-level analyzers.
	AccountIds []string `pulumi:"accountIds"`
	// List of resource ARNs to apply to the internal access analysis rule criteria. The analyzer will only generate findings for resources that match these ARNs.
	ResourceArns []string `pulumi:"resourceArns"`
	// List of resource types to apply to the internal access analysis rule criteria. The analyzer will only generate findings for resources of these types. Refer to [InternalAccessAnalysisRuleCriteria](https://docs.aws.amazon.com/access-analyzer/latest/APIReference/API_InternalAccessAnalysisRuleCriteria.html) in the AWS IAM Access Analyzer API Reference for valid values.
	ResourceTypes []string `pulumi:"resourceTypes"`
}

type AnalyzerConfigurationInternalAccessAnalysisRuleInclusionArgs 

type AnalyzerConfigurationInternalAccessAnalysisRuleInclusionArgs struct {
	// List of AWS account IDs to apply to the internal access analysis rule criteria. Account IDs can only be applied to the analysis rule criteria for organization-level analyzers.
	AccountIds pulumi.StringArrayInput `pulumi:"accountIds"`
	// List of resource ARNs to apply to the internal access analysis rule criteria. The analyzer will only generate findings for resources that match these ARNs.
	ResourceArns pulumi.StringArrayInput `pulumi:"resourceArns"`
	// List of resource types to apply to the internal access analysis rule criteria. The analyzer will only generate findings for resources of these types. Refer to [InternalAccessAnalysisRuleCriteria](https://docs.aws.amazon.com/access-analyzer/latest/APIReference/API_InternalAccessAnalysisRuleCriteria.html) in the AWS IAM Access Analyzer API Reference for valid values.
	ResourceTypes pulumi.StringArrayInput `pulumi:"resourceTypes"`
}

func (AnalyzerConfigurationInternalAccessAnalysisRuleInclusionArgs) ElementType 

func (AnalyzerConfigurationInternalAccessAnalysisRuleInclusionArgs) ElementType() reflect.Type

func (AnalyzerConfigurationInternalAccessAnalysisRuleInclusionArgs) ToAnalyzerConfigurationInternalAccessAnalysisRuleInclusionOutput 

func (i AnalyzerConfigurationInternalAccessAnalysisRuleInclusionArgs) ToAnalyzerConfigurationInternalAccessAnalysisRuleInclusionOutput() AnalyzerConfigurationInternalAccessAnalysisRuleInclusionOutput

func (AnalyzerConfigurationInternalAccessAnalysisRuleInclusionArgs) ToAnalyzerConfigurationInternalAccessAnalysisRuleInclusionOutputWithContext 

func (i AnalyzerConfigurationInternalAccessAnalysisRuleInclusionArgs) ToAnalyzerConfigurationInternalAccessAnalysisRuleInclusionOutputWithContext(ctx context.Context) AnalyzerConfigurationInternalAccessAnalysisRuleInclusionOutput

type AnalyzerConfigurationInternalAccessAnalysisRuleInclusionArray 

type AnalyzerConfigurationInternalAccessAnalysisRuleInclusionArray []AnalyzerConfigurationInternalAccessAnalysisRuleInclusionInput

func (AnalyzerConfigurationInternalAccessAnalysisRuleInclusionArray) ElementType 

func (AnalyzerConfigurationInternalAccessAnalysisRuleInclusionArray) ElementType() reflect.Type

func (AnalyzerConfigurationInternalAccessAnalysisRuleInclusionArray) ToAnalyzerConfigurationInternalAccessAnalysisRuleInclusionArrayOutput 

func (i AnalyzerConfigurationInternalAccessAnalysisRuleInclusionArray) ToAnalyzerConfigurationInternalAccessAnalysisRuleInclusionArrayOutput() AnalyzerConfigurationInternalAccessAnalysisRuleInclusionArrayOutput

func (AnalyzerConfigurationInternalAccessAnalysisRuleInclusionArray) ToAnalyzerConfigurationInternalAccessAnalysisRuleInclusionArrayOutputWithContext 

func (i AnalyzerConfigurationInternalAccessAnalysisRuleInclusionArray) ToAnalyzerConfigurationInternalAccessAnalysisRuleInclusionArrayOutputWithContext(ctx context.Context) AnalyzerConfigurationInternalAccessAnalysisRuleInclusionArrayOutput

type AnalyzerConfigurationInternalAccessAnalysisRuleInclusionArrayInput 

type AnalyzerConfigurationInternalAccessAnalysisRuleInclusionArrayInput interface {
	pulumi.Input

	ToAnalyzerConfigurationInternalAccessAnalysisRuleInclusionArrayOutput() AnalyzerConfigurationInternalAccessAnalysisRuleInclusionArrayOutput
	ToAnalyzerConfigurationInternalAccessAnalysisRuleInclusionArrayOutputWithContext(context.Context) AnalyzerConfigurationInternalAccessAnalysisRuleInclusionArrayOutput
}

AnalyzerConfigurationInternalAccessAnalysisRuleInclusionArrayInput is an input type that accepts AnalyzerConfigurationInternalAccessAnalysisRuleInclusionArray and AnalyzerConfigurationInternalAccessAnalysisRuleInclusionArrayOutput values. You can construct a concrete instance of `AnalyzerConfigurationInternalAccessAnalysisRuleInclusionArrayInput` via: 

AnalyzerConfigurationInternalAccessAnalysisRuleInclusionArray{ AnalyzerConfigurationInternalAccessAnalysisRuleInclusionArgs{...} }

type AnalyzerConfigurationInternalAccessAnalysisRuleInclusionArrayOutput 

type AnalyzerConfigurationInternalAccessAnalysisRuleInclusionArrayOutput struct{ *pulumi.OutputState }

func (AnalyzerConfigurationInternalAccessAnalysisRuleInclusionArrayOutput) ElementType 

func (AnalyzerConfigurationInternalAccessAnalysisRuleInclusionArrayOutput) ElementType() reflect.Type

func (AnalyzerConfigurationInternalAccessAnalysisRuleInclusionArrayOutput) Index 

func (o AnalyzerConfigurationInternalAccessAnalysisRuleInclusionArrayOutput) Index(i pulumi.IntInput) AnalyzerConfigurationInternalAccessAnalysisRuleInclusionOutput

func (AnalyzerConfigurationInternalAccessAnalysisRuleInclusionArrayOutput) ToAnalyzerConfigurationInternalAccessAnalysisRuleInclusionArrayOutput 

func (o AnalyzerConfigurationInternalAccessAnalysisRuleInclusionArrayOutput) ToAnalyzerConfigurationInternalAccessAnalysisRuleInclusionArrayOutput() AnalyzerConfigurationInternalAccessAnalysisRuleInclusionArrayOutput

func (AnalyzerConfigurationInternalAccessAnalysisRuleInclusionArrayOutput) ToAnalyzerConfigurationInternalAccessAnalysisRuleInclusionArrayOutputWithContext 

func (o AnalyzerConfigurationInternalAccessAnalysisRuleInclusionArrayOutput) ToAnalyzerConfigurationInternalAccessAnalysisRuleInclusionArrayOutputWithContext(ctx context.Context) AnalyzerConfigurationInternalAccessAnalysisRuleInclusionArrayOutput

type AnalyzerConfigurationInternalAccessAnalysisRuleInclusionInput 

type AnalyzerConfigurationInternalAccessAnalysisRuleInclusionInput interface {
	pulumi.Input

	ToAnalyzerConfigurationInternalAccessAnalysisRuleInclusionOutput() AnalyzerConfigurationInternalAccessAnalysisRuleInclusionOutput
	ToAnalyzerConfigurationInternalAccessAnalysisRuleInclusionOutputWithContext(context.Context) AnalyzerConfigurationInternalAccessAnalysisRuleInclusionOutput
}

AnalyzerConfigurationInternalAccessAnalysisRuleInclusionInput is an input type that accepts AnalyzerConfigurationInternalAccessAnalysisRuleInclusionArgs and AnalyzerConfigurationInternalAccessAnalysisRuleInclusionOutput values. You can construct a concrete instance of `AnalyzerConfigurationInternalAccessAnalysisRuleInclusionInput` via: 

AnalyzerConfigurationInternalAccessAnalysisRuleInclusionArgs{...}

type AnalyzerConfigurationInternalAccessAnalysisRuleInclusionOutput 

type AnalyzerConfigurationInternalAccessAnalysisRuleInclusionOutput struct{ *pulumi.OutputState }

func (AnalyzerConfigurationInternalAccessAnalysisRuleInclusionOutput) AccountIds 

func (o AnalyzerConfigurationInternalAccessAnalysisRuleInclusionOutput) AccountIds() pulumi.StringArrayOutput

List of AWS account IDs to apply to the internal access analysis rule criteria. Account IDs can only be applied to the analysis rule criteria for organization-level analyzers.

func (AnalyzerConfigurationInternalAccessAnalysisRuleInclusionOutput) ElementType 

func (AnalyzerConfigurationInternalAccessAnalysisRuleInclusionOutput) ElementType() reflect.Type

func (AnalyzerConfigurationInternalAccessAnalysisRuleInclusionOutput) ResourceArns 

func (o AnalyzerConfigurationInternalAccessAnalysisRuleInclusionOutput) ResourceArns() pulumi.StringArrayOutput

List of resource ARNs to apply to the internal access analysis rule criteria. The analyzer will only generate findings for resources that match these ARNs.

func (AnalyzerConfigurationInternalAccessAnalysisRuleInclusionOutput) ResourceTypes 

func (o AnalyzerConfigurationInternalAccessAnalysisRuleInclusionOutput) ResourceTypes() pulumi.StringArrayOutput

List of resource types to apply to the internal access analysis rule criteria. The analyzer will only generate findings for resources of these types. Refer to [InternalAccessAnalysisRuleCriteria](https://docs.aws.amazon.com/access-analyzer/latest/APIReference/API_InternalAccessAnalysisRuleCriteria.html) in the AWS IAM Access Analyzer API Reference for valid values.

func (AnalyzerConfigurationInternalAccessAnalysisRuleInclusionOutput) ToAnalyzerConfigurationInternalAccessAnalysisRuleInclusionOutput 

func (o AnalyzerConfigurationInternalAccessAnalysisRuleInclusionOutput) ToAnalyzerConfigurationInternalAccessAnalysisRuleInclusionOutput() AnalyzerConfigurationInternalAccessAnalysisRuleInclusionOutput

func (AnalyzerConfigurationInternalAccessAnalysisRuleInclusionOutput) ToAnalyzerConfigurationInternalAccessAnalysisRuleInclusionOutputWithContext 

func (o AnalyzerConfigurationInternalAccessAnalysisRuleInclusionOutput) ToAnalyzerConfigurationInternalAccessAnalysisRuleInclusionOutputWithContext(ctx context.Context) AnalyzerConfigurationInternalAccessAnalysisRuleInclusionOutput

type AnalyzerConfigurationInternalAccessAnalysisRuleInput 

type AnalyzerConfigurationInternalAccessAnalysisRuleInput interface {
	pulumi.Input

	ToAnalyzerConfigurationInternalAccessAnalysisRuleOutput() AnalyzerConfigurationInternalAccessAnalysisRuleOutput
	ToAnalyzerConfigurationInternalAccessAnalysisRuleOutputWithContext(context.Context) AnalyzerConfigurationInternalAccessAnalysisRuleOutput
}

AnalyzerConfigurationInternalAccessAnalysisRuleInput is an input type that accepts AnalyzerConfigurationInternalAccessAnalysisRuleArgs and AnalyzerConfigurationInternalAccessAnalysisRuleOutput values. You can construct a concrete instance of `AnalyzerConfigurationInternalAccessAnalysisRuleInput` via: 

AnalyzerConfigurationInternalAccessAnalysisRuleArgs{...}

type AnalyzerConfigurationInternalAccessAnalysisRuleOutput 

type AnalyzerConfigurationInternalAccessAnalysisRuleOutput struct{ *pulumi.OutputState }

func (AnalyzerConfigurationInternalAccessAnalysisRuleOutput) ElementType 

func (AnalyzerConfigurationInternalAccessAnalysisRuleOutput) ElementType() reflect.Type

func (AnalyzerConfigurationInternalAccessAnalysisRuleOutput) Inclusions 

func (o AnalyzerConfigurationInternalAccessAnalysisRuleOutput) Inclusions() AnalyzerConfigurationInternalAccessAnalysisRuleInclusionArrayOutput

List of rules for the internal access analyzer containing criteria to include in analysis. Only resources that meet the rule criteria will generate findings. See `inclusion` Block for details.

func (AnalyzerConfigurationInternalAccessAnalysisRuleOutput) ToAnalyzerConfigurationInternalAccessAnalysisRuleOutput 

func (o AnalyzerConfigurationInternalAccessAnalysisRuleOutput) ToAnalyzerConfigurationInternalAccessAnalysisRuleOutput() AnalyzerConfigurationInternalAccessAnalysisRuleOutput

func (AnalyzerConfigurationInternalAccessAnalysisRuleOutput) ToAnalyzerConfigurationInternalAccessAnalysisRuleOutputWithContext 

func (o AnalyzerConfigurationInternalAccessAnalysisRuleOutput) ToAnalyzerConfigurationInternalAccessAnalysisRuleOutputWithContext(ctx context.Context) AnalyzerConfigurationInternalAccessAnalysisRuleOutput

func (AnalyzerConfigurationInternalAccessAnalysisRuleOutput) ToAnalyzerConfigurationInternalAccessAnalysisRulePtrOutput 

func (o AnalyzerConfigurationInternalAccessAnalysisRuleOutput) ToAnalyzerConfigurationInternalAccessAnalysisRulePtrOutput() AnalyzerConfigurationInternalAccessAnalysisRulePtrOutput

func (AnalyzerConfigurationInternalAccessAnalysisRuleOutput) ToAnalyzerConfigurationInternalAccessAnalysisRulePtrOutputWithContext 

func (o AnalyzerConfigurationInternalAccessAnalysisRuleOutput) ToAnalyzerConfigurationInternalAccessAnalysisRulePtrOutputWithContext(ctx context.Context) AnalyzerConfigurationInternalAccessAnalysisRulePtrOutput

type AnalyzerConfigurationInternalAccessAnalysisRulePtrInput 

type AnalyzerConfigurationInternalAccessAnalysisRulePtrInput interface {
	pulumi.Input

	ToAnalyzerConfigurationInternalAccessAnalysisRulePtrOutput() AnalyzerConfigurationInternalAccessAnalysisRulePtrOutput
	ToAnalyzerConfigurationInternalAccessAnalysisRulePtrOutputWithContext(context.Context) AnalyzerConfigurationInternalAccessAnalysisRulePtrOutput
}

AnalyzerConfigurationInternalAccessAnalysisRulePtrInput is an input type that accepts AnalyzerConfigurationInternalAccessAnalysisRuleArgs, AnalyzerConfigurationInternalAccessAnalysisRulePtr and AnalyzerConfigurationInternalAccessAnalysisRulePtrOutput values. You can construct a concrete instance of `AnalyzerConfigurationInternalAccessAnalysisRulePtrInput` via: 

        AnalyzerConfigurationInternalAccessAnalysisRuleArgs{...}

or:

        nil

func AnalyzerConfigurationInternalAccessAnalysisRulePtr 

func AnalyzerConfigurationInternalAccessAnalysisRulePtr(v *AnalyzerConfigurationInternalAccessAnalysisRuleArgs) AnalyzerConfigurationInternalAccessAnalysisRulePtrInput

type AnalyzerConfigurationInternalAccessAnalysisRulePtrOutput 

type AnalyzerConfigurationInternalAccessAnalysisRulePtrOutput struct{ *pulumi.OutputState }

func (AnalyzerConfigurationInternalAccessAnalysisRulePtrOutput) Elem 

func (o AnalyzerConfigurationInternalAccessAnalysisRulePtrOutput) Elem() AnalyzerConfigurationInternalAccessAnalysisRuleOutput

func (AnalyzerConfigurationInternalAccessAnalysisRulePtrOutput) ElementType 

func (AnalyzerConfigurationInternalAccessAnalysisRulePtrOutput) ElementType() reflect.Type

func (AnalyzerConfigurationInternalAccessAnalysisRulePtrOutput) Inclusions 

func (o AnalyzerConfigurationInternalAccessAnalysisRulePtrOutput) Inclusions() AnalyzerConfigurationInternalAccessAnalysisRuleInclusionArrayOutput

List of rules for the internal access analyzer containing criteria to include in analysis. Only resources that meet the rule criteria will generate findings. See `inclusion` Block for details.

func (AnalyzerConfigurationInternalAccessAnalysisRulePtrOutput) ToAnalyzerConfigurationInternalAccessAnalysisRulePtrOutput 

func (o AnalyzerConfigurationInternalAccessAnalysisRulePtrOutput) ToAnalyzerConfigurationInternalAccessAnalysisRulePtrOutput() AnalyzerConfigurationInternalAccessAnalysisRulePtrOutput

func (AnalyzerConfigurationInternalAccessAnalysisRulePtrOutput) ToAnalyzerConfigurationInternalAccessAnalysisRulePtrOutputWithContext 

func (o AnalyzerConfigurationInternalAccessAnalysisRulePtrOutput) ToAnalyzerConfigurationInternalAccessAnalysisRulePtrOutputWithContext(ctx context.Context) AnalyzerConfigurationInternalAccessAnalysisRulePtrOutput

type AnalyzerConfigurationInternalAccessArgs 

type AnalyzerConfigurationInternalAccessArgs struct {
	// Information about analysis rules for the internal access analyzer. These rules determine which resources and access patterns will be analyzed. See `analysisRule` Block for Internal Access Analyzer for details.
	AnalysisRule AnalyzerConfigurationInternalAccessAnalysisRulePtrInput `pulumi:"analysisRule"`
}

func (AnalyzerConfigurationInternalAccessArgs) ElementType 

func (AnalyzerConfigurationInternalAccessArgs) ElementType() reflect.Type

func (AnalyzerConfigurationInternalAccessArgs) ToAnalyzerConfigurationInternalAccessOutput 

func (i AnalyzerConfigurationInternalAccessArgs) ToAnalyzerConfigurationInternalAccessOutput() AnalyzerConfigurationInternalAccessOutput

func (AnalyzerConfigurationInternalAccessArgs) ToAnalyzerConfigurationInternalAccessOutputWithContext 

func (i AnalyzerConfigurationInternalAccessArgs) ToAnalyzerConfigurationInternalAccessOutputWithContext(ctx context.Context) AnalyzerConfigurationInternalAccessOutput

func (AnalyzerConfigurationInternalAccessArgs) ToAnalyzerConfigurationInternalAccessPtrOutput 

func (i AnalyzerConfigurationInternalAccessArgs) ToAnalyzerConfigurationInternalAccessPtrOutput() AnalyzerConfigurationInternalAccessPtrOutput

func (AnalyzerConfigurationInternalAccessArgs) ToAnalyzerConfigurationInternalAccessPtrOutputWithContext 

func (i AnalyzerConfigurationInternalAccessArgs) ToAnalyzerConfigurationInternalAccessPtrOutputWithContext(ctx context.Context) AnalyzerConfigurationInternalAccessPtrOutput

type AnalyzerConfigurationInternalAccessInput 

type AnalyzerConfigurationInternalAccessInput interface {
	pulumi.Input

	ToAnalyzerConfigurationInternalAccessOutput() AnalyzerConfigurationInternalAccessOutput
	ToAnalyzerConfigurationInternalAccessOutputWithContext(context.Context) AnalyzerConfigurationInternalAccessOutput
}

AnalyzerConfigurationInternalAccessInput is an input type that accepts AnalyzerConfigurationInternalAccessArgs and AnalyzerConfigurationInternalAccessOutput values. You can construct a concrete instance of `AnalyzerConfigurationInternalAccessInput` via: 

AnalyzerConfigurationInternalAccessArgs{...}

type AnalyzerConfigurationInternalAccessOutput 

type AnalyzerConfigurationInternalAccessOutput struct{ *pulumi.OutputState }

func (AnalyzerConfigurationInternalAccessOutput) AnalysisRule 

func (o AnalyzerConfigurationInternalAccessOutput) AnalysisRule() AnalyzerConfigurationInternalAccessAnalysisRulePtrOutput

Information about analysis rules for the internal access analyzer. These rules determine which resources and access patterns will be analyzed. See `analysisRule` Block for Internal Access Analyzer for details.

func (AnalyzerConfigurationInternalAccessOutput) ElementType 

func (AnalyzerConfigurationInternalAccessOutput) ElementType() reflect.Type

func (AnalyzerConfigurationInternalAccessOutput) ToAnalyzerConfigurationInternalAccessOutput 

func (o AnalyzerConfigurationInternalAccessOutput) ToAnalyzerConfigurationInternalAccessOutput() AnalyzerConfigurationInternalAccessOutput

func (AnalyzerConfigurationInternalAccessOutput) ToAnalyzerConfigurationInternalAccessOutputWithContext 

func (o AnalyzerConfigurationInternalAccessOutput) ToAnalyzerConfigurationInternalAccessOutputWithContext(ctx context.Context) AnalyzerConfigurationInternalAccessOutput

func (AnalyzerConfigurationInternalAccessOutput) ToAnalyzerConfigurationInternalAccessPtrOutput 

func (o AnalyzerConfigurationInternalAccessOutput) ToAnalyzerConfigurationInternalAccessPtrOutput() AnalyzerConfigurationInternalAccessPtrOutput

func (AnalyzerConfigurationInternalAccessOutput) ToAnalyzerConfigurationInternalAccessPtrOutputWithContext 

func (o AnalyzerConfigurationInternalAccessOutput) ToAnalyzerConfigurationInternalAccessPtrOutputWithContext(ctx context.Context) AnalyzerConfigurationInternalAccessPtrOutput

type AnalyzerConfigurationInternalAccessPtrInput 

type AnalyzerConfigurationInternalAccessPtrInput interface {
	pulumi.Input

	ToAnalyzerConfigurationInternalAccessPtrOutput() AnalyzerConfigurationInternalAccessPtrOutput
	ToAnalyzerConfigurationInternalAccessPtrOutputWithContext(context.Context) AnalyzerConfigurationInternalAccessPtrOutput
}

AnalyzerConfigurationInternalAccessPtrInput is an input type that accepts AnalyzerConfigurationInternalAccessArgs, AnalyzerConfigurationInternalAccessPtr and AnalyzerConfigurationInternalAccessPtrOutput values. You can construct a concrete instance of `AnalyzerConfigurationInternalAccessPtrInput` via: 

        AnalyzerConfigurationInternalAccessArgs{...}

or:

        nil

func AnalyzerConfigurationInternalAccessPtr 

func AnalyzerConfigurationInternalAccessPtr(v *AnalyzerConfigurationInternalAccessArgs) AnalyzerConfigurationInternalAccessPtrInput

type AnalyzerConfigurationInternalAccessPtrOutput 

type AnalyzerConfigurationInternalAccessPtrOutput struct{ *pulumi.OutputState }

func (AnalyzerConfigurationInternalAccessPtrOutput) AnalysisRule 

func (o AnalyzerConfigurationInternalAccessPtrOutput) AnalysisRule() AnalyzerConfigurationInternalAccessAnalysisRulePtrOutput

Information about analysis rules for the internal access analyzer. These rules determine which resources and access patterns will be analyzed. See `analysisRule` Block for Internal Access Analyzer for details.

func (AnalyzerConfigurationInternalAccessPtrOutput) Elem 

func (o AnalyzerConfigurationInternalAccessPtrOutput) Elem() AnalyzerConfigurationInternalAccessOutput

func (AnalyzerConfigurationInternalAccessPtrOutput) ElementType 

func (AnalyzerConfigurationInternalAccessPtrOutput) ElementType() reflect.Type

func (AnalyzerConfigurationInternalAccessPtrOutput) ToAnalyzerConfigurationInternalAccessPtrOutput 

func (o AnalyzerConfigurationInternalAccessPtrOutput) ToAnalyzerConfigurationInternalAccessPtrOutput() AnalyzerConfigurationInternalAccessPtrOutput

func (AnalyzerConfigurationInternalAccessPtrOutput) ToAnalyzerConfigurationInternalAccessPtrOutputWithContext 

func (o AnalyzerConfigurationInternalAccessPtrOutput) ToAnalyzerConfigurationInternalAccessPtrOutputWithContext(ctx context.Context) AnalyzerConfigurationInternalAccessPtrOutput

type AnalyzerConfigurationOutput 

type AnalyzerConfigurationOutput struct{ *pulumi.OutputState }

func (AnalyzerConfigurationOutput) ElementType 

func (AnalyzerConfigurationOutput) ElementType() reflect.Type

func (AnalyzerConfigurationOutput) InternalAccess 

func (o AnalyzerConfigurationOutput) InternalAccess() AnalyzerConfigurationInternalAccessPtrOutput

Specifies the configuration of an internal access analyzer for an AWS organization or account. This configuration determines how the analyzer evaluates access within your AWS environment. See `internalAccess` Block for details.

func (AnalyzerConfigurationOutput) ToAnalyzerConfigurationOutput 

func (o AnalyzerConfigurationOutput) ToAnalyzerConfigurationOutput() AnalyzerConfigurationOutput

func (AnalyzerConfigurationOutput) ToAnalyzerConfigurationOutputWithContext 

func (o AnalyzerConfigurationOutput) ToAnalyzerConfigurationOutputWithContext(ctx context.Context) AnalyzerConfigurationOutput

func (AnalyzerConfigurationOutput) ToAnalyzerConfigurationPtrOutput 

func (o AnalyzerConfigurationOutput) ToAnalyzerConfigurationPtrOutput() AnalyzerConfigurationPtrOutput

func (AnalyzerConfigurationOutput) ToAnalyzerConfigurationPtrOutputWithContext 

func (o AnalyzerConfigurationOutput) ToAnalyzerConfigurationPtrOutputWithContext(ctx context.Context) AnalyzerConfigurationPtrOutput

func (AnalyzerConfigurationOutput) UnusedAccess 

func (o AnalyzerConfigurationOutput) UnusedAccess() AnalyzerConfigurationUnusedAccessPtrOutput

Specifies the configuration of an unused access analyzer for an AWS organization or account. See `unusedAccess` Block for details.

type AnalyzerConfigurationPtrInput 

type AnalyzerConfigurationPtrInput interface {
	pulumi.Input

	ToAnalyzerConfigurationPtrOutput() AnalyzerConfigurationPtrOutput
	ToAnalyzerConfigurationPtrOutputWithContext(context.Context) AnalyzerConfigurationPtrOutput
}

AnalyzerConfigurationPtrInput is an input type that accepts AnalyzerConfigurationArgs, AnalyzerConfigurationPtr and AnalyzerConfigurationPtrOutput values. You can construct a concrete instance of `AnalyzerConfigurationPtrInput` via: 

        AnalyzerConfigurationArgs{...}

or:

        nil

func AnalyzerConfigurationPtr 

func AnalyzerConfigurationPtr(v *AnalyzerConfigurationArgs) AnalyzerConfigurationPtrInput

type AnalyzerConfigurationPtrOutput 

type AnalyzerConfigurationPtrOutput struct{ *pulumi.OutputState }

func (AnalyzerConfigurationPtrOutput) Elem 

func (o AnalyzerConfigurationPtrOutput) Elem() AnalyzerConfigurationOutput

func (AnalyzerConfigurationPtrOutput) ElementType 

func (AnalyzerConfigurationPtrOutput) ElementType() reflect.Type

func (AnalyzerConfigurationPtrOutput) InternalAccess 

func (o AnalyzerConfigurationPtrOutput) InternalAccess() AnalyzerConfigurationInternalAccessPtrOutput

Specifies the configuration of an internal access analyzer for an AWS organization or account. This configuration determines how the analyzer evaluates access within your AWS environment. See `internalAccess` Block for details.

func (AnalyzerConfigurationPtrOutput) ToAnalyzerConfigurationPtrOutput 

func (o AnalyzerConfigurationPtrOutput) ToAnalyzerConfigurationPtrOutput() AnalyzerConfigurationPtrOutput

func (AnalyzerConfigurationPtrOutput) ToAnalyzerConfigurationPtrOutputWithContext 

func (o AnalyzerConfigurationPtrOutput) ToAnalyzerConfigurationPtrOutputWithContext(ctx context.Context) AnalyzerConfigurationPtrOutput

func (AnalyzerConfigurationPtrOutput) UnusedAccess 

func (o AnalyzerConfigurationPtrOutput) UnusedAccess() AnalyzerConfigurationUnusedAccessPtrOutput

Specifies the configuration of an unused access analyzer for an AWS organization or account. See `unusedAccess` Block for details.

type AnalyzerConfigurationUnusedAccess 

type AnalyzerConfigurationUnusedAccess struct {
	// Information about analysis rules for the analyzer. Analysis rules determine which entities will generate findings based on the criteria you define when you create the rule. See `analysisRule` Block for Unused Access Analyzer for details.
	AnalysisRule *AnalyzerConfigurationUnusedAccessAnalysisRule `pulumi:"analysisRule"`
	// Specified access age in days for which to generate findings for unused access.
	UnusedAccessAge *int `pulumi:"unusedAccessAge"`
}

type AnalyzerConfigurationUnusedAccessAnalysisRule 

type AnalyzerConfigurationUnusedAccessAnalysisRule struct {
	// List of rules for the analyzer containing criteria to exclude from analysis. Entities that meet the rule criteria will not generate findings. See `exclusion` Block for details.
	Exclusions []AnalyzerConfigurationUnusedAccessAnalysisRuleExclusion `pulumi:"exclusions"`
}

type AnalyzerConfigurationUnusedAccessAnalysisRuleArgs 

type AnalyzerConfigurationUnusedAccessAnalysisRuleArgs struct {
	// List of rules for the analyzer containing criteria to exclude from analysis. Entities that meet the rule criteria will not generate findings. See `exclusion` Block for details.
	Exclusions AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionArrayInput `pulumi:"exclusions"`
}

func (AnalyzerConfigurationUnusedAccessAnalysisRuleArgs) ElementType 

func (AnalyzerConfigurationUnusedAccessAnalysisRuleArgs) ElementType() reflect.Type

func (AnalyzerConfigurationUnusedAccessAnalysisRuleArgs) ToAnalyzerConfigurationUnusedAccessAnalysisRuleOutput 

func (i AnalyzerConfigurationUnusedAccessAnalysisRuleArgs) ToAnalyzerConfigurationUnusedAccessAnalysisRuleOutput() AnalyzerConfigurationUnusedAccessAnalysisRuleOutput

func (AnalyzerConfigurationUnusedAccessAnalysisRuleArgs) ToAnalyzerConfigurationUnusedAccessAnalysisRuleOutputWithContext 

func (i AnalyzerConfigurationUnusedAccessAnalysisRuleArgs) ToAnalyzerConfigurationUnusedAccessAnalysisRuleOutputWithContext(ctx context.Context) AnalyzerConfigurationUnusedAccessAnalysisRuleOutput

func (AnalyzerConfigurationUnusedAccessAnalysisRuleArgs) ToAnalyzerConfigurationUnusedAccessAnalysisRulePtrOutput 

func (i AnalyzerConfigurationUnusedAccessAnalysisRuleArgs) ToAnalyzerConfigurationUnusedAccessAnalysisRulePtrOutput() AnalyzerConfigurationUnusedAccessAnalysisRulePtrOutput

func (AnalyzerConfigurationUnusedAccessAnalysisRuleArgs) ToAnalyzerConfigurationUnusedAccessAnalysisRulePtrOutputWithContext 

func (i AnalyzerConfigurationUnusedAccessAnalysisRuleArgs) ToAnalyzerConfigurationUnusedAccessAnalysisRulePtrOutputWithContext(ctx context.Context) AnalyzerConfigurationUnusedAccessAnalysisRulePtrOutput

type AnalyzerConfigurationUnusedAccessAnalysisRuleExclusion 

type AnalyzerConfigurationUnusedAccessAnalysisRuleExclusion struct {
	// List of AWS account IDs to apply to the analysis rule criteria. The accounts cannot include the organization analyzer owner account. Account IDs can only be applied to the analysis rule criteria for organization-level analyzers.
	AccountIds []string `pulumi:"accountIds"`
	// List of key-value pairs for resource tags to exclude from the analysis.
	ResourceTags []map[string]string `pulumi:"resourceTags"`
}

type AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionArgs 

type AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionArgs struct {
	// List of AWS account IDs to apply to the analysis rule criteria. The accounts cannot include the organization analyzer owner account. Account IDs can only be applied to the analysis rule criteria for organization-level analyzers.
	AccountIds pulumi.StringArrayInput `pulumi:"accountIds"`
	// List of key-value pairs for resource tags to exclude from the analysis.
	ResourceTags pulumi.StringMapArrayInput `pulumi:"resourceTags"`
}

func (AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionArgs) ElementType 

func (AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionArgs) ElementType() reflect.Type

func (AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionArgs) ToAnalyzerConfigurationUnusedAccessAnalysisRuleExclusionOutput 

func (i AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionArgs) ToAnalyzerConfigurationUnusedAccessAnalysisRuleExclusionOutput() AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionOutput

func (AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionArgs) ToAnalyzerConfigurationUnusedAccessAnalysisRuleExclusionOutputWithContext 

func (i AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionArgs) ToAnalyzerConfigurationUnusedAccessAnalysisRuleExclusionOutputWithContext(ctx context.Context) AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionOutput

type AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionArray 

type AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionArray []AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionInput

func (AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionArray) ElementType 

func (AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionArray) ElementType() reflect.Type

func (AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionArray) ToAnalyzerConfigurationUnusedAccessAnalysisRuleExclusionArrayOutput 

func (i AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionArray) ToAnalyzerConfigurationUnusedAccessAnalysisRuleExclusionArrayOutput() AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionArrayOutput

func (AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionArray) ToAnalyzerConfigurationUnusedAccessAnalysisRuleExclusionArrayOutputWithContext 

func (i AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionArray) ToAnalyzerConfigurationUnusedAccessAnalysisRuleExclusionArrayOutputWithContext(ctx context.Context) AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionArrayOutput

type AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionArrayInput 

type AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionArrayInput interface {
	pulumi.Input

	ToAnalyzerConfigurationUnusedAccessAnalysisRuleExclusionArrayOutput() AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionArrayOutput
	ToAnalyzerConfigurationUnusedAccessAnalysisRuleExclusionArrayOutputWithContext(context.Context) AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionArrayOutput
}

AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionArrayInput is an input type that accepts AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionArray and AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionArrayOutput values. You can construct a concrete instance of `AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionArrayInput` via: 

AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionArray{ AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionArgs{...} }

type AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionArrayOutput 

type AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionArrayOutput struct{ *pulumi.OutputState }

func (AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionArrayOutput) ElementType 

func (AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionArrayOutput) ElementType() reflect.Type

func (AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionArrayOutput) Index 

func (o AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionArrayOutput) Index(i pulumi.IntInput) AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionOutput

func (AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionArrayOutput) ToAnalyzerConfigurationUnusedAccessAnalysisRuleExclusionArrayOutput 

func (o AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionArrayOutput) ToAnalyzerConfigurationUnusedAccessAnalysisRuleExclusionArrayOutput() AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionArrayOutput

func (AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionArrayOutput) ToAnalyzerConfigurationUnusedAccessAnalysisRuleExclusionArrayOutputWithContext 

func (o AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionArrayOutput) ToAnalyzerConfigurationUnusedAccessAnalysisRuleExclusionArrayOutputWithContext(ctx context.Context) AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionArrayOutput

type AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionInput 

type AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionInput interface {
	pulumi.Input

	ToAnalyzerConfigurationUnusedAccessAnalysisRuleExclusionOutput() AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionOutput
	ToAnalyzerConfigurationUnusedAccessAnalysisRuleExclusionOutputWithContext(context.Context) AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionOutput
}

AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionInput is an input type that accepts AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionArgs and AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionOutput values. You can construct a concrete instance of `AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionInput` via: 

AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionArgs{...}

type AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionOutput 

type AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionOutput struct{ *pulumi.OutputState }

func (AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionOutput) AccountIds 

func (o AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionOutput) AccountIds() pulumi.StringArrayOutput

List of AWS account IDs to apply to the analysis rule criteria. The accounts cannot include the organization analyzer owner account. Account IDs can only be applied to the analysis rule criteria for organization-level analyzers.

func (AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionOutput) ElementType 

func (AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionOutput) ElementType() reflect.Type

func (AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionOutput) ResourceTags 

func (o AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionOutput) ResourceTags() pulumi.StringMapArrayOutput

List of key-value pairs for resource tags to exclude from the analysis.

func (AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionOutput) ToAnalyzerConfigurationUnusedAccessAnalysisRuleExclusionOutput 

func (o AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionOutput) ToAnalyzerConfigurationUnusedAccessAnalysisRuleExclusionOutput() AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionOutput

func (AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionOutput) ToAnalyzerConfigurationUnusedAccessAnalysisRuleExclusionOutputWithContext 

func (o AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionOutput) ToAnalyzerConfigurationUnusedAccessAnalysisRuleExclusionOutputWithContext(ctx context.Context) AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionOutput

type AnalyzerConfigurationUnusedAccessAnalysisRuleInput 

type AnalyzerConfigurationUnusedAccessAnalysisRuleInput interface {
	pulumi.Input

	ToAnalyzerConfigurationUnusedAccessAnalysisRuleOutput() AnalyzerConfigurationUnusedAccessAnalysisRuleOutput
	ToAnalyzerConfigurationUnusedAccessAnalysisRuleOutputWithContext(context.Context) AnalyzerConfigurationUnusedAccessAnalysisRuleOutput
}

AnalyzerConfigurationUnusedAccessAnalysisRuleInput is an input type that accepts AnalyzerConfigurationUnusedAccessAnalysisRuleArgs and AnalyzerConfigurationUnusedAccessAnalysisRuleOutput values. You can construct a concrete instance of `AnalyzerConfigurationUnusedAccessAnalysisRuleInput` via: 

AnalyzerConfigurationUnusedAccessAnalysisRuleArgs{...}

type AnalyzerConfigurationUnusedAccessAnalysisRuleOutput 

type AnalyzerConfigurationUnusedAccessAnalysisRuleOutput struct{ *pulumi.OutputState }

func (AnalyzerConfigurationUnusedAccessAnalysisRuleOutput) ElementType 

func (AnalyzerConfigurationUnusedAccessAnalysisRuleOutput) ElementType() reflect.Type

func (AnalyzerConfigurationUnusedAccessAnalysisRuleOutput) Exclusions 

func (o AnalyzerConfigurationUnusedAccessAnalysisRuleOutput) Exclusions() AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionArrayOutput

List of rules for the analyzer containing criteria to exclude from analysis. Entities that meet the rule criteria will not generate findings. See `exclusion` Block for details.

func (AnalyzerConfigurationUnusedAccessAnalysisRuleOutput) ToAnalyzerConfigurationUnusedAccessAnalysisRuleOutput 

func (o AnalyzerConfigurationUnusedAccessAnalysisRuleOutput) ToAnalyzerConfigurationUnusedAccessAnalysisRuleOutput() AnalyzerConfigurationUnusedAccessAnalysisRuleOutput

func (AnalyzerConfigurationUnusedAccessAnalysisRuleOutput) ToAnalyzerConfigurationUnusedAccessAnalysisRuleOutputWithContext 

func (o AnalyzerConfigurationUnusedAccessAnalysisRuleOutput) ToAnalyzerConfigurationUnusedAccessAnalysisRuleOutputWithContext(ctx context.Context) AnalyzerConfigurationUnusedAccessAnalysisRuleOutput

func (AnalyzerConfigurationUnusedAccessAnalysisRuleOutput) ToAnalyzerConfigurationUnusedAccessAnalysisRulePtrOutput 

func (o AnalyzerConfigurationUnusedAccessAnalysisRuleOutput) ToAnalyzerConfigurationUnusedAccessAnalysisRulePtrOutput() AnalyzerConfigurationUnusedAccessAnalysisRulePtrOutput

func (AnalyzerConfigurationUnusedAccessAnalysisRuleOutput) ToAnalyzerConfigurationUnusedAccessAnalysisRulePtrOutputWithContext 

func (o AnalyzerConfigurationUnusedAccessAnalysisRuleOutput) ToAnalyzerConfigurationUnusedAccessAnalysisRulePtrOutputWithContext(ctx context.Context) AnalyzerConfigurationUnusedAccessAnalysisRulePtrOutput

type AnalyzerConfigurationUnusedAccessAnalysisRulePtrInput 

type AnalyzerConfigurationUnusedAccessAnalysisRulePtrInput interface {
	pulumi.Input

	ToAnalyzerConfigurationUnusedAccessAnalysisRulePtrOutput() AnalyzerConfigurationUnusedAccessAnalysisRulePtrOutput
	ToAnalyzerConfigurationUnusedAccessAnalysisRulePtrOutputWithContext(context.Context) AnalyzerConfigurationUnusedAccessAnalysisRulePtrOutput
}

AnalyzerConfigurationUnusedAccessAnalysisRulePtrInput is an input type that accepts AnalyzerConfigurationUnusedAccessAnalysisRuleArgs, AnalyzerConfigurationUnusedAccessAnalysisRulePtr and AnalyzerConfigurationUnusedAccessAnalysisRulePtrOutput values. You can construct a concrete instance of `AnalyzerConfigurationUnusedAccessAnalysisRulePtrInput` via: 

        AnalyzerConfigurationUnusedAccessAnalysisRuleArgs{...}

or:

        nil

func AnalyzerConfigurationUnusedAccessAnalysisRulePtr 

func AnalyzerConfigurationUnusedAccessAnalysisRulePtr(v *AnalyzerConfigurationUnusedAccessAnalysisRuleArgs) AnalyzerConfigurationUnusedAccessAnalysisRulePtrInput

type AnalyzerConfigurationUnusedAccessAnalysisRulePtrOutput 

type AnalyzerConfigurationUnusedAccessAnalysisRulePtrOutput struct{ *pulumi.OutputState }

func (AnalyzerConfigurationUnusedAccessAnalysisRulePtrOutput) Elem 

func (o AnalyzerConfigurationUnusedAccessAnalysisRulePtrOutput) Elem() AnalyzerConfigurationUnusedAccessAnalysisRuleOutput

func (AnalyzerConfigurationUnusedAccessAnalysisRulePtrOutput) ElementType 

func (AnalyzerConfigurationUnusedAccessAnalysisRulePtrOutput) ElementType() reflect.Type

func (AnalyzerConfigurationUnusedAccessAnalysisRulePtrOutput) Exclusions 

func (o AnalyzerConfigurationUnusedAccessAnalysisRulePtrOutput) Exclusions() AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionArrayOutput

List of rules for the analyzer containing criteria to exclude from analysis. Entities that meet the rule criteria will not generate findings. See `exclusion` Block for details.

func (AnalyzerConfigurationUnusedAccessAnalysisRulePtrOutput) ToAnalyzerConfigurationUnusedAccessAnalysisRulePtrOutput 

func (o AnalyzerConfigurationUnusedAccessAnalysisRulePtrOutput) ToAnalyzerConfigurationUnusedAccessAnalysisRulePtrOutput() AnalyzerConfigurationUnusedAccessAnalysisRulePtrOutput

func (AnalyzerConfigurationUnusedAccessAnalysisRulePtrOutput) ToAnalyzerConfigurationUnusedAccessAnalysisRulePtrOutputWithContext 

func (o AnalyzerConfigurationUnusedAccessAnalysisRulePtrOutput) ToAnalyzerConfigurationUnusedAccessAnalysisRulePtrOutputWithContext(ctx context.Context) AnalyzerConfigurationUnusedAccessAnalysisRulePtrOutput

type AnalyzerConfigurationUnusedAccessArgs 

type AnalyzerConfigurationUnusedAccessArgs struct {
	// Information about analysis rules for the analyzer. Analysis rules determine which entities will generate findings based on the criteria you define when you create the rule. See `analysisRule` Block for Unused Access Analyzer for details.
	AnalysisRule AnalyzerConfigurationUnusedAccessAnalysisRulePtrInput `pulumi:"analysisRule"`
	// Specified access age in days for which to generate findings for unused access.
	UnusedAccessAge pulumi.IntPtrInput `pulumi:"unusedAccessAge"`
}

func (AnalyzerConfigurationUnusedAccessArgs) ElementType 

func (AnalyzerConfigurationUnusedAccessArgs) ElementType() reflect.Type

func (AnalyzerConfigurationUnusedAccessArgs) ToAnalyzerConfigurationUnusedAccessOutput 

func (i AnalyzerConfigurationUnusedAccessArgs) ToAnalyzerConfigurationUnusedAccessOutput() AnalyzerConfigurationUnusedAccessOutput

func (AnalyzerConfigurationUnusedAccessArgs) ToAnalyzerConfigurationUnusedAccessOutputWithContext 

func (i AnalyzerConfigurationUnusedAccessArgs) ToAnalyzerConfigurationUnusedAccessOutputWithContext(ctx context.Context) AnalyzerConfigurationUnusedAccessOutput

func (AnalyzerConfigurationUnusedAccessArgs) ToAnalyzerConfigurationUnusedAccessPtrOutput 

func (i AnalyzerConfigurationUnusedAccessArgs) ToAnalyzerConfigurationUnusedAccessPtrOutput() AnalyzerConfigurationUnusedAccessPtrOutput

func (AnalyzerConfigurationUnusedAccessArgs) ToAnalyzerConfigurationUnusedAccessPtrOutputWithContext 

func (i AnalyzerConfigurationUnusedAccessArgs) ToAnalyzerConfigurationUnusedAccessPtrOutputWithContext(ctx context.Context) AnalyzerConfigurationUnusedAccessPtrOutput

type AnalyzerConfigurationUnusedAccessInput 

type AnalyzerConfigurationUnusedAccessInput interface {
	pulumi.Input

	ToAnalyzerConfigurationUnusedAccessOutput() AnalyzerConfigurationUnusedAccessOutput
	ToAnalyzerConfigurationUnusedAccessOutputWithContext(context.Context) AnalyzerConfigurationUnusedAccessOutput
}

AnalyzerConfigurationUnusedAccessInput is an input type that accepts AnalyzerConfigurationUnusedAccessArgs and AnalyzerConfigurationUnusedAccessOutput values. You can construct a concrete instance of `AnalyzerConfigurationUnusedAccessInput` via: 

AnalyzerConfigurationUnusedAccessArgs{...}

type AnalyzerConfigurationUnusedAccessOutput 

type AnalyzerConfigurationUnusedAccessOutput struct{ *pulumi.OutputState }

func (AnalyzerConfigurationUnusedAccessOutput) AnalysisRule 

func (o AnalyzerConfigurationUnusedAccessOutput) AnalysisRule() AnalyzerConfigurationUnusedAccessAnalysisRulePtrOutput

Information about analysis rules for the analyzer. Analysis rules determine which entities will generate findings based on the criteria you define when you create the rule. See `analysisRule` Block for Unused Access Analyzer for details.

func (AnalyzerConfigurationUnusedAccessOutput) ElementType 

func (AnalyzerConfigurationUnusedAccessOutput) ElementType() reflect.Type

func (AnalyzerConfigurationUnusedAccessOutput) ToAnalyzerConfigurationUnusedAccessOutput 

func (o AnalyzerConfigurationUnusedAccessOutput) ToAnalyzerConfigurationUnusedAccessOutput() AnalyzerConfigurationUnusedAccessOutput

func (AnalyzerConfigurationUnusedAccessOutput) ToAnalyzerConfigurationUnusedAccessOutputWithContext 

func (o AnalyzerConfigurationUnusedAccessOutput) ToAnalyzerConfigurationUnusedAccessOutputWithContext(ctx context.Context) AnalyzerConfigurationUnusedAccessOutput

func (AnalyzerConfigurationUnusedAccessOutput) ToAnalyzerConfigurationUnusedAccessPtrOutput 

func (o AnalyzerConfigurationUnusedAccessOutput) ToAnalyzerConfigurationUnusedAccessPtrOutput() AnalyzerConfigurationUnusedAccessPtrOutput

func (AnalyzerConfigurationUnusedAccessOutput) ToAnalyzerConfigurationUnusedAccessPtrOutputWithContext 

func (o AnalyzerConfigurationUnusedAccessOutput) ToAnalyzerConfigurationUnusedAccessPtrOutputWithContext(ctx context.Context) AnalyzerConfigurationUnusedAccessPtrOutput

func (AnalyzerConfigurationUnusedAccessOutput) UnusedAccessAge 

func (o AnalyzerConfigurationUnusedAccessOutput) UnusedAccessAge() pulumi.IntPtrOutput

Specified access age in days for which to generate findings for unused access.

type AnalyzerConfigurationUnusedAccessPtrInput 

type AnalyzerConfigurationUnusedAccessPtrInput interface {
	pulumi.Input

	ToAnalyzerConfigurationUnusedAccessPtrOutput() AnalyzerConfigurationUnusedAccessPtrOutput
	ToAnalyzerConfigurationUnusedAccessPtrOutputWithContext(context.Context) AnalyzerConfigurationUnusedAccessPtrOutput
}

AnalyzerConfigurationUnusedAccessPtrInput is an input type that accepts AnalyzerConfigurationUnusedAccessArgs, AnalyzerConfigurationUnusedAccessPtr and AnalyzerConfigurationUnusedAccessPtrOutput values. You can construct a concrete instance of `AnalyzerConfigurationUnusedAccessPtrInput` via: 

        AnalyzerConfigurationUnusedAccessArgs{...}

or:

        nil

func AnalyzerConfigurationUnusedAccessPtr 

func AnalyzerConfigurationUnusedAccessPtr(v *AnalyzerConfigurationUnusedAccessArgs) AnalyzerConfigurationUnusedAccessPtrInput

type AnalyzerConfigurationUnusedAccessPtrOutput 

type AnalyzerConfigurationUnusedAccessPtrOutput struct{ *pulumi.OutputState }

func (AnalyzerConfigurationUnusedAccessPtrOutput) AnalysisRule 

func (o AnalyzerConfigurationUnusedAccessPtrOutput) AnalysisRule() AnalyzerConfigurationUnusedAccessAnalysisRulePtrOutput

Information about analysis rules for the analyzer. Analysis rules determine which entities will generate findings based on the criteria you define when you create the rule. See `analysisRule` Block for Unused Access Analyzer for details.

func (AnalyzerConfigurationUnusedAccessPtrOutput) Elem 

func (o AnalyzerConfigurationUnusedAccessPtrOutput) Elem() AnalyzerConfigurationUnusedAccessOutput

func (AnalyzerConfigurationUnusedAccessPtrOutput) ElementType 

func (AnalyzerConfigurationUnusedAccessPtrOutput) ElementType() reflect.Type

func (AnalyzerConfigurationUnusedAccessPtrOutput) ToAnalyzerConfigurationUnusedAccessPtrOutput 

func (o AnalyzerConfigurationUnusedAccessPtrOutput) ToAnalyzerConfigurationUnusedAccessPtrOutput() AnalyzerConfigurationUnusedAccessPtrOutput

func (AnalyzerConfigurationUnusedAccessPtrOutput) ToAnalyzerConfigurationUnusedAccessPtrOutputWithContext 

func (o AnalyzerConfigurationUnusedAccessPtrOutput) ToAnalyzerConfigurationUnusedAccessPtrOutputWithContext(ctx context.Context) AnalyzerConfigurationUnusedAccessPtrOutput

func (AnalyzerConfigurationUnusedAccessPtrOutput) UnusedAccessAge 

func (o AnalyzerConfigurationUnusedAccessPtrOutput) UnusedAccessAge() pulumi.IntPtrOutput

Specified access age in days for which to generate findings for unused access.

type AnalyzerInput 

type AnalyzerInput interface {
	pulumi.Input

	ToAnalyzerOutput() AnalyzerOutput
	ToAnalyzerOutputWithContext(ctx context.Context) AnalyzerOutput
}

type AnalyzerMap 

type AnalyzerMap map[string]AnalyzerInput

func (AnalyzerMap) ElementType 

func (AnalyzerMap) ElementType() reflect.Type

func (AnalyzerMap) ToAnalyzerMapOutput 

func (i AnalyzerMap) ToAnalyzerMapOutput() AnalyzerMapOutput

func (AnalyzerMap) ToAnalyzerMapOutputWithContext 

func (i AnalyzerMap) ToAnalyzerMapOutputWithContext(ctx context.Context) AnalyzerMapOutput

type AnalyzerMapInput 

type AnalyzerMapInput interface {
	pulumi.Input

	ToAnalyzerMapOutput() AnalyzerMapOutput
	ToAnalyzerMapOutputWithContext(context.Context) AnalyzerMapOutput
}

AnalyzerMapInput is an input type that accepts AnalyzerMap and AnalyzerMapOutput values. You can construct a concrete instance of `AnalyzerMapInput` via: 

AnalyzerMap{ "key": AnalyzerArgs{...} }

type AnalyzerMapOutput 

type AnalyzerMapOutput struct{ *pulumi.OutputState }

func (AnalyzerMapOutput) ElementType 

func (AnalyzerMapOutput) ElementType() reflect.Type

func (AnalyzerMapOutput) MapIndex 

func (o AnalyzerMapOutput) MapIndex(k pulumi.StringInput) AnalyzerOutput

func (AnalyzerMapOutput) ToAnalyzerMapOutput 

func (o AnalyzerMapOutput) ToAnalyzerMapOutput() AnalyzerMapOutput

func (AnalyzerMapOutput) ToAnalyzerMapOutputWithContext 

func (o AnalyzerMapOutput) ToAnalyzerMapOutputWithContext(ctx context.Context) AnalyzerMapOutput

type AnalyzerOutput 

type AnalyzerOutput struct{ *pulumi.OutputState }

func (AnalyzerOutput) AnalyzerName 

func (o AnalyzerOutput) AnalyzerName() pulumi.StringOutput

Name of the Analyzer.

The following arguments are optional:

func (AnalyzerOutput) Arn 

func (o AnalyzerOutput) Arn() pulumi.StringOutput

ARN of the Analyzer.

func (AnalyzerOutput) Configuration 

func (o AnalyzerOutput) Configuration() AnalyzerConfigurationPtrOutput

A block that specifies the configuration of the analyzer. See `configuration` Block for details.

func (AnalyzerOutput) ElementType 

func (AnalyzerOutput) ElementType() reflect.Type

func (AnalyzerOutput) Region 

func (o AnalyzerOutput) Region() pulumi.StringOutput

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.

func (AnalyzerOutput) Tags 

func (o AnalyzerOutput) Tags() pulumi.StringMapOutput

Key-value map of resource tags. If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.

func (AnalyzerOutput) TagsAll 

func (o AnalyzerOutput) TagsAll() pulumi.StringMapOutput

Map of tags assigned to the resource, including those inherited from the provider `defaultTags` configuration block.

func (AnalyzerOutput) ToAnalyzerOutput 

func (o AnalyzerOutput) ToAnalyzerOutput() AnalyzerOutput

func (AnalyzerOutput) ToAnalyzerOutputWithContext 

func (o AnalyzerOutput) ToAnalyzerOutputWithContext(ctx context.Context) AnalyzerOutput

func (AnalyzerOutput) Type 

func (o AnalyzerOutput) Type() pulumi.StringPtrOutput

Type that represents the zone of trust or scope for the analyzer. Valid values are `ACCOUNT`, `ACCOUNT_INTERNAL_ACCESS`, `ACCOUNT_UNUSED_ACCESS`, `ORGANIZATION`, `ORGANIZATION_INTERNAL_ACCESS`, `ORGANIZATION_UNUSED_ACCESS`. Defaults to `ACCOUNT`.

type AnalyzerState 

type AnalyzerState struct {
	// Name of the Analyzer.
	//
	// The following arguments are optional:
	AnalyzerName pulumi.StringPtrInput
	// ARN of the Analyzer.
	Arn pulumi.StringPtrInput
	// A block that specifies the configuration of the analyzer. See `configuration` Block for details.
	Configuration AnalyzerConfigurationPtrInput
	// 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.StringPtrInput
	// Key-value map of resource tags. If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapInput
	// Map of tags assigned to the resource, including those inherited from the provider `defaultTags` configuration block.
	TagsAll pulumi.StringMapInput
	// Type that represents the zone of trust or scope for the analyzer. Valid values are `ACCOUNT`, `ACCOUNT_INTERNAL_ACCESS`, `ACCOUNT_UNUSED_ACCESS`, `ORGANIZATION`, `ORGANIZATION_INTERNAL_ACCESS`, `ORGANIZATION_UNUSED_ACCESS`. Defaults to `ACCOUNT`.
	Type pulumi.StringPtrInput
}

func (AnalyzerState) ElementType 

func (AnalyzerState) ElementType() reflect.Type

type ArchiveRule 

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"`
	// 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.StringOutput `pulumi:"region"`
	// Rule name.
	RuleName pulumi.StringOutput `pulumi:"ruleName"`
}

Resource for managing an AWS AccessAnalyzer Archive Rule.

## Example Usage

### Basic Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v7/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"),
			RuleName:     pulumi.String("example-rule"),
			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"),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Using `pulumi import`, import AccessAnalyzer ArchiveRule using the `analyzer_name/rule_name`. For example:

```sh $ pulumi import aws:accessanalyzer/archiveRule:ArchiveRule example example-analyzer/example-rule ```

func GetArchiveRule 

func GetArchiveRule(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ArchiveRuleState, opts ...pulumi.ResourceOption) (*ArchiveRule, error)

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 NewArchiveRule 

func NewArchiveRule(ctx *pulumi.Context,
	name string, args *ArchiveRuleArgs, opts ...pulumi.ResourceOption) (*ArchiveRule, error)

NewArchiveRule registers a new resource with the given unique name, arguments, and options.

func (*ArchiveRule) ElementType 

func (*ArchiveRule) ElementType() reflect.Type

func (*ArchiveRule) ToArchiveRuleOutput 

func (i *ArchiveRule) ToArchiveRuleOutput() ArchiveRuleOutput

func (*ArchiveRule) ToArchiveRuleOutputWithContext 

func (i *ArchiveRule) ToArchiveRuleOutputWithContext(ctx context.Context) ArchiveRuleOutput

type ArchiveRuleArgs 

type ArchiveRuleArgs struct {
	// Analyzer name.
	AnalyzerName pulumi.StringInput
	// Filter criteria for the archive rule. See Filter for more details.
	Filters ArchiveRuleFilterArrayInput
	// 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.StringPtrInput
	// Rule name.
	RuleName pulumi.StringInput
}

The set of arguments for constructing a ArchiveRule resource.

func (ArchiveRuleArgs) ElementType 

func (ArchiveRuleArgs) ElementType() reflect.Type

type ArchiveRuleArray 

type ArchiveRuleArray []ArchiveRuleInput

func (ArchiveRuleArray) ElementType 

func (ArchiveRuleArray) ElementType() reflect.Type

func (ArchiveRuleArray) ToArchiveRuleArrayOutput 

func (i ArchiveRuleArray) ToArchiveRuleArrayOutput() ArchiveRuleArrayOutput

func (ArchiveRuleArray) ToArchiveRuleArrayOutputWithContext 

func (i ArchiveRuleArray) ToArchiveRuleArrayOutputWithContext(ctx context.Context) ArchiveRuleArrayOutput

type ArchiveRuleArrayInput 

type ArchiveRuleArrayInput interface {
	pulumi.Input

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

ArchiveRuleArrayInput is an input type that accepts ArchiveRuleArray and ArchiveRuleArrayOutput values. You can construct a concrete instance of `ArchiveRuleArrayInput` via: 

ArchiveRuleArray{ ArchiveRuleArgs{...} }

type ArchiveRuleArrayOutput 

type ArchiveRuleArrayOutput struct{ *pulumi.OutputState }

func (ArchiveRuleArrayOutput) ElementType 

func (ArchiveRuleArrayOutput) ElementType() reflect.Type

func (ArchiveRuleArrayOutput) Index 

func (o ArchiveRuleArrayOutput) Index(i pulumi.IntInput) ArchiveRuleOutput

func (ArchiveRuleArrayOutput) ToArchiveRuleArrayOutput 

func (o ArchiveRuleArrayOutput) ToArchiveRuleArrayOutput() ArchiveRuleArrayOutput

func (ArchiveRuleArrayOutput) ToArchiveRuleArrayOutputWithContext 

func (o ArchiveRuleArrayOutput) ToArchiveRuleArrayOutputWithContext(ctx context.Context) ArchiveRuleArrayOutput

type ArchiveRuleFilter 

type ArchiveRuleFilter struct {
	// Contains comparator.
	Contains []string `pulumi:"contains"`
	// Filter criteria.
	Criteria string `pulumi:"criteria"`
	// Equals comparator.
	Eqs []string `pulumi:"eqs"`
	// Boolean comparator.
	Exists *string `pulumi:"exists"`
	// Not Equals comparator.
	Neqs []string `pulumi:"neqs"`
}

type ArchiveRuleFilterArgs 

type ArchiveRuleFilterArgs struct {
	// Contains comparator.
	Contains pulumi.StringArrayInput `pulumi:"contains"`
	// Filter criteria.
	Criteria pulumi.StringInput `pulumi:"criteria"`
	// Equals comparator.
	Eqs pulumi.StringArrayInput `pulumi:"eqs"`
	// Boolean comparator.
	Exists pulumi.StringPtrInput `pulumi:"exists"`
	// Not Equals comparator.
	Neqs pulumi.StringArrayInput `pulumi:"neqs"`
}

func (ArchiveRuleFilterArgs) ElementType 

func (ArchiveRuleFilterArgs) ElementType() reflect.Type

func (ArchiveRuleFilterArgs) ToArchiveRuleFilterOutput 

func (i ArchiveRuleFilterArgs) ToArchiveRuleFilterOutput() ArchiveRuleFilterOutput

func (ArchiveRuleFilterArgs) ToArchiveRuleFilterOutputWithContext 

func (i ArchiveRuleFilterArgs) ToArchiveRuleFilterOutputWithContext(ctx context.Context) ArchiveRuleFilterOutput

type ArchiveRuleFilterArray 

type ArchiveRuleFilterArray []ArchiveRuleFilterInput

func (ArchiveRuleFilterArray) ElementType 

func (ArchiveRuleFilterArray) ElementType() reflect.Type

func (ArchiveRuleFilterArray) ToArchiveRuleFilterArrayOutput 

func (i ArchiveRuleFilterArray) ToArchiveRuleFilterArrayOutput() ArchiveRuleFilterArrayOutput

func (ArchiveRuleFilterArray) ToArchiveRuleFilterArrayOutputWithContext 

func (i ArchiveRuleFilterArray) ToArchiveRuleFilterArrayOutputWithContext(ctx context.Context) ArchiveRuleFilterArrayOutput

type ArchiveRuleFilterArrayInput 

type ArchiveRuleFilterArrayInput interface {
	pulumi.Input

	ToArchiveRuleFilterArrayOutput() ArchiveRuleFilterArrayOutput
	ToArchiveRuleFilterArrayOutputWithContext(context.Context) ArchiveRuleFilterArrayOutput
}

ArchiveRuleFilterArrayInput is an input type that accepts ArchiveRuleFilterArray and ArchiveRuleFilterArrayOutput values. You can construct a concrete instance of `ArchiveRuleFilterArrayInput` via: 

ArchiveRuleFilterArray{ ArchiveRuleFilterArgs{...} }

type ArchiveRuleFilterArrayOutput 

type ArchiveRuleFilterArrayOutput struct{ *pulumi.OutputState }

func (ArchiveRuleFilterArrayOutput) ElementType 

func (ArchiveRuleFilterArrayOutput) ElementType() reflect.Type

func (ArchiveRuleFilterArrayOutput) Index 

func (o ArchiveRuleFilterArrayOutput) Index(i pulumi.IntInput) ArchiveRuleFilterOutput

func (ArchiveRuleFilterArrayOutput) ToArchiveRuleFilterArrayOutput 

func (o ArchiveRuleFilterArrayOutput) ToArchiveRuleFilterArrayOutput() ArchiveRuleFilterArrayOutput

func (ArchiveRuleFilterArrayOutput) ToArchiveRuleFilterArrayOutputWithContext 

func (o ArchiveRuleFilterArrayOutput) ToArchiveRuleFilterArrayOutputWithContext(ctx context.Context) ArchiveRuleFilterArrayOutput

type ArchiveRuleFilterInput 

type ArchiveRuleFilterInput interface {
	pulumi.Input

	ToArchiveRuleFilterOutput() ArchiveRuleFilterOutput
	ToArchiveRuleFilterOutputWithContext(context.Context) ArchiveRuleFilterOutput
}

ArchiveRuleFilterInput is an input type that accepts ArchiveRuleFilterArgs and ArchiveRuleFilterOutput values. You can construct a concrete instance of `ArchiveRuleFilterInput` via: 

ArchiveRuleFilterArgs{...}

type ArchiveRuleFilterOutput 

type ArchiveRuleFilterOutput struct{ *pulumi.OutputState }

func (ArchiveRuleFilterOutput) Contains 

func (o ArchiveRuleFilterOutput) Contains() pulumi.StringArrayOutput

Contains comparator.

func (ArchiveRuleFilterOutput) Criteria 

func (o ArchiveRuleFilterOutput) Criteria() pulumi.StringOutput

Filter criteria.

func (ArchiveRuleFilterOutput) ElementType 

func (ArchiveRuleFilterOutput) ElementType() reflect.Type

func (ArchiveRuleFilterOutput) Eqs 

func (o ArchiveRuleFilterOutput) Eqs() pulumi.StringArrayOutput

Equals comparator.

func (ArchiveRuleFilterOutput) Exists 

func (o ArchiveRuleFilterOutput) Exists() pulumi.StringPtrOutput

Boolean comparator.

func (ArchiveRuleFilterOutput) Neqs 

func (o ArchiveRuleFilterOutput) Neqs() pulumi.StringArrayOutput

Not Equals comparator.

func (ArchiveRuleFilterOutput) ToArchiveRuleFilterOutput 

func (o ArchiveRuleFilterOutput) ToArchiveRuleFilterOutput() ArchiveRuleFilterOutput

func (ArchiveRuleFilterOutput) ToArchiveRuleFilterOutputWithContext 

func (o ArchiveRuleFilterOutput) ToArchiveRuleFilterOutputWithContext(ctx context.Context) ArchiveRuleFilterOutput

type ArchiveRuleInput 

type ArchiveRuleInput interface {
	pulumi.Input

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

type ArchiveRuleMap 

type ArchiveRuleMap map[string]ArchiveRuleInput

func (ArchiveRuleMap) ElementType 

func (ArchiveRuleMap) ElementType() reflect.Type

func (ArchiveRuleMap) ToArchiveRuleMapOutput 

func (i ArchiveRuleMap) ToArchiveRuleMapOutput() ArchiveRuleMapOutput

func (ArchiveRuleMap) ToArchiveRuleMapOutputWithContext 

func (i ArchiveRuleMap) ToArchiveRuleMapOutputWithContext(ctx context.Context) ArchiveRuleMapOutput

type ArchiveRuleMapInput 

type ArchiveRuleMapInput interface {
	pulumi.Input

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

ArchiveRuleMapInput is an input type that accepts ArchiveRuleMap and ArchiveRuleMapOutput values. You can construct a concrete instance of `ArchiveRuleMapInput` via: 

ArchiveRuleMap{ "key": ArchiveRuleArgs{...} }

type ArchiveRuleMapOutput 

type ArchiveRuleMapOutput struct{ *pulumi.OutputState }

func (ArchiveRuleMapOutput) ElementType 

func (ArchiveRuleMapOutput) ElementType() reflect.Type

func (ArchiveRuleMapOutput) MapIndex 

func (o ArchiveRuleMapOutput) MapIndex(k pulumi.StringInput) ArchiveRuleOutput

func (ArchiveRuleMapOutput) ToArchiveRuleMapOutput 

func (o ArchiveRuleMapOutput) ToArchiveRuleMapOutput() ArchiveRuleMapOutput

func (ArchiveRuleMapOutput) ToArchiveRuleMapOutputWithContext 

func (o ArchiveRuleMapOutput) ToArchiveRuleMapOutputWithContext(ctx context.Context) ArchiveRuleMapOutput

type ArchiveRuleOutput 

type ArchiveRuleOutput struct{ *pulumi.OutputState }

func (ArchiveRuleOutput) AnalyzerName 

func (o ArchiveRuleOutput) AnalyzerName() pulumi.StringOutput

Analyzer name.

func (ArchiveRuleOutput) ElementType 

func (ArchiveRuleOutput) ElementType() reflect.Type

func (ArchiveRuleOutput) Filters 

func (o ArchiveRuleOutput) Filters() ArchiveRuleFilterArrayOutput

Filter criteria for the archive rule. See Filter for more details.

func (ArchiveRuleOutput) Region 

func (o ArchiveRuleOutput) Region() pulumi.StringOutput

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.

func (ArchiveRuleOutput) RuleName 

func (o ArchiveRuleOutput) RuleName() pulumi.StringOutput

Rule name.

func (ArchiveRuleOutput) ToArchiveRuleOutput 

func (o ArchiveRuleOutput) ToArchiveRuleOutput() ArchiveRuleOutput

func (ArchiveRuleOutput) ToArchiveRuleOutputWithContext 

func (o ArchiveRuleOutput) ToArchiveRuleOutputWithContext(ctx context.Context) ArchiveRuleOutput

type ArchiveRuleState 

type ArchiveRuleState struct {
	// Analyzer name.
	AnalyzerName pulumi.StringPtrInput
	// Filter criteria for the archive rule. See Filter for more details.
	Filters ArchiveRuleFilterArrayInput
	// 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.StringPtrInput
	// Rule name.
	RuleName pulumi.StringPtrInput
}

func (ArchiveRuleState) ElementType 

func (ArchiveRuleState) ElementType() reflect.Type

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.