Documentation

Overview

    Package licensemanager provides the API client, operations, and parameter types for AWS License Manager.

    AWS License Manager AWS License Manager makes it easier to manage licenses from software vendors across multiple AWS accounts and on-premises servers.

    Index

    Constants

    View Source
    const ServiceAPIVersion = "2018-08-01"
    View Source
    const ServiceID = "License Manager"

    Variables

    This section is empty.

    Functions

    func NewDefaultEndpointResolver

    func NewDefaultEndpointResolver() *internalendpoints.Resolver

      NewDefaultEndpointResolver constructs a new service endpoint resolver

      func WithAPIOptions

      func WithAPIOptions(optFns ...func(*middleware.Stack) error) func(*Options)

        WithAPIOptions returns a functional option for setting the Client's APIOptions option.

        func WithEndpointResolver

        func WithEndpointResolver(v EndpointResolver) func(*Options)

          WithEndpointResolver returns a functional option for setting the Client's EndpointResolver option.

          Types

          type AcceptGrantInput

          type AcceptGrantInput struct {
          
          	// Amazon Resource Name (ARN) of the grant.
          	//
          	// This member is required.
          	GrantArn *string
          }

          type AcceptGrantOutput

          type AcceptGrantOutput struct {
          
          	// Grant ARN.
          	GrantArn *string
          
          	// Grant status.
          	Status types.GrantStatus
          
          	// Grant version.
          	Version *string
          
          	// Metadata pertaining to the operation's result.
          	ResultMetadata middleware.Metadata
          }

          type CheckInLicenseInput

          type CheckInLicenseInput struct {
          
          	// License consumption token.
          	//
          	// This member is required.
          	LicenseConsumptionToken *string
          
          	// License beneficiary.
          	Beneficiary *string
          }

          type CheckInLicenseOutput

          type CheckInLicenseOutput struct {
          	// Metadata pertaining to the operation's result.
          	ResultMetadata middleware.Metadata
          }

          type CheckoutBorrowLicenseInput

          type CheckoutBorrowLicenseInput struct {
          
          	// Unique, case-sensitive identifier that you provide to ensure the idempotency of
          	// the request.
          	//
          	// This member is required.
          	ClientToken *string
          
          	// Digital signature method. The possible value is JSON Web Signature (JWS)
          	// algorithm PS384. For more information, see RFC 7518 Digital Signature with
          	// RSASSA-PSS (https://tools.ietf.org/html/rfc7518#section-3.5).
          	//
          	// This member is required.
          	DigitalSignatureMethod types.DigitalSignatureMethod
          
          	// License entitlements. Partial checkouts are not supported.
          	//
          	// This member is required.
          	Entitlements []types.EntitlementData
          
          	// Amazon Resource Name (ARN) of the license. The license must use the borrow
          	// consumption configuration.
          	//
          	// This member is required.
          	LicenseArn *string
          
          	// Information about constraints.
          	CheckoutMetadata []types.Metadata
          
          	// Node ID.
          	NodeId *string
          }

          type CheckoutBorrowLicenseOutput

          type CheckoutBorrowLicenseOutput struct {
          
          	// Information about constraints.
          	CheckoutMetadata []types.Metadata
          
          	// Allowed license entitlements.
          	EntitlementsAllowed []types.EntitlementData
          
          	// Date and time at which the license checkout expires.
          	Expiration *string
          
          	// Date and time at which the license checkout is issued.
          	IssuedAt *string
          
          	// Amazon Resource Name (ARN) of the license.
          	LicenseArn *string
          
          	// License consumption token.
          	LicenseConsumptionToken *string
          
          	// Node ID.
          	NodeId *string
          
          	// Signed token.
          	SignedToken *string
          
          	// Metadata pertaining to the operation's result.
          	ResultMetadata middleware.Metadata
          }

          type CheckoutLicenseInput

          type CheckoutLicenseInput struct {
          
          	// Checkout type.
          	//
          	// This member is required.
          	CheckoutType types.CheckoutType
          
          	// Unique, case-sensitive identifier that you provide to ensure the idempotency of
          	// the request.
          	//
          	// This member is required.
          	ClientToken *string
          
          	// License entitlements.
          	//
          	// This member is required.
          	Entitlements []types.EntitlementData
          
          	// Key fingerprint identifying the license.
          	//
          	// This member is required.
          	KeyFingerprint *string
          
          	// Product SKU.
          	//
          	// This member is required.
          	ProductSKU *string
          
          	// License beneficiary.
          	Beneficiary *string
          
          	// Node ID.
          	NodeId *string
          }

          type CheckoutLicenseOutput

          type CheckoutLicenseOutput struct {
          
          	// Checkout type.
          	CheckoutType types.CheckoutType
          
          	// Allowed license entitlements.
          	EntitlementsAllowed []types.EntitlementData
          
          	// Date and time at which the license checkout expires.
          	Expiration *string
          
          	// Date and time at which the license checkout is issued.
          	IssuedAt *string
          
          	// License consumption token.
          	LicenseConsumptionToken *string
          
          	// Node ID.
          	NodeId *string
          
          	// Signed token.
          	SignedToken *string
          
          	// Metadata pertaining to the operation's result.
          	ResultMetadata middleware.Metadata
          }

          type Client

          type Client struct {
          	// contains filtered or unexported fields
          }

            Client provides the API client to make operations call for AWS License Manager.

            func New

            func New(options Options, optFns ...func(*Options)) *Client

              New returns an initialized Client based on the functional options. Provide additional functional options to further configure the behavior of the client, such as changing the client's endpoint or adding custom middleware behavior.

              func NewFromConfig

              func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client

                NewFromConfig returns a new client from the provided config.

                func (*Client) AcceptGrant

                func (c *Client) AcceptGrant(ctx context.Context, params *AcceptGrantInput, optFns ...func(*Options)) (*AcceptGrantOutput, error)

                  Accepts the specified grant.

                  func (*Client) CheckInLicense

                  func (c *Client) CheckInLicense(ctx context.Context, params *CheckInLicenseInput, optFns ...func(*Options)) (*CheckInLicenseOutput, error)

                    Checks in the specified license. Check in a license when it is no longer in use.

                    func (*Client) CheckoutBorrowLicense

                    func (c *Client) CheckoutBorrowLicense(ctx context.Context, params *CheckoutBorrowLicenseInput, optFns ...func(*Options)) (*CheckoutBorrowLicenseOutput, error)

                      Checks out the specified license for offline use.

                      func (*Client) CheckoutLicense

                      func (c *Client) CheckoutLicense(ctx context.Context, params *CheckoutLicenseInput, optFns ...func(*Options)) (*CheckoutLicenseOutput, error)

                        Checks out the specified license.

                        func (*Client) CreateGrant

                        func (c *Client) CreateGrant(ctx context.Context, params *CreateGrantInput, optFns ...func(*Options)) (*CreateGrantOutput, error)

                          Creates a grant for the specified license. A grant shares the use of license entitlements with specific AWS accounts.

                          func (*Client) CreateGrantVersion

                          func (c *Client) CreateGrantVersion(ctx context.Context, params *CreateGrantVersionInput, optFns ...func(*Options)) (*CreateGrantVersionOutput, error)

                            Creates a new version of the specified grant.

                            func (*Client) CreateLicense

                            func (c *Client) CreateLicense(ctx context.Context, params *CreateLicenseInput, optFns ...func(*Options)) (*CreateLicenseOutput, error)

                              Creates a license.

                              func (*Client) CreateLicenseConfiguration

                              func (c *Client) CreateLicenseConfiguration(ctx context.Context, params *CreateLicenseConfigurationInput, optFns ...func(*Options)) (*CreateLicenseConfigurationOutput, error)

                                Creates a license configuration. A license configuration is an abstraction of a customer license agreement that can be consumed and enforced by License Manager. Components include specifications for the license type (licensing by instance, socket, CPU, or vCPU), allowed tenancy (shared tenancy, Dedicated Instance, Dedicated Host, or all of these), license affinity to host (how long a license must be associated with a host), and the number of licenses purchased and used.

                                func (*Client) CreateLicenseVersion

                                func (c *Client) CreateLicenseVersion(ctx context.Context, params *CreateLicenseVersionInput, optFns ...func(*Options)) (*CreateLicenseVersionOutput, error)

                                  Creates a new version of the specified license.

                                  func (*Client) CreateToken

                                  func (c *Client) CreateToken(ctx context.Context, params *CreateTokenInput, optFns ...func(*Options)) (*CreateTokenOutput, error)

                                    Creates a long-lived token. A refresh token is a JWT token used to get an access token. With an access token, you can call AssumeRoleWithWebIdentity to get role credentials that you can use to call License Manager to manage the specified license.

                                    func (*Client) DeleteGrant

                                    func (c *Client) DeleteGrant(ctx context.Context, params *DeleteGrantInput, optFns ...func(*Options)) (*DeleteGrantOutput, error)

                                      Deletes the specified grant.

                                      func (*Client) DeleteLicense

                                      func (c *Client) DeleteLicense(ctx context.Context, params *DeleteLicenseInput, optFns ...func(*Options)) (*DeleteLicenseOutput, error)

                                        Deletes the specified license.

                                        func (*Client) DeleteLicenseConfiguration

                                        func (c *Client) DeleteLicenseConfiguration(ctx context.Context, params *DeleteLicenseConfigurationInput, optFns ...func(*Options)) (*DeleteLicenseConfigurationOutput, error)

                                          Deletes the specified license configuration. You cannot delete a license configuration that is in use.

                                          func (*Client) DeleteToken

                                          func (c *Client) DeleteToken(ctx context.Context, params *DeleteTokenInput, optFns ...func(*Options)) (*DeleteTokenOutput, error)

                                            Deletes the specified token. Must be called in the license home Region.

                                            func (*Client) ExtendLicenseConsumption

                                            func (c *Client) ExtendLicenseConsumption(ctx context.Context, params *ExtendLicenseConsumptionInput, optFns ...func(*Options)) (*ExtendLicenseConsumptionOutput, error)

                                              Extends the expiration date for license consumption.

                                              func (*Client) GetAccessToken

                                              func (c *Client) GetAccessToken(ctx context.Context, params *GetAccessTokenInput, optFns ...func(*Options)) (*GetAccessTokenOutput, error)

                                                Gets a temporary access token to use with AssumeRoleWithWebIdentity. Access tokens are valid for one hour.

                                                func (*Client) GetGrant

                                                func (c *Client) GetGrant(ctx context.Context, params *GetGrantInput, optFns ...func(*Options)) (*GetGrantOutput, error)

                                                  Gets detailed information about the specified grant.

                                                  func (*Client) GetLicense

                                                  func (c *Client) GetLicense(ctx context.Context, params *GetLicenseInput, optFns ...func(*Options)) (*GetLicenseOutput, error)

                                                    Gets detailed information about the specified license.

                                                    func (*Client) GetLicenseConfiguration

                                                    func (c *Client) GetLicenseConfiguration(ctx context.Context, params *GetLicenseConfigurationInput, optFns ...func(*Options)) (*GetLicenseConfigurationOutput, error)

                                                      Gets detailed information about the specified license configuration.

                                                      func (*Client) GetLicenseUsage

                                                      func (c *Client) GetLicenseUsage(ctx context.Context, params *GetLicenseUsageInput, optFns ...func(*Options)) (*GetLicenseUsageOutput, error)

                                                        Gets detailed information about the usage of the specified license.

                                                        func (*Client) GetServiceSettings

                                                        func (c *Client) GetServiceSettings(ctx context.Context, params *GetServiceSettingsInput, optFns ...func(*Options)) (*GetServiceSettingsOutput, error)

                                                          Gets the License Manager settings for the current Region.

                                                          func (*Client) ListAssociationsForLicenseConfiguration

                                                          func (c *Client) ListAssociationsForLicenseConfiguration(ctx context.Context, params *ListAssociationsForLicenseConfigurationInput, optFns ...func(*Options)) (*ListAssociationsForLicenseConfigurationOutput, error)

                                                            Lists the resource associations for the specified license configuration. Resource associations need not consume licenses from a license configuration. For example, an AMI or a stopped instance might not consume a license (depending on the license rules).

                                                            func (*Client) ListDistributedGrants

                                                            func (c *Client) ListDistributedGrants(ctx context.Context, params *ListDistributedGrantsInput, optFns ...func(*Options)) (*ListDistributedGrantsOutput, error)

                                                              Lists the grants distributed for the specified license.

                                                              func (*Client) ListFailuresForLicenseConfigurationOperations

                                                              func (c *Client) ListFailuresForLicenseConfigurationOperations(ctx context.Context, params *ListFailuresForLicenseConfigurationOperationsInput, optFns ...func(*Options)) (*ListFailuresForLicenseConfigurationOperationsOutput, error)

                                                                Lists the license configuration operations that failed.

                                                                func (*Client) ListLicenseConfigurations

                                                                func (c *Client) ListLicenseConfigurations(ctx context.Context, params *ListLicenseConfigurationsInput, optFns ...func(*Options)) (*ListLicenseConfigurationsOutput, error)

                                                                  Lists the license configurations for your account.

                                                                  func (*Client) ListLicenseSpecificationsForResource

                                                                  func (c *Client) ListLicenseSpecificationsForResource(ctx context.Context, params *ListLicenseSpecificationsForResourceInput, optFns ...func(*Options)) (*ListLicenseSpecificationsForResourceOutput, error)

                                                                    Describes the license configurations for the specified resource.

                                                                    func (*Client) ListLicenseVersions

                                                                    func (c *Client) ListLicenseVersions(ctx context.Context, params *ListLicenseVersionsInput, optFns ...func(*Options)) (*ListLicenseVersionsOutput, error)

                                                                      Lists all versions of the specified license.

                                                                      func (*Client) ListLicenses

                                                                      func (c *Client) ListLicenses(ctx context.Context, params *ListLicensesInput, optFns ...func(*Options)) (*ListLicensesOutput, error)

                                                                        Lists the licenses for your account.

                                                                        func (*Client) ListReceivedGrants

                                                                        func (c *Client) ListReceivedGrants(ctx context.Context, params *ListReceivedGrantsInput, optFns ...func(*Options)) (*ListReceivedGrantsOutput, error)

                                                                          Lists grants that are received but not accepted.

                                                                          func (*Client) ListReceivedLicenses

                                                                          func (c *Client) ListReceivedLicenses(ctx context.Context, params *ListReceivedLicensesInput, optFns ...func(*Options)) (*ListReceivedLicensesOutput, error)

                                                                            Lists received licenses.

                                                                            func (*Client) ListResourceInventory

                                                                            func (c *Client) ListResourceInventory(ctx context.Context, params *ListResourceInventoryInput, optFns ...func(*Options)) (*ListResourceInventoryOutput, error)

                                                                              Lists resources managed using Systems Manager inventory.

                                                                              func (*Client) ListTagsForResource

                                                                              func (c *Client) ListTagsForResource(ctx context.Context, params *ListTagsForResourceInput, optFns ...func(*Options)) (*ListTagsForResourceOutput, error)

                                                                                Lists the tags for the specified license configuration.

                                                                                func (*Client) ListTokens

                                                                                func (c *Client) ListTokens(ctx context.Context, params *ListTokensInput, optFns ...func(*Options)) (*ListTokensOutput, error)

                                                                                  Lists your tokens.

                                                                                  func (*Client) ListUsageForLicenseConfiguration

                                                                                  func (c *Client) ListUsageForLicenseConfiguration(ctx context.Context, params *ListUsageForLicenseConfigurationInput, optFns ...func(*Options)) (*ListUsageForLicenseConfigurationOutput, error)

                                                                                    Lists all license usage records for a license configuration, displaying license consumption details by resource at a selected point in time. Use this action to audit the current license consumption for any license inventory and configuration.

                                                                                    func (*Client) RejectGrant

                                                                                    func (c *Client) RejectGrant(ctx context.Context, params *RejectGrantInput, optFns ...func(*Options)) (*RejectGrantOutput, error)

                                                                                      Rejects the specified grant.

                                                                                      func (*Client) TagResource

                                                                                      func (c *Client) TagResource(ctx context.Context, params *TagResourceInput, optFns ...func(*Options)) (*TagResourceOutput, error)

                                                                                        Adds the specified tags to the specified license configuration.

                                                                                        func (*Client) UntagResource

                                                                                        func (c *Client) UntagResource(ctx context.Context, params *UntagResourceInput, optFns ...func(*Options)) (*UntagResourceOutput, error)

                                                                                          Removes the specified tags from the specified license configuration.

                                                                                          func (*Client) UpdateLicenseConfiguration

                                                                                          func (c *Client) UpdateLicenseConfiguration(ctx context.Context, params *UpdateLicenseConfigurationInput, optFns ...func(*Options)) (*UpdateLicenseConfigurationOutput, error)

                                                                                            Modifies the attributes of an existing license configuration.

                                                                                            func (*Client) UpdateLicenseSpecificationsForResource

                                                                                            func (c *Client) UpdateLicenseSpecificationsForResource(ctx context.Context, params *UpdateLicenseSpecificationsForResourceInput, optFns ...func(*Options)) (*UpdateLicenseSpecificationsForResourceOutput, error)

                                                                                              Adds or removes the specified license configurations for the specified AWS resource. You can update the license specifications of AMIs, instances, and hosts. You cannot update the license specifications for launch templates and AWS CloudFormation templates, as they send license configurations to the operation that creates the resource.

                                                                                              func (*Client) UpdateServiceSettings

                                                                                              func (c *Client) UpdateServiceSettings(ctx context.Context, params *UpdateServiceSettingsInput, optFns ...func(*Options)) (*UpdateServiceSettingsOutput, error)

                                                                                                Updates License Manager settings for the current Region.

                                                                                                type CreateGrantInput

                                                                                                type CreateGrantInput struct {
                                                                                                
                                                                                                	// Allowed operations for the grant.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	AllowedOperations []types.AllowedOperation
                                                                                                
                                                                                                	// Unique, case-sensitive identifier that you provide to ensure the idempotency of
                                                                                                	// the request.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	ClientToken *string
                                                                                                
                                                                                                	// Grant name.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	GrantName *string
                                                                                                
                                                                                                	// Home Region of the grant.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	HomeRegion *string
                                                                                                
                                                                                                	// Amazon Resource Name (ARN) of the license.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	LicenseArn *string
                                                                                                
                                                                                                	// The grant principals.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	Principals []string
                                                                                                }

                                                                                                type CreateGrantOutput

                                                                                                type CreateGrantOutput struct {
                                                                                                
                                                                                                	// Grant ARN.
                                                                                                	GrantArn *string
                                                                                                
                                                                                                	// Grant status.
                                                                                                	Status types.GrantStatus
                                                                                                
                                                                                                	// Grant version.
                                                                                                	Version *string
                                                                                                
                                                                                                	// Metadata pertaining to the operation's result.
                                                                                                	ResultMetadata middleware.Metadata
                                                                                                }

                                                                                                type CreateGrantVersionInput

                                                                                                type CreateGrantVersionInput struct {
                                                                                                
                                                                                                	// Unique, case-sensitive identifier that you provide to ensure the idempotency of
                                                                                                	// the request.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	ClientToken *string
                                                                                                
                                                                                                	// Amazon Resource Name (ARN) of the grant.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	GrantArn *string
                                                                                                
                                                                                                	// Allowed operations for the grant.
                                                                                                	AllowedOperations []types.AllowedOperation
                                                                                                
                                                                                                	// Grant name.
                                                                                                	GrantName *string
                                                                                                
                                                                                                	// Current version of the grant.
                                                                                                	SourceVersion *string
                                                                                                
                                                                                                	// Grant status.
                                                                                                	Status types.GrantStatus
                                                                                                }

                                                                                                type CreateGrantVersionOutput

                                                                                                type CreateGrantVersionOutput struct {
                                                                                                
                                                                                                	// Grant ARN.
                                                                                                	GrantArn *string
                                                                                                
                                                                                                	// Grant status.
                                                                                                	Status types.GrantStatus
                                                                                                
                                                                                                	// New version of the grant.
                                                                                                	Version *string
                                                                                                
                                                                                                	// Metadata pertaining to the operation's result.
                                                                                                	ResultMetadata middleware.Metadata
                                                                                                }

                                                                                                type CreateLicenseConfigurationInput

                                                                                                type CreateLicenseConfigurationInput struct {
                                                                                                
                                                                                                	// Dimension used to track the license inventory.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	LicenseCountingType types.LicenseCountingType
                                                                                                
                                                                                                	// Name of the license configuration.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	Name *string
                                                                                                
                                                                                                	// Description of the license configuration.
                                                                                                	Description *string
                                                                                                
                                                                                                	// When true, disassociates a resource when software is uninstalled.
                                                                                                	DisassociateWhenNotFound *bool
                                                                                                
                                                                                                	// Number of licenses managed by the license configuration.
                                                                                                	LicenseCount *int64
                                                                                                
                                                                                                	// Indicates whether hard or soft license enforcement is used. Exceeding a hard
                                                                                                	// limit blocks the launch of new instances.
                                                                                                	LicenseCountHardLimit *bool
                                                                                                
                                                                                                	// License rules. The syntax is #name=value (for example,
                                                                                                	// #allowedTenancy=EC2-DedicatedHost). The available rules vary by dimension, as
                                                                                                	// follows.
                                                                                                	//
                                                                                                	// * Cores dimension: allowedTenancy | licenseAffinityToHost |
                                                                                                	// maximumCores | minimumCores
                                                                                                	//
                                                                                                	// * Instances dimension: allowedTenancy |
                                                                                                	// maximumCores | minimumCores | maximumSockets | minimumSockets | maximumVcpus |
                                                                                                	// minimumVcpus
                                                                                                	//
                                                                                                	// * Sockets dimension: allowedTenancy | licenseAffinityToHost |
                                                                                                	// maximumSockets | minimumSockets
                                                                                                	//
                                                                                                	// * vCPUs dimension: allowedTenancy |
                                                                                                	// honorVcpuOptimization | maximumVcpus | minimumVcpus
                                                                                                	//
                                                                                                	// The unit for
                                                                                                	// licenseAffinityToHost is days and the range is 1 to 180. The possible values for
                                                                                                	// allowedTenancy are EC2-Default, EC2-DedicatedHost, and EC2-DedicatedInstance.
                                                                                                	// The possible values for honorVcpuOptimization are True and False.
                                                                                                	LicenseRules []string
                                                                                                
                                                                                                	// Product information.
                                                                                                	ProductInformationList []types.ProductInformation
                                                                                                
                                                                                                	// Tags to add to the license configuration.
                                                                                                	Tags []types.Tag
                                                                                                }

                                                                                                type CreateLicenseConfigurationOutput

                                                                                                type CreateLicenseConfigurationOutput struct {
                                                                                                
                                                                                                	// Amazon Resource Name (ARN) of the license configuration.
                                                                                                	LicenseConfigurationArn *string
                                                                                                
                                                                                                	// Metadata pertaining to the operation's result.
                                                                                                	ResultMetadata middleware.Metadata
                                                                                                }

                                                                                                type CreateLicenseInput

                                                                                                type CreateLicenseInput struct {
                                                                                                
                                                                                                	// License beneficiary.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	Beneficiary *string
                                                                                                
                                                                                                	// Unique, case-sensitive identifier that you provide to ensure the idempotency of
                                                                                                	// the request.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	ClientToken *string
                                                                                                
                                                                                                	// Configuration for consumption of the license. Choose a provisional configuration
                                                                                                	// for workloads running with continuous connectivity. Choose a borrow
                                                                                                	// configuration for workloads with offline usage.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	ConsumptionConfiguration *types.ConsumptionConfiguration
                                                                                                
                                                                                                	// License entitlements.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	Entitlements []types.Entitlement
                                                                                                
                                                                                                	// Home Region for the license.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	HomeRegion *string
                                                                                                
                                                                                                	// License issuer.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	Issuer *types.Issuer
                                                                                                
                                                                                                	// License name.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	LicenseName *string
                                                                                                
                                                                                                	// Product name.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	ProductName *string
                                                                                                
                                                                                                	// Product SKU.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	ProductSKU *string
                                                                                                
                                                                                                	// Date and time range during which the license is valid, in ISO8601-UTC format.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	Validity *types.DatetimeRange
                                                                                                
                                                                                                	// Information about the license.
                                                                                                	LicenseMetadata []types.Metadata
                                                                                                }

                                                                                                type CreateLicenseOutput

                                                                                                type CreateLicenseOutput struct {
                                                                                                
                                                                                                	// Amazon Resource Name (ARN) of the license.
                                                                                                	LicenseArn *string
                                                                                                
                                                                                                	// License status.
                                                                                                	Status types.LicenseStatus
                                                                                                
                                                                                                	// License version.
                                                                                                	Version *string
                                                                                                
                                                                                                	// Metadata pertaining to the operation's result.
                                                                                                	ResultMetadata middleware.Metadata
                                                                                                }

                                                                                                type CreateLicenseVersionInput

                                                                                                type CreateLicenseVersionInput struct {
                                                                                                
                                                                                                	// Unique, case-sensitive identifier that you provide to ensure the idempotency of
                                                                                                	// the request.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	ClientToken *string
                                                                                                
                                                                                                	// Configuration for consumption of the license. Choose a provisional configuration
                                                                                                	// for workloads running with continuous connectivity. Choose a borrow
                                                                                                	// configuration for workloads with offline usage.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	ConsumptionConfiguration *types.ConsumptionConfiguration
                                                                                                
                                                                                                	// License entitlements.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	Entitlements []types.Entitlement
                                                                                                
                                                                                                	// Home Region of the license.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	HomeRegion *string
                                                                                                
                                                                                                	// License issuer.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	Issuer *types.Issuer
                                                                                                
                                                                                                	// Amazon Resource Name (ARN) of the license.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	LicenseArn *string
                                                                                                
                                                                                                	// License name.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	LicenseName *string
                                                                                                
                                                                                                	// Product name.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	ProductName *string
                                                                                                
                                                                                                	// License status.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	Status types.LicenseStatus
                                                                                                
                                                                                                	// Date and time range during which the license is valid, in ISO8601-UTC format.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	Validity *types.DatetimeRange
                                                                                                
                                                                                                	// Information about the license.
                                                                                                	LicenseMetadata []types.Metadata
                                                                                                
                                                                                                	// Current version of the license.
                                                                                                	SourceVersion *string
                                                                                                }

                                                                                                type CreateLicenseVersionOutput

                                                                                                type CreateLicenseVersionOutput struct {
                                                                                                
                                                                                                	// License ARN.
                                                                                                	LicenseArn *string
                                                                                                
                                                                                                	// License status.
                                                                                                	Status types.LicenseStatus
                                                                                                
                                                                                                	// New version of the license.
                                                                                                	Version *string
                                                                                                
                                                                                                	// Metadata pertaining to the operation's result.
                                                                                                	ResultMetadata middleware.Metadata
                                                                                                }

                                                                                                type CreateTokenInput

                                                                                                type CreateTokenInput struct {
                                                                                                
                                                                                                	// Idempotency token, valid for 10 minutes.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	ClientToken *string
                                                                                                
                                                                                                	// Amazon Resource Name (ARN) of the license. The ARN is mapped to the aud claim of
                                                                                                	// the JWT token.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	LicenseArn *string
                                                                                                
                                                                                                	// Token expiration, in days, counted from token creation. The default is 365 days.
                                                                                                	ExpirationInDays *int32
                                                                                                
                                                                                                	// Amazon Resource Name (ARN) of the IAM roles to embed in the token. License
                                                                                                	// Manager does not check whether the roles are in use.
                                                                                                	RoleArns []string
                                                                                                
                                                                                                	// Data specified by the caller to be included in the JWT token. The data is mapped
                                                                                                	// to the amr claim of the JWT token.
                                                                                                	TokenProperties []string
                                                                                                }

                                                                                                type CreateTokenOutput

                                                                                                type CreateTokenOutput struct {
                                                                                                
                                                                                                	// Refresh token, encoded as a JWT token.
                                                                                                	Token *string
                                                                                                
                                                                                                	// Token ID.
                                                                                                	TokenId *string
                                                                                                
                                                                                                	// Token type.
                                                                                                	TokenType types.TokenType
                                                                                                
                                                                                                	// Metadata pertaining to the operation's result.
                                                                                                	ResultMetadata middleware.Metadata
                                                                                                }

                                                                                                type DeleteGrantInput

                                                                                                type DeleteGrantInput struct {
                                                                                                
                                                                                                	// Amazon Resource Name (ARN) of the grant.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	GrantArn *string
                                                                                                
                                                                                                	// Current version of the grant.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	Version *string
                                                                                                }

                                                                                                type DeleteGrantOutput

                                                                                                type DeleteGrantOutput struct {
                                                                                                
                                                                                                	// Grant ARN.
                                                                                                	GrantArn *string
                                                                                                
                                                                                                	// Grant status.
                                                                                                	Status types.GrantStatus
                                                                                                
                                                                                                	// Grant version.
                                                                                                	Version *string
                                                                                                
                                                                                                	// Metadata pertaining to the operation's result.
                                                                                                	ResultMetadata middleware.Metadata
                                                                                                }

                                                                                                type DeleteLicenseConfigurationInput

                                                                                                type DeleteLicenseConfigurationInput struct {
                                                                                                
                                                                                                	// ID of the license configuration.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	LicenseConfigurationArn *string
                                                                                                }

                                                                                                type DeleteLicenseConfigurationOutput

                                                                                                type DeleteLicenseConfigurationOutput struct {
                                                                                                	// Metadata pertaining to the operation's result.
                                                                                                	ResultMetadata middleware.Metadata
                                                                                                }

                                                                                                type DeleteLicenseInput

                                                                                                type DeleteLicenseInput struct {
                                                                                                
                                                                                                	// Amazon Resource Name (ARN) of the license.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	LicenseArn *string
                                                                                                
                                                                                                	// Current version of the license.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	SourceVersion *string
                                                                                                }

                                                                                                type DeleteLicenseOutput

                                                                                                type DeleteLicenseOutput struct {
                                                                                                
                                                                                                	// Date on which the license is deleted.
                                                                                                	DeletionDate *string
                                                                                                
                                                                                                	// License status.
                                                                                                	Status types.LicenseDeletionStatus
                                                                                                
                                                                                                	// Metadata pertaining to the operation's result.
                                                                                                	ResultMetadata middleware.Metadata
                                                                                                }

                                                                                                type DeleteTokenInput

                                                                                                type DeleteTokenInput struct {
                                                                                                
                                                                                                	// Token ID.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	TokenId *string
                                                                                                }

                                                                                                type DeleteTokenOutput

                                                                                                type DeleteTokenOutput struct {
                                                                                                	// Metadata pertaining to the operation's result.
                                                                                                	ResultMetadata middleware.Metadata
                                                                                                }

                                                                                                type EndpointResolver

                                                                                                type EndpointResolver interface {
                                                                                                	ResolveEndpoint(region string, options EndpointResolverOptions) (aws.Endpoint, error)
                                                                                                }

                                                                                                  EndpointResolver interface for resolving service endpoints.

                                                                                                  func EndpointResolverFromURL

                                                                                                  func EndpointResolverFromURL(url string, optFns ...func(*aws.Endpoint)) EndpointResolver

                                                                                                    EndpointResolverFromURL returns an EndpointResolver configured using the provided endpoint url. By default, the resolved endpoint resolver uses the client region as signing region, and the endpoint source is set to EndpointSourceCustom.You can provide functional options to configure endpoint values for the resolved endpoint.

                                                                                                    type EndpointResolverFunc

                                                                                                    type EndpointResolverFunc func(region string, options EndpointResolverOptions) (aws.Endpoint, error)

                                                                                                      EndpointResolverFunc is a helper utility that wraps a function so it satisfies the EndpointResolver interface. This is useful when you want to add additional endpoint resolving logic, or stub out specific endpoints with custom values.

                                                                                                      func (EndpointResolverFunc) ResolveEndpoint

                                                                                                      func (fn EndpointResolverFunc) ResolveEndpoint(region string, options EndpointResolverOptions) (endpoint aws.Endpoint, err error)

                                                                                                      type EndpointResolverOptions

                                                                                                      type EndpointResolverOptions = internalendpoints.Options

                                                                                                        EndpointResolverOptions is the service endpoint resolver options

                                                                                                        type ExtendLicenseConsumptionInput

                                                                                                        type ExtendLicenseConsumptionInput struct {
                                                                                                        
                                                                                                        	// License consumption token.
                                                                                                        	//
                                                                                                        	// This member is required.
                                                                                                        	LicenseConsumptionToken *string
                                                                                                        
                                                                                                        	// Checks whether you have the required permissions for the action, without
                                                                                                        	// actually making the request. Provides an error response if you do not have the
                                                                                                        	// required permissions.
                                                                                                        	DryRun bool
                                                                                                        }

                                                                                                        type ExtendLicenseConsumptionOutput

                                                                                                        type ExtendLicenseConsumptionOutput struct {
                                                                                                        
                                                                                                        	// Date and time at which the license consumption expires.
                                                                                                        	Expiration *string
                                                                                                        
                                                                                                        	// License consumption token.
                                                                                                        	LicenseConsumptionToken *string
                                                                                                        
                                                                                                        	// Metadata pertaining to the operation's result.
                                                                                                        	ResultMetadata middleware.Metadata
                                                                                                        }

                                                                                                        type GetAccessTokenInput

                                                                                                        type GetAccessTokenInput struct {
                                                                                                        
                                                                                                        	// Refresh token, encoded as a JWT token.
                                                                                                        	//
                                                                                                        	// This member is required.
                                                                                                        	Token *string
                                                                                                        
                                                                                                        	// Token properties to validate against those present in the JWT token.
                                                                                                        	TokenProperties []string
                                                                                                        }

                                                                                                        type GetAccessTokenOutput

                                                                                                        type GetAccessTokenOutput struct {
                                                                                                        
                                                                                                        	// Temporary access token.
                                                                                                        	AccessToken *string
                                                                                                        
                                                                                                        	// Metadata pertaining to the operation's result.
                                                                                                        	ResultMetadata middleware.Metadata
                                                                                                        }

                                                                                                        type GetGrantInput

                                                                                                        type GetGrantInput struct {
                                                                                                        
                                                                                                        	// Amazon Resource Name (ARN) of the grant.
                                                                                                        	//
                                                                                                        	// This member is required.
                                                                                                        	GrantArn *string
                                                                                                        
                                                                                                        	// Grant version.
                                                                                                        	Version *string
                                                                                                        }

                                                                                                        type GetGrantOutput

                                                                                                        type GetGrantOutput struct {
                                                                                                        
                                                                                                        	// Grant details.
                                                                                                        	Grant *types.Grant
                                                                                                        
                                                                                                        	// Metadata pertaining to the operation's result.
                                                                                                        	ResultMetadata middleware.Metadata
                                                                                                        }

                                                                                                        type GetLicenseConfigurationInput

                                                                                                        type GetLicenseConfigurationInput struct {
                                                                                                        
                                                                                                        	// Amazon Resource Name (ARN) of the license configuration.
                                                                                                        	//
                                                                                                        	// This member is required.
                                                                                                        	LicenseConfigurationArn *string
                                                                                                        }

                                                                                                        type GetLicenseConfigurationOutput

                                                                                                        type GetLicenseConfigurationOutput struct {
                                                                                                        
                                                                                                        	// Automated discovery information.
                                                                                                        	AutomatedDiscoveryInformation *types.AutomatedDiscoveryInformation
                                                                                                        
                                                                                                        	// Summaries of the licenses consumed by resources.
                                                                                                        	ConsumedLicenseSummaryList []types.ConsumedLicenseSummary
                                                                                                        
                                                                                                        	// Number of licenses assigned to resources.
                                                                                                        	ConsumedLicenses *int64
                                                                                                        
                                                                                                        	// Description of the license configuration.
                                                                                                        	Description *string
                                                                                                        
                                                                                                        	// When true, disassociates a resource when software is uninstalled.
                                                                                                        	DisassociateWhenNotFound *bool
                                                                                                        
                                                                                                        	// Amazon Resource Name (ARN) of the license configuration.
                                                                                                        	LicenseConfigurationArn *string
                                                                                                        
                                                                                                        	// Unique ID for the license configuration.
                                                                                                        	LicenseConfigurationId *string
                                                                                                        
                                                                                                        	// Number of available licenses.
                                                                                                        	LicenseCount *int64
                                                                                                        
                                                                                                        	// Sets the number of available licenses as a hard limit.
                                                                                                        	LicenseCountHardLimit *bool
                                                                                                        
                                                                                                        	// Dimension on which the licenses are counted.
                                                                                                        	LicenseCountingType types.LicenseCountingType
                                                                                                        
                                                                                                        	// License rules.
                                                                                                        	LicenseRules []string
                                                                                                        
                                                                                                        	// Summaries of the managed resources.
                                                                                                        	ManagedResourceSummaryList []types.ManagedResourceSummary
                                                                                                        
                                                                                                        	// Name of the license configuration.
                                                                                                        	Name *string
                                                                                                        
                                                                                                        	// Account ID of the owner of the license configuration.
                                                                                                        	OwnerAccountId *string
                                                                                                        
                                                                                                        	// Product information.
                                                                                                        	ProductInformationList []types.ProductInformation
                                                                                                        
                                                                                                        	// License configuration status.
                                                                                                        	Status *string
                                                                                                        
                                                                                                        	// Tags for the license configuration.
                                                                                                        	Tags []types.Tag
                                                                                                        
                                                                                                        	// Metadata pertaining to the operation's result.
                                                                                                        	ResultMetadata middleware.Metadata
                                                                                                        }

                                                                                                        type GetLicenseInput

                                                                                                        type GetLicenseInput struct {
                                                                                                        
                                                                                                        	// Amazon Resource Name (ARN) of the license.
                                                                                                        	//
                                                                                                        	// This member is required.
                                                                                                        	LicenseArn *string
                                                                                                        
                                                                                                        	// License version.
                                                                                                        	Version *string
                                                                                                        }

                                                                                                        type GetLicenseOutput

                                                                                                        type GetLicenseOutput struct {
                                                                                                        
                                                                                                        	// License details.
                                                                                                        	License *types.License
                                                                                                        
                                                                                                        	// Metadata pertaining to the operation's result.
                                                                                                        	ResultMetadata middleware.Metadata
                                                                                                        }

                                                                                                        type GetLicenseUsageInput

                                                                                                        type GetLicenseUsageInput struct {
                                                                                                        
                                                                                                        	// Amazon Resource Name (ARN) of the license.
                                                                                                        	//
                                                                                                        	// This member is required.
                                                                                                        	LicenseArn *string
                                                                                                        }

                                                                                                        type GetLicenseUsageOutput

                                                                                                        type GetLicenseUsageOutput struct {
                                                                                                        
                                                                                                        	// License usage details.
                                                                                                        	LicenseUsage *types.LicenseUsage
                                                                                                        
                                                                                                        	// Metadata pertaining to the operation's result.
                                                                                                        	ResultMetadata middleware.Metadata
                                                                                                        }

                                                                                                        type GetServiceSettingsInput

                                                                                                        type GetServiceSettingsInput struct {
                                                                                                        }

                                                                                                        type GetServiceSettingsOutput

                                                                                                        type GetServiceSettingsOutput struct {
                                                                                                        
                                                                                                        	// Indicates whether cross-account discovery is enabled.
                                                                                                        	EnableCrossAccountsDiscovery *bool
                                                                                                        
                                                                                                        	// Amazon Resource Name (ARN) of the AWS resource share. The License Manager master
                                                                                                        	// account will provide member accounts with access to this share.
                                                                                                        	LicenseManagerResourceShareArn *string
                                                                                                        
                                                                                                        	// Indicates whether AWS Organizations is integrated with License Manager for
                                                                                                        	// cross-account discovery.
                                                                                                        	OrganizationConfiguration *types.OrganizationConfiguration
                                                                                                        
                                                                                                        	// Regional S3 bucket path for storing reports, license trail event data, discovery
                                                                                                        	// data, and so on.
                                                                                                        	S3BucketArn *string
                                                                                                        
                                                                                                        	// SNS topic configured to receive notifications from License Manager.
                                                                                                        	SnsTopicArn *string
                                                                                                        
                                                                                                        	// Metadata pertaining to the operation's result.
                                                                                                        	ResultMetadata middleware.Metadata
                                                                                                        }

                                                                                                        type HTTPClient

                                                                                                        type HTTPClient interface {
                                                                                                        	Do(*http.Request) (*http.Response, error)
                                                                                                        }

                                                                                                        type HTTPSignerV4

                                                                                                        type HTTPSignerV4 interface {
                                                                                                        	SignHTTP(ctx context.Context, credentials aws.Credentials, r *http.Request, payloadHash string, service string, region string, signingTime time.Time, optFns ...func(*v4.SignerOptions)) error
                                                                                                        }

                                                                                                        type ListAssociationsForLicenseConfigurationInput

                                                                                                        type ListAssociationsForLicenseConfigurationInput struct {
                                                                                                        
                                                                                                        	// Amazon Resource Name (ARN) of a license configuration.
                                                                                                        	//
                                                                                                        	// This member is required.
                                                                                                        	LicenseConfigurationArn *string
                                                                                                        
                                                                                                        	// Maximum number of results to return in a single call.
                                                                                                        	MaxResults *int32
                                                                                                        
                                                                                                        	// Token for the next set of results.
                                                                                                        	NextToken *string
                                                                                                        }

                                                                                                        type ListAssociationsForLicenseConfigurationOutput

                                                                                                        type ListAssociationsForLicenseConfigurationOutput struct {
                                                                                                        
                                                                                                        	// Information about the associations for the license configuration.
                                                                                                        	LicenseConfigurationAssociations []types.LicenseConfigurationAssociation
                                                                                                        
                                                                                                        	// Token for the next set of results.
                                                                                                        	NextToken *string
                                                                                                        
                                                                                                        	// Metadata pertaining to the operation's result.
                                                                                                        	ResultMetadata middleware.Metadata
                                                                                                        }

                                                                                                        type ListDistributedGrantsInput

                                                                                                        type ListDistributedGrantsInput struct {
                                                                                                        
                                                                                                        	// Filters to scope the results. The following filters are supported:
                                                                                                        	//
                                                                                                        	// *
                                                                                                        	// LicenseARN
                                                                                                        	//
                                                                                                        	// * Status
                                                                                                        	//
                                                                                                        	// * PrincipalARN
                                                                                                        	//
                                                                                                        	// * ParentARN
                                                                                                        	Filters []types.Filter
                                                                                                        
                                                                                                        	// Amazon Resource Names (ARNs) of the grants.
                                                                                                        	GrantArns []string
                                                                                                        
                                                                                                        	// Maximum number of results to return in a single call.
                                                                                                        	MaxResults *int32
                                                                                                        
                                                                                                        	// Token for the next set of results.
                                                                                                        	NextToken *string
                                                                                                        }

                                                                                                        type ListDistributedGrantsOutput

                                                                                                        type ListDistributedGrantsOutput struct {
                                                                                                        
                                                                                                        	// Distributed grant details.
                                                                                                        	Grants []types.Grant
                                                                                                        
                                                                                                        	// Token for the next set of results.
                                                                                                        	NextToken *string
                                                                                                        
                                                                                                        	// Metadata pertaining to the operation's result.
                                                                                                        	ResultMetadata middleware.Metadata
                                                                                                        }

                                                                                                        type ListFailuresForLicenseConfigurationOperationsInput

                                                                                                        type ListFailuresForLicenseConfigurationOperationsInput struct {
                                                                                                        
                                                                                                        	// Amazon Resource Name of the license configuration.
                                                                                                        	//
                                                                                                        	// This member is required.
                                                                                                        	LicenseConfigurationArn *string
                                                                                                        
                                                                                                        	// Maximum number of results to return in a single call.
                                                                                                        	MaxResults *int32
                                                                                                        
                                                                                                        	// Token for the next set of results.
                                                                                                        	NextToken *string
                                                                                                        }

                                                                                                        type ListFailuresForLicenseConfigurationOperationsOutput

                                                                                                        type ListFailuresForLicenseConfigurationOperationsOutput struct {
                                                                                                        
                                                                                                        	// License configuration operations that failed.
                                                                                                        	LicenseOperationFailureList []types.LicenseOperationFailure
                                                                                                        
                                                                                                        	// Token for the next set of results.
                                                                                                        	NextToken *string
                                                                                                        
                                                                                                        	// Metadata pertaining to the operation's result.
                                                                                                        	ResultMetadata middleware.Metadata
                                                                                                        }

                                                                                                        type ListLicenseConfigurationsInput

                                                                                                        type ListLicenseConfigurationsInput struct {
                                                                                                        
                                                                                                        	// Filters to scope the results. The following filters and logical operators are
                                                                                                        	// supported:
                                                                                                        	//
                                                                                                        	// * licenseCountingType - The dimension on which licenses are counted.
                                                                                                        	// Possible values are vCPU | Instance | Core | Socket. Logical operators are
                                                                                                        	// EQUALS | NOT_EQUALS.
                                                                                                        	//
                                                                                                        	// * enforceLicenseCount - A Boolean value that indicates
                                                                                                        	// whether hard license enforcement is used. Logical operators are EQUALS |
                                                                                                        	// NOT_EQUALS.
                                                                                                        	//
                                                                                                        	// * usagelimitExceeded - A Boolean value that indicates whether the
                                                                                                        	// available licenses have been exceeded. Logical operators are EQUALS |
                                                                                                        	// NOT_EQUALS.
                                                                                                        	Filters []types.Filter
                                                                                                        
                                                                                                        	// Amazon Resource Names (ARN) of the license configurations.
                                                                                                        	LicenseConfigurationArns []string
                                                                                                        
                                                                                                        	// Maximum number of results to return in a single call.
                                                                                                        	MaxResults *int32
                                                                                                        
                                                                                                        	// Token for the next set of results.
                                                                                                        	NextToken *string
                                                                                                        }

                                                                                                        type ListLicenseConfigurationsOutput

                                                                                                        type ListLicenseConfigurationsOutput struct {
                                                                                                        
                                                                                                        	// Information about the license configurations.
                                                                                                        	LicenseConfigurations []types.LicenseConfiguration
                                                                                                        
                                                                                                        	// Token for the next set of results.
                                                                                                        	NextToken *string
                                                                                                        
                                                                                                        	// Metadata pertaining to the operation's result.
                                                                                                        	ResultMetadata middleware.Metadata
                                                                                                        }

                                                                                                        type ListLicenseSpecificationsForResourceInput

                                                                                                        type ListLicenseSpecificationsForResourceInput struct {
                                                                                                        
                                                                                                        	// Amazon Resource Name (ARN) of a resource that has an associated license
                                                                                                        	// configuration.
                                                                                                        	//
                                                                                                        	// This member is required.
                                                                                                        	ResourceArn *string
                                                                                                        
                                                                                                        	// Maximum number of results to return in a single call.
                                                                                                        	MaxResults *int32
                                                                                                        
                                                                                                        	// Token for the next set of results.
                                                                                                        	NextToken *string
                                                                                                        }

                                                                                                        type ListLicenseSpecificationsForResourceOutput

                                                                                                        type ListLicenseSpecificationsForResourceOutput struct {
                                                                                                        
                                                                                                        	// License configurations associated with a resource.
                                                                                                        	LicenseSpecifications []types.LicenseSpecification
                                                                                                        
                                                                                                        	// Token for the next set of results.
                                                                                                        	NextToken *string
                                                                                                        
                                                                                                        	// Metadata pertaining to the operation's result.
                                                                                                        	ResultMetadata middleware.Metadata
                                                                                                        }

                                                                                                        type ListLicenseVersionsInput

                                                                                                        type ListLicenseVersionsInput struct {
                                                                                                        
                                                                                                        	// Amazon Resource Name (ARN) of the license.
                                                                                                        	//
                                                                                                        	// This member is required.
                                                                                                        	LicenseArn *string
                                                                                                        
                                                                                                        	// Maximum number of results to return in a single call.
                                                                                                        	MaxResults *int32
                                                                                                        
                                                                                                        	// Token for the next set of results.
                                                                                                        	NextToken *string
                                                                                                        }

                                                                                                        type ListLicenseVersionsOutput

                                                                                                        type ListLicenseVersionsOutput struct {
                                                                                                        
                                                                                                        	// License details.
                                                                                                        	Licenses []types.License
                                                                                                        
                                                                                                        	// Token for the next set of results.
                                                                                                        	NextToken *string
                                                                                                        
                                                                                                        	// Metadata pertaining to the operation's result.
                                                                                                        	ResultMetadata middleware.Metadata
                                                                                                        }

                                                                                                        type ListLicensesInput

                                                                                                        type ListLicensesInput struct {
                                                                                                        
                                                                                                        	// Filters to scope the results. The following filters are supported:
                                                                                                        	//
                                                                                                        	// *
                                                                                                        	// Beneficiary
                                                                                                        	//
                                                                                                        	// * ProductSKU
                                                                                                        	//
                                                                                                        	// * KeyFingerprint
                                                                                                        	//
                                                                                                        	// * Status
                                                                                                        	Filters []types.Filter
                                                                                                        
                                                                                                        	// Amazon Resource Names (ARNs) of the licenses.
                                                                                                        	LicenseArns []string
                                                                                                        
                                                                                                        	// Maximum number of results to return in a single call.
                                                                                                        	MaxResults *int32
                                                                                                        
                                                                                                        	// Token for the next set of results.
                                                                                                        	NextToken *string
                                                                                                        }

                                                                                                        type ListLicensesOutput

                                                                                                        type ListLicensesOutput struct {
                                                                                                        
                                                                                                        	// License details.
                                                                                                        	Licenses []types.License
                                                                                                        
                                                                                                        	// Token for the next set of results.
                                                                                                        	NextToken *string
                                                                                                        
                                                                                                        	// Metadata pertaining to the operation's result.
                                                                                                        	ResultMetadata middleware.Metadata
                                                                                                        }

                                                                                                        type ListReceivedGrantsInput

                                                                                                        type ListReceivedGrantsInput struct {
                                                                                                        
                                                                                                        	// Filters to scope the results. The following filters are supported:
                                                                                                        	//
                                                                                                        	// *
                                                                                                        	// LicenseARN
                                                                                                        	//
                                                                                                        	// * Status
                                                                                                        	Filters []types.Filter
                                                                                                        
                                                                                                        	// Amazon Resource Names (ARNs) of the grants.
                                                                                                        	GrantArns []string
                                                                                                        
                                                                                                        	// Maximum number of results to return in a single call.
                                                                                                        	MaxResults *int32
                                                                                                        
                                                                                                        	// Token for the next set of results.
                                                                                                        	NextToken *string
                                                                                                        }

                                                                                                        type ListReceivedGrantsOutput

                                                                                                        type ListReceivedGrantsOutput struct {
                                                                                                        
                                                                                                        	// Received grant details.
                                                                                                        	Grants []types.Grant
                                                                                                        
                                                                                                        	// Token for the next set of results.
                                                                                                        	NextToken *string
                                                                                                        
                                                                                                        	// Metadata pertaining to the operation's result.
                                                                                                        	ResultMetadata middleware.Metadata
                                                                                                        }

                                                                                                        type ListReceivedLicensesInput

                                                                                                        type ListReceivedLicensesInput struct {
                                                                                                        
                                                                                                        	// Filters to scope the results. The following filters are supported:
                                                                                                        	//
                                                                                                        	// *
                                                                                                        	// ProductSKU
                                                                                                        	//
                                                                                                        	// * Status
                                                                                                        	//
                                                                                                        	// * KeyFingerprint
                                                                                                        	//
                                                                                                        	// * Issuer
                                                                                                        	Filters []types.Filter
                                                                                                        
                                                                                                        	// Amazon Resource Names (ARNs) of the licenses.
                                                                                                        	LicenseArns []string
                                                                                                        
                                                                                                        	// Maximum number of results to return in a single call.
                                                                                                        	MaxResults *int32
                                                                                                        
                                                                                                        	// Token for the next set of results.
                                                                                                        	NextToken *string
                                                                                                        }

                                                                                                        type ListReceivedLicensesOutput

                                                                                                        type ListReceivedLicensesOutput struct {
                                                                                                        
                                                                                                        	// Received license details.
                                                                                                        	Licenses []types.GrantedLicense
                                                                                                        
                                                                                                        	// Token for the next set of results.
                                                                                                        	NextToken *string
                                                                                                        
                                                                                                        	// Metadata pertaining to the operation's result.
                                                                                                        	ResultMetadata middleware.Metadata
                                                                                                        }

                                                                                                        type ListResourceInventoryInput

                                                                                                        type ListResourceInventoryInput struct {
                                                                                                        
                                                                                                        	// Filters to scope the results. The following filters and logical operators are
                                                                                                        	// supported:
                                                                                                        	//
                                                                                                        	// * account_id - The ID of the AWS account that owns the resource.
                                                                                                        	// Logical operators are EQUALS | NOT_EQUALS.
                                                                                                        	//
                                                                                                        	// * application_name - The name of the
                                                                                                        	// application. Logical operators are EQUALS | BEGINS_WITH.
                                                                                                        	//
                                                                                                        	// * license_included -
                                                                                                        	// The type of license included. Logical operators are EQUALS | NOT_EQUALS.
                                                                                                        	// Possible values are sql-server-enterprise | sql-server-standard | sql-server-web
                                                                                                        	// | windows-server-datacenter.
                                                                                                        	//
                                                                                                        	// * platform - The platform of the resource. Logical
                                                                                                        	// operators are EQUALS | BEGINS_WITH.
                                                                                                        	//
                                                                                                        	// * resource_id - The ID of the resource.
                                                                                                        	// Logical operators are EQUALS | NOT_EQUALS.
                                                                                                        	//
                                                                                                        	// * tag: - The key/value combination
                                                                                                        	// of a tag assigned to the resource. Logical operators are EQUALS (single account)
                                                                                                        	// or EQUALS | NOT_EQUALS (cross account).
                                                                                                        	Filters []types.InventoryFilter
                                                                                                        
                                                                                                        	// Maximum number of results to return in a single call.
                                                                                                        	MaxResults *int32
                                                                                                        
                                                                                                        	// Token for the next set of results.
                                                                                                        	NextToken *string
                                                                                                        }

                                                                                                        type ListResourceInventoryOutput

                                                                                                        type ListResourceInventoryOutput struct {
                                                                                                        
                                                                                                        	// Token for the next set of results.
                                                                                                        	NextToken *string
                                                                                                        
                                                                                                        	// Information about the resources.
                                                                                                        	ResourceInventoryList []types.ResourceInventory
                                                                                                        
                                                                                                        	// Metadata pertaining to the operation's result.
                                                                                                        	ResultMetadata middleware.Metadata
                                                                                                        }

                                                                                                        type ListTagsForResourceInput

                                                                                                        type ListTagsForResourceInput struct {
                                                                                                        
                                                                                                        	// Amazon Resource Name (ARN) of the license configuration.
                                                                                                        	//
                                                                                                        	// This member is required.
                                                                                                        	ResourceArn *string
                                                                                                        }

                                                                                                        type ListTagsForResourceOutput

                                                                                                        type ListTagsForResourceOutput struct {
                                                                                                        
                                                                                                        	// Information about the tags.
                                                                                                        	Tags []types.Tag
                                                                                                        
                                                                                                        	// Metadata pertaining to the operation's result.
                                                                                                        	ResultMetadata middleware.Metadata
                                                                                                        }

                                                                                                        type ListTokensInput

                                                                                                        type ListTokensInput struct {
                                                                                                        
                                                                                                        	// Filters to scope the results. The following filter is supported:
                                                                                                        	//
                                                                                                        	// * licenseArns
                                                                                                        	Filters []types.Filter
                                                                                                        
                                                                                                        	// Maximum number of results to return in a single call.
                                                                                                        	MaxResults *int32
                                                                                                        
                                                                                                        	// Token for the next set of results.
                                                                                                        	NextToken *string
                                                                                                        
                                                                                                        	// Token IDs.
                                                                                                        	TokenIds []string
                                                                                                        }

                                                                                                        type ListTokensOutput

                                                                                                        type ListTokensOutput struct {
                                                                                                        
                                                                                                        	// Token for the next set of results.
                                                                                                        	NextToken *string
                                                                                                        
                                                                                                        	// Received token details.
                                                                                                        	Tokens []types.TokenData
                                                                                                        
                                                                                                        	// Metadata pertaining to the operation's result.
                                                                                                        	ResultMetadata middleware.Metadata
                                                                                                        }

                                                                                                        type ListUsageForLicenseConfigurationInput

                                                                                                        type ListUsageForLicenseConfigurationInput struct {
                                                                                                        
                                                                                                        	// Amazon Resource Name (ARN) of the license configuration.
                                                                                                        	//
                                                                                                        	// This member is required.
                                                                                                        	LicenseConfigurationArn *string
                                                                                                        
                                                                                                        	// Filters to scope the results. The following filters and logical operators are
                                                                                                        	// supported:
                                                                                                        	//
                                                                                                        	// * resourceArn - The ARN of the license configuration resource.
                                                                                                        	// Logical operators are EQUALS | NOT_EQUALS.
                                                                                                        	//
                                                                                                        	// * resourceType - The resource type
                                                                                                        	// (EC2_INSTANCE | EC2_HOST | EC2_AMI | SYSTEMS_MANAGER_MANAGED_INSTANCE). Logical
                                                                                                        	// operators are EQUALS | NOT_EQUALS.
                                                                                                        	//
                                                                                                        	// * resourceAccount - The ID of the account
                                                                                                        	// that owns the resource. Logical operators are EQUALS | NOT_EQUALS.
                                                                                                        	Filters []types.Filter
                                                                                                        
                                                                                                        	// Maximum number of results to return in a single call.
                                                                                                        	MaxResults *int32
                                                                                                        
                                                                                                        	// Token for the next set of results.
                                                                                                        	NextToken *string
                                                                                                        }

                                                                                                        type ListUsageForLicenseConfigurationOutput

                                                                                                        type ListUsageForLicenseConfigurationOutput struct {
                                                                                                        
                                                                                                        	// Information about the license configurations.
                                                                                                        	LicenseConfigurationUsageList []types.LicenseConfigurationUsage
                                                                                                        
                                                                                                        	// Token for the next set of results.
                                                                                                        	NextToken *string
                                                                                                        
                                                                                                        	// Metadata pertaining to the operation's result.
                                                                                                        	ResultMetadata middleware.Metadata
                                                                                                        }

                                                                                                        type Options

                                                                                                        type Options struct {
                                                                                                        	// Set of options to modify how an operation is invoked. These apply to all
                                                                                                        	// operations invoked for this client. Use functional options on operation call to
                                                                                                        	// modify this list for per operation behavior.
                                                                                                        	APIOptions []func(*middleware.Stack) error
                                                                                                        
                                                                                                        	// Configures the events that will be sent to the configured logger.
                                                                                                        	ClientLogMode aws.ClientLogMode
                                                                                                        
                                                                                                        	// The credentials object to use when signing requests.
                                                                                                        	Credentials aws.CredentialsProvider
                                                                                                        
                                                                                                        	// The endpoint options to be used when attempting to resolve an endpoint.
                                                                                                        	EndpointOptions EndpointResolverOptions
                                                                                                        
                                                                                                        	// The service endpoint resolver.
                                                                                                        	EndpointResolver EndpointResolver
                                                                                                        
                                                                                                        	// Signature Version 4 (SigV4) Signer
                                                                                                        	HTTPSignerV4 HTTPSignerV4
                                                                                                        
                                                                                                        	// The logger writer interface to write logging messages to.
                                                                                                        	Logger logging.Logger
                                                                                                        
                                                                                                        	// The region to send requests to. (Required)
                                                                                                        	Region string
                                                                                                        
                                                                                                        	// Retryer guides how HTTP requests should be retried in case of recoverable
                                                                                                        	// failures. When nil the API client will use a default retryer.
                                                                                                        	Retryer aws.Retryer
                                                                                                        
                                                                                                        	// The HTTP client to invoke API calls with. Defaults to client's default HTTP
                                                                                                        	// implementation if nil.
                                                                                                        	HTTPClient HTTPClient
                                                                                                        }

                                                                                                        func (Options) Copy

                                                                                                        func (o Options) Copy() Options

                                                                                                          Copy creates a clone where the APIOptions list is deep copied.

                                                                                                          type RejectGrantInput

                                                                                                          type RejectGrantInput struct {
                                                                                                          
                                                                                                          	// Amazon Resource Name (ARN) of the grant.
                                                                                                          	//
                                                                                                          	// This member is required.
                                                                                                          	GrantArn *string
                                                                                                          }

                                                                                                          type RejectGrantOutput

                                                                                                          type RejectGrantOutput struct {
                                                                                                          
                                                                                                          	// Grant ARN.
                                                                                                          	GrantArn *string
                                                                                                          
                                                                                                          	// Grant status.
                                                                                                          	Status types.GrantStatus
                                                                                                          
                                                                                                          	// Grant version.
                                                                                                          	Version *string
                                                                                                          
                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                          }

                                                                                                          type ResolveEndpoint

                                                                                                          type ResolveEndpoint struct {
                                                                                                          	Resolver EndpointResolver
                                                                                                          	Options  EndpointResolverOptions
                                                                                                          }

                                                                                                          func (*ResolveEndpoint) HandleSerialize

                                                                                                          func (*ResolveEndpoint) ID

                                                                                                          func (*ResolveEndpoint) ID() string

                                                                                                          type TagResourceInput

                                                                                                          type TagResourceInput struct {
                                                                                                          
                                                                                                          	// Amazon Resource Name (ARN) of the license configuration.
                                                                                                          	//
                                                                                                          	// This member is required.
                                                                                                          	ResourceArn *string
                                                                                                          
                                                                                                          	// One or more tags.
                                                                                                          	//
                                                                                                          	// This member is required.
                                                                                                          	Tags []types.Tag
                                                                                                          }

                                                                                                          type TagResourceOutput

                                                                                                          type TagResourceOutput struct {
                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                          }

                                                                                                          type UntagResourceInput

                                                                                                          type UntagResourceInput struct {
                                                                                                          
                                                                                                          	// Amazon Resource Name (ARN) of the license configuration.
                                                                                                          	//
                                                                                                          	// This member is required.
                                                                                                          	ResourceArn *string
                                                                                                          
                                                                                                          	// Keys identifying the tags to remove.
                                                                                                          	//
                                                                                                          	// This member is required.
                                                                                                          	TagKeys []string
                                                                                                          }

                                                                                                          type UntagResourceOutput

                                                                                                          type UntagResourceOutput struct {
                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                          }

                                                                                                          type UpdateLicenseConfigurationInput

                                                                                                          type UpdateLicenseConfigurationInput struct {
                                                                                                          
                                                                                                          	// Amazon Resource Name (ARN) of the license configuration.
                                                                                                          	//
                                                                                                          	// This member is required.
                                                                                                          	LicenseConfigurationArn *string
                                                                                                          
                                                                                                          	// New description of the license configuration.
                                                                                                          	Description *string
                                                                                                          
                                                                                                          	// When true, disassociates a resource when software is uninstalled.
                                                                                                          	DisassociateWhenNotFound *bool
                                                                                                          
                                                                                                          	// New status of the license configuration.
                                                                                                          	LicenseConfigurationStatus types.LicenseConfigurationStatus
                                                                                                          
                                                                                                          	// New number of licenses managed by the license configuration.
                                                                                                          	LicenseCount *int64
                                                                                                          
                                                                                                          	// New hard limit of the number of available licenses.
                                                                                                          	LicenseCountHardLimit *bool
                                                                                                          
                                                                                                          	// New license rule. The only rule that you can add after you create a license
                                                                                                          	// configuration is licenseAffinityToHost.
                                                                                                          	LicenseRules []string
                                                                                                          
                                                                                                          	// New name of the license configuration.
                                                                                                          	Name *string
                                                                                                          
                                                                                                          	// New product information.
                                                                                                          	ProductInformationList []types.ProductInformation
                                                                                                          }

                                                                                                          type UpdateLicenseConfigurationOutput

                                                                                                          type UpdateLicenseConfigurationOutput struct {
                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                          }

                                                                                                          type UpdateLicenseSpecificationsForResourceInput

                                                                                                          type UpdateLicenseSpecificationsForResourceInput struct {
                                                                                                          
                                                                                                          	// Amazon Resource Name (ARN) of the AWS resource.
                                                                                                          	//
                                                                                                          	// This member is required.
                                                                                                          	ResourceArn *string
                                                                                                          
                                                                                                          	// ARNs of the license configurations to add.
                                                                                                          	AddLicenseSpecifications []types.LicenseSpecification
                                                                                                          
                                                                                                          	// ARNs of the license configurations to remove.
                                                                                                          	RemoveLicenseSpecifications []types.LicenseSpecification
                                                                                                          }

                                                                                                          type UpdateLicenseSpecificationsForResourceOutput

                                                                                                          type UpdateLicenseSpecificationsForResourceOutput struct {
                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                          }

                                                                                                          type UpdateServiceSettingsInput

                                                                                                          type UpdateServiceSettingsInput struct {
                                                                                                          
                                                                                                          	// Activates cross-account discovery.
                                                                                                          	EnableCrossAccountsDiscovery *bool
                                                                                                          
                                                                                                          	// Enables integration with AWS Organizations for cross-account discovery.
                                                                                                          	OrganizationConfiguration *types.OrganizationConfiguration
                                                                                                          
                                                                                                          	// Amazon Resource Name (ARN) of the Amazon S3 bucket where the License Manager
                                                                                                          	// information is stored.
                                                                                                          	S3BucketArn *string
                                                                                                          
                                                                                                          	// Amazon Resource Name (ARN) of the Amazon SNS topic used for License Manager
                                                                                                          	// alerts.
                                                                                                          	SnsTopicArn *string
                                                                                                          }

                                                                                                          type UpdateServiceSettingsOutput

                                                                                                          type UpdateServiceSettingsOutput struct {
                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                          }

                                                                                                          Directories

                                                                                                          Path Synopsis
                                                                                                          internal