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

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

@@ -6,29 +6,11 @@ export interface AcceptGrantCommandInput extends AcceptGrantRequest {
 }
 export interface AcceptGrantCommandOutput extends AcceptGrantResponse, __MetadataBearer {
 }
-/**
- * <p>Accepts the specified grant.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LicenseManagerClient, AcceptGrantCommand } from "@aws-sdk/client-license-manager"; // ES Modules import
- * // const { LicenseManagerClient, AcceptGrantCommand } = require("@aws-sdk/client-license-manager"); // CommonJS import
- * const client = new LicenseManagerClient(config);
- * const command = new AcceptGrantCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link AcceptGrantCommandInput} for command's `input` shape.
- * @see {@link AcceptGrantCommandOutput} for command's `response` shape.
- * @see {@link LicenseManagerClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class AcceptGrantCommand extends $Command<AcceptGrantCommandInput, AcceptGrantCommandOutput, LicenseManagerClientResolvedConfig> {
     readonly input: AcceptGrantCommandInput;
     constructor(input: AcceptGrantCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LicenseManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AcceptGrantCommandInput, AcceptGrantCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface CheckInLicenseCommandInput extends CheckInLicenseRequest {
 }
 export interface CheckInLicenseCommandOutput extends CheckInLicenseResponse, __MetadataBearer {
 }
-/**
- * <p>Checks in the specified license. Check in a license when it is no longer in use.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LicenseManagerClient, CheckInLicenseCommand } from "@aws-sdk/client-license-manager"; // ES Modules import
- * // const { LicenseManagerClient, CheckInLicenseCommand } = require("@aws-sdk/client-license-manager"); // CommonJS import
- * const client = new LicenseManagerClient(config);
- * const command = new CheckInLicenseCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CheckInLicenseCommandInput} for command's `input` shape.
- * @see {@link CheckInLicenseCommandOutput} for command's `response` shape.
- * @see {@link LicenseManagerClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CheckInLicenseCommand extends $Command<CheckInLicenseCommandInput, CheckInLicenseCommandOutput, LicenseManagerClientResolvedConfig> {
     readonly input: CheckInLicenseCommandInput;
     constructor(input: CheckInLicenseCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LicenseManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CheckInLicenseCommandInput, CheckInLicenseCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface CheckoutBorrowLicenseCommandInput extends CheckoutBorrowLicense
 }
 export interface CheckoutBorrowLicenseCommandOutput extends CheckoutBorrowLicenseResponse, __MetadataBearer {
 }
-/**
- * <p>Checks out the specified license for offline use.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LicenseManagerClient, CheckoutBorrowLicenseCommand } from "@aws-sdk/client-license-manager"; // ES Modules import
- * // const { LicenseManagerClient, CheckoutBorrowLicenseCommand } = require("@aws-sdk/client-license-manager"); // CommonJS import
- * const client = new LicenseManagerClient(config);
- * const command = new CheckoutBorrowLicenseCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CheckoutBorrowLicenseCommandInput} for command's `input` shape.
- * @see {@link CheckoutBorrowLicenseCommandOutput} for command's `response` shape.
- * @see {@link LicenseManagerClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CheckoutBorrowLicenseCommand extends $Command<CheckoutBorrowLicenseCommandInput, CheckoutBorrowLicenseCommandOutput, LicenseManagerClientResolvedConfig> {
     readonly input: CheckoutBorrowLicenseCommandInput;
     constructor(input: CheckoutBorrowLicenseCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LicenseManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CheckoutBorrowLicenseCommandInput, CheckoutBorrowLicenseCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface CheckoutLicenseCommandInput extends CheckoutLicenseRequest {
 }
 export interface CheckoutLicenseCommandOutput extends CheckoutLicenseResponse, __MetadataBearer {
 }
-/**
- * <p>Checks out the specified license.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LicenseManagerClient, CheckoutLicenseCommand } from "@aws-sdk/client-license-manager"; // ES Modules import
- * // const { LicenseManagerClient, CheckoutLicenseCommand } = require("@aws-sdk/client-license-manager"); // CommonJS import
- * const client = new LicenseManagerClient(config);
- * const command = new CheckoutLicenseCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CheckoutLicenseCommandInput} for command's `input` shape.
- * @see {@link CheckoutLicenseCommandOutput} for command's `response` shape.
- * @see {@link LicenseManagerClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CheckoutLicenseCommand extends $Command<CheckoutLicenseCommandInput, CheckoutLicenseCommandOutput, LicenseManagerClientResolvedConfig> {
     readonly input: CheckoutLicenseCommandInput;
     constructor(input: CheckoutLicenseCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LicenseManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CheckoutLicenseCommandInput, CheckoutLicenseCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ 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 Amazon Web Services 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/CreateGrantVersionCommand.d.ts

@@ -6,29 +6,11 @@ export interface CreateGrantVersionCommandInput extends CreateGrantVersionReques
 }
 export interface CreateGrantVersionCommandOutput extends CreateGrantVersionResponse, __MetadataBearer {
 }
-/**
- * <p>Creates a new version of the specified grant.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LicenseManagerClient, CreateGrantVersionCommand } from "@aws-sdk/client-license-manager"; // ES Modules import
- * // const { LicenseManagerClient, CreateGrantVersionCommand } = require("@aws-sdk/client-license-manager"); // CommonJS import
- * const client = new LicenseManagerClient(config);
- * const command = new CreateGrantVersionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateGrantVersionCommandInput} for command's `input` shape.
- * @see {@link CreateGrantVersionCommandOutput} for command's `response` shape.
- * @see {@link LicenseManagerClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateGrantVersionCommand extends $Command<CreateGrantVersionCommandInput, CreateGrantVersionCommandOutput, LicenseManagerClientResolvedConfig> {
     readonly input: CreateGrantVersionCommandInput;
     constructor(input: CreateGrantVersionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LicenseManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateGrantVersionCommandInput, CreateGrantVersionCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface CreateLicenseCommandInput extends CreateLicenseRequest {
 }
 export interface CreateLicenseCommandOutput extends CreateLicenseResponse, __MetadataBearer {
 }
-/**
- * <p>Creates a license.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LicenseManagerClient, CreateLicenseCommand } from "@aws-sdk/client-license-manager"; // ES Modules import
- * // const { LicenseManagerClient, CreateLicenseCommand } = require("@aws-sdk/client-license-manager"); // CommonJS import
- * const client = new LicenseManagerClient(config);
- * const command = new CreateLicenseCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateLicenseCommandInput} for command's `input` shape.
- * @see {@link CreateLicenseCommandOutput} for command's `response` shape.
- * @see {@link LicenseManagerClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateLicenseCommand extends $Command<CreateLicenseCommandInput, CreateLicenseCommandOutput, LicenseManagerClientResolvedConfig> {
     readonly input: CreateLicenseCommandInput;
     constructor(input: CreateLicenseCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LicenseManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateLicenseCommandInput, CreateLicenseCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,34 +6,11 @@ export interface CreateLicenseConfigurationCommandInput extends CreateLicenseCon
 }
 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/CreateLicenseConversionTaskForResourceCommand.d.ts

@@ -6,29 +6,11 @@ export interface CreateLicenseConversionTaskForResourceCommandInput extends Crea
 }
 export interface CreateLicenseConversionTaskForResourceCommandOutput extends CreateLicenseConversionTaskForResourceResponse, __MetadataBearer {
 }
-/**
- * <p>Creates a new license conversion task.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LicenseManagerClient, CreateLicenseConversionTaskForResourceCommand } from "@aws-sdk/client-license-manager"; // ES Modules import
- * // const { LicenseManagerClient, CreateLicenseConversionTaskForResourceCommand } = require("@aws-sdk/client-license-manager"); // CommonJS import
- * const client = new LicenseManagerClient(config);
- * const command = new CreateLicenseConversionTaskForResourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateLicenseConversionTaskForResourceCommandInput} for command's `input` shape.
- * @see {@link CreateLicenseConversionTaskForResourceCommandOutput} for command's `response` shape.
- * @see {@link LicenseManagerClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateLicenseConversionTaskForResourceCommand extends $Command<CreateLicenseConversionTaskForResourceCommandInput, CreateLicenseConversionTaskForResourceCommandOutput, LicenseManagerClientResolvedConfig> {
     readonly input: CreateLicenseConversionTaskForResourceCommandInput;
     constructor(input: CreateLicenseConversionTaskForResourceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LicenseManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateLicenseConversionTaskForResourceCommandInput, CreateLicenseConversionTaskForResourceCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface CreateLicenseManagerReportGeneratorCommandInput extends CreateL
 }
 export interface CreateLicenseManagerReportGeneratorCommandOutput extends CreateLicenseManagerReportGeneratorResponse, __MetadataBearer {
 }
-/**
- * <p>Creates a report generator.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LicenseManagerClient, CreateLicenseManagerReportGeneratorCommand } from "@aws-sdk/client-license-manager"; // ES Modules import
- * // const { LicenseManagerClient, CreateLicenseManagerReportGeneratorCommand } = require("@aws-sdk/client-license-manager"); // CommonJS import
- * const client = new LicenseManagerClient(config);
- * const command = new CreateLicenseManagerReportGeneratorCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateLicenseManagerReportGeneratorCommandInput} for command's `input` shape.
- * @see {@link CreateLicenseManagerReportGeneratorCommandOutput} for command's `response` shape.
- * @see {@link LicenseManagerClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateLicenseManagerReportGeneratorCommand extends $Command<CreateLicenseManagerReportGeneratorCommandInput, CreateLicenseManagerReportGeneratorCommandOutput, LicenseManagerClientResolvedConfig> {
     readonly input: CreateLicenseManagerReportGeneratorCommandInput;
     constructor(input: CreateLicenseManagerReportGeneratorCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LicenseManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateLicenseManagerReportGeneratorCommandInput, CreateLicenseManagerReportGeneratorCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface CreateLicenseVersionCommandInput extends CreateLicenseVersionRe
 }
 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

@@ -6,32 +6,11 @@ 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

@@ -6,29 +6,11 @@ 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

@@ -6,29 +6,11 @@ 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/DeleteLicenseConfigurationCommand.d.ts

@@ -6,30 +6,11 @@ export interface DeleteLicenseConfigurationCommandInput extends DeleteLicenseCon
 }
 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

@@ -6,31 +6,11 @@ export interface DeleteLicenseManagerReportGeneratorCommandInput extends DeleteL
 }
 export interface DeleteLicenseManagerReportGeneratorCommandOutput extends DeleteLicenseManagerReportGeneratorResponse, __MetadataBearer {
 }
-/**
- * <p>Deletes the specified report generator.</p>
- *          <p>This action deletes the report generator, which stops it from generating future reports.
- *          The action cannot be reversed. It has no effect on the previous reports from this generator.</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

@@ -6,29 +6,11 @@ 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/ExtendLicenseConsumptionCommand.d.ts

@@ -6,29 +6,11 @@ export interface ExtendLicenseConsumptionCommandInput extends ExtendLicenseConsu
 }
 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

@@ -6,30 +6,11 @@ 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;