licensemanager

package
v6.53.0 Latest Latest
Warning

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

 Go to latest Published: Sep 26, 2024 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 Association 

type Association struct {
	pulumi.CustomResourceState

	// ARN of the license configuration.
	LicenseConfigurationArn pulumi.StringOutput `pulumi:"licenseConfigurationArn"`
	// ARN of the resource associated with the license configuration.
	ResourceArn pulumi.StringOutput `pulumi:"resourceArn"`
}

Provides a License Manager association.

> **Note:** License configurations can also be associated with launch templates by specifying the `licenseSpecifications` block for an `ec2.LaunchTemplate`.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/ec2"
"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/licensemanager"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := ec2.LookupAmi(ctx, &ec2.LookupAmiArgs{
			MostRecent: pulumi.BoolRef(true),
			Owners: []string{
				"amazon",
			},
			Filters: []ec2.GetAmiFilter{
				{
					Name: "name",
					Values: []string{
						"amzn-ami-vpc-nat*",
					},
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		exampleInstance, err := ec2.NewInstance(ctx, "example", &ec2.InstanceArgs{
			Ami:          pulumi.String(example.Id),
			InstanceType: pulumi.String(ec2.InstanceType_T2_Micro),
		})
		if err != nil {
			return err
		}
		exampleLicenseConfiguration, err := licensemanager.NewLicenseConfiguration(ctx, "example", &licensemanager.LicenseConfigurationArgs{
			Name:                pulumi.String("Example"),
			LicenseCountingType: pulumi.String("Instance"),
		})
		if err != nil {
			return err
		}
		_, err = licensemanager.NewAssociation(ctx, "example", &licensemanager.AssociationArgs{
			LicenseConfigurationArn: exampleLicenseConfiguration.Arn,
			ResourceArn:             exampleInstance.Arn,
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Using `pulumi import`, import license configurations using `resource_arn,license_configuration_arn`. For example:

```sh $ pulumi import aws:licensemanager/association:Association example arn:aws:ec2:eu-west-1:123456789012:image/ami-123456789abcdef01,arn:aws:license-manager:eu-west-1:123456789012:license-configuration:lic-0123456789abcdef0123456789abcdef ```

func GetAssociation 

func GetAssociation(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *AssociationState, opts ...pulumi.ResourceOption) (*Association, error)

GetAssociation gets an existing Association 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 NewAssociation 

func NewAssociation(ctx *pulumi.Context,
	name string, args *AssociationArgs, opts ...pulumi.ResourceOption) (*Association, error)

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

func (*Association) ElementType 

func (*Association) ElementType() reflect.Type

func (*Association) ToAssociationOutput 

func (i *Association) ToAssociationOutput() AssociationOutput

func (*Association) ToAssociationOutputWithContext 

func (i *Association) ToAssociationOutputWithContext(ctx context.Context) AssociationOutput

type AssociationArgs 

type AssociationArgs struct {
	// ARN of the license configuration.
	LicenseConfigurationArn pulumi.StringInput
	// ARN of the resource associated with the license configuration.
	ResourceArn pulumi.StringInput
}

The set of arguments for constructing a Association resource.

func (AssociationArgs) ElementType 

func (AssociationArgs) ElementType() reflect.Type

type AssociationArray 

type AssociationArray []AssociationInput

func (AssociationArray) ElementType 

func (AssociationArray) ElementType() reflect.Type

func (AssociationArray) ToAssociationArrayOutput 

func (i AssociationArray) ToAssociationArrayOutput() AssociationArrayOutput

func (AssociationArray) ToAssociationArrayOutputWithContext 

func (i AssociationArray) ToAssociationArrayOutputWithContext(ctx context.Context) AssociationArrayOutput

type AssociationArrayInput 

type AssociationArrayInput interface {
	pulumi.Input

	ToAssociationArrayOutput() AssociationArrayOutput
	ToAssociationArrayOutputWithContext(context.Context) AssociationArrayOutput
}

AssociationArrayInput is an input type that accepts AssociationArray and AssociationArrayOutput values. You can construct a concrete instance of `AssociationArrayInput` via: 

AssociationArray{ AssociationArgs{...} }

type AssociationArrayOutput 

type AssociationArrayOutput struct{ *pulumi.OutputState }

func (AssociationArrayOutput) ElementType 

func (AssociationArrayOutput) ElementType() reflect.Type

func (AssociationArrayOutput) Index 

func (o AssociationArrayOutput) Index(i pulumi.IntInput) AssociationOutput

func (AssociationArrayOutput) ToAssociationArrayOutput 

func (o AssociationArrayOutput) ToAssociationArrayOutput() AssociationArrayOutput

func (AssociationArrayOutput) ToAssociationArrayOutputWithContext 

func (o AssociationArrayOutput) ToAssociationArrayOutputWithContext(ctx context.Context) AssociationArrayOutput

type AssociationInput 

type AssociationInput interface {
	pulumi.Input

	ToAssociationOutput() AssociationOutput
	ToAssociationOutputWithContext(ctx context.Context) AssociationOutput
}

type AssociationMap 

type AssociationMap map[string]AssociationInput

func (AssociationMap) ElementType 

func (AssociationMap) ElementType() reflect.Type

func (AssociationMap) ToAssociationMapOutput 

func (i AssociationMap) ToAssociationMapOutput() AssociationMapOutput

func (AssociationMap) ToAssociationMapOutputWithContext 

func (i AssociationMap) ToAssociationMapOutputWithContext(ctx context.Context) AssociationMapOutput

type AssociationMapInput 

type AssociationMapInput interface {
	pulumi.Input

	ToAssociationMapOutput() AssociationMapOutput
	ToAssociationMapOutputWithContext(context.Context) AssociationMapOutput
}

AssociationMapInput is an input type that accepts AssociationMap and AssociationMapOutput values. You can construct a concrete instance of `AssociationMapInput` via: 

AssociationMap{ "key": AssociationArgs{...} }

type AssociationMapOutput 

type AssociationMapOutput struct{ *pulumi.OutputState }

func (AssociationMapOutput) ElementType 

func (AssociationMapOutput) ElementType() reflect.Type

func (AssociationMapOutput) MapIndex 

func (o AssociationMapOutput) MapIndex(k pulumi.StringInput) AssociationOutput

func (AssociationMapOutput) ToAssociationMapOutput 

func (o AssociationMapOutput) ToAssociationMapOutput() AssociationMapOutput

func (AssociationMapOutput) ToAssociationMapOutputWithContext 

func (o AssociationMapOutput) ToAssociationMapOutputWithContext(ctx context.Context) AssociationMapOutput

type AssociationOutput 

type AssociationOutput struct{ *pulumi.OutputState }

func (AssociationOutput) ElementType 

func (AssociationOutput) ElementType() reflect.Type

func (AssociationOutput) LicenseConfigurationArn 

func (o AssociationOutput) LicenseConfigurationArn() pulumi.StringOutput

ARN of the license configuration.

func (AssociationOutput) ResourceArn 

func (o AssociationOutput) ResourceArn() pulumi.StringOutput

ARN of the resource associated with the license configuration.

func (AssociationOutput) ToAssociationOutput 

func (o AssociationOutput) ToAssociationOutput() AssociationOutput

func (AssociationOutput) ToAssociationOutputWithContext 

func (o AssociationOutput) ToAssociationOutputWithContext(ctx context.Context) AssociationOutput

type AssociationState 

type AssociationState struct {
	// ARN of the license configuration.
	LicenseConfigurationArn pulumi.StringPtrInput
	// ARN of the resource associated with the license configuration.
	ResourceArn pulumi.StringPtrInput
}

func (AssociationState) ElementType 

func (AssociationState) ElementType() reflect.Type

type GetLicenseGrantsArgs 

type GetLicenseGrantsArgs struct {
	// Custom filter block as described below.
	//
	// More complex filters can be expressed using one or more `filter` sub-blocks,
	// which take the following arguments:
	Filters []GetLicenseGrantsFilter `pulumi:"filters"`
}

A collection of arguments for invoking getLicenseGrants.

type GetLicenseGrantsFilter 

type GetLicenseGrantsFilter struct {
	// Name of the field to filter by, as defined by
	// [the underlying AWS API](https://docs.aws.amazon.com/license-manager/latest/APIReference/API_ListReceivedGrants.html#API_ListReceivedGrants_RequestSyntax).
	// For example, if filtering using `ProductSKU`, use:
	//
	// “`go
	// package main
	//
	// import (
	// 	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/licensemanager"
	// 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	// )
	//
	// func main() {
	// 	pulumi.Run(func(ctx *pulumi.Context) error {
	// 		_, err := licensemanager.GetLicenseGrants(ctx, &licensemanager.GetLicenseGrantsArgs{
	// 			Filters: []licensemanager.GetLicenseGrantsFilter{
	// 				{
	// 					Name: "ProductSKU",
	// 					Values: []string{
	// 						"",
	// 					},
	// 				},
	// 			},
	// 		}, nil)
	// 		if err != nil {
	// 			return err
	// 		}
	// 		return nil
	// 	})
	// }
	// “`
	Name string `pulumi:"name"`
	// Set of values that are accepted for the given field.
	Values []string `pulumi:"values"`
}

type GetLicenseGrantsFilterArgs 

type GetLicenseGrantsFilterArgs struct {
	// Name of the field to filter by, as defined by
	// [the underlying AWS API](https://docs.aws.amazon.com/license-manager/latest/APIReference/API_ListReceivedGrants.html#API_ListReceivedGrants_RequestSyntax).
	// For example, if filtering using `ProductSKU`, use:
	//
	// “`go
	// package main
	//
	// import (
	// 	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/licensemanager"
	// 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	// )
	//
	// func main() {
	// 	pulumi.Run(func(ctx *pulumi.Context) error {
	// 		_, err := licensemanager.GetLicenseGrants(ctx, &licensemanager.GetLicenseGrantsArgs{
	// 			Filters: []licensemanager.GetLicenseGrantsFilter{
	// 				{
	// 					Name: "ProductSKU",
	// 					Values: []string{
	// 						"",
	// 					},
	// 				},
	// 			},
	// 		}, nil)
	// 		if err != nil {
	// 			return err
	// 		}
	// 		return nil
	// 	})
	// }
	// “`
	Name pulumi.StringInput `pulumi:"name"`
	// Set of values that are accepted for the given field.
	Values pulumi.StringArrayInput `pulumi:"values"`
}

func (GetLicenseGrantsFilterArgs) ElementType 

func (GetLicenseGrantsFilterArgs) ElementType() reflect.Type

func (GetLicenseGrantsFilterArgs) ToGetLicenseGrantsFilterOutput 

func (i GetLicenseGrantsFilterArgs) ToGetLicenseGrantsFilterOutput() GetLicenseGrantsFilterOutput

func (GetLicenseGrantsFilterArgs) ToGetLicenseGrantsFilterOutputWithContext 

func (i GetLicenseGrantsFilterArgs) ToGetLicenseGrantsFilterOutputWithContext(ctx context.Context) GetLicenseGrantsFilterOutput

type GetLicenseGrantsFilterArray 

type GetLicenseGrantsFilterArray []GetLicenseGrantsFilterInput

func (GetLicenseGrantsFilterArray) ElementType 

func (GetLicenseGrantsFilterArray) ElementType() reflect.Type

func (GetLicenseGrantsFilterArray) ToGetLicenseGrantsFilterArrayOutput 

func (i GetLicenseGrantsFilterArray) ToGetLicenseGrantsFilterArrayOutput() GetLicenseGrantsFilterArrayOutput

func (GetLicenseGrantsFilterArray) ToGetLicenseGrantsFilterArrayOutputWithContext 

func (i GetLicenseGrantsFilterArray) ToGetLicenseGrantsFilterArrayOutputWithContext(ctx context.Context) GetLicenseGrantsFilterArrayOutput

type GetLicenseGrantsFilterArrayInput 

type GetLicenseGrantsFilterArrayInput interface {
	pulumi.Input

	ToGetLicenseGrantsFilterArrayOutput() GetLicenseGrantsFilterArrayOutput
	ToGetLicenseGrantsFilterArrayOutputWithContext(context.Context) GetLicenseGrantsFilterArrayOutput
}

GetLicenseGrantsFilterArrayInput is an input type that accepts GetLicenseGrantsFilterArray and GetLicenseGrantsFilterArrayOutput values. You can construct a concrete instance of `GetLicenseGrantsFilterArrayInput` via: 

GetLicenseGrantsFilterArray{ GetLicenseGrantsFilterArgs{...} }

type GetLicenseGrantsFilterArrayOutput 

type GetLicenseGrantsFilterArrayOutput struct{ *pulumi.OutputState }

func (GetLicenseGrantsFilterArrayOutput) ElementType 

func (GetLicenseGrantsFilterArrayOutput) ElementType() reflect.Type

func (GetLicenseGrantsFilterArrayOutput) Index 

func (o GetLicenseGrantsFilterArrayOutput) Index(i pulumi.IntInput) GetLicenseGrantsFilterOutput

func (GetLicenseGrantsFilterArrayOutput) ToGetLicenseGrantsFilterArrayOutput 

func (o GetLicenseGrantsFilterArrayOutput) ToGetLicenseGrantsFilterArrayOutput() GetLicenseGrantsFilterArrayOutput

func (GetLicenseGrantsFilterArrayOutput) ToGetLicenseGrantsFilterArrayOutputWithContext 

func (o GetLicenseGrantsFilterArrayOutput) ToGetLicenseGrantsFilterArrayOutputWithContext(ctx context.Context) GetLicenseGrantsFilterArrayOutput

type GetLicenseGrantsFilterInput 

type GetLicenseGrantsFilterInput interface {
	pulumi.Input

	ToGetLicenseGrantsFilterOutput() GetLicenseGrantsFilterOutput
	ToGetLicenseGrantsFilterOutputWithContext(context.Context) GetLicenseGrantsFilterOutput
}

GetLicenseGrantsFilterInput is an input type that accepts GetLicenseGrantsFilterArgs and GetLicenseGrantsFilterOutput values. You can construct a concrete instance of `GetLicenseGrantsFilterInput` via: 

GetLicenseGrantsFilterArgs{...}

type GetLicenseGrantsFilterOutput 

type GetLicenseGrantsFilterOutput struct{ *pulumi.OutputState }

func (GetLicenseGrantsFilterOutput) ElementType 

func (GetLicenseGrantsFilterOutput) ElementType() reflect.Type

func (GetLicenseGrantsFilterOutput) Name 

func (o GetLicenseGrantsFilterOutput) Name() pulumi.StringOutput

Name of the field to filter by, as defined by [the underlying AWS API](https://docs.aws.amazon.com/license-manager/latest/APIReference/API_ListReceivedGrants.html#API_ListReceivedGrants_RequestSyntax). For example, if filtering using `ProductSKU`, use:

```go package main

import ( 

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

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := licensemanager.GetLicenseGrants(ctx, &licensemanager.GetLicenseGrantsArgs{
			Filters: []licensemanager.GetLicenseGrantsFilter{
				{
					Name: "ProductSKU",
					Values: []string{
						"",
					},
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

func (GetLicenseGrantsFilterOutput) ToGetLicenseGrantsFilterOutput 

func (o GetLicenseGrantsFilterOutput) ToGetLicenseGrantsFilterOutput() GetLicenseGrantsFilterOutput

func (GetLicenseGrantsFilterOutput) ToGetLicenseGrantsFilterOutputWithContext 

func (o GetLicenseGrantsFilterOutput) ToGetLicenseGrantsFilterOutputWithContext(ctx context.Context) GetLicenseGrantsFilterOutput

func (GetLicenseGrantsFilterOutput) Values 

func (o GetLicenseGrantsFilterOutput) Values() pulumi.StringArrayOutput

Set of values that are accepted for the given field.

type GetLicenseGrantsOutputArgs 

type GetLicenseGrantsOutputArgs struct {
	// Custom filter block as described below.
	//
	// More complex filters can be expressed using one or more `filter` sub-blocks,
	// which take the following arguments:
	Filters GetLicenseGrantsFilterArrayInput `pulumi:"filters"`
}

A collection of arguments for invoking getLicenseGrants.

func (GetLicenseGrantsOutputArgs) ElementType 

func (GetLicenseGrantsOutputArgs) ElementType() reflect.Type

type GetLicenseGrantsResult 

type GetLicenseGrantsResult struct {
	// List of all the license grant ARNs found.
	Arns    []string                 `pulumi:"arns"`
	Filters []GetLicenseGrantsFilter `pulumi:"filters"`
	// The provider-assigned unique ID for this managed resource.
	Id string `pulumi:"id"`
}

A collection of values returned by getLicenseGrants.

func GetLicenseGrants 

func GetLicenseGrants(ctx *pulumi.Context, args *GetLicenseGrantsArgs, opts ...pulumi.InvokeOption) (*GetLicenseGrantsResult, error)

This resource can be used to get a set of license grant ARNs matching a filter.

## Example Usage

The following shows getting all license grant ARNs granted to your account.

```go package main

import ( 

"fmt"

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

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		current, err := aws.GetCallerIdentity(ctx, nil, nil)
		if err != nil {
			return err
		}
		_, err = licensemanager.GetLicenseGrants(ctx, &licensemanager.GetLicenseGrantsArgs{
			Filters: []licensemanager.GetLicenseGrantsFilter{
				{
					Name: "GranteePrincipalARN",
					Values: []string{
						fmt.Sprintf("arn:aws:iam::%v:root", current.AccountId),
					},
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

type GetLicenseGrantsResultOutput 

type GetLicenseGrantsResultOutput struct{ *pulumi.OutputState }

A collection of values returned by getLicenseGrants.

func GetLicenseGrantsOutput 

func GetLicenseGrantsOutput(ctx *pulumi.Context, args GetLicenseGrantsOutputArgs, opts ...pulumi.InvokeOption) GetLicenseGrantsResultOutput

func (GetLicenseGrantsResultOutput) Arns 

func (o GetLicenseGrantsResultOutput) Arns() pulumi.StringArrayOutput

List of all the license grant ARNs found.

func (GetLicenseGrantsResultOutput) ElementType 

func (GetLicenseGrantsResultOutput) ElementType() reflect.Type

func (GetLicenseGrantsResultOutput) Filters 

func (o GetLicenseGrantsResultOutput) Filters() GetLicenseGrantsFilterArrayOutput

func (GetLicenseGrantsResultOutput) Id 

func (o GetLicenseGrantsResultOutput) Id() pulumi.StringOutput

The provider-assigned unique ID for this managed resource.

func (GetLicenseGrantsResultOutput) ToGetLicenseGrantsResultOutput 

func (o GetLicenseGrantsResultOutput) ToGetLicenseGrantsResultOutput() GetLicenseGrantsResultOutput

func (GetLicenseGrantsResultOutput) ToGetLicenseGrantsResultOutputWithContext 

func (o GetLicenseGrantsResultOutput) ToGetLicenseGrantsResultOutputWithContext(ctx context.Context) GetLicenseGrantsResultOutput

type GetReceivedLicenseArgs 

type GetReceivedLicenseArgs struct {
	// The ARN of the received license you want data for.
	LicenseArn string `pulumi:"licenseArn"`
}

A collection of arguments for invoking getReceivedLicense.

type GetReceivedLicenseConsumptionConfiguration 

type GetReceivedLicenseConsumptionConfiguration struct {
	// Details about a borrow configuration. Detailed below
	BorrowConfigurations []GetReceivedLicenseConsumptionConfigurationBorrowConfiguration `pulumi:"borrowConfigurations"`
	// Details about a provisional configuration. Detailed below
	ProvisionalConfigurations []GetReceivedLicenseConsumptionConfigurationProvisionalConfiguration `pulumi:"provisionalConfigurations"`
	RenewType                 string                                                               `pulumi:"renewType"`
}

type GetReceivedLicenseConsumptionConfigurationArgs 

type GetReceivedLicenseConsumptionConfigurationArgs struct {
	// Details about a borrow configuration. Detailed below
	BorrowConfigurations GetReceivedLicenseConsumptionConfigurationBorrowConfigurationArrayInput `pulumi:"borrowConfigurations"`
	// Details about a provisional configuration. Detailed below
	ProvisionalConfigurations GetReceivedLicenseConsumptionConfigurationProvisionalConfigurationArrayInput `pulumi:"provisionalConfigurations"`
	RenewType                 pulumi.StringInput                                                           `pulumi:"renewType"`
}

func (GetReceivedLicenseConsumptionConfigurationArgs) ElementType 

func (GetReceivedLicenseConsumptionConfigurationArgs) ElementType() reflect.Type

func (GetReceivedLicenseConsumptionConfigurationArgs) ToGetReceivedLicenseConsumptionConfigurationOutput 

func (i GetReceivedLicenseConsumptionConfigurationArgs) ToGetReceivedLicenseConsumptionConfigurationOutput() GetReceivedLicenseConsumptionConfigurationOutput

func (GetReceivedLicenseConsumptionConfigurationArgs) ToGetReceivedLicenseConsumptionConfigurationOutputWithContext 

func (i GetReceivedLicenseConsumptionConfigurationArgs) ToGetReceivedLicenseConsumptionConfigurationOutputWithContext(ctx context.Context) GetReceivedLicenseConsumptionConfigurationOutput

type GetReceivedLicenseConsumptionConfigurationArray 

type GetReceivedLicenseConsumptionConfigurationArray []GetReceivedLicenseConsumptionConfigurationInput

func (GetReceivedLicenseConsumptionConfigurationArray) ElementType 

func (GetReceivedLicenseConsumptionConfigurationArray) ElementType() reflect.Type

func (GetReceivedLicenseConsumptionConfigurationArray) ToGetReceivedLicenseConsumptionConfigurationArrayOutput 

func (i GetReceivedLicenseConsumptionConfigurationArray) ToGetReceivedLicenseConsumptionConfigurationArrayOutput() GetReceivedLicenseConsumptionConfigurationArrayOutput

func (GetReceivedLicenseConsumptionConfigurationArray) ToGetReceivedLicenseConsumptionConfigurationArrayOutputWithContext 

func (i GetReceivedLicenseConsumptionConfigurationArray) ToGetReceivedLicenseConsumptionConfigurationArrayOutputWithContext(ctx context.Context) GetReceivedLicenseConsumptionConfigurationArrayOutput

type GetReceivedLicenseConsumptionConfigurationArrayInput 

type GetReceivedLicenseConsumptionConfigurationArrayInput interface {
	pulumi.Input

	ToGetReceivedLicenseConsumptionConfigurationArrayOutput() GetReceivedLicenseConsumptionConfigurationArrayOutput
	ToGetReceivedLicenseConsumptionConfigurationArrayOutputWithContext(context.Context) GetReceivedLicenseConsumptionConfigurationArrayOutput
}

GetReceivedLicenseConsumptionConfigurationArrayInput is an input type that accepts GetReceivedLicenseConsumptionConfigurationArray and GetReceivedLicenseConsumptionConfigurationArrayOutput values. You can construct a concrete instance of `GetReceivedLicenseConsumptionConfigurationArrayInput` via: 

GetReceivedLicenseConsumptionConfigurationArray{ GetReceivedLicenseConsumptionConfigurationArgs{...} }

type GetReceivedLicenseConsumptionConfigurationArrayOutput 

type GetReceivedLicenseConsumptionConfigurationArrayOutput struct{ *pulumi.OutputState }

func (GetReceivedLicenseConsumptionConfigurationArrayOutput) ElementType 

func (GetReceivedLicenseConsumptionConfigurationArrayOutput) ElementType() reflect.Type

func (GetReceivedLicenseConsumptionConfigurationArrayOutput) Index 

func (o GetReceivedLicenseConsumptionConfigurationArrayOutput) Index(i pulumi.IntInput) GetReceivedLicenseConsumptionConfigurationOutput

func (GetReceivedLicenseConsumptionConfigurationArrayOutput) ToGetReceivedLicenseConsumptionConfigurationArrayOutput 

func (o GetReceivedLicenseConsumptionConfigurationArrayOutput) ToGetReceivedLicenseConsumptionConfigurationArrayOutput() GetReceivedLicenseConsumptionConfigurationArrayOutput

func (GetReceivedLicenseConsumptionConfigurationArrayOutput) ToGetReceivedLicenseConsumptionConfigurationArrayOutputWithContext 

func (o GetReceivedLicenseConsumptionConfigurationArrayOutput) ToGetReceivedLicenseConsumptionConfigurationArrayOutputWithContext(ctx context.Context) GetReceivedLicenseConsumptionConfigurationArrayOutput

type GetReceivedLicenseConsumptionConfigurationBorrowConfiguration 

type GetReceivedLicenseConsumptionConfigurationBorrowConfiguration struct {
	// Indicates whether early check-ins are allowed.
	AllowEarlyCheckIn bool `pulumi:"allowEarlyCheckIn"`
	// Maximum time for the provisional configuration, in minutes.
	MaxTimeToLiveInMinutes int `pulumi:"maxTimeToLiveInMinutes"`
}

type GetReceivedLicenseConsumptionConfigurationBorrowConfigurationArgs 

type GetReceivedLicenseConsumptionConfigurationBorrowConfigurationArgs struct {
	// Indicates whether early check-ins are allowed.
	AllowEarlyCheckIn pulumi.BoolInput `pulumi:"allowEarlyCheckIn"`
	// Maximum time for the provisional configuration, in minutes.
	MaxTimeToLiveInMinutes pulumi.IntInput `pulumi:"maxTimeToLiveInMinutes"`
}

func (GetReceivedLicenseConsumptionConfigurationBorrowConfigurationArgs) ElementType 

func (GetReceivedLicenseConsumptionConfigurationBorrowConfigurationArgs) ElementType() reflect.Type

func (GetReceivedLicenseConsumptionConfigurationBorrowConfigurationArgs) ToGetReceivedLicenseConsumptionConfigurationBorrowConfigurationOutput 

func (i GetReceivedLicenseConsumptionConfigurationBorrowConfigurationArgs) ToGetReceivedLicenseConsumptionConfigurationBorrowConfigurationOutput() GetReceivedLicenseConsumptionConfigurationBorrowConfigurationOutput

func (GetReceivedLicenseConsumptionConfigurationBorrowConfigurationArgs) ToGetReceivedLicenseConsumptionConfigurationBorrowConfigurationOutputWithContext 

func (i GetReceivedLicenseConsumptionConfigurationBorrowConfigurationArgs) ToGetReceivedLicenseConsumptionConfigurationBorrowConfigurationOutputWithContext(ctx context.Context) GetReceivedLicenseConsumptionConfigurationBorrowConfigurationOutput

type GetReceivedLicenseConsumptionConfigurationBorrowConfigurationArray 

type GetReceivedLicenseConsumptionConfigurationBorrowConfigurationArray []GetReceivedLicenseConsumptionConfigurationBorrowConfigurationInput

func (GetReceivedLicenseConsumptionConfigurationBorrowConfigurationArray) ElementType 

func (GetReceivedLicenseConsumptionConfigurationBorrowConfigurationArray) ElementType() reflect.Type

func (GetReceivedLicenseConsumptionConfigurationBorrowConfigurationArray) ToGetReceivedLicenseConsumptionConfigurationBorrowConfigurationArrayOutput 

func (i GetReceivedLicenseConsumptionConfigurationBorrowConfigurationArray) ToGetReceivedLicenseConsumptionConfigurationBorrowConfigurationArrayOutput() GetReceivedLicenseConsumptionConfigurationBorrowConfigurationArrayOutput

func (GetReceivedLicenseConsumptionConfigurationBorrowConfigurationArray) ToGetReceivedLicenseConsumptionConfigurationBorrowConfigurationArrayOutputWithContext 

func (i GetReceivedLicenseConsumptionConfigurationBorrowConfigurationArray) ToGetReceivedLicenseConsumptionConfigurationBorrowConfigurationArrayOutputWithContext(ctx context.Context) GetReceivedLicenseConsumptionConfigurationBorrowConfigurationArrayOutput

type GetReceivedLicenseConsumptionConfigurationBorrowConfigurationArrayInput 

type GetReceivedLicenseConsumptionConfigurationBorrowConfigurationArrayInput interface {
	pulumi.Input

	ToGetReceivedLicenseConsumptionConfigurationBorrowConfigurationArrayOutput() GetReceivedLicenseConsumptionConfigurationBorrowConfigurationArrayOutput
	ToGetReceivedLicenseConsumptionConfigurationBorrowConfigurationArrayOutputWithContext(context.Context) GetReceivedLicenseConsumptionConfigurationBorrowConfigurationArrayOutput
}

GetReceivedLicenseConsumptionConfigurationBorrowConfigurationArrayInput is an input type that accepts GetReceivedLicenseConsumptionConfigurationBorrowConfigurationArray and GetReceivedLicenseConsumptionConfigurationBorrowConfigurationArrayOutput values. You can construct a concrete instance of `GetReceivedLicenseConsumptionConfigurationBorrowConfigurationArrayInput` via: 

GetReceivedLicenseConsumptionConfigurationBorrowConfigurationArray{ GetReceivedLicenseConsumptionConfigurationBorrowConfigurationArgs{...} }

type GetReceivedLicenseConsumptionConfigurationBorrowConfigurationArrayOutput 

type GetReceivedLicenseConsumptionConfigurationBorrowConfigurationArrayOutput struct{ *pulumi.OutputState }

func (GetReceivedLicenseConsumptionConfigurationBorrowConfigurationArrayOutput) ElementType 

func (GetReceivedLicenseConsumptionConfigurationBorrowConfigurationArrayOutput) ElementType() reflect.Type

func (GetReceivedLicenseConsumptionConfigurationBorrowConfigurationArrayOutput) Index 

func (o GetReceivedLicenseConsumptionConfigurationBorrowConfigurationArrayOutput) Index(i pulumi.IntInput) GetReceivedLicenseConsumptionConfigurationBorrowConfigurationOutput

func (GetReceivedLicenseConsumptionConfigurationBorrowConfigurationArrayOutput) ToGetReceivedLicenseConsumptionConfigurationBorrowConfigurationArrayOutput 

func (o GetReceivedLicenseConsumptionConfigurationBorrowConfigurationArrayOutput) ToGetReceivedLicenseConsumptionConfigurationBorrowConfigurationArrayOutput() GetReceivedLicenseConsumptionConfigurationBorrowConfigurationArrayOutput

func (GetReceivedLicenseConsumptionConfigurationBorrowConfigurationArrayOutput) ToGetReceivedLicenseConsumptionConfigurationBorrowConfigurationArrayOutputWithContext 

func (o GetReceivedLicenseConsumptionConfigurationBorrowConfigurationArrayOutput) ToGetReceivedLicenseConsumptionConfigurationBorrowConfigurationArrayOutputWithContext(ctx context.Context) GetReceivedLicenseConsumptionConfigurationBorrowConfigurationArrayOutput

type GetReceivedLicenseConsumptionConfigurationBorrowConfigurationInput 

type GetReceivedLicenseConsumptionConfigurationBorrowConfigurationInput interface {
	pulumi.Input

	ToGetReceivedLicenseConsumptionConfigurationBorrowConfigurationOutput() GetReceivedLicenseConsumptionConfigurationBorrowConfigurationOutput
	ToGetReceivedLicenseConsumptionConfigurationBorrowConfigurationOutputWithContext(context.Context) GetReceivedLicenseConsumptionConfigurationBorrowConfigurationOutput
}

GetReceivedLicenseConsumptionConfigurationBorrowConfigurationInput is an input type that accepts GetReceivedLicenseConsumptionConfigurationBorrowConfigurationArgs and GetReceivedLicenseConsumptionConfigurationBorrowConfigurationOutput values. You can construct a concrete instance of `GetReceivedLicenseConsumptionConfigurationBorrowConfigurationInput` via: 

GetReceivedLicenseConsumptionConfigurationBorrowConfigurationArgs{...}

type GetReceivedLicenseConsumptionConfigurationBorrowConfigurationOutput 

type GetReceivedLicenseConsumptionConfigurationBorrowConfigurationOutput struct{ *pulumi.OutputState }

func (GetReceivedLicenseConsumptionConfigurationBorrowConfigurationOutput) AllowEarlyCheckIn 

func (o GetReceivedLicenseConsumptionConfigurationBorrowConfigurationOutput) AllowEarlyCheckIn() pulumi.BoolOutput

Indicates whether early check-ins are allowed.

func (GetReceivedLicenseConsumptionConfigurationBorrowConfigurationOutput) ElementType 

func (GetReceivedLicenseConsumptionConfigurationBorrowConfigurationOutput) ElementType() reflect.Type

func (GetReceivedLicenseConsumptionConfigurationBorrowConfigurationOutput) MaxTimeToLiveInMinutes 

func (o GetReceivedLicenseConsumptionConfigurationBorrowConfigurationOutput) MaxTimeToLiveInMinutes() pulumi.IntOutput

Maximum time for the provisional configuration, in minutes.

func (GetReceivedLicenseConsumptionConfigurationBorrowConfigurationOutput) ToGetReceivedLicenseConsumptionConfigurationBorrowConfigurationOutput 

func (o GetReceivedLicenseConsumptionConfigurationBorrowConfigurationOutput) ToGetReceivedLicenseConsumptionConfigurationBorrowConfigurationOutput() GetReceivedLicenseConsumptionConfigurationBorrowConfigurationOutput

func (GetReceivedLicenseConsumptionConfigurationBorrowConfigurationOutput) ToGetReceivedLicenseConsumptionConfigurationBorrowConfigurationOutputWithContext 

func (o GetReceivedLicenseConsumptionConfigurationBorrowConfigurationOutput) ToGetReceivedLicenseConsumptionConfigurationBorrowConfigurationOutputWithContext(ctx context.Context) GetReceivedLicenseConsumptionConfigurationBorrowConfigurationOutput

type GetReceivedLicenseConsumptionConfigurationInput 

type GetReceivedLicenseConsumptionConfigurationInput interface {
	pulumi.Input

	ToGetReceivedLicenseConsumptionConfigurationOutput() GetReceivedLicenseConsumptionConfigurationOutput
	ToGetReceivedLicenseConsumptionConfigurationOutputWithContext(context.Context) GetReceivedLicenseConsumptionConfigurationOutput
}

GetReceivedLicenseConsumptionConfigurationInput is an input type that accepts GetReceivedLicenseConsumptionConfigurationArgs and GetReceivedLicenseConsumptionConfigurationOutput values. You can construct a concrete instance of `GetReceivedLicenseConsumptionConfigurationInput` via: 

GetReceivedLicenseConsumptionConfigurationArgs{...}

type GetReceivedLicenseConsumptionConfigurationOutput 

type GetReceivedLicenseConsumptionConfigurationOutput struct{ *pulumi.OutputState }

func (GetReceivedLicenseConsumptionConfigurationOutput) BorrowConfigurations 

func (o GetReceivedLicenseConsumptionConfigurationOutput) BorrowConfigurations() GetReceivedLicenseConsumptionConfigurationBorrowConfigurationArrayOutput

Details about a borrow configuration. Detailed below

func (GetReceivedLicenseConsumptionConfigurationOutput) ElementType 

func (GetReceivedLicenseConsumptionConfigurationOutput) ElementType() reflect.Type

func (GetReceivedLicenseConsumptionConfigurationOutput) ProvisionalConfigurations 

func (o GetReceivedLicenseConsumptionConfigurationOutput) ProvisionalConfigurations() GetReceivedLicenseConsumptionConfigurationProvisionalConfigurationArrayOutput

Details about a provisional configuration. Detailed below

func (GetReceivedLicenseConsumptionConfigurationOutput) RenewType 

func (o GetReceivedLicenseConsumptionConfigurationOutput) RenewType() pulumi.StringOutput

func (GetReceivedLicenseConsumptionConfigurationOutput) ToGetReceivedLicenseConsumptionConfigurationOutput 

func (o GetReceivedLicenseConsumptionConfigurationOutput) ToGetReceivedLicenseConsumptionConfigurationOutput() GetReceivedLicenseConsumptionConfigurationOutput

func (GetReceivedLicenseConsumptionConfigurationOutput) ToGetReceivedLicenseConsumptionConfigurationOutputWithContext 

func (o GetReceivedLicenseConsumptionConfigurationOutput) ToGetReceivedLicenseConsumptionConfigurationOutputWithContext(ctx context.Context) GetReceivedLicenseConsumptionConfigurationOutput

type GetReceivedLicenseConsumptionConfigurationProvisionalConfiguration 

type GetReceivedLicenseConsumptionConfigurationProvisionalConfiguration struct {
	// Maximum time for the provisional configuration, in minutes.
	MaxTimeToLiveInMinutes int `pulumi:"maxTimeToLiveInMinutes"`
}

type GetReceivedLicenseConsumptionConfigurationProvisionalConfigurationArgs 

type GetReceivedLicenseConsumptionConfigurationProvisionalConfigurationArgs struct {
	// Maximum time for the provisional configuration, in minutes.
	MaxTimeToLiveInMinutes pulumi.IntInput `pulumi:"maxTimeToLiveInMinutes"`
}

func (GetReceivedLicenseConsumptionConfigurationProvisionalConfigurationArgs) ElementType 

func (GetReceivedLicenseConsumptionConfigurationProvisionalConfigurationArgs) ElementType() reflect.Type

func (GetReceivedLicenseConsumptionConfigurationProvisionalConfigurationArgs) ToGetReceivedLicenseConsumptionConfigurationProvisionalConfigurationOutput 

func (i GetReceivedLicenseConsumptionConfigurationProvisionalConfigurationArgs) ToGetReceivedLicenseConsumptionConfigurationProvisionalConfigurationOutput() GetReceivedLicenseConsumptionConfigurationProvisionalConfigurationOutput

func (GetReceivedLicenseConsumptionConfigurationProvisionalConfigurationArgs) ToGetReceivedLicenseConsumptionConfigurationProvisionalConfigurationOutputWithContext 

func (i GetReceivedLicenseConsumptionConfigurationProvisionalConfigurationArgs) ToGetReceivedLicenseConsumptionConfigurationProvisionalConfigurationOutputWithContext(ctx context.Context) GetReceivedLicenseConsumptionConfigurationProvisionalConfigurationOutput

type GetReceivedLicenseConsumptionConfigurationProvisionalConfigurationArray 

type GetReceivedLicenseConsumptionConfigurationProvisionalConfigurationArray []GetReceivedLicenseConsumptionConfigurationProvisionalConfigurationInput

func (GetReceivedLicenseConsumptionConfigurationProvisionalConfigurationArray) ElementType 

func (GetReceivedLicenseConsumptionConfigurationProvisionalConfigurationArray) ElementType() reflect.Type

func (GetReceivedLicenseConsumptionConfigurationProvisionalConfigurationArray) ToGetReceivedLicenseConsumptionConfigurationProvisionalConfigurationArrayOutput 

func (i GetReceivedLicenseConsumptionConfigurationProvisionalConfigurationArray) ToGetReceivedLicenseConsumptionConfigurationProvisionalConfigurationArrayOutput() GetReceivedLicenseConsumptionConfigurationProvisionalConfigurationArrayOutput

func (GetReceivedLicenseConsumptionConfigurationProvisionalConfigurationArray) ToGetReceivedLicenseConsumptionConfigurationProvisionalConfigurationArrayOutputWithContext 

func (i GetReceivedLicenseConsumptionConfigurationProvisionalConfigurationArray) ToGetReceivedLicenseConsumptionConfigurationProvisionalConfigurationArrayOutputWithContext(ctx context.Context) GetReceivedLicenseConsumptionConfigurationProvisionalConfigurationArrayOutput

type GetReceivedLicenseConsumptionConfigurationProvisionalConfigurationArrayInput 

type GetReceivedLicenseConsumptionConfigurationProvisionalConfigurationArrayInput interface {
	pulumi.Input

	ToGetReceivedLicenseConsumptionConfigurationProvisionalConfigurationArrayOutput() GetReceivedLicenseConsumptionConfigurationProvisionalConfigurationArrayOutput
	ToGetReceivedLicenseConsumptionConfigurationProvisionalConfigurationArrayOutputWithContext(context.Context) GetReceivedLicenseConsumptionConfigurationProvisionalConfigurationArrayOutput
}

GetReceivedLicenseConsumptionConfigurationProvisionalConfigurationArrayInput is an input type that accepts GetReceivedLicenseConsumptionConfigurationProvisionalConfigurationArray and GetReceivedLicenseConsumptionConfigurationProvisionalConfigurationArrayOutput values. You can construct a concrete instance of `GetReceivedLicenseConsumptionConfigurationProvisionalConfigurationArrayInput` via: 

GetReceivedLicenseConsumptionConfigurationProvisionalConfigurationArray{ GetReceivedLicenseConsumptionConfigurationProvisionalConfigurationArgs{...} }

type GetReceivedLicenseConsumptionConfigurationProvisionalConfigurationArrayOutput 

type GetReceivedLicenseConsumptionConfigurationProvisionalConfigurationArrayOutput struct{ *pulumi.OutputState }

func (GetReceivedLicenseConsumptionConfigurationProvisionalConfigurationArrayOutput) ElementType 

func (GetReceivedLicenseConsumptionConfigurationProvisionalConfigurationArrayOutput) ElementType() reflect.Type

func (GetReceivedLicenseConsumptionConfigurationProvisionalConfigurationArrayOutput) Index 

func (o GetReceivedLicenseConsumptionConfigurationProvisionalConfigurationArrayOutput) Index(i pulumi.IntInput) GetReceivedLicenseConsumptionConfigurationProvisionalConfigurationOutput

func (GetReceivedLicenseConsumptionConfigurationProvisionalConfigurationArrayOutput) ToGetReceivedLicenseConsumptionConfigurationProvisionalConfigurationArrayOutput 

func (o GetReceivedLicenseConsumptionConfigurationProvisionalConfigurationArrayOutput) ToGetReceivedLicenseConsumptionConfigurationProvisionalConfigurationArrayOutput() GetReceivedLicenseConsumptionConfigurationProvisionalConfigurationArrayOutput

func (GetReceivedLicenseConsumptionConfigurationProvisionalConfigurationArrayOutput) ToGetReceivedLicenseConsumptionConfigurationProvisionalConfigurationArrayOutputWithContext 

func (o GetReceivedLicenseConsumptionConfigurationProvisionalConfigurationArrayOutput) ToGetReceivedLicenseConsumptionConfigurationProvisionalConfigurationArrayOutputWithContext(ctx context.Context) GetReceivedLicenseConsumptionConfigurationProvisionalConfigurationArrayOutput

type GetReceivedLicenseConsumptionConfigurationProvisionalConfigurationInput 

type GetReceivedLicenseConsumptionConfigurationProvisionalConfigurationInput interface {
	pulumi.Input

	ToGetReceivedLicenseConsumptionConfigurationProvisionalConfigurationOutput() GetReceivedLicenseConsumptionConfigurationProvisionalConfigurationOutput
	ToGetReceivedLicenseConsumptionConfigurationProvisionalConfigurationOutputWithContext(context.Context) GetReceivedLicenseConsumptionConfigurationProvisionalConfigurationOutput
}

GetReceivedLicenseConsumptionConfigurationProvisionalConfigurationInput is an input type that accepts GetReceivedLicenseConsumptionConfigurationProvisionalConfigurationArgs and GetReceivedLicenseConsumptionConfigurationProvisionalConfigurationOutput values. You can construct a concrete instance of `GetReceivedLicenseConsumptionConfigurationProvisionalConfigurationInput` via: 

GetReceivedLicenseConsumptionConfigurationProvisionalConfigurationArgs{...}

type GetReceivedLicenseConsumptionConfigurationProvisionalConfigurationOutput 

type GetReceivedLicenseConsumptionConfigurationProvisionalConfigurationOutput struct{ *pulumi.OutputState }

func (GetReceivedLicenseConsumptionConfigurationProvisionalConfigurationOutput) ElementType 

func (GetReceivedLicenseConsumptionConfigurationProvisionalConfigurationOutput) ElementType() reflect.Type

func (GetReceivedLicenseConsumptionConfigurationProvisionalConfigurationOutput) MaxTimeToLiveInMinutes 

func (o GetReceivedLicenseConsumptionConfigurationProvisionalConfigurationOutput) MaxTimeToLiveInMinutes() pulumi.IntOutput

Maximum time for the provisional configuration, in minutes.

func (GetReceivedLicenseConsumptionConfigurationProvisionalConfigurationOutput) ToGetReceivedLicenseConsumptionConfigurationProvisionalConfigurationOutput 

func (o GetReceivedLicenseConsumptionConfigurationProvisionalConfigurationOutput) ToGetReceivedLicenseConsumptionConfigurationProvisionalConfigurationOutput() GetReceivedLicenseConsumptionConfigurationProvisionalConfigurationOutput

func (GetReceivedLicenseConsumptionConfigurationProvisionalConfigurationOutput) ToGetReceivedLicenseConsumptionConfigurationProvisionalConfigurationOutputWithContext 

func (o GetReceivedLicenseConsumptionConfigurationProvisionalConfigurationOutput) ToGetReceivedLicenseConsumptionConfigurationProvisionalConfigurationOutputWithContext(ctx context.Context) GetReceivedLicenseConsumptionConfigurationProvisionalConfigurationOutput

type GetReceivedLicenseEntitlement 

type GetReceivedLicenseEntitlement struct {
	// Indicates whether check-ins are allowed.
	AllowCheckIn bool `pulumi:"allowCheckIn"`
	// Maximum entitlement count. Use if the unit is not None.
	MaxCount int `pulumi:"maxCount"`
	// The key name.
	Name string `pulumi:"name"`
	// Entitlement unit.
	Unit string `pulumi:"unit"`
	// The value.
	Value string `pulumi:"value"`
}

type GetReceivedLicenseEntitlementArgs 

type GetReceivedLicenseEntitlementArgs struct {
	// Indicates whether check-ins are allowed.
	AllowCheckIn pulumi.BoolInput `pulumi:"allowCheckIn"`
	// Maximum entitlement count. Use if the unit is not None.
	MaxCount pulumi.IntInput `pulumi:"maxCount"`
	// The key name.
	Name pulumi.StringInput `pulumi:"name"`
	// Entitlement unit.
	Unit pulumi.StringInput `pulumi:"unit"`
	// The value.
	Value pulumi.StringInput `pulumi:"value"`
}

func (GetReceivedLicenseEntitlementArgs) ElementType 

func (GetReceivedLicenseEntitlementArgs) ElementType() reflect.Type

func (GetReceivedLicenseEntitlementArgs) ToGetReceivedLicenseEntitlementOutput 

func (i GetReceivedLicenseEntitlementArgs) ToGetReceivedLicenseEntitlementOutput() GetReceivedLicenseEntitlementOutput

func (GetReceivedLicenseEntitlementArgs) ToGetReceivedLicenseEntitlementOutputWithContext 

func (i GetReceivedLicenseEntitlementArgs) ToGetReceivedLicenseEntitlementOutputWithContext(ctx context.Context) GetReceivedLicenseEntitlementOutput

type GetReceivedLicenseEntitlementArray 

type GetReceivedLicenseEntitlementArray []GetReceivedLicenseEntitlementInput

func (GetReceivedLicenseEntitlementArray) ElementType 

func (GetReceivedLicenseEntitlementArray) ElementType() reflect.Type

func (GetReceivedLicenseEntitlementArray) ToGetReceivedLicenseEntitlementArrayOutput 

func (i GetReceivedLicenseEntitlementArray) ToGetReceivedLicenseEntitlementArrayOutput() GetReceivedLicenseEntitlementArrayOutput

func (GetReceivedLicenseEntitlementArray) ToGetReceivedLicenseEntitlementArrayOutputWithContext 

func (i GetReceivedLicenseEntitlementArray) ToGetReceivedLicenseEntitlementArrayOutputWithContext(ctx context.Context) GetReceivedLicenseEntitlementArrayOutput

type GetReceivedLicenseEntitlementArrayInput 

type GetReceivedLicenseEntitlementArrayInput interface {
	pulumi.Input

	ToGetReceivedLicenseEntitlementArrayOutput() GetReceivedLicenseEntitlementArrayOutput
	ToGetReceivedLicenseEntitlementArrayOutputWithContext(context.Context) GetReceivedLicenseEntitlementArrayOutput
}

GetReceivedLicenseEntitlementArrayInput is an input type that accepts GetReceivedLicenseEntitlementArray and GetReceivedLicenseEntitlementArrayOutput values. You can construct a concrete instance of `GetReceivedLicenseEntitlementArrayInput` via: 

GetReceivedLicenseEntitlementArray{ GetReceivedLicenseEntitlementArgs{...} }

type GetReceivedLicenseEntitlementArrayOutput 

type GetReceivedLicenseEntitlementArrayOutput struct{ *pulumi.OutputState }

func (GetReceivedLicenseEntitlementArrayOutput) ElementType 

func (GetReceivedLicenseEntitlementArrayOutput) ElementType() reflect.Type

func (GetReceivedLicenseEntitlementArrayOutput) Index 

func (o GetReceivedLicenseEntitlementArrayOutput) Index(i pulumi.IntInput) GetReceivedLicenseEntitlementOutput

func (GetReceivedLicenseEntitlementArrayOutput) ToGetReceivedLicenseEntitlementArrayOutput 

func (o GetReceivedLicenseEntitlementArrayOutput) ToGetReceivedLicenseEntitlementArrayOutput() GetReceivedLicenseEntitlementArrayOutput

func (GetReceivedLicenseEntitlementArrayOutput) ToGetReceivedLicenseEntitlementArrayOutputWithContext 

func (o GetReceivedLicenseEntitlementArrayOutput) ToGetReceivedLicenseEntitlementArrayOutputWithContext(ctx context.Context) GetReceivedLicenseEntitlementArrayOutput

type GetReceivedLicenseEntitlementInput 

type GetReceivedLicenseEntitlementInput interface {
	pulumi.Input

	ToGetReceivedLicenseEntitlementOutput() GetReceivedLicenseEntitlementOutput
	ToGetReceivedLicenseEntitlementOutputWithContext(context.Context) GetReceivedLicenseEntitlementOutput
}

GetReceivedLicenseEntitlementInput is an input type that accepts GetReceivedLicenseEntitlementArgs and GetReceivedLicenseEntitlementOutput values. You can construct a concrete instance of `GetReceivedLicenseEntitlementInput` via: 

GetReceivedLicenseEntitlementArgs{...}

type GetReceivedLicenseEntitlementOutput 

type GetReceivedLicenseEntitlementOutput struct{ *pulumi.OutputState }

func (GetReceivedLicenseEntitlementOutput) AllowCheckIn 

func (o GetReceivedLicenseEntitlementOutput) AllowCheckIn() pulumi.BoolOutput

Indicates whether check-ins are allowed.

func (GetReceivedLicenseEntitlementOutput) ElementType 

func (GetReceivedLicenseEntitlementOutput) ElementType() reflect.Type

func (GetReceivedLicenseEntitlementOutput) MaxCount 

func (o GetReceivedLicenseEntitlementOutput) MaxCount() pulumi.IntOutput

Maximum entitlement count. Use if the unit is not None.

func (GetReceivedLicenseEntitlementOutput) Name 

func (o GetReceivedLicenseEntitlementOutput) Name() pulumi.StringOutput

The key name.

func (GetReceivedLicenseEntitlementOutput) ToGetReceivedLicenseEntitlementOutput 

func (o GetReceivedLicenseEntitlementOutput) ToGetReceivedLicenseEntitlementOutput() GetReceivedLicenseEntitlementOutput

func (GetReceivedLicenseEntitlementOutput) ToGetReceivedLicenseEntitlementOutputWithContext 

func (o GetReceivedLicenseEntitlementOutput) ToGetReceivedLicenseEntitlementOutputWithContext(ctx context.Context) GetReceivedLicenseEntitlementOutput

func (GetReceivedLicenseEntitlementOutput) Unit 

func (o GetReceivedLicenseEntitlementOutput) Unit() pulumi.StringOutput

Entitlement unit.

func (GetReceivedLicenseEntitlementOutput) Value 

func (o GetReceivedLicenseEntitlementOutput) Value() pulumi.StringOutput

The value.

type GetReceivedLicenseIssuer 

type GetReceivedLicenseIssuer struct {
	// Issuer key fingerprint.
	KeyFingerprint string `pulumi:"keyFingerprint"`
	// The key name.
	Name string `pulumi:"name"`
	// Asymmetric KMS key from AWS Key Management Service. The KMS key must have a key usage of sign and verify, and support the RSASSA-PSS SHA-256 signing algorithm.
	SignKey string `pulumi:"signKey"`
}

type GetReceivedLicenseIssuerArgs 

type GetReceivedLicenseIssuerArgs struct {
	// Issuer key fingerprint.
	KeyFingerprint pulumi.StringInput `pulumi:"keyFingerprint"`
	// The key name.
	Name pulumi.StringInput `pulumi:"name"`
	// Asymmetric KMS key from AWS Key Management Service. The KMS key must have a key usage of sign and verify, and support the RSASSA-PSS SHA-256 signing algorithm.
	SignKey pulumi.StringInput `pulumi:"signKey"`
}

func (GetReceivedLicenseIssuerArgs) ElementType 

func (GetReceivedLicenseIssuerArgs) ElementType() reflect.Type

func (GetReceivedLicenseIssuerArgs) ToGetReceivedLicenseIssuerOutput 

func (i GetReceivedLicenseIssuerArgs) ToGetReceivedLicenseIssuerOutput() GetReceivedLicenseIssuerOutput

func (GetReceivedLicenseIssuerArgs) ToGetReceivedLicenseIssuerOutputWithContext 

func (i GetReceivedLicenseIssuerArgs) ToGetReceivedLicenseIssuerOutputWithContext(ctx context.Context) GetReceivedLicenseIssuerOutput

type GetReceivedLicenseIssuerArray 

type GetReceivedLicenseIssuerArray []GetReceivedLicenseIssuerInput

func (GetReceivedLicenseIssuerArray) ElementType 

func (GetReceivedLicenseIssuerArray) ElementType() reflect.Type

func (GetReceivedLicenseIssuerArray) ToGetReceivedLicenseIssuerArrayOutput 

func (i GetReceivedLicenseIssuerArray) ToGetReceivedLicenseIssuerArrayOutput() GetReceivedLicenseIssuerArrayOutput

func (GetReceivedLicenseIssuerArray) ToGetReceivedLicenseIssuerArrayOutputWithContext 

func (i GetReceivedLicenseIssuerArray) ToGetReceivedLicenseIssuerArrayOutputWithContext(ctx context.Context) GetReceivedLicenseIssuerArrayOutput

type GetReceivedLicenseIssuerArrayInput 

type GetReceivedLicenseIssuerArrayInput interface {
	pulumi.Input

	ToGetReceivedLicenseIssuerArrayOutput() GetReceivedLicenseIssuerArrayOutput
	ToGetReceivedLicenseIssuerArrayOutputWithContext(context.Context) GetReceivedLicenseIssuerArrayOutput
}

GetReceivedLicenseIssuerArrayInput is an input type that accepts GetReceivedLicenseIssuerArray and GetReceivedLicenseIssuerArrayOutput values. You can construct a concrete instance of `GetReceivedLicenseIssuerArrayInput` via: 

GetReceivedLicenseIssuerArray{ GetReceivedLicenseIssuerArgs{...} }

type GetReceivedLicenseIssuerArrayOutput 

type GetReceivedLicenseIssuerArrayOutput struct{ *pulumi.OutputState }

func (GetReceivedLicenseIssuerArrayOutput) ElementType 

func (GetReceivedLicenseIssuerArrayOutput) ElementType() reflect.Type

func (GetReceivedLicenseIssuerArrayOutput) Index 

func (o GetReceivedLicenseIssuerArrayOutput) Index(i pulumi.IntInput) GetReceivedLicenseIssuerOutput

func (GetReceivedLicenseIssuerArrayOutput) ToGetReceivedLicenseIssuerArrayOutput 

func (o GetReceivedLicenseIssuerArrayOutput) ToGetReceivedLicenseIssuerArrayOutput() GetReceivedLicenseIssuerArrayOutput

func (GetReceivedLicenseIssuerArrayOutput) ToGetReceivedLicenseIssuerArrayOutputWithContext 

func (o GetReceivedLicenseIssuerArrayOutput) ToGetReceivedLicenseIssuerArrayOutputWithContext(ctx context.Context) GetReceivedLicenseIssuerArrayOutput

type GetReceivedLicenseIssuerInput 

type GetReceivedLicenseIssuerInput interface {
	pulumi.Input

	ToGetReceivedLicenseIssuerOutput() GetReceivedLicenseIssuerOutput
	ToGetReceivedLicenseIssuerOutputWithContext(context.Context) GetReceivedLicenseIssuerOutput
}

GetReceivedLicenseIssuerInput is an input type that accepts GetReceivedLicenseIssuerArgs and GetReceivedLicenseIssuerOutput values. You can construct a concrete instance of `GetReceivedLicenseIssuerInput` via: 

GetReceivedLicenseIssuerArgs{...}

type GetReceivedLicenseIssuerOutput 

type GetReceivedLicenseIssuerOutput struct{ *pulumi.OutputState }

func (GetReceivedLicenseIssuerOutput) ElementType 

func (GetReceivedLicenseIssuerOutput) ElementType() reflect.Type

func (GetReceivedLicenseIssuerOutput) KeyFingerprint 

func (o GetReceivedLicenseIssuerOutput) KeyFingerprint() pulumi.StringOutput

Issuer key fingerprint.

func (GetReceivedLicenseIssuerOutput) Name 

func (o GetReceivedLicenseIssuerOutput) Name() pulumi.StringOutput

The key name.

func (GetReceivedLicenseIssuerOutput) SignKey 

func (o GetReceivedLicenseIssuerOutput) SignKey() pulumi.StringOutput

Asymmetric KMS key from AWS Key Management Service. The KMS key must have a key usage of sign and verify, and support the RSASSA-PSS SHA-256 signing algorithm.

func (GetReceivedLicenseIssuerOutput) ToGetReceivedLicenseIssuerOutput 

func (o GetReceivedLicenseIssuerOutput) ToGetReceivedLicenseIssuerOutput() GetReceivedLicenseIssuerOutput

func (GetReceivedLicenseIssuerOutput) ToGetReceivedLicenseIssuerOutputWithContext 

func (o GetReceivedLicenseIssuerOutput) ToGetReceivedLicenseIssuerOutputWithContext(ctx context.Context) GetReceivedLicenseIssuerOutput

type GetReceivedLicenseLicenseMetadata 

type GetReceivedLicenseLicenseMetadata struct {
	// The key name.
	Name string `pulumi:"name"`
	// The value.
	Value string `pulumi:"value"`
}

type GetReceivedLicenseLicenseMetadataArgs 

type GetReceivedLicenseLicenseMetadataArgs struct {
	// The key name.
	Name pulumi.StringInput `pulumi:"name"`
	// The value.
	Value pulumi.StringInput `pulumi:"value"`
}

func (GetReceivedLicenseLicenseMetadataArgs) ElementType 

func (GetReceivedLicenseLicenseMetadataArgs) ElementType() reflect.Type

func (GetReceivedLicenseLicenseMetadataArgs) ToGetReceivedLicenseLicenseMetadataOutput 

func (i GetReceivedLicenseLicenseMetadataArgs) ToGetReceivedLicenseLicenseMetadataOutput() GetReceivedLicenseLicenseMetadataOutput

func (GetReceivedLicenseLicenseMetadataArgs) ToGetReceivedLicenseLicenseMetadataOutputWithContext 

func (i GetReceivedLicenseLicenseMetadataArgs) ToGetReceivedLicenseLicenseMetadataOutputWithContext(ctx context.Context) GetReceivedLicenseLicenseMetadataOutput

type GetReceivedLicenseLicenseMetadataArray 

type GetReceivedLicenseLicenseMetadataArray []GetReceivedLicenseLicenseMetadataInput

func (GetReceivedLicenseLicenseMetadataArray) ElementType 

func (GetReceivedLicenseLicenseMetadataArray) ElementType() reflect.Type

func (GetReceivedLicenseLicenseMetadataArray) ToGetReceivedLicenseLicenseMetadataArrayOutput 

func (i GetReceivedLicenseLicenseMetadataArray) ToGetReceivedLicenseLicenseMetadataArrayOutput() GetReceivedLicenseLicenseMetadataArrayOutput

func (GetReceivedLicenseLicenseMetadataArray) ToGetReceivedLicenseLicenseMetadataArrayOutputWithContext 

func (i GetReceivedLicenseLicenseMetadataArray) ToGetReceivedLicenseLicenseMetadataArrayOutputWithContext(ctx context.Context) GetReceivedLicenseLicenseMetadataArrayOutput

type GetReceivedLicenseLicenseMetadataArrayInput 

type GetReceivedLicenseLicenseMetadataArrayInput interface {
	pulumi.Input

	ToGetReceivedLicenseLicenseMetadataArrayOutput() GetReceivedLicenseLicenseMetadataArrayOutput
	ToGetReceivedLicenseLicenseMetadataArrayOutputWithContext(context.Context) GetReceivedLicenseLicenseMetadataArrayOutput
}

GetReceivedLicenseLicenseMetadataArrayInput is an input type that accepts GetReceivedLicenseLicenseMetadataArray and GetReceivedLicenseLicenseMetadataArrayOutput values. You can construct a concrete instance of `GetReceivedLicenseLicenseMetadataArrayInput` via: 

GetReceivedLicenseLicenseMetadataArray{ GetReceivedLicenseLicenseMetadataArgs{...} }

type GetReceivedLicenseLicenseMetadataArrayOutput 

type GetReceivedLicenseLicenseMetadataArrayOutput struct{ *pulumi.OutputState }

func (GetReceivedLicenseLicenseMetadataArrayOutput) ElementType 

func (GetReceivedLicenseLicenseMetadataArrayOutput) ElementType() reflect.Type

func (GetReceivedLicenseLicenseMetadataArrayOutput) Index 

func (o GetReceivedLicenseLicenseMetadataArrayOutput) Index(i pulumi.IntInput) GetReceivedLicenseLicenseMetadataOutput

func (GetReceivedLicenseLicenseMetadataArrayOutput) ToGetReceivedLicenseLicenseMetadataArrayOutput 

func (o GetReceivedLicenseLicenseMetadataArrayOutput) ToGetReceivedLicenseLicenseMetadataArrayOutput() GetReceivedLicenseLicenseMetadataArrayOutput

func (GetReceivedLicenseLicenseMetadataArrayOutput) ToGetReceivedLicenseLicenseMetadataArrayOutputWithContext 

func (o GetReceivedLicenseLicenseMetadataArrayOutput) ToGetReceivedLicenseLicenseMetadataArrayOutputWithContext(ctx context.Context) GetReceivedLicenseLicenseMetadataArrayOutput

type GetReceivedLicenseLicenseMetadataInput 

type GetReceivedLicenseLicenseMetadataInput interface {
	pulumi.Input

	ToGetReceivedLicenseLicenseMetadataOutput() GetReceivedLicenseLicenseMetadataOutput
	ToGetReceivedLicenseLicenseMetadataOutputWithContext(context.Context) GetReceivedLicenseLicenseMetadataOutput
}

GetReceivedLicenseLicenseMetadataInput is an input type that accepts GetReceivedLicenseLicenseMetadataArgs and GetReceivedLicenseLicenseMetadataOutput values. You can construct a concrete instance of `GetReceivedLicenseLicenseMetadataInput` via: 

GetReceivedLicenseLicenseMetadataArgs{...}

type GetReceivedLicenseLicenseMetadataOutput 

type GetReceivedLicenseLicenseMetadataOutput struct{ *pulumi.OutputState }

func (GetReceivedLicenseLicenseMetadataOutput) ElementType 

func (GetReceivedLicenseLicenseMetadataOutput) ElementType() reflect.Type

func (GetReceivedLicenseLicenseMetadataOutput) Name 

func (o GetReceivedLicenseLicenseMetadataOutput) Name() pulumi.StringOutput

The key name.

func (GetReceivedLicenseLicenseMetadataOutput) ToGetReceivedLicenseLicenseMetadataOutput 

func (o GetReceivedLicenseLicenseMetadataOutput) ToGetReceivedLicenseLicenseMetadataOutput() GetReceivedLicenseLicenseMetadataOutput

func (GetReceivedLicenseLicenseMetadataOutput) ToGetReceivedLicenseLicenseMetadataOutputWithContext 

func (o GetReceivedLicenseLicenseMetadataOutput) ToGetReceivedLicenseLicenseMetadataOutputWithContext(ctx context.Context) GetReceivedLicenseLicenseMetadataOutput

func (GetReceivedLicenseLicenseMetadataOutput) Value 

func (o GetReceivedLicenseLicenseMetadataOutput) Value() pulumi.StringOutput

The value.

type GetReceivedLicenseOutputArgs 

type GetReceivedLicenseOutputArgs struct {
	// The ARN of the received license you want data for.
	LicenseArn pulumi.StringInput `pulumi:"licenseArn"`
}

A collection of arguments for invoking getReceivedLicense.

func (GetReceivedLicenseOutputArgs) ElementType 

func (GetReceivedLicenseOutputArgs) ElementType() reflect.Type

type GetReceivedLicenseReceivedMetadata 

type GetReceivedLicenseReceivedMetadata struct {
	// A list of allowed operations.
	AllowedOperations []string `pulumi:"allowedOperations"`
	// Received status.
	ReceivedStatus string `pulumi:"receivedStatus"`
	// Received status reason.
	ReceivedStatusReason string `pulumi:"receivedStatusReason"`
}

type GetReceivedLicenseReceivedMetadataArgs 

type GetReceivedLicenseReceivedMetadataArgs struct {
	// A list of allowed operations.
	AllowedOperations pulumi.StringArrayInput `pulumi:"allowedOperations"`
	// Received status.
	ReceivedStatus pulumi.StringInput `pulumi:"receivedStatus"`
	// Received status reason.
	ReceivedStatusReason pulumi.StringInput `pulumi:"receivedStatusReason"`
}

func (GetReceivedLicenseReceivedMetadataArgs) ElementType 

func (GetReceivedLicenseReceivedMetadataArgs) ElementType() reflect.Type

func (GetReceivedLicenseReceivedMetadataArgs) ToGetReceivedLicenseReceivedMetadataOutput 

func (i GetReceivedLicenseReceivedMetadataArgs) ToGetReceivedLicenseReceivedMetadataOutput() GetReceivedLicenseReceivedMetadataOutput

func (GetReceivedLicenseReceivedMetadataArgs) ToGetReceivedLicenseReceivedMetadataOutputWithContext 

func (i GetReceivedLicenseReceivedMetadataArgs) ToGetReceivedLicenseReceivedMetadataOutputWithContext(ctx context.Context) GetReceivedLicenseReceivedMetadataOutput

type GetReceivedLicenseReceivedMetadataArray 

type GetReceivedLicenseReceivedMetadataArray []GetReceivedLicenseReceivedMetadataInput

func (GetReceivedLicenseReceivedMetadataArray) ElementType 

func (GetReceivedLicenseReceivedMetadataArray) ElementType() reflect.Type

func (GetReceivedLicenseReceivedMetadataArray) ToGetReceivedLicenseReceivedMetadataArrayOutput 

func (i GetReceivedLicenseReceivedMetadataArray) ToGetReceivedLicenseReceivedMetadataArrayOutput() GetReceivedLicenseReceivedMetadataArrayOutput

func (GetReceivedLicenseReceivedMetadataArray) ToGetReceivedLicenseReceivedMetadataArrayOutputWithContext 

func (i GetReceivedLicenseReceivedMetadataArray) ToGetReceivedLicenseReceivedMetadataArrayOutputWithContext(ctx context.Context) GetReceivedLicenseReceivedMetadataArrayOutput

type GetReceivedLicenseReceivedMetadataArrayInput 

type GetReceivedLicenseReceivedMetadataArrayInput interface {
	pulumi.Input

	ToGetReceivedLicenseReceivedMetadataArrayOutput() GetReceivedLicenseReceivedMetadataArrayOutput
	ToGetReceivedLicenseReceivedMetadataArrayOutputWithContext(context.Context) GetReceivedLicenseReceivedMetadataArrayOutput
}

GetReceivedLicenseReceivedMetadataArrayInput is an input type that accepts GetReceivedLicenseReceivedMetadataArray and GetReceivedLicenseReceivedMetadataArrayOutput values. You can construct a concrete instance of `GetReceivedLicenseReceivedMetadataArrayInput` via: 

GetReceivedLicenseReceivedMetadataArray{ GetReceivedLicenseReceivedMetadataArgs{...} }

type GetReceivedLicenseReceivedMetadataArrayOutput 

type GetReceivedLicenseReceivedMetadataArrayOutput struct{ *pulumi.OutputState }

func (GetReceivedLicenseReceivedMetadataArrayOutput) ElementType 

func (GetReceivedLicenseReceivedMetadataArrayOutput) ElementType() reflect.Type

func (GetReceivedLicenseReceivedMetadataArrayOutput) Index 

func (o GetReceivedLicenseReceivedMetadataArrayOutput) Index(i pulumi.IntInput) GetReceivedLicenseReceivedMetadataOutput

func (GetReceivedLicenseReceivedMetadataArrayOutput) ToGetReceivedLicenseReceivedMetadataArrayOutput 

func (o GetReceivedLicenseReceivedMetadataArrayOutput) ToGetReceivedLicenseReceivedMetadataArrayOutput() GetReceivedLicenseReceivedMetadataArrayOutput

func (GetReceivedLicenseReceivedMetadataArrayOutput) ToGetReceivedLicenseReceivedMetadataArrayOutputWithContext 

func (o GetReceivedLicenseReceivedMetadataArrayOutput) ToGetReceivedLicenseReceivedMetadataArrayOutputWithContext(ctx context.Context) GetReceivedLicenseReceivedMetadataArrayOutput

type GetReceivedLicenseReceivedMetadataInput 

type GetReceivedLicenseReceivedMetadataInput interface {
	pulumi.Input

	ToGetReceivedLicenseReceivedMetadataOutput() GetReceivedLicenseReceivedMetadataOutput
	ToGetReceivedLicenseReceivedMetadataOutputWithContext(context.Context) GetReceivedLicenseReceivedMetadataOutput
}

GetReceivedLicenseReceivedMetadataInput is an input type that accepts GetReceivedLicenseReceivedMetadataArgs and GetReceivedLicenseReceivedMetadataOutput values. You can construct a concrete instance of `GetReceivedLicenseReceivedMetadataInput` via: 

GetReceivedLicenseReceivedMetadataArgs{...}

type GetReceivedLicenseReceivedMetadataOutput 

type GetReceivedLicenseReceivedMetadataOutput struct{ *pulumi.OutputState }

func (GetReceivedLicenseReceivedMetadataOutput) AllowedOperations 

func (o GetReceivedLicenseReceivedMetadataOutput) AllowedOperations() pulumi.StringArrayOutput

A list of allowed operations.

func (GetReceivedLicenseReceivedMetadataOutput) ElementType 

func (GetReceivedLicenseReceivedMetadataOutput) ElementType() reflect.Type

func (GetReceivedLicenseReceivedMetadataOutput) ReceivedStatus 

func (o GetReceivedLicenseReceivedMetadataOutput) ReceivedStatus() pulumi.StringOutput

Received status.

func (GetReceivedLicenseReceivedMetadataOutput) ReceivedStatusReason 

func (o GetReceivedLicenseReceivedMetadataOutput) ReceivedStatusReason() pulumi.StringOutput

Received status reason.

func (GetReceivedLicenseReceivedMetadataOutput) ToGetReceivedLicenseReceivedMetadataOutput 

func (o GetReceivedLicenseReceivedMetadataOutput) ToGetReceivedLicenseReceivedMetadataOutput() GetReceivedLicenseReceivedMetadataOutput

func (GetReceivedLicenseReceivedMetadataOutput) ToGetReceivedLicenseReceivedMetadataOutputWithContext 

func (o GetReceivedLicenseReceivedMetadataOutput) ToGetReceivedLicenseReceivedMetadataOutputWithContext(ctx context.Context) GetReceivedLicenseReceivedMetadataOutput

type GetReceivedLicenseResult 

type GetReceivedLicenseResult struct {
	// Granted license beneficiary. This is in the form of the ARN of the root user of the account.
	Beneficiary string `pulumi:"beneficiary"`
	// Configuration for consumption of the license. Detailed below
	ConsumptionConfigurations []GetReceivedLicenseConsumptionConfiguration `pulumi:"consumptionConfigurations"`
	// Creation time of the granted license in RFC 3339 format.
	CreateTime string `pulumi:"createTime"`
	// License entitlements. Detailed below
	Entitlements []GetReceivedLicenseEntitlement `pulumi:"entitlements"`
	// Home Region of the granted license.
	HomeRegion string `pulumi:"homeRegion"`
	// The provider-assigned unique ID for this managed resource.
	Id string `pulumi:"id"`
	// Granted license issuer. Detailed below
	Issuers []GetReceivedLicenseIssuer `pulumi:"issuers"`
	// Amazon Resource Name (ARN) of the license.
	LicenseArn string `pulumi:"licenseArn"`
	// Granted license metadata. This is in the form of a set of all meta data. Detailed below
	LicenseMetadatas []GetReceivedLicenseLicenseMetadata `pulumi:"licenseMetadatas"`
	// License name.
	LicenseName string `pulumi:"licenseName"`
	// Product name.
	// * ` productSku  ` - Product SKU.
	ProductName string `pulumi:"productName"`
	ProductSku  string `pulumi:"productSku"`
	// Granted license received metadata. Detailed below
	ReceivedMetadatas []GetReceivedLicenseReceivedMetadata `pulumi:"receivedMetadatas"`
	// Granted license status.
	Status string `pulumi:"status"`
	// Date and time range during which the granted license is valid, in ISO8601-UTC format. Detailed below
	Validities []GetReceivedLicenseValidity `pulumi:"validities"`
	// Version of the granted license.
	Version string `pulumi:"version"`
}

A collection of values returned by getReceivedLicense.

func GetReceivedLicense 

func GetReceivedLicense(ctx *pulumi.Context, args *GetReceivedLicenseArgs, opts ...pulumi.InvokeOption) (*GetReceivedLicenseResult, error)

This resource can be used to get data on a received license using an ARN. This can be helpful for pulling in data on a license from the AWS marketplace and sharing that license with another account.

## Example Usage

The following shows getting the received license data using and ARN.

```go package main

import ( 

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

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := licensemanager.GetReceivedLicense(ctx, &licensemanager.GetReceivedLicenseArgs{
			LicenseArn: "arn:aws:license-manager::111111111111:license:l-ecbaa94eb71a4830b6d7e49268fecaa0",
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

type GetReceivedLicenseResultOutput 

type GetReceivedLicenseResultOutput struct{ *pulumi.OutputState }

A collection of values returned by getReceivedLicense.

func GetReceivedLicenseOutput 

func GetReceivedLicenseOutput(ctx *pulumi.Context, args GetReceivedLicenseOutputArgs, opts ...pulumi.InvokeOption) GetReceivedLicenseResultOutput

func (GetReceivedLicenseResultOutput) Beneficiary 

func (o GetReceivedLicenseResultOutput) Beneficiary() pulumi.StringOutput

Granted license beneficiary. This is in the form of the ARN of the root user of the account.

func (GetReceivedLicenseResultOutput) ConsumptionConfigurations 

func (o GetReceivedLicenseResultOutput) ConsumptionConfigurations() GetReceivedLicenseConsumptionConfigurationArrayOutput

Configuration for consumption of the license. Detailed below

func (GetReceivedLicenseResultOutput) CreateTime 

func (o GetReceivedLicenseResultOutput) CreateTime() pulumi.StringOutput

Creation time of the granted license in RFC 3339 format.

func (GetReceivedLicenseResultOutput) ElementType 

func (GetReceivedLicenseResultOutput) ElementType() reflect.Type

func (GetReceivedLicenseResultOutput) Entitlements 

func (o GetReceivedLicenseResultOutput) Entitlements() GetReceivedLicenseEntitlementArrayOutput

License entitlements. Detailed below

func (GetReceivedLicenseResultOutput) HomeRegion 

func (o GetReceivedLicenseResultOutput) HomeRegion() pulumi.StringOutput

Home Region of the granted license.

func (GetReceivedLicenseResultOutput) Id 

func (o GetReceivedLicenseResultOutput) Id() pulumi.StringOutput

The provider-assigned unique ID for this managed resource.

func (GetReceivedLicenseResultOutput) Issuers 

func (o GetReceivedLicenseResultOutput) Issuers() GetReceivedLicenseIssuerArrayOutput

Granted license issuer. Detailed below

func (GetReceivedLicenseResultOutput) LicenseArn 

func (o GetReceivedLicenseResultOutput) LicenseArn() pulumi.StringOutput

Amazon Resource Name (ARN) of the license.

func (GetReceivedLicenseResultOutput) LicenseMetadatas 

func (o GetReceivedLicenseResultOutput) LicenseMetadatas() GetReceivedLicenseLicenseMetadataArrayOutput

Granted license metadata. This is in the form of a set of all meta data. Detailed below

func (GetReceivedLicenseResultOutput) LicenseName 

func (o GetReceivedLicenseResultOutput) LicenseName() pulumi.StringOutput

License name.

func (GetReceivedLicenseResultOutput) ProductName 

func (o GetReceivedLicenseResultOutput) ProductName() pulumi.StringOutput

Product name. * ` productSku ` - Product SKU.

func (GetReceivedLicenseResultOutput) ProductSku 

func (o GetReceivedLicenseResultOutput) ProductSku() pulumi.StringOutput

func (GetReceivedLicenseResultOutput) ReceivedMetadatas 

func (o GetReceivedLicenseResultOutput) ReceivedMetadatas() GetReceivedLicenseReceivedMetadataArrayOutput

Granted license received metadata. Detailed below

func (GetReceivedLicenseResultOutput) Status 

func (o GetReceivedLicenseResultOutput) Status() pulumi.StringOutput

Granted license status.

func (GetReceivedLicenseResultOutput) ToGetReceivedLicenseResultOutput 

func (o GetReceivedLicenseResultOutput) ToGetReceivedLicenseResultOutput() GetReceivedLicenseResultOutput

func (GetReceivedLicenseResultOutput) ToGetReceivedLicenseResultOutputWithContext 

func (o GetReceivedLicenseResultOutput) ToGetReceivedLicenseResultOutputWithContext(ctx context.Context) GetReceivedLicenseResultOutput

func (GetReceivedLicenseResultOutput) Validities 

func (o GetReceivedLicenseResultOutput) Validities() GetReceivedLicenseValidityArrayOutput

Date and time range during which the granted license is valid, in ISO8601-UTC format. Detailed below

func (GetReceivedLicenseResultOutput) Version 

func (o GetReceivedLicenseResultOutput) Version() pulumi.StringOutput

Version of the granted license.

type GetReceivedLicenseValidity 

type GetReceivedLicenseValidity struct {
	// Start of the validity time range.
	Begin string `pulumi:"begin"`
	// End of the validity time range.
	End string `pulumi:"end"`
}

type GetReceivedLicenseValidityArgs 

type GetReceivedLicenseValidityArgs struct {
	// Start of the validity time range.
	Begin pulumi.StringInput `pulumi:"begin"`
	// End of the validity time range.
	End pulumi.StringInput `pulumi:"end"`
}

func (GetReceivedLicenseValidityArgs) ElementType 

func (GetReceivedLicenseValidityArgs) ElementType() reflect.Type

func (GetReceivedLicenseValidityArgs) ToGetReceivedLicenseValidityOutput 

func (i GetReceivedLicenseValidityArgs) ToGetReceivedLicenseValidityOutput() GetReceivedLicenseValidityOutput

func (GetReceivedLicenseValidityArgs) ToGetReceivedLicenseValidityOutputWithContext 

func (i GetReceivedLicenseValidityArgs) ToGetReceivedLicenseValidityOutputWithContext(ctx context.Context) GetReceivedLicenseValidityOutput

type GetReceivedLicenseValidityArray 

type GetReceivedLicenseValidityArray []GetReceivedLicenseValidityInput

func (GetReceivedLicenseValidityArray) ElementType 

func (GetReceivedLicenseValidityArray) ElementType() reflect.Type

func (GetReceivedLicenseValidityArray) ToGetReceivedLicenseValidityArrayOutput 

func (i GetReceivedLicenseValidityArray) ToGetReceivedLicenseValidityArrayOutput() GetReceivedLicenseValidityArrayOutput

func (GetReceivedLicenseValidityArray) ToGetReceivedLicenseValidityArrayOutputWithContext 

func (i GetReceivedLicenseValidityArray) ToGetReceivedLicenseValidityArrayOutputWithContext(ctx context.Context) GetReceivedLicenseValidityArrayOutput

type GetReceivedLicenseValidityArrayInput 

type GetReceivedLicenseValidityArrayInput interface {
	pulumi.Input

	ToGetReceivedLicenseValidityArrayOutput() GetReceivedLicenseValidityArrayOutput
	ToGetReceivedLicenseValidityArrayOutputWithContext(context.Context) GetReceivedLicenseValidityArrayOutput
}

GetReceivedLicenseValidityArrayInput is an input type that accepts GetReceivedLicenseValidityArray and GetReceivedLicenseValidityArrayOutput values. You can construct a concrete instance of `GetReceivedLicenseValidityArrayInput` via: 

GetReceivedLicenseValidityArray{ GetReceivedLicenseValidityArgs{...} }

type GetReceivedLicenseValidityArrayOutput 

type GetReceivedLicenseValidityArrayOutput struct{ *pulumi.OutputState }

func (GetReceivedLicenseValidityArrayOutput) ElementType 

func (GetReceivedLicenseValidityArrayOutput) ElementType() reflect.Type

func (GetReceivedLicenseValidityArrayOutput) Index 

func (o GetReceivedLicenseValidityArrayOutput) Index(i pulumi.IntInput) GetReceivedLicenseValidityOutput

func (GetReceivedLicenseValidityArrayOutput) ToGetReceivedLicenseValidityArrayOutput 

func (o GetReceivedLicenseValidityArrayOutput) ToGetReceivedLicenseValidityArrayOutput() GetReceivedLicenseValidityArrayOutput

func (GetReceivedLicenseValidityArrayOutput) ToGetReceivedLicenseValidityArrayOutputWithContext 

func (o GetReceivedLicenseValidityArrayOutput) ToGetReceivedLicenseValidityArrayOutputWithContext(ctx context.Context) GetReceivedLicenseValidityArrayOutput

type GetReceivedLicenseValidityInput 

type GetReceivedLicenseValidityInput interface {
	pulumi.Input

	ToGetReceivedLicenseValidityOutput() GetReceivedLicenseValidityOutput
	ToGetReceivedLicenseValidityOutputWithContext(context.Context) GetReceivedLicenseValidityOutput
}

GetReceivedLicenseValidityInput is an input type that accepts GetReceivedLicenseValidityArgs and GetReceivedLicenseValidityOutput values. You can construct a concrete instance of `GetReceivedLicenseValidityInput` via: 

GetReceivedLicenseValidityArgs{...}

type GetReceivedLicenseValidityOutput 

type GetReceivedLicenseValidityOutput struct{ *pulumi.OutputState }

func (GetReceivedLicenseValidityOutput) Begin 

func (o GetReceivedLicenseValidityOutput) Begin() pulumi.StringOutput

Start of the validity time range.

func (GetReceivedLicenseValidityOutput) ElementType 

func (GetReceivedLicenseValidityOutput) ElementType() reflect.Type

func (GetReceivedLicenseValidityOutput) End 

func (o GetReceivedLicenseValidityOutput) End() pulumi.StringOutput

End of the validity time range.

func (GetReceivedLicenseValidityOutput) ToGetReceivedLicenseValidityOutput 

func (o GetReceivedLicenseValidityOutput) ToGetReceivedLicenseValidityOutput() GetReceivedLicenseValidityOutput

func (GetReceivedLicenseValidityOutput) ToGetReceivedLicenseValidityOutputWithContext 

func (o GetReceivedLicenseValidityOutput) ToGetReceivedLicenseValidityOutputWithContext(ctx context.Context) GetReceivedLicenseValidityOutput

type GetReceivedLicensesArgs 

type GetReceivedLicensesArgs struct {
	// Custom filter block as described below.
	//
	// More complex filters can be expressed using one or more `filter` sub-blocks,
	// which take the following arguments:
	Filters []GetReceivedLicensesFilter `pulumi:"filters"`
}

A collection of arguments for invoking getReceivedLicenses.

type GetReceivedLicensesFilter 

type GetReceivedLicensesFilter struct {
	// Name of the field to filter by, as defined by
	// [the underlying AWS API](https://docs.aws.amazon.com/license-manager/latest/APIReference/API_ListReceivedLicenses.html#API_ListReceivedLicenses_RequestSyntax).
	// For example, if filtering using `ProductSKU`, use:
	//
	// “`go
	// package main
	//
	// import (
	// 	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/licensemanager"
	// 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	// )
	//
	// func main() {
	// 	pulumi.Run(func(ctx *pulumi.Context) error {
	// 		_, err := licensemanager.GetReceivedLicenses(ctx, &licensemanager.GetReceivedLicensesArgs{
	// 			Filters: []licensemanager.GetReceivedLicensesFilter{
	// 				{
	// 					Name: "ProductSKU",
	// 					Values: []string{
	// 						"",
	// 					},
	// 				},
	// 			},
	// 		}, nil)
	// 		if err != nil {
	// 			return err
	// 		}
	// 		return nil
	// 	})
	// }
	// “`
	Name string `pulumi:"name"`
	// Set of values that are accepted for the given field.
	Values []string `pulumi:"values"`
}

type GetReceivedLicensesFilterArgs 

type GetReceivedLicensesFilterArgs struct {
	// Name of the field to filter by, as defined by
	// [the underlying AWS API](https://docs.aws.amazon.com/license-manager/latest/APIReference/API_ListReceivedLicenses.html#API_ListReceivedLicenses_RequestSyntax).
	// For example, if filtering using `ProductSKU`, use:
	//
	// “`go
	// package main
	//
	// import (
	// 	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/licensemanager"
	// 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	// )
	//
	// func main() {
	// 	pulumi.Run(func(ctx *pulumi.Context) error {
	// 		_, err := licensemanager.GetReceivedLicenses(ctx, &licensemanager.GetReceivedLicensesArgs{
	// 			Filters: []licensemanager.GetReceivedLicensesFilter{
	// 				{
	// 					Name: "ProductSKU",
	// 					Values: []string{
	// 						"",
	// 					},
	// 				},
	// 			},
	// 		}, nil)
	// 		if err != nil {
	// 			return err
	// 		}
	// 		return nil
	// 	})
	// }
	// “`
	Name pulumi.StringInput `pulumi:"name"`
	// Set of values that are accepted for the given field.
	Values pulumi.StringArrayInput `pulumi:"values"`
}

func (GetReceivedLicensesFilterArgs) ElementType 

func (GetReceivedLicensesFilterArgs) ElementType() reflect.Type

func (GetReceivedLicensesFilterArgs) ToGetReceivedLicensesFilterOutput 

func (i GetReceivedLicensesFilterArgs) ToGetReceivedLicensesFilterOutput() GetReceivedLicensesFilterOutput

func (GetReceivedLicensesFilterArgs) ToGetReceivedLicensesFilterOutputWithContext 

func (i GetReceivedLicensesFilterArgs) ToGetReceivedLicensesFilterOutputWithContext(ctx context.Context) GetReceivedLicensesFilterOutput

type GetReceivedLicensesFilterArray 

type GetReceivedLicensesFilterArray []GetReceivedLicensesFilterInput

func (GetReceivedLicensesFilterArray) ElementType 

func (GetReceivedLicensesFilterArray) ElementType() reflect.Type

func (GetReceivedLicensesFilterArray) ToGetReceivedLicensesFilterArrayOutput 

func (i GetReceivedLicensesFilterArray) ToGetReceivedLicensesFilterArrayOutput() GetReceivedLicensesFilterArrayOutput

func (GetReceivedLicensesFilterArray) ToGetReceivedLicensesFilterArrayOutputWithContext 

func (i GetReceivedLicensesFilterArray) ToGetReceivedLicensesFilterArrayOutputWithContext(ctx context.Context) GetReceivedLicensesFilterArrayOutput

type GetReceivedLicensesFilterArrayInput 

type GetReceivedLicensesFilterArrayInput interface {
	pulumi.Input

	ToGetReceivedLicensesFilterArrayOutput() GetReceivedLicensesFilterArrayOutput
	ToGetReceivedLicensesFilterArrayOutputWithContext(context.Context) GetReceivedLicensesFilterArrayOutput
}

GetReceivedLicensesFilterArrayInput is an input type that accepts GetReceivedLicensesFilterArray and GetReceivedLicensesFilterArrayOutput values. You can construct a concrete instance of `GetReceivedLicensesFilterArrayInput` via: 

GetReceivedLicensesFilterArray{ GetReceivedLicensesFilterArgs{...} }

type GetReceivedLicensesFilterArrayOutput 

type GetReceivedLicensesFilterArrayOutput struct{ *pulumi.OutputState }

func (GetReceivedLicensesFilterArrayOutput) ElementType 

func (GetReceivedLicensesFilterArrayOutput) ElementType() reflect.Type

func (GetReceivedLicensesFilterArrayOutput) Index 

func (o GetReceivedLicensesFilterArrayOutput) Index(i pulumi.IntInput) GetReceivedLicensesFilterOutput

func (GetReceivedLicensesFilterArrayOutput) ToGetReceivedLicensesFilterArrayOutput 

func (o GetReceivedLicensesFilterArrayOutput) ToGetReceivedLicensesFilterArrayOutput() GetReceivedLicensesFilterArrayOutput

func (GetReceivedLicensesFilterArrayOutput) ToGetReceivedLicensesFilterArrayOutputWithContext 

func (o GetReceivedLicensesFilterArrayOutput) ToGetReceivedLicensesFilterArrayOutputWithContext(ctx context.Context) GetReceivedLicensesFilterArrayOutput

type GetReceivedLicensesFilterInput 

type GetReceivedLicensesFilterInput interface {
	pulumi.Input

	ToGetReceivedLicensesFilterOutput() GetReceivedLicensesFilterOutput
	ToGetReceivedLicensesFilterOutputWithContext(context.Context) GetReceivedLicensesFilterOutput
}

GetReceivedLicensesFilterInput is an input type that accepts GetReceivedLicensesFilterArgs and GetReceivedLicensesFilterOutput values. You can construct a concrete instance of `GetReceivedLicensesFilterInput` via: 

GetReceivedLicensesFilterArgs{...}

type GetReceivedLicensesFilterOutput 

type GetReceivedLicensesFilterOutput struct{ *pulumi.OutputState }

func (GetReceivedLicensesFilterOutput) ElementType 

func (GetReceivedLicensesFilterOutput) ElementType() reflect.Type

func (GetReceivedLicensesFilterOutput) Name 

func (o GetReceivedLicensesFilterOutput) Name() pulumi.StringOutput

Name of the field to filter by, as defined by [the underlying AWS API](https://docs.aws.amazon.com/license-manager/latest/APIReference/API_ListReceivedLicenses.html#API_ListReceivedLicenses_RequestSyntax). For example, if filtering using `ProductSKU`, use:

```go package main

import ( 

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

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := licensemanager.GetReceivedLicenses(ctx, &licensemanager.GetReceivedLicensesArgs{
			Filters: []licensemanager.GetReceivedLicensesFilter{
				{
					Name: "ProductSKU",
					Values: []string{
						"",
					},
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

func (GetReceivedLicensesFilterOutput) ToGetReceivedLicensesFilterOutput 

func (o GetReceivedLicensesFilterOutput) ToGetReceivedLicensesFilterOutput() GetReceivedLicensesFilterOutput

func (GetReceivedLicensesFilterOutput) ToGetReceivedLicensesFilterOutputWithContext 

func (o GetReceivedLicensesFilterOutput) ToGetReceivedLicensesFilterOutputWithContext(ctx context.Context) GetReceivedLicensesFilterOutput

func (GetReceivedLicensesFilterOutput) Values 

func (o GetReceivedLicensesFilterOutput) Values() pulumi.StringArrayOutput

Set of values that are accepted for the given field.

type GetReceivedLicensesOutputArgs 

type GetReceivedLicensesOutputArgs struct {
	// Custom filter block as described below.
	//
	// More complex filters can be expressed using one or more `filter` sub-blocks,
	// which take the following arguments:
	Filters GetReceivedLicensesFilterArrayInput `pulumi:"filters"`
}

A collection of arguments for invoking getReceivedLicenses.

func (GetReceivedLicensesOutputArgs) ElementType 

func (GetReceivedLicensesOutputArgs) ElementType() reflect.Type

type GetReceivedLicensesResult 

type GetReceivedLicensesResult struct {
	// List of all the license ARNs found.
	Arns    []string                    `pulumi:"arns"`
	Filters []GetReceivedLicensesFilter `pulumi:"filters"`
	// The provider-assigned unique ID for this managed resource.
	Id string `pulumi:"id"`
}

A collection of values returned by getReceivedLicenses.

func GetReceivedLicenses 

func GetReceivedLicenses(ctx *pulumi.Context, args *GetReceivedLicensesArgs, opts ...pulumi.InvokeOption) (*GetReceivedLicensesResult, error)

This resource can be used to get a set of license ARNs matching a filter.

## Example Usage

The following shows getting all license ARNs issued from the AWS marketplace. Providing no filter, would provide all license ARNs for the entire account.

```go package main

import ( 

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

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := licensemanager.GetReceivedLicenses(ctx, &licensemanager.GetReceivedLicensesArgs{
			Filters: []licensemanager.GetReceivedLicensesFilter{
				{
					Name: "IssuerName",
					Values: []string{
						"AWS/Marketplace",
					},
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

type GetReceivedLicensesResultOutput 

type GetReceivedLicensesResultOutput struct{ *pulumi.OutputState }

A collection of values returned by getReceivedLicenses.

func GetReceivedLicensesOutput 

func GetReceivedLicensesOutput(ctx *pulumi.Context, args GetReceivedLicensesOutputArgs, opts ...pulumi.InvokeOption) GetReceivedLicensesResultOutput

func (GetReceivedLicensesResultOutput) Arns 

func (o GetReceivedLicensesResultOutput) Arns() pulumi.StringArrayOutput

List of all the license ARNs found.

func (GetReceivedLicensesResultOutput) ElementType 

func (GetReceivedLicensesResultOutput) ElementType() reflect.Type

func (GetReceivedLicensesResultOutput) Filters 

func (o GetReceivedLicensesResultOutput) Filters() GetReceivedLicensesFilterArrayOutput

func (GetReceivedLicensesResultOutput) Id 

func (o GetReceivedLicensesResultOutput) Id() pulumi.StringOutput

The provider-assigned unique ID for this managed resource.

func (GetReceivedLicensesResultOutput) ToGetReceivedLicensesResultOutput 

func (o GetReceivedLicensesResultOutput) ToGetReceivedLicensesResultOutput() GetReceivedLicensesResultOutput

func (GetReceivedLicensesResultOutput) ToGetReceivedLicensesResultOutputWithContext 

func (o GetReceivedLicensesResultOutput) ToGetReceivedLicensesResultOutputWithContext(ctx context.Context) GetReceivedLicensesResultOutput

type LicenseConfiguration 

type LicenseConfiguration struct {
	pulumi.CustomResourceState

	// The license configuration ARN.
	Arn pulumi.StringOutput `pulumi:"arn"`
	// Description of the license configuration.
	Description pulumi.StringPtrOutput `pulumi:"description"`
	// Number of licenses managed by the license configuration.
	LicenseCount pulumi.IntPtrOutput `pulumi:"licenseCount"`
	// Sets the number of available licenses as a hard limit.
	LicenseCountHardLimit pulumi.BoolPtrOutput `pulumi:"licenseCountHardLimit"`
	// Dimension to use to track license inventory. Specify either `vCPU`, `Instance`, `Core` or `Socket`.
	LicenseCountingType pulumi.StringOutput `pulumi:"licenseCountingType"`
	// Array of configured License Manager rules.
	LicenseRules pulumi.StringArrayOutput `pulumi:"licenseRules"`
	// Name of the license configuration.
	Name pulumi.StringOutput `pulumi:"name"`
	// Account ID of the owner of the license configuration.
	OwnerAccountId pulumi.StringOutput `pulumi:"ownerAccountId"`
	// A map of tags to assign to the resource. If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapOutput `pulumi:"tags"`
	// A map of tags assigned to the resource, including those inherited from the provider `defaultTags` configuration block.
	//
	// Deprecated: Please use `tags` instead.
	TagsAll pulumi.StringMapOutput `pulumi:"tagsAll"`
}

Provides a License Manager license configuration resource.

> **Note:** Removing the `licenseCount` attribute is not supported by the License Manager API.

## Example Usage

```go package main

import ( 

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

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := licensemanager.NewLicenseConfiguration(ctx, "example", &licensemanager.LicenseConfigurationArgs{
			Name:                  pulumi.String("Example"),
			Description:           pulumi.String("Example"),
			LicenseCount:          pulumi.Int(10),
			LicenseCountHardLimit: pulumi.Bool(true),
			LicenseCountingType:   pulumi.String("Socket"),
			LicenseRules: pulumi.StringArray{
				pulumi.String("#minimumSockets=2"),
			},
			Tags: pulumi.StringMap{
				"foo": pulumi.String("barr"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Rules

License rules should be in the format of `#RuleType=RuleValue`. Supported rule types:

* `minimumVcpus` - Resource must have minimum vCPU count in order to use the license. Default: 1 * `maximumVcpus` - Resource must have maximum vCPU count in order to use the license. Default: unbounded, limit: 10000 * `minimumCores` - Resource must have minimum core count in order to use the license. Default: 1 * `maximumCores` - Resource must have maximum core count in order to use the license. Default: unbounded, limit: 10000 * `minimumSockets` - Resource must have minimum socket count in order to use the license. Default: 1 * `maximumSockets` - Resource must have maximum socket count in order to use the license. Default: unbounded, limit: 10000 * `allowedTenancy` - Defines where the license can be used. If set, restricts license usage to selected tenancies. Specify a comma delimited list of `EC2-Default`, `EC2-DedicatedHost`, `EC2-DedicatedInstance`

## Import

Using `pulumi import`, import license configurations using the `id`. For example:

```sh $ pulumi import aws:licensemanager/licenseConfiguration:LicenseConfiguration example arn:aws:license-manager:eu-west-1:123456789012:license-configuration:lic-0123456789abcdef0123456789abcdef ```

func GetLicenseConfiguration 

func GetLicenseConfiguration(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *LicenseConfigurationState, opts ...pulumi.ResourceOption) (*LicenseConfiguration, error)

GetLicenseConfiguration gets an existing LicenseConfiguration 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 NewLicenseConfiguration 

func NewLicenseConfiguration(ctx *pulumi.Context,
	name string, args *LicenseConfigurationArgs, opts ...pulumi.ResourceOption) (*LicenseConfiguration, error)

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

func (*LicenseConfiguration) ElementType 

func (*LicenseConfiguration) ElementType() reflect.Type

func (*LicenseConfiguration) ToLicenseConfigurationOutput 

func (i *LicenseConfiguration) ToLicenseConfigurationOutput() LicenseConfigurationOutput

func (*LicenseConfiguration) ToLicenseConfigurationOutputWithContext 

func (i *LicenseConfiguration) ToLicenseConfigurationOutputWithContext(ctx context.Context) LicenseConfigurationOutput

type LicenseConfigurationArgs 

type LicenseConfigurationArgs struct {
	// Description of the license configuration.
	Description pulumi.StringPtrInput
	// Number of licenses managed by the license configuration.
	LicenseCount pulumi.IntPtrInput
	// Sets the number of available licenses as a hard limit.
	LicenseCountHardLimit pulumi.BoolPtrInput
	// Dimension to use to track license inventory. Specify either `vCPU`, `Instance`, `Core` or `Socket`.
	LicenseCountingType pulumi.StringInput
	// Array of configured License Manager rules.
	LicenseRules pulumi.StringArrayInput
	// Name of the license configuration.
	Name pulumi.StringPtrInput
	// A map of tags to assign to the resource. If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapInput
}

The set of arguments for constructing a LicenseConfiguration resource.

func (LicenseConfigurationArgs) ElementType 

func (LicenseConfigurationArgs) ElementType() reflect.Type

type LicenseConfigurationArray 

type LicenseConfigurationArray []LicenseConfigurationInput

func (LicenseConfigurationArray) ElementType 

func (LicenseConfigurationArray) ElementType() reflect.Type

func (LicenseConfigurationArray) ToLicenseConfigurationArrayOutput 

func (i LicenseConfigurationArray) ToLicenseConfigurationArrayOutput() LicenseConfigurationArrayOutput

func (LicenseConfigurationArray) ToLicenseConfigurationArrayOutputWithContext 

func (i LicenseConfigurationArray) ToLicenseConfigurationArrayOutputWithContext(ctx context.Context) LicenseConfigurationArrayOutput

type LicenseConfigurationArrayInput 

type LicenseConfigurationArrayInput interface {
	pulumi.Input

	ToLicenseConfigurationArrayOutput() LicenseConfigurationArrayOutput
	ToLicenseConfigurationArrayOutputWithContext(context.Context) LicenseConfigurationArrayOutput
}

LicenseConfigurationArrayInput is an input type that accepts LicenseConfigurationArray and LicenseConfigurationArrayOutput values. You can construct a concrete instance of `LicenseConfigurationArrayInput` via: 

LicenseConfigurationArray{ LicenseConfigurationArgs{...} }

type LicenseConfigurationArrayOutput 

type LicenseConfigurationArrayOutput struct{ *pulumi.OutputState }

func (LicenseConfigurationArrayOutput) ElementType 

func (LicenseConfigurationArrayOutput) ElementType() reflect.Type

func (LicenseConfigurationArrayOutput) Index 

func (o LicenseConfigurationArrayOutput) Index(i pulumi.IntInput) LicenseConfigurationOutput

func (LicenseConfigurationArrayOutput) ToLicenseConfigurationArrayOutput 

func (o LicenseConfigurationArrayOutput) ToLicenseConfigurationArrayOutput() LicenseConfigurationArrayOutput

func (LicenseConfigurationArrayOutput) ToLicenseConfigurationArrayOutputWithContext 

func (o LicenseConfigurationArrayOutput) ToLicenseConfigurationArrayOutputWithContext(ctx context.Context) LicenseConfigurationArrayOutput

type LicenseConfigurationInput 

type LicenseConfigurationInput interface {
	pulumi.Input

	ToLicenseConfigurationOutput() LicenseConfigurationOutput
	ToLicenseConfigurationOutputWithContext(ctx context.Context) LicenseConfigurationOutput
}

type LicenseConfigurationMap 

type LicenseConfigurationMap map[string]LicenseConfigurationInput

func (LicenseConfigurationMap) ElementType 

func (LicenseConfigurationMap) ElementType() reflect.Type

func (LicenseConfigurationMap) ToLicenseConfigurationMapOutput 

func (i LicenseConfigurationMap) ToLicenseConfigurationMapOutput() LicenseConfigurationMapOutput

func (LicenseConfigurationMap) ToLicenseConfigurationMapOutputWithContext 

func (i LicenseConfigurationMap) ToLicenseConfigurationMapOutputWithContext(ctx context.Context) LicenseConfigurationMapOutput

type LicenseConfigurationMapInput 

type LicenseConfigurationMapInput interface {
	pulumi.Input

	ToLicenseConfigurationMapOutput() LicenseConfigurationMapOutput
	ToLicenseConfigurationMapOutputWithContext(context.Context) LicenseConfigurationMapOutput
}

LicenseConfigurationMapInput is an input type that accepts LicenseConfigurationMap and LicenseConfigurationMapOutput values. You can construct a concrete instance of `LicenseConfigurationMapInput` via: 

LicenseConfigurationMap{ "key": LicenseConfigurationArgs{...} }

type LicenseConfigurationMapOutput 

type LicenseConfigurationMapOutput struct{ *pulumi.OutputState }

func (LicenseConfigurationMapOutput) ElementType 

func (LicenseConfigurationMapOutput) ElementType() reflect.Type

func (LicenseConfigurationMapOutput) MapIndex 

func (o LicenseConfigurationMapOutput) MapIndex(k pulumi.StringInput) LicenseConfigurationOutput

func (LicenseConfigurationMapOutput) ToLicenseConfigurationMapOutput 

func (o LicenseConfigurationMapOutput) ToLicenseConfigurationMapOutput() LicenseConfigurationMapOutput

func (LicenseConfigurationMapOutput) ToLicenseConfigurationMapOutputWithContext 

func (o LicenseConfigurationMapOutput) ToLicenseConfigurationMapOutputWithContext(ctx context.Context) LicenseConfigurationMapOutput

type LicenseConfigurationOutput 

type LicenseConfigurationOutput struct{ *pulumi.OutputState }

func (LicenseConfigurationOutput) Arn 

func (o LicenseConfigurationOutput) Arn() pulumi.StringOutput

The license configuration ARN.

func (LicenseConfigurationOutput) Description 

func (o LicenseConfigurationOutput) Description() pulumi.StringPtrOutput

Description of the license configuration.

func (LicenseConfigurationOutput) ElementType 

func (LicenseConfigurationOutput) ElementType() reflect.Type

func (LicenseConfigurationOutput) LicenseCount 

func (o LicenseConfigurationOutput) LicenseCount() pulumi.IntPtrOutput

Number of licenses managed by the license configuration.

func (LicenseConfigurationOutput) LicenseCountHardLimit 

func (o LicenseConfigurationOutput) LicenseCountHardLimit() pulumi.BoolPtrOutput

Sets the number of available licenses as a hard limit.

func (LicenseConfigurationOutput) LicenseCountingType 

func (o LicenseConfigurationOutput) LicenseCountingType() pulumi.StringOutput

Dimension to use to track license inventory. Specify either `vCPU`, `Instance`, `Core` or `Socket`.

func (LicenseConfigurationOutput) LicenseRules 

func (o LicenseConfigurationOutput) LicenseRules() pulumi.StringArrayOutput

Array of configured License Manager rules.

func (LicenseConfigurationOutput) Name 

func (o LicenseConfigurationOutput) Name() pulumi.StringOutput

Name of the license configuration.

func (LicenseConfigurationOutput) OwnerAccountId 

func (o LicenseConfigurationOutput) OwnerAccountId() pulumi.StringOutput

Account ID of the owner of the license configuration.

func (LicenseConfigurationOutput) Tags 

func (o LicenseConfigurationOutput) Tags() pulumi.StringMapOutput

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

func (LicenseConfigurationOutput) TagsAll deprecated 

func (o LicenseConfigurationOutput) TagsAll() pulumi.StringMapOutput

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

Deprecated: Please use `tags` instead.

func (LicenseConfigurationOutput) ToLicenseConfigurationOutput 

func (o LicenseConfigurationOutput) ToLicenseConfigurationOutput() LicenseConfigurationOutput

func (LicenseConfigurationOutput) ToLicenseConfigurationOutputWithContext 

func (o LicenseConfigurationOutput) ToLicenseConfigurationOutputWithContext(ctx context.Context) LicenseConfigurationOutput

type LicenseConfigurationState 

type LicenseConfigurationState struct {
	// The license configuration ARN.
	Arn pulumi.StringPtrInput
	// Description of the license configuration.
	Description pulumi.StringPtrInput
	// Number of licenses managed by the license configuration.
	LicenseCount pulumi.IntPtrInput
	// Sets the number of available licenses as a hard limit.
	LicenseCountHardLimit pulumi.BoolPtrInput
	// Dimension to use to track license inventory. Specify either `vCPU`, `Instance`, `Core` or `Socket`.
	LicenseCountingType pulumi.StringPtrInput
	// Array of configured License Manager rules.
	LicenseRules pulumi.StringArrayInput
	// Name of the license configuration.
	Name pulumi.StringPtrInput
	// Account ID of the owner of the license configuration.
	OwnerAccountId pulumi.StringPtrInput
	// A map of tags to assign to the resource. If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapInput
	// A map of tags assigned to the resource, including those inherited from the provider `defaultTags` configuration block.
	//
	// Deprecated: Please use `tags` instead.
	TagsAll pulumi.StringMapInput
}

func (LicenseConfigurationState) ElementType 

func (LicenseConfigurationState) ElementType() reflect.Type

type LicenseGrant 

type LicenseGrant struct {
	pulumi.CustomResourceState

	// A list of the allowed operations for the grant. This is a subset of the allowed operations on the license.
	AllowedOperations pulumi.StringArrayOutput `pulumi:"allowedOperations"`
	// The grant ARN.
	Arn pulumi.StringOutput `pulumi:"arn"`
	// The home region for the license.
	HomeRegion pulumi.StringOutput `pulumi:"homeRegion"`
	// The ARN of the license to grant.
	LicenseArn pulumi.StringOutput `pulumi:"licenseArn"`
	// The Name of the grant.
	Name pulumi.StringOutput `pulumi:"name"`
	// The parent ARN.
	ParentArn pulumi.StringOutput `pulumi:"parentArn"`
	// The target account for the grant in the form of the ARN for an account principal of the root user.
	Principal pulumi.StringOutput `pulumi:"principal"`
	// The grant status.
	Status pulumi.StringOutput `pulumi:"status"`
	// The grant version.
	Version pulumi.StringOutput `pulumi:"version"`
}

Provides a License Manager grant. This allows for sharing licenses with other AWS accounts.

## Import

Using `pulumi import`, import `aws_licensemanager_grant` using the grant arn. For example:

```sh $ pulumi import aws:licensemanager/licenseGrant:LicenseGrant test arn:aws:license-manager::123456789011:grant:g-01d313393d9e443d8664cc054db1e089 ```

func GetLicenseGrant 

func GetLicenseGrant(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *LicenseGrantState, opts ...pulumi.ResourceOption) (*LicenseGrant, error)

GetLicenseGrant gets an existing LicenseGrant 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 NewLicenseGrant 

func NewLicenseGrant(ctx *pulumi.Context,
	name string, args *LicenseGrantArgs, opts ...pulumi.ResourceOption) (*LicenseGrant, error)

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

func (*LicenseGrant) ElementType 

func (*LicenseGrant) ElementType() reflect.Type

func (*LicenseGrant) ToLicenseGrantOutput 

func (i *LicenseGrant) ToLicenseGrantOutput() LicenseGrantOutput

func (*LicenseGrant) ToLicenseGrantOutputWithContext 

func (i *LicenseGrant) ToLicenseGrantOutputWithContext(ctx context.Context) LicenseGrantOutput

type LicenseGrantAccepter 

type LicenseGrantAccepter struct {
	pulumi.CustomResourceState

	// A list of the allowed operations for the grant.
	AllowedOperations pulumi.StringArrayOutput `pulumi:"allowedOperations"`
	// The ARN of the grant to accept.
	GrantArn pulumi.StringOutput `pulumi:"grantArn"`
	// The home region for the license.
	HomeRegion pulumi.StringOutput `pulumi:"homeRegion"`
	// The ARN of the license for the grant.
	LicenseArn pulumi.StringOutput `pulumi:"licenseArn"`
	// The Name of the grant.
	Name pulumi.StringOutput `pulumi:"name"`
	// The parent ARN.
	ParentArn pulumi.StringOutput `pulumi:"parentArn"`
	// The target account for the grant.
	Principal pulumi.StringOutput `pulumi:"principal"`
	// The grant status.
	Status pulumi.StringOutput `pulumi:"status"`
	// The grant version.
	Version pulumi.StringOutput `pulumi:"version"`
}

Accepts a License Manager grant. This allows for sharing licenses with other aws accounts.

## Example Usage

```go package main

import ( 

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

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := licensemanager.NewLicenseGrantAccepter(ctx, "test", &licensemanager.LicenseGrantAccepterArgs{
			GrantArn: pulumi.String("arn:aws:license-manager::123456789012:grant:g-1cf9fba4ba2f42dcab11c686c4b4d329"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Using `pulumi import`, import `aws_licensemanager_grant_accepter` using the grant arn. For example:

```sh $ pulumi import aws:licensemanager/licenseGrantAccepter:LicenseGrantAccepter test arn:aws:license-manager::123456789012:grant:g-1cf9fba4ba2f42dcab11c686c4b4d329 ```

func GetLicenseGrantAccepter 

func GetLicenseGrantAccepter(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *LicenseGrantAccepterState, opts ...pulumi.ResourceOption) (*LicenseGrantAccepter, error)

GetLicenseGrantAccepter gets an existing LicenseGrantAccepter 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 NewLicenseGrantAccepter 

func NewLicenseGrantAccepter(ctx *pulumi.Context,
	name string, args *LicenseGrantAccepterArgs, opts ...pulumi.ResourceOption) (*LicenseGrantAccepter, error)

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

func (*LicenseGrantAccepter) ElementType 

func (*LicenseGrantAccepter) ElementType() reflect.Type

func (*LicenseGrantAccepter) ToLicenseGrantAccepterOutput 

func (i *LicenseGrantAccepter) ToLicenseGrantAccepterOutput() LicenseGrantAccepterOutput

func (*LicenseGrantAccepter) ToLicenseGrantAccepterOutputWithContext 

func (i *LicenseGrantAccepter) ToLicenseGrantAccepterOutputWithContext(ctx context.Context) LicenseGrantAccepterOutput

type LicenseGrantAccepterArgs 

type LicenseGrantAccepterArgs struct {
	// The ARN of the grant to accept.
	GrantArn pulumi.StringInput
}

The set of arguments for constructing a LicenseGrantAccepter resource.

func (LicenseGrantAccepterArgs) ElementType 

func (LicenseGrantAccepterArgs) ElementType() reflect.Type

type LicenseGrantAccepterArray 

type LicenseGrantAccepterArray []LicenseGrantAccepterInput

func (LicenseGrantAccepterArray) ElementType 

func (LicenseGrantAccepterArray) ElementType() reflect.Type

func (LicenseGrantAccepterArray) ToLicenseGrantAccepterArrayOutput 

func (i LicenseGrantAccepterArray) ToLicenseGrantAccepterArrayOutput() LicenseGrantAccepterArrayOutput

func (LicenseGrantAccepterArray) ToLicenseGrantAccepterArrayOutputWithContext 

func (i LicenseGrantAccepterArray) ToLicenseGrantAccepterArrayOutputWithContext(ctx context.Context) LicenseGrantAccepterArrayOutput

type LicenseGrantAccepterArrayInput 

type LicenseGrantAccepterArrayInput interface {
	pulumi.Input

	ToLicenseGrantAccepterArrayOutput() LicenseGrantAccepterArrayOutput
	ToLicenseGrantAccepterArrayOutputWithContext(context.Context) LicenseGrantAccepterArrayOutput
}

LicenseGrantAccepterArrayInput is an input type that accepts LicenseGrantAccepterArray and LicenseGrantAccepterArrayOutput values. You can construct a concrete instance of `LicenseGrantAccepterArrayInput` via: 

LicenseGrantAccepterArray{ LicenseGrantAccepterArgs{...} }

type LicenseGrantAccepterArrayOutput 

type LicenseGrantAccepterArrayOutput struct{ *pulumi.OutputState }

func (LicenseGrantAccepterArrayOutput) ElementType 

func (LicenseGrantAccepterArrayOutput) ElementType() reflect.Type

func (LicenseGrantAccepterArrayOutput) Index 

func (o LicenseGrantAccepterArrayOutput) Index(i pulumi.IntInput) LicenseGrantAccepterOutput

func (LicenseGrantAccepterArrayOutput) ToLicenseGrantAccepterArrayOutput 

func (o LicenseGrantAccepterArrayOutput) ToLicenseGrantAccepterArrayOutput() LicenseGrantAccepterArrayOutput

func (LicenseGrantAccepterArrayOutput) ToLicenseGrantAccepterArrayOutputWithContext 

func (o LicenseGrantAccepterArrayOutput) ToLicenseGrantAccepterArrayOutputWithContext(ctx context.Context) LicenseGrantAccepterArrayOutput

type LicenseGrantAccepterInput 

type LicenseGrantAccepterInput interface {
	pulumi.Input

	ToLicenseGrantAccepterOutput() LicenseGrantAccepterOutput
	ToLicenseGrantAccepterOutputWithContext(ctx context.Context) LicenseGrantAccepterOutput
}

type LicenseGrantAccepterMap 

type LicenseGrantAccepterMap map[string]LicenseGrantAccepterInput

func (LicenseGrantAccepterMap) ElementType 

func (LicenseGrantAccepterMap) ElementType() reflect.Type

func (LicenseGrantAccepterMap) ToLicenseGrantAccepterMapOutput 

func (i LicenseGrantAccepterMap) ToLicenseGrantAccepterMapOutput() LicenseGrantAccepterMapOutput

func (LicenseGrantAccepterMap) ToLicenseGrantAccepterMapOutputWithContext 

func (i LicenseGrantAccepterMap) ToLicenseGrantAccepterMapOutputWithContext(ctx context.Context) LicenseGrantAccepterMapOutput

type LicenseGrantAccepterMapInput 

type LicenseGrantAccepterMapInput interface {
	pulumi.Input

	ToLicenseGrantAccepterMapOutput() LicenseGrantAccepterMapOutput
	ToLicenseGrantAccepterMapOutputWithContext(context.Context) LicenseGrantAccepterMapOutput
}

LicenseGrantAccepterMapInput is an input type that accepts LicenseGrantAccepterMap and LicenseGrantAccepterMapOutput values. You can construct a concrete instance of `LicenseGrantAccepterMapInput` via: 

LicenseGrantAccepterMap{ "key": LicenseGrantAccepterArgs{...} }

type LicenseGrantAccepterMapOutput 

type LicenseGrantAccepterMapOutput struct{ *pulumi.OutputState }

func (LicenseGrantAccepterMapOutput) ElementType 

func (LicenseGrantAccepterMapOutput) ElementType() reflect.Type

func (LicenseGrantAccepterMapOutput) MapIndex 

func (o LicenseGrantAccepterMapOutput) MapIndex(k pulumi.StringInput) LicenseGrantAccepterOutput

func (LicenseGrantAccepterMapOutput) ToLicenseGrantAccepterMapOutput 

func (o LicenseGrantAccepterMapOutput) ToLicenseGrantAccepterMapOutput() LicenseGrantAccepterMapOutput

func (LicenseGrantAccepterMapOutput) ToLicenseGrantAccepterMapOutputWithContext 

func (o LicenseGrantAccepterMapOutput) ToLicenseGrantAccepterMapOutputWithContext(ctx context.Context) LicenseGrantAccepterMapOutput

type LicenseGrantAccepterOutput 

type LicenseGrantAccepterOutput struct{ *pulumi.OutputState }

func (LicenseGrantAccepterOutput) AllowedOperations 

func (o LicenseGrantAccepterOutput) AllowedOperations() pulumi.StringArrayOutput

A list of the allowed operations for the grant.

func (LicenseGrantAccepterOutput) ElementType 

func (LicenseGrantAccepterOutput) ElementType() reflect.Type

func (LicenseGrantAccepterOutput) GrantArn 

func (o LicenseGrantAccepterOutput) GrantArn() pulumi.StringOutput

The ARN of the grant to accept.

func (LicenseGrantAccepterOutput) HomeRegion 

func (o LicenseGrantAccepterOutput) HomeRegion() pulumi.StringOutput

The home region for the license.

func (LicenseGrantAccepterOutput) LicenseArn 

func (o LicenseGrantAccepterOutput) LicenseArn() pulumi.StringOutput

The ARN of the license for the grant.

func (LicenseGrantAccepterOutput) Name 

func (o LicenseGrantAccepterOutput) Name() pulumi.StringOutput

The Name of the grant.

func (LicenseGrantAccepterOutput) ParentArn 

func (o LicenseGrantAccepterOutput) ParentArn() pulumi.StringOutput

The parent ARN.

func (LicenseGrantAccepterOutput) Principal 

func (o LicenseGrantAccepterOutput) Principal() pulumi.StringOutput

The target account for the grant.

func (LicenseGrantAccepterOutput) Status 

func (o LicenseGrantAccepterOutput) Status() pulumi.StringOutput

The grant status.

func (LicenseGrantAccepterOutput) ToLicenseGrantAccepterOutput 

func (o LicenseGrantAccepterOutput) ToLicenseGrantAccepterOutput() LicenseGrantAccepterOutput

func (LicenseGrantAccepterOutput) ToLicenseGrantAccepterOutputWithContext 

func (o LicenseGrantAccepterOutput) ToLicenseGrantAccepterOutputWithContext(ctx context.Context) LicenseGrantAccepterOutput

func (LicenseGrantAccepterOutput) Version 

func (o LicenseGrantAccepterOutput) Version() pulumi.StringOutput

The grant version.

type LicenseGrantAccepterState 

type LicenseGrantAccepterState struct {
	// A list of the allowed operations for the grant.
	AllowedOperations pulumi.StringArrayInput
	// The ARN of the grant to accept.
	GrantArn pulumi.StringPtrInput
	// The home region for the license.
	HomeRegion pulumi.StringPtrInput
	// The ARN of the license for the grant.
	LicenseArn pulumi.StringPtrInput
	// The Name of the grant.
	Name pulumi.StringPtrInput
	// The parent ARN.
	ParentArn pulumi.StringPtrInput
	// The target account for the grant.
	Principal pulumi.StringPtrInput
	// The grant status.
	Status pulumi.StringPtrInput
	// The grant version.
	Version pulumi.StringPtrInput
}

func (LicenseGrantAccepterState) ElementType 

func (LicenseGrantAccepterState) ElementType() reflect.Type

type LicenseGrantArgs 

type LicenseGrantArgs struct {
	// A list of the allowed operations for the grant. This is a subset of the allowed operations on the license.
	AllowedOperations pulumi.StringArrayInput
	// The ARN of the license to grant.
	LicenseArn pulumi.StringInput
	// The Name of the grant.
	Name pulumi.StringPtrInput
	// The target account for the grant in the form of the ARN for an account principal of the root user.
	Principal pulumi.StringInput
}

The set of arguments for constructing a LicenseGrant resource.

func (LicenseGrantArgs) ElementType 

func (LicenseGrantArgs) ElementType() reflect.Type

type LicenseGrantArray 

type LicenseGrantArray []LicenseGrantInput

func (LicenseGrantArray) ElementType 

func (LicenseGrantArray) ElementType() reflect.Type

func (LicenseGrantArray) ToLicenseGrantArrayOutput 

func (i LicenseGrantArray) ToLicenseGrantArrayOutput() LicenseGrantArrayOutput

func (LicenseGrantArray) ToLicenseGrantArrayOutputWithContext 

func (i LicenseGrantArray) ToLicenseGrantArrayOutputWithContext(ctx context.Context) LicenseGrantArrayOutput

type LicenseGrantArrayInput 

type LicenseGrantArrayInput interface {
	pulumi.Input

	ToLicenseGrantArrayOutput() LicenseGrantArrayOutput
	ToLicenseGrantArrayOutputWithContext(context.Context) LicenseGrantArrayOutput
}

LicenseGrantArrayInput is an input type that accepts LicenseGrantArray and LicenseGrantArrayOutput values. You can construct a concrete instance of `LicenseGrantArrayInput` via: 

LicenseGrantArray{ LicenseGrantArgs{...} }

type LicenseGrantArrayOutput 

type LicenseGrantArrayOutput struct{ *pulumi.OutputState }

func (LicenseGrantArrayOutput) ElementType 

func (LicenseGrantArrayOutput) ElementType() reflect.Type

func (LicenseGrantArrayOutput) Index 

func (o LicenseGrantArrayOutput) Index(i pulumi.IntInput) LicenseGrantOutput

func (LicenseGrantArrayOutput) ToLicenseGrantArrayOutput 

func (o LicenseGrantArrayOutput) ToLicenseGrantArrayOutput() LicenseGrantArrayOutput

func (LicenseGrantArrayOutput) ToLicenseGrantArrayOutputWithContext 

func (o LicenseGrantArrayOutput) ToLicenseGrantArrayOutputWithContext(ctx context.Context) LicenseGrantArrayOutput

type LicenseGrantInput 

type LicenseGrantInput interface {
	pulumi.Input

	ToLicenseGrantOutput() LicenseGrantOutput
	ToLicenseGrantOutputWithContext(ctx context.Context) LicenseGrantOutput
}

type LicenseGrantMap 

type LicenseGrantMap map[string]LicenseGrantInput

func (LicenseGrantMap) ElementType 

func (LicenseGrantMap) ElementType() reflect.Type

func (LicenseGrantMap) ToLicenseGrantMapOutput 

func (i LicenseGrantMap) ToLicenseGrantMapOutput() LicenseGrantMapOutput

func (LicenseGrantMap) ToLicenseGrantMapOutputWithContext 

func (i LicenseGrantMap) ToLicenseGrantMapOutputWithContext(ctx context.Context) LicenseGrantMapOutput

type LicenseGrantMapInput 

type LicenseGrantMapInput interface {
	pulumi.Input

	ToLicenseGrantMapOutput() LicenseGrantMapOutput
	ToLicenseGrantMapOutputWithContext(context.Context) LicenseGrantMapOutput
}

LicenseGrantMapInput is an input type that accepts LicenseGrantMap and LicenseGrantMapOutput values. You can construct a concrete instance of `LicenseGrantMapInput` via: 

LicenseGrantMap{ "key": LicenseGrantArgs{...} }

type LicenseGrantMapOutput 

type LicenseGrantMapOutput struct{ *pulumi.OutputState }

func (LicenseGrantMapOutput) ElementType 

func (LicenseGrantMapOutput) ElementType() reflect.Type

func (LicenseGrantMapOutput) MapIndex 

func (o LicenseGrantMapOutput) MapIndex(k pulumi.StringInput) LicenseGrantOutput

func (LicenseGrantMapOutput) ToLicenseGrantMapOutput 

func (o LicenseGrantMapOutput) ToLicenseGrantMapOutput() LicenseGrantMapOutput

func (LicenseGrantMapOutput) ToLicenseGrantMapOutputWithContext 

func (o LicenseGrantMapOutput) ToLicenseGrantMapOutputWithContext(ctx context.Context) LicenseGrantMapOutput

type LicenseGrantOutput 

type LicenseGrantOutput struct{ *pulumi.OutputState }

func (LicenseGrantOutput) AllowedOperations 

func (o LicenseGrantOutput) AllowedOperations() pulumi.StringArrayOutput

A list of the allowed operations for the grant. This is a subset of the allowed operations on the license.

func (LicenseGrantOutput) Arn 

func (o LicenseGrantOutput) Arn() pulumi.StringOutput

The grant ARN.

func (LicenseGrantOutput) ElementType 

func (LicenseGrantOutput) ElementType() reflect.Type

func (LicenseGrantOutput) HomeRegion 

func (o LicenseGrantOutput) HomeRegion() pulumi.StringOutput

The home region for the license.

func (LicenseGrantOutput) LicenseArn 

func (o LicenseGrantOutput) LicenseArn() pulumi.StringOutput

The ARN of the license to grant.

func (LicenseGrantOutput) Name 

func (o LicenseGrantOutput) Name() pulumi.StringOutput

The Name of the grant.

func (LicenseGrantOutput) ParentArn 

func (o LicenseGrantOutput) ParentArn() pulumi.StringOutput

The parent ARN.

func (LicenseGrantOutput) Principal 

func (o LicenseGrantOutput) Principal() pulumi.StringOutput

The target account for the grant in the form of the ARN for an account principal of the root user.

func (LicenseGrantOutput) Status 

func (o LicenseGrantOutput) Status() pulumi.StringOutput

The grant status.

func (LicenseGrantOutput) ToLicenseGrantOutput 

func (o LicenseGrantOutput) ToLicenseGrantOutput() LicenseGrantOutput

func (LicenseGrantOutput) ToLicenseGrantOutputWithContext 

func (o LicenseGrantOutput) ToLicenseGrantOutputWithContext(ctx context.Context) LicenseGrantOutput

func (LicenseGrantOutput) Version 

func (o LicenseGrantOutput) Version() pulumi.StringOutput

The grant version.

type LicenseGrantState 

type LicenseGrantState struct {
	// A list of the allowed operations for the grant. This is a subset of the allowed operations on the license.
	AllowedOperations pulumi.StringArrayInput
	// The grant ARN.
	Arn pulumi.StringPtrInput
	// The home region for the license.
	HomeRegion pulumi.StringPtrInput
	// The ARN of the license to grant.
	LicenseArn pulumi.StringPtrInput
	// The Name of the grant.
	Name pulumi.StringPtrInput
	// The parent ARN.
	ParentArn pulumi.StringPtrInput
	// The target account for the grant in the form of the ARN for an account principal of the root user.
	Principal pulumi.StringPtrInput
	// The grant status.
	Status pulumi.StringPtrInput
	// The grant version.
	Version pulumi.StringPtrInput
}

func (LicenseGrantState) ElementType 

func (LicenseGrantState) 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.