@aws-sdk/client-license-manager 3.50.0 → 3.53.0

package/dist-types/ts3.4/models/models_0.d.ts

@@ -0,0 +1,2034 @@
+import { ExceptionOptionType as __ExceptionOptionType } from "@aws-sdk/smithy-client";
+import { LicenseManagerServiceException as __BaseException } from "./LicenseManagerServiceException";
+export interface AcceptGrantRequest {
+    
+    GrantArn: string | undefined;
+}
+export declare namespace AcceptGrantRequest {
+    
+    const filterSensitiveLog: (obj: AcceptGrantRequest) => any;
+}
+export declare enum GrantStatus {
+    ACTIVE = "ACTIVE",
+    DELETED = "DELETED",
+    DISABLED = "DISABLED",
+    FAILED_WORKFLOW = "FAILED_WORKFLOW",
+    PENDING_ACCEPT = "PENDING_ACCEPT",
+    PENDING_DELETE = "PENDING_DELETE",
+    PENDING_WORKFLOW = "PENDING_WORKFLOW",
+    REJECTED = "REJECTED",
+    WORKFLOW_COMPLETED = "WORKFLOW_COMPLETED"
+}
+export interface AcceptGrantResponse {
+    
+    GrantArn?: string;
+    
+    Status?: GrantStatus | string;
+    
+    Version?: string;
+}
+export declare namespace AcceptGrantResponse {
+    
+    const filterSensitiveLog: (obj: AcceptGrantResponse) => any;
+}
+
+export declare class AccessDeniedException extends __BaseException {
+    readonly name: "AccessDeniedException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<AccessDeniedException, __BaseException>);
+}
+
+export declare class AuthorizationException extends __BaseException {
+    readonly name: "AuthorizationException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<AuthorizationException, __BaseException>);
+}
+
+export declare class InvalidParameterValueException extends __BaseException {
+    readonly name: "InvalidParameterValueException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidParameterValueException, __BaseException>);
+}
+
+export declare class RateLimitExceededException extends __BaseException {
+    readonly name: "RateLimitExceededException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<RateLimitExceededException, __BaseException>);
+}
+
+export declare class ResourceLimitExceededException extends __BaseException {
+    readonly name: "ResourceLimitExceededException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<ResourceLimitExceededException, __BaseException>);
+}
+
+export declare class ServerInternalException extends __BaseException {
+    readonly name: "ServerInternalException";
+    readonly $fault: "server";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<ServerInternalException, __BaseException>);
+}
+
+export declare class ValidationException extends __BaseException {
+    readonly name: "ValidationException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<ValidationException, __BaseException>);
+}
+export declare enum AllowedOperation {
+    CHECKOUT_BORROW_LICENSE = "CheckoutBorrowLicense",
+    CHECKOUT_LICENSE = "CheckoutLicense",
+    CHECK_IN_LICENSE = "CheckInLicense",
+    CREATE_GRANT = "CreateGrant",
+    CREATE_TOKEN = "CreateToken",
+    EXTEND_CONSUMPTION_LICENSE = "ExtendConsumptionLicense",
+    LIST_PURCHASED_LICENSES = "ListPurchasedLicenses"
+}
+
+export interface AutomatedDiscoveryInformation {
+    
+    LastRunTime?: Date;
+}
+export declare namespace AutomatedDiscoveryInformation {
+    
+    const filterSensitiveLog: (obj: AutomatedDiscoveryInformation) => any;
+}
+export interface CheckInLicenseRequest {
+    
+    LicenseConsumptionToken: string | undefined;
+    
+    Beneficiary?: string;
+}
+export declare namespace CheckInLicenseRequest {
+    
+    const filterSensitiveLog: (obj: CheckInLicenseRequest) => any;
+}
+export interface CheckInLicenseResponse {
+}
+export declare namespace CheckInLicenseResponse {
+    
+    const filterSensitiveLog: (obj: CheckInLicenseResponse) => any;
+}
+
+export declare class ConflictException extends __BaseException {
+    readonly name: "ConflictException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<ConflictException, __BaseException>);
+}
+
+export declare class ResourceNotFoundException extends __BaseException {
+    readonly name: "ResourceNotFoundException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<ResourceNotFoundException, __BaseException>);
+}
+
+export interface Metadata {
+    
+    Name?: string;
+    
+    Value?: string;
+}
+export declare namespace Metadata {
+    
+    const filterSensitiveLog: (obj: Metadata) => any;
+}
+export declare enum DigitalSignatureMethod {
+    JWT_PS384 = "JWT_PS384"
+}
+export declare enum EntitlementDataUnit {
+    BITS = "Bits",
+    BITS_PER_SECOND = "Bits/Second",
+    BYTES = "Bytes",
+    BYTES_PER_SECOND = "Bytes/Second",
+    COUNT = "Count",
+    COUNT_PER_SECOND = "Count/Second",
+    GIGABITS = "Gigabits",
+    GIGABITS_PER_SECOND = "Gigabits/Second",
+    GIGABYTES = "Gigabytes",
+    GIGABYTES_PER_SECOND = "Gigabytes/Second",
+    KILOBITS = "Kilobits",
+    KILOBITS_PER_SECOND = "Kilobits/Second",
+    KILOBYTES = "Kilobytes",
+    KILOBYTES_PER_SECOND = "Kilobytes/Second",
+    MEGABITS = "Megabits",
+    MEGABITS_PER_SECOND = "Megabits/Second",
+    MEGABYTES = "Megabytes",
+    MEGABYTES_PER_SECOND = "Megabytes/Second",
+    MICROSECONDS = "Microseconds",
+    MILLISECONDS = "Milliseconds",
+    NONE = "None",
+    PERCENT = "Percent",
+    SECONDS = "Seconds",
+    TERABITS = "Terabits",
+    TERABITS_PER_SECOND = "Terabits/Second",
+    TERABYTES = "Terabytes",
+    TERABYTES_PER_SECOND = "Terabytes/Second"
+}
+
+export interface EntitlementData {
+    
+    Name: string | undefined;
+    
+    Value?: string;
+    
+    Unit: EntitlementDataUnit | string | undefined;
+}
+export declare namespace EntitlementData {
+    
+    const filterSensitiveLog: (obj: EntitlementData) => any;
+}
+export interface CheckoutBorrowLicenseRequest {
+    
+    LicenseArn: string | undefined;
+    
+    Entitlements: EntitlementData[] | undefined;
+    
+    DigitalSignatureMethod: DigitalSignatureMethod | string | undefined;
+    
+    NodeId?: string;
+    
+    CheckoutMetadata?: Metadata[];
+    
+    ClientToken: string | undefined;
+}
+export declare namespace CheckoutBorrowLicenseRequest {
+    
+    const filterSensitiveLog: (obj: CheckoutBorrowLicenseRequest) => any;
+}
+export interface CheckoutBorrowLicenseResponse {
+    
+    LicenseArn?: string;
+    
+    LicenseConsumptionToken?: string;
+    
+    EntitlementsAllowed?: EntitlementData[];
+    
+    NodeId?: string;
+    
+    SignedToken?: string;
+    
+    IssuedAt?: string;
+    
+    Expiration?: string;
+    
+    CheckoutMetadata?: Metadata[];
+}
+export declare namespace CheckoutBorrowLicenseResponse {
+    
+    const filterSensitiveLog: (obj: CheckoutBorrowLicenseResponse) => any;
+}
+
+export declare class EntitlementNotAllowedException extends __BaseException {
+    readonly name: "EntitlementNotAllowedException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<EntitlementNotAllowedException, __BaseException>);
+}
+
+export declare class NoEntitlementsAllowedException extends __BaseException {
+    readonly name: "NoEntitlementsAllowedException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<NoEntitlementsAllowedException, __BaseException>);
+}
+
+export declare class RedirectException extends __BaseException {
+    readonly name: "RedirectException";
+    readonly $fault: "client";
+    Location?: string;
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<RedirectException, __BaseException>);
+}
+
+export declare class UnsupportedDigitalSignatureMethodException extends __BaseException {
+    readonly name: "UnsupportedDigitalSignatureMethodException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<UnsupportedDigitalSignatureMethodException, __BaseException>);
+}
+export declare enum CheckoutType {
+    PERPETUAL = "PERPETUAL",
+    PROVISIONAL = "PROVISIONAL"
+}
+export interface CheckoutLicenseRequest {
+    
+    ProductSKU: string | undefined;
+    
+    CheckoutType: CheckoutType | string | undefined;
+    
+    KeyFingerprint: string | undefined;
+    
+    Entitlements: EntitlementData[] | undefined;
+    
+    ClientToken: string | undefined;
+    
+    Beneficiary?: string;
+    
+    NodeId?: string;
+}
+export declare namespace CheckoutLicenseRequest {
+    
+    const filterSensitiveLog: (obj: CheckoutLicenseRequest) => any;
+}
+export interface CheckoutLicenseResponse {
+    
+    CheckoutType?: CheckoutType | string;
+    
+    LicenseConsumptionToken?: string;
+    
+    EntitlementsAllowed?: EntitlementData[];
+    
+    SignedToken?: string;
+    
+    NodeId?: string;
+    
+    IssuedAt?: string;
+    
+    Expiration?: string;
+    
+    LicenseArn?: string;
+}
+export declare namespace CheckoutLicenseResponse {
+    
+    const filterSensitiveLog: (obj: CheckoutLicenseResponse) => any;
+}
+export interface CreateGrantRequest {
+    
+    ClientToken: string | undefined;
+    
+    GrantName: string | undefined;
+    
+    LicenseArn: string | undefined;
+    
+    Principals: string[] | undefined;
+    
+    HomeRegion: string | undefined;
+    
+    AllowedOperations: (AllowedOperation | string)[] | undefined;
+}
+export declare namespace CreateGrantRequest {
+    
+    const filterSensitiveLog: (obj: CreateGrantRequest) => any;
+}
+export interface CreateGrantResponse {
+    
+    GrantArn?: string;
+    
+    Status?: GrantStatus | string;
+    
+    Version?: string;
+}
+export declare namespace CreateGrantResponse {
+    
+    const filterSensitiveLog: (obj: CreateGrantResponse) => any;
+}
+export interface CreateGrantVersionRequest {
+    
+    ClientToken: string | undefined;
+    
+    GrantArn: string | undefined;
+    
+    GrantName?: string;
+    
+    AllowedOperations?: (AllowedOperation | string)[];
+    
+    Status?: GrantStatus | string;
+    
+    StatusReason?: string;
+    
+    SourceVersion?: string;
+}
+export declare namespace CreateGrantVersionRequest {
+    
+    const filterSensitiveLog: (obj: CreateGrantVersionRequest) => any;
+}
+export interface CreateGrantVersionResponse {
+    
+    GrantArn?: string;
+    
+    Status?: GrantStatus | string;
+    
+    Version?: string;
+}
+export declare namespace CreateGrantVersionResponse {
+    
+    const filterSensitiveLog: (obj: CreateGrantVersionResponse) => any;
+}
+
+export interface BorrowConfiguration {
+    
+    AllowEarlyCheckIn: boolean | undefined;
+    
+    MaxTimeToLiveInMinutes: number | undefined;
+}
+export declare namespace BorrowConfiguration {
+    
+    const filterSensitiveLog: (obj: BorrowConfiguration) => any;
+}
+
+export interface ProvisionalConfiguration {
+    
+    MaxTimeToLiveInMinutes: number | undefined;
+}
+export declare namespace ProvisionalConfiguration {
+    
+    const filterSensitiveLog: (obj: ProvisionalConfiguration) => any;
+}
+export declare enum RenewType {
+    MONTHLY = "Monthly",
+    NONE = "None",
+    WEEKLY = "Weekly"
+}
+
+export interface ConsumptionConfiguration {
+    
+    RenewType?: RenewType | string;
+    
+    ProvisionalConfiguration?: ProvisionalConfiguration;
+    
+    BorrowConfiguration?: BorrowConfiguration;
+}
+export declare namespace ConsumptionConfiguration {
+    
+    const filterSensitiveLog: (obj: ConsumptionConfiguration) => any;
+}
+export declare enum EntitlementUnit {
+    BITS = "Bits",
+    BITS_PER_SECOND = "Bits/Second",
+    BYTES = "Bytes",
+    BYTES_PER_SECOND = "Bytes/Second",
+    COUNT = "Count",
+    COUNT_PER_SECOND = "Count/Second",
+    GIGABITS = "Gigabits",
+    GIGABITS_PER_SECOND = "Gigabits/Second",
+    GIGABYTES = "Gigabytes",
+    GIGABYTES_PER_SECOND = "Gigabytes/Second",
+    KILOBITS = "Kilobits",
+    KILOBITS_PER_SECOND = "Kilobits/Second",
+    KILOBYTES = "Kilobytes",
+    KILOBYTES_PER_SECOND = "Kilobytes/Second",
+    MEGABITS = "Megabits",
+    MEGABITS_PER_SECOND = "Megabits/Second",
+    MEGABYTES = "Megabytes",
+    MEGABYTES_PER_SECOND = "Megabytes/Second",
+    MICROSECONDS = "Microseconds",
+    MILLISECONDS = "Milliseconds",
+    NONE = "None",
+    PERCENT = "Percent",
+    SECONDS = "Seconds",
+    TERABITS = "Terabits",
+    TERABITS_PER_SECOND = "Terabits/Second",
+    TERABYTES = "Terabytes",
+    TERABYTES_PER_SECOND = "Terabytes/Second"
+}
+
+export interface Entitlement {
+    
+    Name: string | undefined;
+    
+    Value?: string;
+    
+    MaxCount?: number;
+    
+    Overage?: boolean;
+    
+    Unit: EntitlementUnit | string | undefined;
+    
+    AllowCheckIn?: boolean;
+}
+export declare namespace Entitlement {
+    
+    const filterSensitiveLog: (obj: Entitlement) => any;
+}
+
+export interface Issuer {
+    
+    Name: string | undefined;
+    
+    SignKey?: string;
+}
+export declare namespace Issuer {
+    
+    const filterSensitiveLog: (obj: Issuer) => any;
+}
+
+export interface DatetimeRange {
+    
+    Begin: string | undefined;
+    
+    End?: string;
+}
+export declare namespace DatetimeRange {
+    
+    const filterSensitiveLog: (obj: DatetimeRange) => any;
+}
+export interface CreateLicenseRequest {
+    
+    LicenseName: string | undefined;
+    
+    ProductName: string | undefined;
+    
+    ProductSKU: string | undefined;
+    
+    Issuer: Issuer | undefined;
+    
+    HomeRegion: string | undefined;
+    
+    Validity: DatetimeRange | undefined;
+    
+    Entitlements: Entitlement[] | undefined;
+    
+    Beneficiary: string | undefined;
+    
+    ConsumptionConfiguration: ConsumptionConfiguration | undefined;
+    
+    LicenseMetadata?: Metadata[];
+    
+    ClientToken: string | undefined;
+}
+export declare namespace CreateLicenseRequest {
+    
+    const filterSensitiveLog: (obj: CreateLicenseRequest) => any;
+}
+export declare enum LicenseStatus {
+    AVAILABLE = "AVAILABLE",
+    DEACTIVATED = "DEACTIVATED",
+    DELETED = "DELETED",
+    EXPIRED = "EXPIRED",
+    PENDING_AVAILABLE = "PENDING_AVAILABLE",
+    PENDING_DELETE = "PENDING_DELETE",
+    SUSPENDED = "SUSPENDED"
+}
+export interface CreateLicenseResponse {
+    
+    LicenseArn?: string;
+    
+    Status?: LicenseStatus | string;
+    
+    Version?: string;
+}
+export declare namespace CreateLicenseResponse {
+    
+    const filterSensitiveLog: (obj: CreateLicenseResponse) => any;
+}
+export declare enum LicenseCountingType {
+    CORE = "Core",
+    INSTANCE = "Instance",
+    SOCKET = "Socket",
+    VCPU = "vCPU"
+}
+
+export interface ProductInformationFilter {
+    
+    ProductInformationFilterName: string | undefined;
+    
+    ProductInformationFilterValue?: string[];
+    
+    ProductInformationFilterComparator: string | undefined;
+}
+export declare namespace ProductInformationFilter {
+    
+    const filterSensitiveLog: (obj: ProductInformationFilter) => any;
+}
+
+export interface ProductInformation {
+    
+    ResourceType: string | undefined;
+    
+    ProductInformationFilterList: ProductInformationFilter[] | undefined;
+}
+export declare namespace ProductInformation {
+    
+    const filterSensitiveLog: (obj: ProductInformation) => any;
+}
+
+export interface Tag {
+    
+    Key?: string;
+    
+    Value?: string;
+}
+export declare namespace Tag {
+    
+    const filterSensitiveLog: (obj: Tag) => any;
+}
+export interface CreateLicenseConfigurationRequest {
+    
+    Name: string | undefined;
+    
+    Description?: string;
+    
+    LicenseCountingType: LicenseCountingType | string | undefined;
+    
+    LicenseCount?: number;
+    
+    LicenseCountHardLimit?: boolean;
+    
+    LicenseRules?: string[];
+    
+    Tags?: Tag[];
+    
+    DisassociateWhenNotFound?: boolean;
+    
+    ProductInformationList?: ProductInformation[];
+}
+export declare namespace CreateLicenseConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: CreateLicenseConfigurationRequest) => any;
+}
+export interface CreateLicenseConfigurationResponse {
+    
+    LicenseConfigurationArn?: string;
+}
+export declare namespace CreateLicenseConfigurationResponse {
+    
+    const filterSensitiveLog: (obj: CreateLicenseConfigurationResponse) => any;
+}
+
+export interface LicenseConversionContext {
+    
+    UsageOperation?: string;
+}
+export declare namespace LicenseConversionContext {
+    
+    const filterSensitiveLog: (obj: LicenseConversionContext) => any;
+}
+export interface CreateLicenseConversionTaskForResourceRequest {
+    
+    ResourceArn: string | undefined;
+    
+    SourceLicenseContext: LicenseConversionContext | undefined;
+    
+    DestinationLicenseContext: LicenseConversionContext | undefined;
+}
+export declare namespace CreateLicenseConversionTaskForResourceRequest {
+    
+    const filterSensitiveLog: (obj: CreateLicenseConversionTaskForResourceRequest) => any;
+}
+export interface CreateLicenseConversionTaskForResourceResponse {
+    
+    LicenseConversionTaskId?: string;
+}
+export declare namespace CreateLicenseConversionTaskForResourceResponse {
+    
+    const filterSensitiveLog: (obj: CreateLicenseConversionTaskForResourceResponse) => any;
+}
+
+export interface ReportContext {
+    
+    licenseConfigurationArns: string[] | undefined;
+}
+export declare namespace ReportContext {
+    
+    const filterSensitiveLog: (obj: ReportContext) => any;
+}
+export declare enum ReportFrequencyType {
+    DAY = "DAY",
+    MONTH = "MONTH",
+    WEEK = "WEEK"
+}
+
+export interface ReportFrequency {
+    
+    value?: number;
+    
+    period?: ReportFrequencyType | string;
+}
+export declare namespace ReportFrequency {
+    
+    const filterSensitiveLog: (obj: ReportFrequency) => any;
+}
+export declare enum ReportType {
+    LICENSE_CONFIGURATION_SUMMARY_REPORT = "LicenseConfigurationSummaryReport",
+    LICENSE_CONFIGURATION_USAGE_REPORT = "LicenseConfigurationUsageReport"
+}
+export interface CreateLicenseManagerReportGeneratorRequest {
+    
+    ReportGeneratorName: string | undefined;
+    
+    Type: (ReportType | string)[] | undefined;
+    
+    ReportContext: ReportContext | undefined;
+    
+    ReportFrequency: ReportFrequency | undefined;
+    
+    ClientToken: string | undefined;
+    
+    Description?: string;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateLicenseManagerReportGeneratorRequest {
+    
+    const filterSensitiveLog: (obj: CreateLicenseManagerReportGeneratorRequest) => any;
+}
+export interface CreateLicenseManagerReportGeneratorResponse {
+    
+    LicenseManagerReportGeneratorArn?: string;
+}
+export declare namespace CreateLicenseManagerReportGeneratorResponse {
+    
+    const filterSensitiveLog: (obj: CreateLicenseManagerReportGeneratorResponse) => any;
+}
+export interface CreateLicenseVersionRequest {
+    
+    LicenseArn: string | undefined;
+    
+    LicenseName: string | undefined;
+    
+    ProductName: string | undefined;
+    
+    Issuer: Issuer | undefined;
+    
+    HomeRegion: string | undefined;
+    
+    Validity: DatetimeRange | undefined;
+    
+    LicenseMetadata?: Metadata[];
+    
+    Entitlements: Entitlement[] | undefined;
+    
+    ConsumptionConfiguration: ConsumptionConfiguration | undefined;
+    
+    Status: LicenseStatus | string | undefined;
+    
+    ClientToken: string | undefined;
+    
+    SourceVersion?: string;
+}
+export declare namespace CreateLicenseVersionRequest {
+    
+    const filterSensitiveLog: (obj: CreateLicenseVersionRequest) => any;
+}
+export interface CreateLicenseVersionResponse {
+    
+    LicenseArn?: string;
+    
+    Version?: string;
+    
+    Status?: LicenseStatus | string;
+}
+export declare namespace CreateLicenseVersionResponse {
+    
+    const filterSensitiveLog: (obj: CreateLicenseVersionResponse) => any;
+}
+export interface CreateTokenRequest {
+    
+    LicenseArn: string | undefined;
+    
+    RoleArns?: string[];
+    
+    ExpirationInDays?: number;
+    
+    TokenProperties?: string[];
+    
+    ClientToken: string | undefined;
+}
+export declare namespace CreateTokenRequest {
+    
+    const filterSensitiveLog: (obj: CreateTokenRequest) => any;
+}
+export declare enum TokenType {
+    REFRESH_TOKEN = "REFRESH_TOKEN"
+}
+export interface CreateTokenResponse {
+    
+    TokenId?: string;
+    
+    TokenType?: TokenType | string;
+    
+    Token?: string;
+}
+export declare namespace CreateTokenResponse {
+    
+    const filterSensitiveLog: (obj: CreateTokenResponse) => any;
+}
+export interface DeleteGrantRequest {
+    
+    GrantArn: string | undefined;
+    
+    StatusReason?: string;
+    
+    Version: string | undefined;
+}
+export declare namespace DeleteGrantRequest {
+    
+    const filterSensitiveLog: (obj: DeleteGrantRequest) => any;
+}
+export interface DeleteGrantResponse {
+    
+    GrantArn?: string;
+    
+    Status?: GrantStatus | string;
+    
+    Version?: string;
+}
+export declare namespace DeleteGrantResponse {
+    
+    const filterSensitiveLog: (obj: DeleteGrantResponse) => any;
+}
+export interface DeleteLicenseRequest {
+    
+    LicenseArn: string | undefined;
+    
+    SourceVersion: string | undefined;
+}
+export declare namespace DeleteLicenseRequest {
+    
+    const filterSensitiveLog: (obj: DeleteLicenseRequest) => any;
+}
+export declare enum LicenseDeletionStatus {
+    DELETED = "DELETED",
+    PENDING_DELETE = "PENDING_DELETE"
+}
+export interface DeleteLicenseResponse {
+    
+    Status?: LicenseDeletionStatus | string;
+    
+    DeletionDate?: string;
+}
+export declare namespace DeleteLicenseResponse {
+    
+    const filterSensitiveLog: (obj: DeleteLicenseResponse) => any;
+}
+export interface DeleteLicenseConfigurationRequest {
+    
+    LicenseConfigurationArn: string | undefined;
+}
+export declare namespace DeleteLicenseConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: DeleteLicenseConfigurationRequest) => any;
+}
+export interface DeleteLicenseConfigurationResponse {
+}
+export declare namespace DeleteLicenseConfigurationResponse {
+    
+    const filterSensitiveLog: (obj: DeleteLicenseConfigurationResponse) => any;
+}
+export interface DeleteLicenseManagerReportGeneratorRequest {
+    
+    LicenseManagerReportGeneratorArn: string | undefined;
+}
+export declare namespace DeleteLicenseManagerReportGeneratorRequest {
+    
+    const filterSensitiveLog: (obj: DeleteLicenseManagerReportGeneratorRequest) => any;
+}
+export interface DeleteLicenseManagerReportGeneratorResponse {
+}
+export declare namespace DeleteLicenseManagerReportGeneratorResponse {
+    
+    const filterSensitiveLog: (obj: DeleteLicenseManagerReportGeneratorResponse) => any;
+}
+export interface DeleteTokenRequest {
+    
+    TokenId: string | undefined;
+}
+export declare namespace DeleteTokenRequest {
+    
+    const filterSensitiveLog: (obj: DeleteTokenRequest) => any;
+}
+export interface DeleteTokenResponse {
+}
+export declare namespace DeleteTokenResponse {
+    
+    const filterSensitiveLog: (obj: DeleteTokenResponse) => any;
+}
+export interface ExtendLicenseConsumptionRequest {
+    
+    LicenseConsumptionToken: string | undefined;
+    
+    DryRun?: boolean;
+}
+export declare namespace ExtendLicenseConsumptionRequest {
+    
+    const filterSensitiveLog: (obj: ExtendLicenseConsumptionRequest) => any;
+}
+export interface ExtendLicenseConsumptionResponse {
+    
+    LicenseConsumptionToken?: string;
+    
+    Expiration?: string;
+}
+export declare namespace ExtendLicenseConsumptionResponse {
+    
+    const filterSensitiveLog: (obj: ExtendLicenseConsumptionResponse) => any;
+}
+export interface GetAccessTokenRequest {
+    
+    Token: string | undefined;
+    
+    TokenProperties?: string[];
+}
+export declare namespace GetAccessTokenRequest {
+    
+    const filterSensitiveLog: (obj: GetAccessTokenRequest) => any;
+}
+export interface GetAccessTokenResponse {
+    
+    AccessToken?: string;
+}
+export declare namespace GetAccessTokenResponse {
+    
+    const filterSensitiveLog: (obj: GetAccessTokenResponse) => any;
+}
+export interface GetGrantRequest {
+    
+    GrantArn: string | undefined;
+    
+    Version?: string;
+}
+export declare namespace GetGrantRequest {
+    
+    const filterSensitiveLog: (obj: GetGrantRequest) => any;
+}
+
+export interface Grant {
+    
+    GrantArn: string | undefined;
+    
+    GrantName: string | undefined;
+    
+    ParentArn: string | undefined;
+    
+    LicenseArn: string | undefined;
+    
+    GranteePrincipalArn: string | undefined;
+    
+    HomeRegion: string | undefined;
+    
+    GrantStatus: GrantStatus | string | undefined;
+    
+    StatusReason?: string;
+    
+    Version: string | undefined;
+    
+    GrantedOperations: (AllowedOperation | string)[] | undefined;
+}
+export declare namespace Grant {
+    
+    const filterSensitiveLog: (obj: Grant) => any;
+}
+export interface GetGrantResponse {
+    
+    Grant?: Grant;
+}
+export declare namespace GetGrantResponse {
+    
+    const filterSensitiveLog: (obj: GetGrantResponse) => any;
+}
+export interface GetLicenseRequest {
+    
+    LicenseArn: string | undefined;
+    
+    Version?: string;
+}
+export declare namespace GetLicenseRequest {
+    
+    const filterSensitiveLog: (obj: GetLicenseRequest) => any;
+}
+
+export interface IssuerDetails {
+    
+    Name?: string;
+    
+    SignKey?: string;
+    
+    KeyFingerprint?: string;
+}
+export declare namespace IssuerDetails {
+    
+    const filterSensitiveLog: (obj: IssuerDetails) => any;
+}
+
+export interface License {
+    
+    LicenseArn?: string;
+    
+    LicenseName?: string;
+    
+    ProductName?: string;
+    
+    ProductSKU?: string;
+    
+    Issuer?: IssuerDetails;
+    
+    HomeRegion?: string;
+    
+    Status?: LicenseStatus | string;
+    
+    Validity?: DatetimeRange;
+    
+    Beneficiary?: string;
+    
+    Entitlements?: Entitlement[];
+    
+    ConsumptionConfiguration?: ConsumptionConfiguration;
+    
+    LicenseMetadata?: Metadata[];
+    
+    CreateTime?: string;
+    
+    Version?: string;
+}
+export declare namespace License {
+    
+    const filterSensitiveLog: (obj: License) => any;
+}
+export interface GetLicenseResponse {
+    
+    License?: License;
+}
+export declare namespace GetLicenseResponse {
+    
+    const filterSensitiveLog: (obj: GetLicenseResponse) => any;
+}
+export interface GetLicenseConfigurationRequest {
+    
+    LicenseConfigurationArn: string | undefined;
+}
+export declare namespace GetLicenseConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: GetLicenseConfigurationRequest) => any;
+}
+export declare enum ResourceType {
+    EC2_AMI = "EC2_AMI",
+    EC2_HOST = "EC2_HOST",
+    EC2_INSTANCE = "EC2_INSTANCE",
+    RDS = "RDS",
+    SYSTEMS_MANAGER_MANAGED_INSTANCE = "SYSTEMS_MANAGER_MANAGED_INSTANCE"
+}
+
+export interface ConsumedLicenseSummary {
+    
+    ResourceType?: ResourceType | string;
+    
+    ConsumedLicenses?: number;
+}
+export declare namespace ConsumedLicenseSummary {
+    
+    const filterSensitiveLog: (obj: ConsumedLicenseSummary) => any;
+}
+
+export interface ManagedResourceSummary {
+    
+    ResourceType?: ResourceType | string;
+    
+    AssociationCount?: number;
+}
+export declare namespace ManagedResourceSummary {
+    
+    const filterSensitiveLog: (obj: ManagedResourceSummary) => any;
+}
+export interface GetLicenseConfigurationResponse {
+    
+    LicenseConfigurationId?: string;
+    
+    LicenseConfigurationArn?: string;
+    
+    Name?: string;
+    
+    Description?: string;
+    
+    LicenseCountingType?: LicenseCountingType | string;
+    
+    LicenseRules?: string[];
+    
+    LicenseCount?: number;
+    
+    LicenseCountHardLimit?: boolean;
+    
+    ConsumedLicenses?: number;
+    
+    Status?: string;
+    
+    OwnerAccountId?: string;
+    
+    ConsumedLicenseSummaryList?: ConsumedLicenseSummary[];
+    
+    ManagedResourceSummaryList?: ManagedResourceSummary[];
+    
+    Tags?: Tag[];
+    
+    ProductInformationList?: ProductInformation[];
+    
+    AutomatedDiscoveryInformation?: AutomatedDiscoveryInformation;
+    
+    DisassociateWhenNotFound?: boolean;
+}
+export declare namespace GetLicenseConfigurationResponse {
+    
+    const filterSensitiveLog: (obj: GetLicenseConfigurationResponse) => any;
+}
+export interface GetLicenseConversionTaskRequest {
+    
+    LicenseConversionTaskId: string | undefined;
+}
+export declare namespace GetLicenseConversionTaskRequest {
+    
+    const filterSensitiveLog: (obj: GetLicenseConversionTaskRequest) => any;
+}
+export declare enum LicenseConversionTaskStatus {
+    FAILED = "FAILED",
+    IN_PROGRESS = "IN_PROGRESS",
+    SUCCEEDED = "SUCCEEDED"
+}
+export interface GetLicenseConversionTaskResponse {
+    
+    LicenseConversionTaskId?: string;
+    
+    ResourceArn?: string;
+    
+    SourceLicenseContext?: LicenseConversionContext;
+    
+    DestinationLicenseContext?: LicenseConversionContext;
+    
+    StatusMessage?: string;
+    
+    Status?: LicenseConversionTaskStatus | string;
+    
+    StartTime?: Date;
+    
+    LicenseConversionTime?: Date;
+    
+    EndTime?: Date;
+}
+export declare namespace GetLicenseConversionTaskResponse {
+    
+    const filterSensitiveLog: (obj: GetLicenseConversionTaskResponse) => any;
+}
+export interface GetLicenseManagerReportGeneratorRequest {
+    
+    LicenseManagerReportGeneratorArn: string | undefined;
+}
+export declare namespace GetLicenseManagerReportGeneratorRequest {
+    
+    const filterSensitiveLog: (obj: GetLicenseManagerReportGeneratorRequest) => any;
+}
+
+export interface S3Location {
+    
+    bucket?: string;
+    
+    keyPrefix?: string;
+}
+export declare namespace S3Location {
+    
+    const filterSensitiveLog: (obj: S3Location) => any;
+}
+
+export interface ReportGenerator {
+    
+    ReportGeneratorName?: string;
+    
+    ReportType?: (ReportType | string)[];
+    
+    ReportContext?: ReportContext;
+    
+    ReportFrequency?: ReportFrequency;
+    
+    LicenseManagerReportGeneratorArn?: string;
+    
+    LastRunStatus?: string;
+    
+    LastRunFailureReason?: string;
+    
+    LastReportGenerationTime?: string;
+    
+    ReportCreatorAccount?: string;
+    
+    Description?: string;
+    
+    S3Location?: S3Location;
+    
+    CreateTime?: string;
+    
+    Tags?: Tag[];
+}
+export declare namespace ReportGenerator {
+    
+    const filterSensitiveLog: (obj: ReportGenerator) => any;
+}
+export interface GetLicenseManagerReportGeneratorResponse {
+    
+    ReportGenerator?: ReportGenerator;
+}
+export declare namespace GetLicenseManagerReportGeneratorResponse {
+    
+    const filterSensitiveLog: (obj: GetLicenseManagerReportGeneratorResponse) => any;
+}
+export interface GetLicenseUsageRequest {
+    
+    LicenseArn: string | undefined;
+}
+export declare namespace GetLicenseUsageRequest {
+    
+    const filterSensitiveLog: (obj: GetLicenseUsageRequest) => any;
+}
+
+export interface EntitlementUsage {
+    
+    Name: string | undefined;
+    
+    ConsumedValue: string | undefined;
+    
+    MaxCount?: string;
+    
+    Unit: EntitlementDataUnit | string | undefined;
+}
+export declare namespace EntitlementUsage {
+    
+    const filterSensitiveLog: (obj: EntitlementUsage) => any;
+}
+
+export interface LicenseUsage {
+    
+    EntitlementUsages?: EntitlementUsage[];
+}
+export declare namespace LicenseUsage {
+    
+    const filterSensitiveLog: (obj: LicenseUsage) => any;
+}
+export interface GetLicenseUsageResponse {
+    
+    LicenseUsage?: LicenseUsage;
+}
+export declare namespace GetLicenseUsageResponse {
+    
+    const filterSensitiveLog: (obj: GetLicenseUsageResponse) => any;
+}
+export interface GetServiceSettingsRequest {
+}
+export declare namespace GetServiceSettingsRequest {
+    
+    const filterSensitiveLog: (obj: GetServiceSettingsRequest) => any;
+}
+
+export interface OrganizationConfiguration {
+    
+    EnableIntegration: boolean | undefined;
+}
+export declare namespace OrganizationConfiguration {
+    
+    const filterSensitiveLog: (obj: OrganizationConfiguration) => any;
+}
+export interface GetServiceSettingsResponse {
+    
+    S3BucketArn?: string;
+    
+    SnsTopicArn?: string;
+    
+    OrganizationConfiguration?: OrganizationConfiguration;
+    
+    EnableCrossAccountsDiscovery?: boolean;
+    
+    LicenseManagerResourceShareArn?: string;
+}
+export declare namespace GetServiceSettingsResponse {
+    
+    const filterSensitiveLog: (obj: GetServiceSettingsResponse) => any;
+}
+
+export declare class FilterLimitExceededException extends __BaseException {
+    readonly name: "FilterLimitExceededException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<FilterLimitExceededException, __BaseException>);
+}
+export interface ListAssociationsForLicenseConfigurationRequest {
+    
+    LicenseConfigurationArn: string | undefined;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListAssociationsForLicenseConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: ListAssociationsForLicenseConfigurationRequest) => any;
+}
+
+export interface LicenseConfigurationAssociation {
+    
+    ResourceArn?: string;
+    
+    ResourceType?: ResourceType | string;
+    
+    ResourceOwnerId?: string;
+    
+    AssociationTime?: Date;
+    
+    AmiAssociationScope?: string;
+}
+export declare namespace LicenseConfigurationAssociation {
+    
+    const filterSensitiveLog: (obj: LicenseConfigurationAssociation) => any;
+}
+export interface ListAssociationsForLicenseConfigurationResponse {
+    
+    LicenseConfigurationAssociations?: LicenseConfigurationAssociation[];
+    
+    NextToken?: string;
+}
+export declare namespace ListAssociationsForLicenseConfigurationResponse {
+    
+    const filterSensitiveLog: (obj: ListAssociationsForLicenseConfigurationResponse) => any;
+}
+
+export interface Filter {
+    
+    Name?: string;
+    
+    Values?: string[];
+}
+export declare namespace Filter {
+    
+    const filterSensitiveLog: (obj: Filter) => any;
+}
+export interface ListDistributedGrantsRequest {
+    
+    GrantArns?: string[];
+    
+    Filters?: Filter[];
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListDistributedGrantsRequest {
+    
+    const filterSensitiveLog: (obj: ListDistributedGrantsRequest) => any;
+}
+export interface ListDistributedGrantsResponse {
+    
+    Grants?: Grant[];
+    
+    NextToken?: string;
+}
+export declare namespace ListDistributedGrantsResponse {
+    
+    const filterSensitiveLog: (obj: ListDistributedGrantsResponse) => any;
+}
+export interface ListFailuresForLicenseConfigurationOperationsRequest {
+    
+    LicenseConfigurationArn: string | undefined;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListFailuresForLicenseConfigurationOperationsRequest {
+    
+    const filterSensitiveLog: (obj: ListFailuresForLicenseConfigurationOperationsRequest) => any;
+}
+
+export interface LicenseOperationFailure {
+    
+    ResourceArn?: string;
+    
+    ResourceType?: ResourceType | string;
+    
+    ErrorMessage?: string;
+    
+    FailureTime?: Date;
+    
+    OperationName?: string;
+    
+    ResourceOwnerId?: string;
+    
+    OperationRequestedBy?: string;
+    
+    MetadataList?: Metadata[];
+}
+export declare namespace LicenseOperationFailure {
+    
+    const filterSensitiveLog: (obj: LicenseOperationFailure) => any;
+}
+export interface ListFailuresForLicenseConfigurationOperationsResponse {
+    
+    LicenseOperationFailureList?: LicenseOperationFailure[];
+    
+    NextToken?: string;
+}
+export declare namespace ListFailuresForLicenseConfigurationOperationsResponse {
+    
+    const filterSensitiveLog: (obj: ListFailuresForLicenseConfigurationOperationsResponse) => any;
+}
+export interface ListLicenseConfigurationsRequest {
+    
+    LicenseConfigurationArns?: string[];
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+    
+    Filters?: Filter[];
+}
+export declare namespace ListLicenseConfigurationsRequest {
+    
+    const filterSensitiveLog: (obj: ListLicenseConfigurationsRequest) => any;
+}
+
+export interface LicenseConfiguration {
+    
+    LicenseConfigurationId?: string;
+    
+    LicenseConfigurationArn?: string;
+    
+    Name?: string;
+    
+    Description?: string;
+    
+    LicenseCountingType?: LicenseCountingType | string;
+    
+    LicenseRules?: string[];
+    
+    LicenseCount?: number;
+    
+    LicenseCountHardLimit?: boolean;
+    
+    DisassociateWhenNotFound?: boolean;
+    
+    ConsumedLicenses?: number;
+    
+    Status?: string;
+    
+    OwnerAccountId?: string;
+    
+    ConsumedLicenseSummaryList?: ConsumedLicenseSummary[];
+    
+    ManagedResourceSummaryList?: ManagedResourceSummary[];
+    
+    ProductInformationList?: ProductInformation[];
+    
+    AutomatedDiscoveryInformation?: AutomatedDiscoveryInformation;
+}
+export declare namespace LicenseConfiguration {
+    
+    const filterSensitiveLog: (obj: LicenseConfiguration) => any;
+}
+export interface ListLicenseConfigurationsResponse {
+    
+    LicenseConfigurations?: LicenseConfiguration[];
+    
+    NextToken?: string;
+}
+export declare namespace ListLicenseConfigurationsResponse {
+    
+    const filterSensitiveLog: (obj: ListLicenseConfigurationsResponse) => any;
+}
+export interface ListLicenseConversionTasksRequest {
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+    
+    Filters?: Filter[];
+}
+export declare namespace ListLicenseConversionTasksRequest {
+    
+    const filterSensitiveLog: (obj: ListLicenseConversionTasksRequest) => any;
+}
+
+export interface LicenseConversionTask {
+    
+    LicenseConversionTaskId?: string;
+    
+    ResourceArn?: string;
+    
+    SourceLicenseContext?: LicenseConversionContext;
+    
+    DestinationLicenseContext?: LicenseConversionContext;
+    
+    Status?: LicenseConversionTaskStatus | string;
+    
+    StatusMessage?: string;
+    
+    StartTime?: Date;
+    
+    LicenseConversionTime?: Date;
+    
+    EndTime?: Date;
+}
+export declare namespace LicenseConversionTask {
+    
+    const filterSensitiveLog: (obj: LicenseConversionTask) => any;
+}
+export interface ListLicenseConversionTasksResponse {
+    
+    LicenseConversionTasks?: LicenseConversionTask[];
+    
+    NextToken?: string;
+}
+export declare namespace ListLicenseConversionTasksResponse {
+    
+    const filterSensitiveLog: (obj: ListLicenseConversionTasksResponse) => any;
+}
+export interface ListLicenseManagerReportGeneratorsRequest {
+    
+    Filters?: Filter[];
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListLicenseManagerReportGeneratorsRequest {
+    
+    const filterSensitiveLog: (obj: ListLicenseManagerReportGeneratorsRequest) => any;
+}
+export interface ListLicenseManagerReportGeneratorsResponse {
+    
+    ReportGenerators?: ReportGenerator[];
+    
+    NextToken?: string;
+}
+export declare namespace ListLicenseManagerReportGeneratorsResponse {
+    
+    const filterSensitiveLog: (obj: ListLicenseManagerReportGeneratorsResponse) => any;
+}
+export interface ListLicensesRequest {
+    
+    LicenseArns?: string[];
+    
+    Filters?: Filter[];
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListLicensesRequest {
+    
+    const filterSensitiveLog: (obj: ListLicensesRequest) => any;
+}
+export interface ListLicensesResponse {
+    
+    Licenses?: License[];
+    
+    NextToken?: string;
+}
+export declare namespace ListLicensesResponse {
+    
+    const filterSensitiveLog: (obj: ListLicensesResponse) => any;
+}
+export interface ListLicenseSpecificationsForResourceRequest {
+    
+    ResourceArn: string | undefined;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListLicenseSpecificationsForResourceRequest {
+    
+    const filterSensitiveLog: (obj: ListLicenseSpecificationsForResourceRequest) => any;
+}
+
+export interface LicenseSpecification {
+    
+    LicenseConfigurationArn: string | undefined;
+    
+    AmiAssociationScope?: string;
+}
+export declare namespace LicenseSpecification {
+    
+    const filterSensitiveLog: (obj: LicenseSpecification) => any;
+}
+export interface ListLicenseSpecificationsForResourceResponse {
+    
+    LicenseSpecifications?: LicenseSpecification[];
+    
+    NextToken?: string;
+}
+export declare namespace ListLicenseSpecificationsForResourceResponse {
+    
+    const filterSensitiveLog: (obj: ListLicenseSpecificationsForResourceResponse) => any;
+}
+export interface ListLicenseVersionsRequest {
+    
+    LicenseArn: string | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListLicenseVersionsRequest {
+    
+    const filterSensitiveLog: (obj: ListLicenseVersionsRequest) => any;
+}
+export interface ListLicenseVersionsResponse {
+    
+    Licenses?: License[];
+    
+    NextToken?: string;
+}
+export declare namespace ListLicenseVersionsResponse {
+    
+    const filterSensitiveLog: (obj: ListLicenseVersionsResponse) => any;
+}
+export interface ListReceivedGrantsRequest {
+    
+    GrantArns?: string[];
+    
+    Filters?: Filter[];
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListReceivedGrantsRequest {
+    
+    const filterSensitiveLog: (obj: ListReceivedGrantsRequest) => any;
+}
+export interface ListReceivedGrantsResponse {
+    
+    Grants?: Grant[];
+    
+    NextToken?: string;
+}
+export declare namespace ListReceivedGrantsResponse {
+    
+    const filterSensitiveLog: (obj: ListReceivedGrantsResponse) => any;
+}
+export interface ListReceivedLicensesRequest {
+    
+    LicenseArns?: string[];
+    
+    Filters?: Filter[];
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListReceivedLicensesRequest {
+    
+    const filterSensitiveLog: (obj: ListReceivedLicensesRequest) => any;
+}
+export declare enum ReceivedStatus {
+    ACTIVE = "ACTIVE",
+    DELETED = "DELETED",
+    DISABLED = "DISABLED",
+    FAILED_WORKFLOW = "FAILED_WORKFLOW",
+    PENDING_ACCEPT = "PENDING_ACCEPT",
+    PENDING_WORKFLOW = "PENDING_WORKFLOW",
+    REJECTED = "REJECTED",
+    WORKFLOW_COMPLETED = "WORKFLOW_COMPLETED"
+}
+
+export interface ReceivedMetadata {
+    
+    ReceivedStatus?: ReceivedStatus | string;
+    
+    ReceivedStatusReason?: string;
+    
+    AllowedOperations?: (AllowedOperation | string)[];
+}
+export declare namespace ReceivedMetadata {
+    
+    const filterSensitiveLog: (obj: ReceivedMetadata) => any;
+}
+
+export interface GrantedLicense {
+    
+    LicenseArn?: string;
+    
+    LicenseName?: string;
+    
+    ProductName?: string;
+    
+    ProductSKU?: string;
+    
+    Issuer?: IssuerDetails;
+    
+    HomeRegion?: string;
+    
+    Status?: LicenseStatus | string;
+    
+    Validity?: DatetimeRange;
+    
+    Beneficiary?: string;
+    
+    Entitlements?: Entitlement[];
+    
+    ConsumptionConfiguration?: ConsumptionConfiguration;
+    
+    LicenseMetadata?: Metadata[];
+    
+    CreateTime?: string;
+    
+    Version?: string;
+    
+    ReceivedMetadata?: ReceivedMetadata;
+}
+export declare namespace GrantedLicense {
+    
+    const filterSensitiveLog: (obj: GrantedLicense) => any;
+}
+export interface ListReceivedLicensesResponse {
+    
+    Licenses?: GrantedLicense[];
+    
+    NextToken?: string;
+}
+export declare namespace ListReceivedLicensesResponse {
+    
+    const filterSensitiveLog: (obj: ListReceivedLicensesResponse) => any;
+}
+
+export declare class FailedDependencyException extends __BaseException {
+    readonly name: "FailedDependencyException";
+    readonly $fault: "client";
+    Message?: string;
+    ErrorCode?: string;
+    
+    constructor(opts: __ExceptionOptionType<FailedDependencyException, __BaseException>);
+}
+export declare enum InventoryFilterCondition {
+    BEGINS_WITH = "BEGINS_WITH",
+    CONTAINS = "CONTAINS",
+    EQUALS = "EQUALS",
+    NOT_EQUALS = "NOT_EQUALS"
+}
+
+export interface InventoryFilter {
+    
+    Name: string | undefined;
+    
+    Condition: InventoryFilterCondition | string | undefined;
+    
+    Value?: string;
+}
+export declare namespace InventoryFilter {
+    
+    const filterSensitiveLog: (obj: InventoryFilter) => any;
+}
+export interface ListResourceInventoryRequest {
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+    
+    Filters?: InventoryFilter[];
+}
+export declare namespace ListResourceInventoryRequest {
+    
+    const filterSensitiveLog: (obj: ListResourceInventoryRequest) => any;
+}
+
+export interface ResourceInventory {
+    
+    ResourceId?: string;
+    
+    ResourceType?: ResourceType | string;
+    
+    ResourceArn?: string;
+    
+    Platform?: string;
+    
+    PlatformVersion?: string;
+    
+    ResourceOwningAccountId?: string;
+}
+export declare namespace ResourceInventory {
+    
+    const filterSensitiveLog: (obj: ResourceInventory) => any;
+}
+export interface ListResourceInventoryResponse {
+    
+    ResourceInventoryList?: ResourceInventory[];
+    
+    NextToken?: string;
+}
+export declare namespace ListResourceInventoryResponse {
+    
+    const filterSensitiveLog: (obj: ListResourceInventoryResponse) => any;
+}
+export interface ListTagsForResourceRequest {
+    
+    ResourceArn: string | undefined;
+}
+export declare namespace ListTagsForResourceRequest {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceRequest) => any;
+}
+export interface ListTagsForResourceResponse {
+    
+    Tags?: Tag[];
+}
+export declare namespace ListTagsForResourceResponse {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceResponse) => any;
+}
+export interface ListTokensRequest {
+    
+    TokenIds?: string[];
+    
+    Filters?: Filter[];
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListTokensRequest {
+    
+    const filterSensitiveLog: (obj: ListTokensRequest) => any;
+}
+
+export interface TokenData {
+    
+    TokenId?: string;
+    
+    TokenType?: string;
+    
+    LicenseArn?: string;
+    
+    ExpirationTime?: string;
+    
+    TokenProperties?: string[];
+    
+    RoleArns?: string[];
+    
+    Status?: string;
+}
+export declare namespace TokenData {
+    
+    const filterSensitiveLog: (obj: TokenData) => any;
+}
+export interface ListTokensResponse {
+    
+    Tokens?: TokenData[];
+    
+    NextToken?: string;
+}
+export declare namespace ListTokensResponse {
+    
+    const filterSensitiveLog: (obj: ListTokensResponse) => any;
+}
+export interface ListUsageForLicenseConfigurationRequest {
+    
+    LicenseConfigurationArn: string | undefined;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+    
+    Filters?: Filter[];
+}
+export declare namespace ListUsageForLicenseConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: ListUsageForLicenseConfigurationRequest) => any;
+}
+
+export interface LicenseConfigurationUsage {
+    
+    ResourceArn?: string;
+    
+    ResourceType?: ResourceType | string;
+    
+    ResourceStatus?: string;
+    
+    ResourceOwnerId?: string;
+    
+    AssociationTime?: Date;
+    
+    ConsumedLicenses?: number;
+}
+export declare namespace LicenseConfigurationUsage {
+    
+    const filterSensitiveLog: (obj: LicenseConfigurationUsage) => any;
+}
+export interface ListUsageForLicenseConfigurationResponse {
+    
+    LicenseConfigurationUsageList?: LicenseConfigurationUsage[];
+    
+    NextToken?: string;
+}
+export declare namespace ListUsageForLicenseConfigurationResponse {
+    
+    const filterSensitiveLog: (obj: ListUsageForLicenseConfigurationResponse) => any;
+}
+export interface RejectGrantRequest {
+    
+    GrantArn: string | undefined;
+}
+export declare namespace RejectGrantRequest {
+    
+    const filterSensitiveLog: (obj: RejectGrantRequest) => any;
+}
+export interface RejectGrantResponse {
+    
+    GrantArn?: string;
+    
+    Status?: GrantStatus | string;
+    
+    Version?: string;
+}
+export declare namespace RejectGrantResponse {
+    
+    const filterSensitiveLog: (obj: RejectGrantResponse) => any;
+}
+export interface TagResourceRequest {
+    
+    ResourceArn: string | undefined;
+    
+    Tags: Tag[] | undefined;
+}
+export declare namespace TagResourceRequest {
+    
+    const filterSensitiveLog: (obj: TagResourceRequest) => any;
+}
+export interface TagResourceResponse {
+}
+export declare namespace TagResourceResponse {
+    
+    const filterSensitiveLog: (obj: TagResourceResponse) => any;
+}
+export interface UntagResourceRequest {
+    
+    ResourceArn: string | undefined;
+    
+    TagKeys: string[] | undefined;
+}
+export declare namespace UntagResourceRequest {
+    
+    const filterSensitiveLog: (obj: UntagResourceRequest) => any;
+}
+export interface UntagResourceResponse {
+}
+export declare namespace UntagResourceResponse {
+    
+    const filterSensitiveLog: (obj: UntagResourceResponse) => any;
+}
+export declare enum LicenseConfigurationStatus {
+    AVAILABLE = "AVAILABLE",
+    DISABLED = "DISABLED"
+}
+export interface UpdateLicenseConfigurationRequest {
+    
+    LicenseConfigurationArn: string | undefined;
+    
+    LicenseConfigurationStatus?: LicenseConfigurationStatus | string;
+    
+    LicenseRules?: string[];
+    
+    LicenseCount?: number;
+    
+    LicenseCountHardLimit?: boolean;
+    
+    Name?: string;
+    
+    Description?: string;
+    
+    ProductInformationList?: ProductInformation[];
+    
+    DisassociateWhenNotFound?: boolean;
+}
+export declare namespace UpdateLicenseConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: UpdateLicenseConfigurationRequest) => any;
+}
+export interface UpdateLicenseConfigurationResponse {
+}
+export declare namespace UpdateLicenseConfigurationResponse {
+    
+    const filterSensitiveLog: (obj: UpdateLicenseConfigurationResponse) => any;
+}
+export interface UpdateLicenseManagerReportGeneratorRequest {
+    
+    LicenseManagerReportGeneratorArn: string | undefined;
+    
+    ReportGeneratorName: string | undefined;
+    
+    Type: (ReportType | string)[] | undefined;
+    
+    ReportContext: ReportContext | undefined;
+    
+    ReportFrequency: ReportFrequency | undefined;
+    
+    ClientToken: string | undefined;
+    
+    Description?: string;
+}
+export declare namespace UpdateLicenseManagerReportGeneratorRequest {
+    
+    const filterSensitiveLog: (obj: UpdateLicenseManagerReportGeneratorRequest) => any;
+}
+export interface UpdateLicenseManagerReportGeneratorResponse {
+}
+export declare namespace UpdateLicenseManagerReportGeneratorResponse {
+    
+    const filterSensitiveLog: (obj: UpdateLicenseManagerReportGeneratorResponse) => any;
+}
+
+export declare class InvalidResourceStateException extends __BaseException {
+    readonly name: "InvalidResourceStateException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidResourceStateException, __BaseException>);
+}
+
+export declare class LicenseUsageException extends __BaseException {
+    readonly name: "LicenseUsageException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<LicenseUsageException, __BaseException>);
+}
+export interface UpdateLicenseSpecificationsForResourceRequest {
+    
+    ResourceArn: string | undefined;
+    
+    AddLicenseSpecifications?: LicenseSpecification[];
+    
+    RemoveLicenseSpecifications?: LicenseSpecification[];
+}
+export declare namespace UpdateLicenseSpecificationsForResourceRequest {
+    
+    const filterSensitiveLog: (obj: UpdateLicenseSpecificationsForResourceRequest) => any;
+}
+export interface UpdateLicenseSpecificationsForResourceResponse {
+}
+export declare namespace UpdateLicenseSpecificationsForResourceResponse {
+    
+    const filterSensitiveLog: (obj: UpdateLicenseSpecificationsForResourceResponse) => any;
+}
+export interface UpdateServiceSettingsRequest {
+    
+    S3BucketArn?: string;
+    
+    SnsTopicArn?: string;
+    
+    OrganizationConfiguration?: OrganizationConfiguration;
+    
+    EnableCrossAccountsDiscovery?: boolean;
+}
+export declare namespace UpdateServiceSettingsRequest {
+    
+    const filterSensitiveLog: (obj: UpdateServiceSettingsRequest) => any;
+}
+export interface UpdateServiceSettingsResponse {
+}
+export declare namespace UpdateServiceSettingsResponse {
+    
+    const filterSensitiveLog: (obj: UpdateServiceSettingsResponse) => any;
+}