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

package/{dist/types → dist-types}/ts3.4/commands/CreateLicenseVersionCommand.d.ts

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

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LicenseManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LicenseManagerClient";
+import { CreateTokenRequest, CreateTokenResponse } from "../models/models_0";
+export interface CreateTokenCommandInput extends CreateTokenRequest {
+}
+export interface CreateTokenCommandOutput extends CreateTokenResponse, __MetadataBearer {
+}
+
+export declare class CreateTokenCommand extends $Command<CreateTokenCommandInput, CreateTokenCommandOutput, LicenseManagerClientResolvedConfig> {
+    readonly input: CreateTokenCommandInput;
+    constructor(input: CreateTokenCommandInput);
+    
+    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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LicenseManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LicenseManagerClient";
+import { DeleteGrantRequest, DeleteGrantResponse } from "../models/models_0";
+export interface DeleteGrantCommandInput extends DeleteGrantRequest {
+}
+export interface DeleteGrantCommandOutput extends DeleteGrantResponse, __MetadataBearer {
+}
+
+export declare class DeleteGrantCommand extends $Command<DeleteGrantCommandInput, DeleteGrantCommandOutput, LicenseManagerClientResolvedConfig> {
+    readonly input: DeleteGrantCommandInput;
+    constructor(input: DeleteGrantCommandInput);
+    
+    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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LicenseManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LicenseManagerClient";
+import { DeleteLicenseRequest, DeleteLicenseResponse } from "../models/models_0";
+export interface DeleteLicenseCommandInput extends DeleteLicenseRequest {
+}
+export interface DeleteLicenseCommandOutput extends DeleteLicenseResponse, __MetadataBearer {
+}
+
+export declare class DeleteLicenseCommand extends $Command<DeleteLicenseCommandInput, DeleteLicenseCommandOutput, LicenseManagerClientResolvedConfig> {
+    readonly input: DeleteLicenseCommandInput;
+    constructor(input: DeleteLicenseCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LicenseManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteLicenseCommandInput, DeleteLicenseCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/{dist/types → dist-types}/ts3.4/commands/DeleteLicenseConfigurationCommand.d.ts

@@ -1,35 +1,16 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
 import { LicenseManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LicenseManagerClient";
 import { DeleteLicenseConfigurationRequest, DeleteLicenseConfigurationResponse } 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 DeleteLicenseConfigurationCommandInput extends DeleteLicenseConfigurationRequest {
 }
 export interface DeleteLicenseConfigurationCommandOutput extends DeleteLicenseConfigurationResponse, __MetadataBearer {
 }
-/**
- * <p>Deletes the specified license configuration.</p>
- *          <p>You cannot delete a license configuration that is in use.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LicenseManagerClient, DeleteLicenseConfigurationCommand } from "@aws-sdk/client-license-manager"; // ES Modules import
- * // const { LicenseManagerClient, DeleteLicenseConfigurationCommand } = require("@aws-sdk/client-license-manager"); // CommonJS import
- * const client = new LicenseManagerClient(config);
- * const command = new DeleteLicenseConfigurationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteLicenseConfigurationCommandInput} for command's `input` shape.
- * @see {@link DeleteLicenseConfigurationCommandOutput} for command's `response` shape.
- * @see {@link LicenseManagerClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteLicenseConfigurationCommand extends $Command<DeleteLicenseConfigurationCommandInput, DeleteLicenseConfigurationCommandOutput, LicenseManagerClientResolvedConfig> {
     readonly input: DeleteLicenseConfigurationCommandInput;
     constructor(input: DeleteLicenseConfigurationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LicenseManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteLicenseConfigurationCommandInput, DeleteLicenseConfigurationCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LicenseManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LicenseManagerClient";
+import { DeleteLicenseManagerReportGeneratorRequest, DeleteLicenseManagerReportGeneratorResponse } from "../models/models_0";
+export interface DeleteLicenseManagerReportGeneratorCommandInput extends DeleteLicenseManagerReportGeneratorRequest {
+}
+export interface DeleteLicenseManagerReportGeneratorCommandOutput extends DeleteLicenseManagerReportGeneratorResponse, __MetadataBearer {
+}
+
+export declare class DeleteLicenseManagerReportGeneratorCommand extends $Command<DeleteLicenseManagerReportGeneratorCommandInput, DeleteLicenseManagerReportGeneratorCommandOutput, LicenseManagerClientResolvedConfig> {
+    readonly input: DeleteLicenseManagerReportGeneratorCommandInput;
+    constructor(input: DeleteLicenseManagerReportGeneratorCommandInput);
+    
+    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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LicenseManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LicenseManagerClient";
+import { DeleteTokenRequest, DeleteTokenResponse } from "../models/models_0";
+export interface DeleteTokenCommandInput extends DeleteTokenRequest {
+}
+export interface DeleteTokenCommandOutput extends DeleteTokenResponse, __MetadataBearer {
+}
+
+export declare class DeleteTokenCommand extends $Command<DeleteTokenCommandInput, DeleteTokenCommandOutput, LicenseManagerClientResolvedConfig> {
+    readonly input: DeleteTokenCommandInput;
+    constructor(input: DeleteTokenCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LicenseManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteTokenCommandInput, DeleteTokenCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/{dist/types → dist-types}/ts3.4/commands/ExtendLicenseConsumptionCommand.d.ts

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

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LicenseManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LicenseManagerClient";
+import { GetAccessTokenRequest, GetAccessTokenResponse } from "../models/models_0";
+export interface GetAccessTokenCommandInput extends GetAccessTokenRequest {
+}
+export interface GetAccessTokenCommandOutput extends GetAccessTokenResponse, __MetadataBearer {
+}
+
+export declare class GetAccessTokenCommand extends $Command<GetAccessTokenCommandInput, GetAccessTokenCommandOutput, LicenseManagerClientResolvedConfig> {
+    readonly input: GetAccessTokenCommandInput;
+    constructor(input: GetAccessTokenCommandInput);
+    
+    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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LicenseManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LicenseManagerClient";
+import { GetGrantRequest, GetGrantResponse } from "../models/models_0";
+export interface GetGrantCommandInput extends GetGrantRequest {
+}
+export interface GetGrantCommandOutput extends GetGrantResponse, __MetadataBearer {
+}
+
+export declare class GetGrantCommand extends $Command<GetGrantCommandInput, GetGrantCommandOutput, LicenseManagerClientResolvedConfig> {
+    readonly input: GetGrantCommandInput;
+    constructor(input: GetGrantCommandInput);
+    
+    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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LicenseManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LicenseManagerClient";
+import { GetLicenseRequest, GetLicenseResponse } from "../models/models_0";
+export interface GetLicenseCommandInput extends GetLicenseRequest {
+}
+export interface GetLicenseCommandOutput extends GetLicenseResponse, __MetadataBearer {
+}
+
+export declare class GetLicenseCommand extends $Command<GetLicenseCommandInput, GetLicenseCommandOutput, LicenseManagerClientResolvedConfig> {
+    readonly input: GetLicenseCommandInput;
+    constructor(input: GetLicenseCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LicenseManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetLicenseCommandInput, GetLicenseCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/{dist/types → dist-types}/ts3.4/commands/GetLicenseConfigurationCommand.d.ts

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

package/dist-types/ts3.4/commands/GetLicenseConversionTaskCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LicenseManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LicenseManagerClient";
+import { GetLicenseConversionTaskRequest, GetLicenseConversionTaskResponse } from "../models/models_0";
+export interface GetLicenseConversionTaskCommandInput extends GetLicenseConversionTaskRequest {
+}
+export interface GetLicenseConversionTaskCommandOutput extends GetLicenseConversionTaskResponse, __MetadataBearer {
+}
+
+export declare class GetLicenseConversionTaskCommand extends $Command<GetLicenseConversionTaskCommandInput, GetLicenseConversionTaskCommandOutput, LicenseManagerClientResolvedConfig> {
+    readonly input: GetLicenseConversionTaskCommandInput;
+    constructor(input: GetLicenseConversionTaskCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LicenseManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetLicenseConversionTaskCommandInput, GetLicenseConversionTaskCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/{dist/types → dist-types}/ts3.4/commands/GetLicenseManagerReportGeneratorCommand.d.ts

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

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LicenseManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LicenseManagerClient";
+import { GetLicenseUsageRequest, GetLicenseUsageResponse } from "../models/models_0";
+export interface GetLicenseUsageCommandInput extends GetLicenseUsageRequest {
+}
+export interface GetLicenseUsageCommandOutput extends GetLicenseUsageResponse, __MetadataBearer {
+}
+
+export declare class GetLicenseUsageCommand extends $Command<GetLicenseUsageCommandInput, GetLicenseUsageCommandOutput, LicenseManagerClientResolvedConfig> {
+    readonly input: GetLicenseUsageCommandInput;
+    constructor(input: GetLicenseUsageCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LicenseManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetLicenseUsageCommandInput, GetLicenseUsageCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/{dist/types → dist-types}/ts3.4/commands/GetServiceSettingsCommand.d.ts

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

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LicenseManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LicenseManagerClient";
+import { ListAssociationsForLicenseConfigurationRequest, ListAssociationsForLicenseConfigurationResponse } from "../models/models_0";
+export interface ListAssociationsForLicenseConfigurationCommandInput extends ListAssociationsForLicenseConfigurationRequest {
+}
+export interface ListAssociationsForLicenseConfigurationCommandOutput extends ListAssociationsForLicenseConfigurationResponse, __MetadataBearer {
+}
+
+export declare class ListAssociationsForLicenseConfigurationCommand extends $Command<ListAssociationsForLicenseConfigurationCommandInput, ListAssociationsForLicenseConfigurationCommandOutput, LicenseManagerClientResolvedConfig> {
+    readonly input: ListAssociationsForLicenseConfigurationCommandInput;
+    constructor(input: ListAssociationsForLicenseConfigurationCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LicenseManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListAssociationsForLicenseConfigurationCommandInput, ListAssociationsForLicenseConfigurationCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/{dist/types → dist-types}/ts3.4/commands/ListDistributedGrantsCommand.d.ts

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

package/{dist/types → dist-types}/ts3.4/commands/ListFailuresForLicenseConfigurationOperationsCommand.d.ts

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

package/{dist/types → dist-types}/ts3.4/commands/ListLicenseConfigurationsCommand.d.ts

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

package/dist-types/ts3.4/commands/ListLicenseConversionTasksCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LicenseManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LicenseManagerClient";
+import { ListLicenseConversionTasksRequest, ListLicenseConversionTasksResponse } from "../models/models_0";
+export interface ListLicenseConversionTasksCommandInput extends ListLicenseConversionTasksRequest {
+}
+export interface ListLicenseConversionTasksCommandOutput extends ListLicenseConversionTasksResponse, __MetadataBearer {
+}
+
+export declare class ListLicenseConversionTasksCommand extends $Command<ListLicenseConversionTasksCommandInput, ListLicenseConversionTasksCommandOutput, LicenseManagerClientResolvedConfig> {
+    readonly input: ListLicenseConversionTasksCommandInput;
+    constructor(input: ListLicenseConversionTasksCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LicenseManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListLicenseConversionTasksCommandInput, ListLicenseConversionTasksCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/{dist/types → dist-types}/ts3.4/commands/ListLicenseManagerReportGeneratorsCommand.d.ts

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