@aws-sdk/client-license-manager 3.33.0 → 3.36.1

package/dist/types/ts3.4/commands/CreateGrantCommand.d.ts

@@ -1,35 +0,0 @@
-import { LicenseManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LicenseManagerClient";
-import { CreateGrantRequest, CreateGrantResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface CreateGrantCommandInput extends CreateGrantRequest {
-}
-export interface CreateGrantCommandOutput extends CreateGrantResponse, __MetadataBearer {
-}
-/**
- * <p>Creates a grant for the specified license. A grant shares the use of license entitlements with specific AWS accounts.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LicenseManagerClient, CreateGrantCommand } from "@aws-sdk/client-license-manager"; // ES Modules import
- * // const { LicenseManagerClient, CreateGrantCommand } = require("@aws-sdk/client-license-manager"); // CommonJS import
- * const client = new LicenseManagerClient(config);
- * const command = new CreateGrantCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateGrantCommandInput} for command's `input` shape.
- * @see {@link CreateGrantCommandOutput} for command's `response` shape.
- * @see {@link LicenseManagerClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class CreateGrantCommand extends $Command<CreateGrantCommandInput, CreateGrantCommandOutput, LicenseManagerClientResolvedConfig> {
-    readonly input: CreateGrantCommandInput;
-    constructor(input: CreateGrantCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LicenseManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateGrantCommandInput, CreateGrantCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/CreateLicenseConfigurationCommand.d.ts

@@ -1,40 +0,0 @@
-import { LicenseManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LicenseManagerClient";
-import { CreateLicenseConfigurationRequest, CreateLicenseConfigurationResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface CreateLicenseConfigurationCommandInput extends CreateLicenseConfigurationRequest {
-}
-export interface CreateLicenseConfigurationCommandOutput extends CreateLicenseConfigurationResponse, __MetadataBearer {
-}
-/**
- * <p>Creates a license configuration.</p>
- *          <p>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.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LicenseManagerClient, CreateLicenseConfigurationCommand } from "@aws-sdk/client-license-manager"; // ES Modules import
- * // const { LicenseManagerClient, CreateLicenseConfigurationCommand } = require("@aws-sdk/client-license-manager"); // CommonJS import
- * const client = new LicenseManagerClient(config);
- * const command = new CreateLicenseConfigurationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateLicenseConfigurationCommandInput} for command's `input` shape.
- * @see {@link CreateLicenseConfigurationCommandOutput} for command's `response` shape.
- * @see {@link LicenseManagerClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class CreateLicenseConfigurationCommand extends $Command<CreateLicenseConfigurationCommandInput, CreateLicenseConfigurationCommandOutput, LicenseManagerClientResolvedConfig> {
-    readonly input: CreateLicenseConfigurationCommandInput;
-    constructor(input: CreateLicenseConfigurationCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LicenseManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateLicenseConfigurationCommandInput, CreateLicenseConfigurationCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/CreateTokenCommand.d.ts

@@ -1,38 +0,0 @@
-import { LicenseManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LicenseManagerClient";
-import { CreateTokenRequest, CreateTokenResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface CreateTokenCommandInput extends CreateTokenRequest {
-}
-export interface CreateTokenCommandOutput extends CreateTokenResponse, __MetadataBearer {
-}
-/**
- * <p>Creates a long-lived token.</p>
- *          <p>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.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LicenseManagerClient, CreateTokenCommand } from "@aws-sdk/client-license-manager"; // ES Modules import
- * // const { LicenseManagerClient, CreateTokenCommand } = require("@aws-sdk/client-license-manager"); // CommonJS import
- * const client = new LicenseManagerClient(config);
- * const command = new CreateTokenCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateTokenCommandInput} for command's `input` shape.
- * @see {@link CreateTokenCommandOutput} for command's `response` shape.
- * @see {@link LicenseManagerClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class CreateTokenCommand extends $Command<CreateTokenCommandInput, CreateTokenCommandOutput, LicenseManagerClientResolvedConfig> {
-    readonly input: CreateTokenCommandInput;
-    constructor(input: CreateTokenCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LicenseManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateTokenCommandInput, CreateTokenCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/DeleteGrantCommand.d.ts

@@ -1,35 +0,0 @@
-import { LicenseManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LicenseManagerClient";
-import { DeleteGrantRequest, DeleteGrantResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DeleteGrantCommandInput extends DeleteGrantRequest {
-}
-export interface DeleteGrantCommandOutput extends DeleteGrantResponse, __MetadataBearer {
-}
-/**
- * <p>Deletes the specified grant.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LicenseManagerClient, DeleteGrantCommand } from "@aws-sdk/client-license-manager"; // ES Modules import
- * // const { LicenseManagerClient, DeleteGrantCommand } = require("@aws-sdk/client-license-manager"); // CommonJS import
- * const client = new LicenseManagerClient(config);
- * const command = new DeleteGrantCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteGrantCommandInput} for command's `input` shape.
- * @see {@link DeleteGrantCommandOutput} for command's `response` shape.
- * @see {@link LicenseManagerClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DeleteGrantCommand extends $Command<DeleteGrantCommandInput, DeleteGrantCommandOutput, LicenseManagerClientResolvedConfig> {
-    readonly input: DeleteGrantCommandInput;
-    constructor(input: DeleteGrantCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LicenseManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteGrantCommandInput, DeleteGrantCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/DeleteLicenseCommand.d.ts

@@ -1,35 +0,0 @@
-import { LicenseManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LicenseManagerClient";
-import { DeleteLicenseRequest, DeleteLicenseResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DeleteLicenseCommandInput extends DeleteLicenseRequest {
-}
-export interface DeleteLicenseCommandOutput extends DeleteLicenseResponse, __MetadataBearer {
-}
-/**
- * <p>Deletes the specified license.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LicenseManagerClient, DeleteLicenseCommand } from "@aws-sdk/client-license-manager"; // ES Modules import
- * // const { LicenseManagerClient, DeleteLicenseCommand } = require("@aws-sdk/client-license-manager"); // CommonJS import
- * const client = new LicenseManagerClient(config);
- * const command = new DeleteLicenseCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteLicenseCommandInput} for command's `input` shape.
- * @see {@link DeleteLicenseCommandOutput} for command's `response` shape.
- * @see {@link LicenseManagerClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DeleteLicenseCommand extends $Command<DeleteLicenseCommandInput, DeleteLicenseCommandOutput, LicenseManagerClientResolvedConfig> {
-    readonly input: DeleteLicenseCommandInput;
-    constructor(input: DeleteLicenseCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LicenseManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteLicenseCommandInput, DeleteLicenseCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/DeleteLicenseManagerReportGeneratorCommand.d.ts

@@ -1,36 +0,0 @@
-import { LicenseManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LicenseManagerClient";
-import { DeleteLicenseManagerReportGeneratorRequest, DeleteLicenseManagerReportGeneratorResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DeleteLicenseManagerReportGeneratorCommandInput extends DeleteLicenseManagerReportGeneratorRequest {
-}
-export interface DeleteLicenseManagerReportGeneratorCommandOutput extends DeleteLicenseManagerReportGeneratorResponse, __MetadataBearer {
-}
-/**
- * <p>Delete an existing report generator.</p>
- *          <p>This action deletes the report generator, which stops it from generating future reports and cannot be reversed. However, the previous reports from this generator will remain in your S3 bucket.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LicenseManagerClient, DeleteLicenseManagerReportGeneratorCommand } from "@aws-sdk/client-license-manager"; // ES Modules import
- * // const { LicenseManagerClient, DeleteLicenseManagerReportGeneratorCommand } = require("@aws-sdk/client-license-manager"); // CommonJS import
- * const client = new LicenseManagerClient(config);
- * const command = new DeleteLicenseManagerReportGeneratorCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteLicenseManagerReportGeneratorCommandInput} for command's `input` shape.
- * @see {@link DeleteLicenseManagerReportGeneratorCommandOutput} for command's `response` shape.
- * @see {@link LicenseManagerClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DeleteLicenseManagerReportGeneratorCommand extends $Command<DeleteLicenseManagerReportGeneratorCommandInput, DeleteLicenseManagerReportGeneratorCommandOutput, LicenseManagerClientResolvedConfig> {
-    readonly input: DeleteLicenseManagerReportGeneratorCommandInput;
-    constructor(input: DeleteLicenseManagerReportGeneratorCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LicenseManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteLicenseManagerReportGeneratorCommandInput, DeleteLicenseManagerReportGeneratorCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/DeleteTokenCommand.d.ts

@@ -1,35 +0,0 @@
-import { LicenseManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LicenseManagerClient";
-import { DeleteTokenRequest, DeleteTokenResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DeleteTokenCommandInput extends DeleteTokenRequest {
-}
-export interface DeleteTokenCommandOutput extends DeleteTokenResponse, __MetadataBearer {
-}
-/**
- * <p>Deletes the specified token. Must be called in the license home Region.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LicenseManagerClient, DeleteTokenCommand } from "@aws-sdk/client-license-manager"; // ES Modules import
- * // const { LicenseManagerClient, DeleteTokenCommand } = require("@aws-sdk/client-license-manager"); // CommonJS import
- * const client = new LicenseManagerClient(config);
- * const command = new DeleteTokenCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteTokenCommandInput} for command's `input` shape.
- * @see {@link DeleteTokenCommandOutput} for command's `response` shape.
- * @see {@link LicenseManagerClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DeleteTokenCommand extends $Command<DeleteTokenCommandInput, DeleteTokenCommandOutput, LicenseManagerClientResolvedConfig> {
-    readonly input: DeleteTokenCommandInput;
-    constructor(input: DeleteTokenCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LicenseManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteTokenCommandInput, DeleteTokenCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/GetAccessTokenCommand.d.ts

@@ -1,36 +0,0 @@
-import { LicenseManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LicenseManagerClient";
-import { GetAccessTokenRequest, GetAccessTokenResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface GetAccessTokenCommandInput extends GetAccessTokenRequest {
-}
-export interface GetAccessTokenCommandOutput extends GetAccessTokenResponse, __MetadataBearer {
-}
-/**
- * <p>Gets a temporary access token to use with AssumeRoleWithWebIdentity. Access tokens
- *           are valid for one hour.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LicenseManagerClient, GetAccessTokenCommand } from "@aws-sdk/client-license-manager"; // ES Modules import
- * // const { LicenseManagerClient, GetAccessTokenCommand } = require("@aws-sdk/client-license-manager"); // CommonJS import
- * const client = new LicenseManagerClient(config);
- * const command = new GetAccessTokenCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetAccessTokenCommandInput} for command's `input` shape.
- * @see {@link GetAccessTokenCommandOutput} for command's `response` shape.
- * @see {@link LicenseManagerClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class GetAccessTokenCommand extends $Command<GetAccessTokenCommandInput, GetAccessTokenCommandOutput, LicenseManagerClientResolvedConfig> {
-    readonly input: GetAccessTokenCommandInput;
-    constructor(input: GetAccessTokenCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LicenseManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetAccessTokenCommandInput, GetAccessTokenCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/GetGrantCommand.d.ts

@@ -1,35 +0,0 @@
-import { LicenseManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LicenseManagerClient";
-import { GetGrantRequest, GetGrantResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface GetGrantCommandInput extends GetGrantRequest {
-}
-export interface GetGrantCommandOutput extends GetGrantResponse, __MetadataBearer {
-}
-/**
- * <p>Gets detailed information about the specified grant.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LicenseManagerClient, GetGrantCommand } from "@aws-sdk/client-license-manager"; // ES Modules import
- * // const { LicenseManagerClient, GetGrantCommand } = require("@aws-sdk/client-license-manager"); // CommonJS import
- * const client = new LicenseManagerClient(config);
- * const command = new GetGrantCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetGrantCommandInput} for command's `input` shape.
- * @see {@link GetGrantCommandOutput} for command's `response` shape.
- * @see {@link LicenseManagerClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class GetGrantCommand extends $Command<GetGrantCommandInput, GetGrantCommandOutput, LicenseManagerClientResolvedConfig> {
-    readonly input: GetGrantCommandInput;
-    constructor(input: GetGrantCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LicenseManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetGrantCommandInput, GetGrantCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/GetLicenseCommand.d.ts

@@ -1,35 +0,0 @@
-import { LicenseManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LicenseManagerClient";
-import { GetLicenseRequest, GetLicenseResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface GetLicenseCommandInput extends GetLicenseRequest {
-}
-export interface GetLicenseCommandOutput extends GetLicenseResponse, __MetadataBearer {
-}
-/**
- * <p>Gets detailed information about the specified license.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LicenseManagerClient, GetLicenseCommand } from "@aws-sdk/client-license-manager"; // ES Modules import
- * // const { LicenseManagerClient, GetLicenseCommand } = require("@aws-sdk/client-license-manager"); // CommonJS import
- * const client = new LicenseManagerClient(config);
- * const command = new GetLicenseCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetLicenseCommandInput} for command's `input` shape.
- * @see {@link GetLicenseCommandOutput} for command's `response` shape.
- * @see {@link LicenseManagerClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class GetLicenseCommand extends $Command<GetLicenseCommandInput, GetLicenseCommandOutput, LicenseManagerClientResolvedConfig> {
-    readonly input: GetLicenseCommandInput;
-    constructor(input: GetLicenseCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LicenseManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetLicenseCommandInput, GetLicenseCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/GetLicenseUsageCommand.d.ts

@@ -1,35 +0,0 @@
-import { LicenseManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LicenseManagerClient";
-import { GetLicenseUsageRequest, GetLicenseUsageResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface GetLicenseUsageCommandInput extends GetLicenseUsageRequest {
-}
-export interface GetLicenseUsageCommandOutput extends GetLicenseUsageResponse, __MetadataBearer {
-}
-/**
- * <p>Gets detailed information about the usage of the specified license.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LicenseManagerClient, GetLicenseUsageCommand } from "@aws-sdk/client-license-manager"; // ES Modules import
- * // const { LicenseManagerClient, GetLicenseUsageCommand } = require("@aws-sdk/client-license-manager"); // CommonJS import
- * const client = new LicenseManagerClient(config);
- * const command = new GetLicenseUsageCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetLicenseUsageCommandInput} for command's `input` shape.
- * @see {@link GetLicenseUsageCommandOutput} for command's `response` shape.
- * @see {@link LicenseManagerClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class GetLicenseUsageCommand extends $Command<GetLicenseUsageCommandInput, GetLicenseUsageCommandOutput, LicenseManagerClientResolvedConfig> {
-    readonly input: GetLicenseUsageCommandInput;
-    constructor(input: GetLicenseUsageCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LicenseManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetLicenseUsageCommandInput, GetLicenseUsageCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/ListAssociationsForLicenseConfigurationCommand.d.ts

@@ -1,38 +0,0 @@
-import { LicenseManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LicenseManagerClient";
-import { ListAssociationsForLicenseConfigurationRequest, ListAssociationsForLicenseConfigurationResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface ListAssociationsForLicenseConfigurationCommandInput extends ListAssociationsForLicenseConfigurationRequest {
-}
-export interface ListAssociationsForLicenseConfigurationCommandOutput extends ListAssociationsForLicenseConfigurationResponse, __MetadataBearer {
-}
-/**
- * <p>Lists the resource associations for the specified license configuration.</p>
- *          <p>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).</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LicenseManagerClient, ListAssociationsForLicenseConfigurationCommand } from "@aws-sdk/client-license-manager"; // ES Modules import
- * // const { LicenseManagerClient, ListAssociationsForLicenseConfigurationCommand } = require("@aws-sdk/client-license-manager"); // CommonJS import
- * const client = new LicenseManagerClient(config);
- * const command = new ListAssociationsForLicenseConfigurationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListAssociationsForLicenseConfigurationCommandInput} for command's `input` shape.
- * @see {@link ListAssociationsForLicenseConfigurationCommandOutput} for command's `response` shape.
- * @see {@link LicenseManagerClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class ListAssociationsForLicenseConfigurationCommand extends $Command<ListAssociationsForLicenseConfigurationCommandInput, ListAssociationsForLicenseConfigurationCommandOutput, LicenseManagerClientResolvedConfig> {
-    readonly input: ListAssociationsForLicenseConfigurationCommandInput;
-    constructor(input: ListAssociationsForLicenseConfigurationCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LicenseManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListAssociationsForLicenseConfigurationCommandInput, ListAssociationsForLicenseConfigurationCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/ListLicensesCommand.d.ts

@@ -1,35 +0,0 @@
-import { LicenseManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LicenseManagerClient";
-import { ListLicensesRequest, ListLicensesResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface ListLicensesCommandInput extends ListLicensesRequest {
-}
-export interface ListLicensesCommandOutput extends ListLicensesResponse, __MetadataBearer {
-}
-/**
- * <p>Lists the licenses for your account.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LicenseManagerClient, ListLicensesCommand } from "@aws-sdk/client-license-manager"; // ES Modules import
- * // const { LicenseManagerClient, ListLicensesCommand } = require("@aws-sdk/client-license-manager"); // CommonJS import
- * const client = new LicenseManagerClient(config);
- * const command = new ListLicensesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListLicensesCommandInput} for command's `input` shape.
- * @see {@link ListLicensesCommandOutput} for command's `response` shape.
- * @see {@link LicenseManagerClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class ListLicensesCommand extends $Command<ListLicensesCommandInput, ListLicensesCommandOutput, LicenseManagerClientResolvedConfig> {
-    readonly input: ListLicensesCommandInput;
-    constructor(input: ListLicensesCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LicenseManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListLicensesCommandInput, ListLicensesCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/ListTokensCommand.d.ts

@@ -1,35 +0,0 @@
-import { LicenseManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LicenseManagerClient";
-import { ListTokensRequest, ListTokensResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface ListTokensCommandInput extends ListTokensRequest {
-}
-export interface ListTokensCommandOutput extends ListTokensResponse, __MetadataBearer {
-}
-/**
- * <p>Lists your tokens.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LicenseManagerClient, ListTokensCommand } from "@aws-sdk/client-license-manager"; // ES Modules import
- * // const { LicenseManagerClient, ListTokensCommand } = require("@aws-sdk/client-license-manager"); // CommonJS import
- * const client = new LicenseManagerClient(config);
- * const command = new ListTokensCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListTokensCommandInput} for command's `input` shape.
- * @see {@link ListTokensCommandOutput} for command's `response` shape.
- * @see {@link LicenseManagerClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class ListTokensCommand extends $Command<ListTokensCommandInput, ListTokensCommandOutput, LicenseManagerClientResolvedConfig> {
-    readonly input: ListTokensCommandInput;
-    constructor(input: ListTokensCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LicenseManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListTokensCommandInput, ListTokensCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/ListUsageForLicenseConfigurationCommand.d.ts

@@ -1,37 +0,0 @@
-import { LicenseManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LicenseManagerClient";
-import { ListUsageForLicenseConfigurationRequest, ListUsageForLicenseConfigurationResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface ListUsageForLicenseConfigurationCommandInput extends ListUsageForLicenseConfigurationRequest {
-}
-export interface ListUsageForLicenseConfigurationCommandOutput extends ListUsageForLicenseConfigurationResponse, __MetadataBearer {
-}
-/**
- * <p>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.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LicenseManagerClient, ListUsageForLicenseConfigurationCommand } from "@aws-sdk/client-license-manager"; // ES Modules import
- * // const { LicenseManagerClient, ListUsageForLicenseConfigurationCommand } = require("@aws-sdk/client-license-manager"); // CommonJS import
- * const client = new LicenseManagerClient(config);
- * const command = new ListUsageForLicenseConfigurationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListUsageForLicenseConfigurationCommandInput} for command's `input` shape.
- * @see {@link ListUsageForLicenseConfigurationCommandOutput} for command's `response` shape.
- * @see {@link LicenseManagerClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class ListUsageForLicenseConfigurationCommand extends $Command<ListUsageForLicenseConfigurationCommandInput, ListUsageForLicenseConfigurationCommandOutput, LicenseManagerClientResolvedConfig> {
-    readonly input: ListUsageForLicenseConfigurationCommandInput;
-    constructor(input: ListUsageForLicenseConfigurationCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LicenseManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListUsageForLicenseConfigurationCommandInput, ListUsageForLicenseConfigurationCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/RejectGrantCommand.d.ts

@@ -1,35 +0,0 @@
-import { LicenseManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LicenseManagerClient";
-import { RejectGrantRequest, RejectGrantResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface RejectGrantCommandInput extends RejectGrantRequest {
-}
-export interface RejectGrantCommandOutput extends RejectGrantResponse, __MetadataBearer {
-}
-/**
- * <p>Rejects the specified grant.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LicenseManagerClient, RejectGrantCommand } from "@aws-sdk/client-license-manager"; // ES Modules import
- * // const { LicenseManagerClient, RejectGrantCommand } = require("@aws-sdk/client-license-manager"); // CommonJS import
- * const client = new LicenseManagerClient(config);
- * const command = new RejectGrantCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link RejectGrantCommandInput} for command's `input` shape.
- * @see {@link RejectGrantCommandOutput} for command's `response` shape.
- * @see {@link LicenseManagerClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class RejectGrantCommand extends $Command<RejectGrantCommandInput, RejectGrantCommandOutput, LicenseManagerClientResolvedConfig> {
-    readonly input: RejectGrantCommandInput;
-    constructor(input: RejectGrantCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LicenseManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RejectGrantCommandInput, RejectGrantCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/TagResourceCommand.d.ts

@@ -1,35 +0,0 @@
-import { LicenseManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LicenseManagerClient";
-import { TagResourceRequest, TagResourceResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface TagResourceCommandInput extends TagResourceRequest {
-}
-export interface TagResourceCommandOutput extends TagResourceResponse, __MetadataBearer {
-}
-/**
- * <p>Adds the specified tags to the specified license configuration.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LicenseManagerClient, TagResourceCommand } from "@aws-sdk/client-license-manager"; // ES Modules import
- * // const { LicenseManagerClient, TagResourceCommand } = require("@aws-sdk/client-license-manager"); // CommonJS import
- * const client = new LicenseManagerClient(config);
- * const command = new TagResourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link TagResourceCommandInput} for command's `input` shape.
- * @see {@link TagResourceCommandOutput} for command's `response` shape.
- * @see {@link LicenseManagerClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class TagResourceCommand extends $Command<TagResourceCommandInput, TagResourceCommandOutput, LicenseManagerClientResolvedConfig> {
-    readonly input: TagResourceCommandInput;
-    constructor(input: TagResourceCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LicenseManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TagResourceCommandInput, TagResourceCommandOutput>;
-    private serialize;
-    private deserialize;
-}