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

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

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

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

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

@@ -6,31 +6,11 @@ export interface ListUsageForLicenseConfigurationCommandInput extends ListUsageF
 }
 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

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

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

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

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

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

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

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

@@ -6,30 +6,11 @@ export interface UpdateLicenseManagerReportGeneratorCommandInput extends UpdateL
 }
 export interface UpdateLicenseManagerReportGeneratorCommandOutput extends UpdateLicenseManagerReportGeneratorResponse, __MetadataBearer {
 }
-/**
- * <p>Updates a report generator.</p>
- *          <p>After you make changes to a report generator, it starts generating new reports within 60 minutes of being updated.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LicenseManagerClient, UpdateLicenseManagerReportGeneratorCommand } from "@aws-sdk/client-license-manager"; // ES Modules import
- * // const { LicenseManagerClient, UpdateLicenseManagerReportGeneratorCommand } = require("@aws-sdk/client-license-manager"); // CommonJS import
- * const client = new LicenseManagerClient(config);
- * const command = new UpdateLicenseManagerReportGeneratorCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateLicenseManagerReportGeneratorCommandInput} for command's `input` shape.
- * @see {@link UpdateLicenseManagerReportGeneratorCommandOutput} for command's `response` shape.
- * @see {@link LicenseManagerClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateLicenseManagerReportGeneratorCommand extends $Command<UpdateLicenseManagerReportGeneratorCommandInput, UpdateLicenseManagerReportGeneratorCommandOutput, LicenseManagerClientResolvedConfig> {
     readonly input: UpdateLicenseManagerReportGeneratorCommandInput;
     constructor(input: UpdateLicenseManagerReportGeneratorCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LicenseManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateLicenseManagerReportGeneratorCommandInput, UpdateLicenseManagerReportGeneratorCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface UpdateLicenseSpecificationsForResourceCommandInput extends Upda
 }
 export interface UpdateLicenseSpecificationsForResourceCommandOutput extends UpdateLicenseSpecificationsForResourceResponse, __MetadataBearer {
 }
-/**
- * <p>Adds or removes the specified license configurations for the specified Amazon Web Services resource.</p>
- *          <p>You can update the license specifications of AMIs, instances, and hosts.
- *          You cannot update the license specifications for launch templates and CloudFormation templates,
- *          as they send license configurations to the operation that creates the resource.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LicenseManagerClient, UpdateLicenseSpecificationsForResourceCommand } from "@aws-sdk/client-license-manager"; // ES Modules import
- * // const { LicenseManagerClient, UpdateLicenseSpecificationsForResourceCommand } = require("@aws-sdk/client-license-manager"); // CommonJS import
- * const client = new LicenseManagerClient(config);
- * const command = new UpdateLicenseSpecificationsForResourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateLicenseSpecificationsForResourceCommandInput} for command's `input` shape.
- * @see {@link UpdateLicenseSpecificationsForResourceCommandOutput} for command's `response` shape.
- * @see {@link LicenseManagerClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateLicenseSpecificationsForResourceCommand extends $Command<UpdateLicenseSpecificationsForResourceCommandInput, UpdateLicenseSpecificationsForResourceCommandOutput, LicenseManagerClientResolvedConfig> {
     readonly input: UpdateLicenseSpecificationsForResourceCommandInput;
     constructor(input: UpdateLicenseSpecificationsForResourceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LicenseManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateLicenseSpecificationsForResourceCommandInput, UpdateLicenseSpecificationsForResourceCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface UpdateServiceSettingsCommandInput extends UpdateServiceSettings
 }
 export interface UpdateServiceSettingsCommandOutput extends UpdateServiceSettingsResponse, __MetadataBearer {
 }
-/**
- * <p>Updates 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, UpdateServiceSettingsCommand } from "@aws-sdk/client-license-manager"; // ES Modules import
- * // const { LicenseManagerClient, UpdateServiceSettingsCommand } = require("@aws-sdk/client-license-manager"); // CommonJS import
- * const client = new LicenseManagerClient(config);
- * const command = new UpdateServiceSettingsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateServiceSettingsCommandInput} for command's `input` shape.
- * @see {@link UpdateServiceSettingsCommandOutput} for command's `response` shape.
- * @see {@link LicenseManagerClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateServiceSettingsCommand extends $Command<UpdateServiceSettingsCommandInput, UpdateServiceSettingsCommandOutput, LicenseManagerClientResolvedConfig> {
     readonly input: UpdateServiceSettingsCommandInput;
     constructor(input: UpdateServiceSettingsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LicenseManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateServiceSettingsCommandInput, UpdateServiceSettingsCommandOutput>;
     private serialize;
     private deserialize;