@aws-sdk/client-license-manager 3.296.0 → 3.297.0

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LicenseManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LicenseManagerClient";
 import { DeleteLicenseManagerReportGeneratorRequest, DeleteLicenseManagerReportGeneratorResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link DeleteLicenseManagerReportGeneratorCommand}.
  */
 export interface DeleteLicenseManagerReportGeneratorCommandInput extends DeleteLicenseManagerReportGeneratorRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DeleteLicenseManagerReportGeneratorCommand}.
  */
 export interface DeleteLicenseManagerReportGeneratorCommandOutput extends DeleteLicenseManagerReportGeneratorResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <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>
@@ -27,6 +32,8 @@ export interface DeleteLicenseManagerReportGeneratorCommandOutput extends Delete
  * const response = await client.send(command);
  * ```
  *
+ * @param DeleteLicenseManagerReportGeneratorCommandInput - {@link DeleteLicenseManagerReportGeneratorCommandInput}
+ * @returns {@link DeleteLicenseManagerReportGeneratorCommandOutput}
  * @see {@link DeleteLicenseManagerReportGeneratorCommandInput} for command's `input` shape.
  * @see {@link DeleteLicenseManagerReportGeneratorCommandOutput} for command's `response` shape.
  * @see {@link LicenseManagerClientResolvedConfig | config} for LicenseManagerClient's `config` shape.
@@ -61,11 +68,20 @@ export interface DeleteLicenseManagerReportGeneratorCommandOutput extends Delete
 export declare class DeleteLicenseManagerReportGeneratorCommand extends $Command<DeleteLicenseManagerReportGeneratorCommandInput, DeleteLicenseManagerReportGeneratorCommandOutput, LicenseManagerClientResolvedConfig> {
     readonly input: DeleteLicenseManagerReportGeneratorCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeleteLicenseManagerReportGeneratorCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LicenseManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteLicenseManagerReportGeneratorCommandInput, DeleteLicenseManagerReportGeneratorCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/DeleteTokenCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LicenseManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LicenseManagerClient";
 import { DeleteTokenRequest, DeleteTokenResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link DeleteTokenCommand}.
  */
 export interface DeleteTokenCommandInput extends DeleteTokenRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DeleteTokenCommand}.
  */
 export interface DeleteTokenCommandOutput extends DeleteTokenResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <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.
@@ -25,6 +30,8 @@ export interface DeleteTokenCommandOutput extends DeleteTokenResponse, __Metadat
  * const response = await client.send(command);
  * ```
  *
+ * @param DeleteTokenCommandInput - {@link DeleteTokenCommandInput}
+ * @returns {@link DeleteTokenCommandOutput}
  * @see {@link DeleteTokenCommandInput} for command's `input` shape.
  * @see {@link DeleteTokenCommandOutput} for command's `response` shape.
  * @see {@link LicenseManagerClientResolvedConfig | config} for LicenseManagerClient's `config` shape.
@@ -56,11 +63,20 @@ export interface DeleteTokenCommandOutput extends DeleteTokenResponse, __Metadat
 export declare class DeleteTokenCommand extends $Command<DeleteTokenCommandInput, DeleteTokenCommandOutput, LicenseManagerClientResolvedConfig> {
     readonly input: DeleteTokenCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeleteTokenCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LicenseManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteTokenCommandInput, DeleteTokenCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/ExtendLicenseConsumptionCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LicenseManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LicenseManagerClient";
 import { ExtendLicenseConsumptionRequest, ExtendLicenseConsumptionResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link ExtendLicenseConsumptionCommand}.
  */
 export interface ExtendLicenseConsumptionCommandInput extends ExtendLicenseConsumptionRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link ExtendLicenseConsumptionCommand}.
  */
 export interface ExtendLicenseConsumptionCommandOutput extends ExtendLicenseConsumptionResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <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.
@@ -25,6 +30,8 @@ export interface ExtendLicenseConsumptionCommandOutput extends ExtendLicenseCons
  * const response = await client.send(command);
  * ```
  *
+ * @param ExtendLicenseConsumptionCommandInput - {@link ExtendLicenseConsumptionCommandInput}
+ * @returns {@link ExtendLicenseConsumptionCommandOutput}
  * @see {@link ExtendLicenseConsumptionCommandInput} for command's `input` shape.
  * @see {@link ExtendLicenseConsumptionCommandOutput} for command's `response` shape.
  * @see {@link LicenseManagerClientResolvedConfig | config} for LicenseManagerClient's `config` shape.
@@ -56,11 +63,20 @@ export interface ExtendLicenseConsumptionCommandOutput extends ExtendLicenseCons
 export declare class ExtendLicenseConsumptionCommand extends $Command<ExtendLicenseConsumptionCommandInput, ExtendLicenseConsumptionCommandOutput, LicenseManagerClientResolvedConfig> {
     readonly input: ExtendLicenseConsumptionCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: ExtendLicenseConsumptionCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LicenseManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ExtendLicenseConsumptionCommandInput, ExtendLicenseConsumptionCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LicenseManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LicenseManagerClient";
 import { GetAccessTokenRequest, GetAccessTokenResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link GetAccessTokenCommand}.
  */
 export interface GetAccessTokenCommandInput extends GetAccessTokenRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link GetAccessTokenCommand}.
  */
 export interface GetAccessTokenCommandOutput extends GetAccessTokenResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Gets a temporary access token to use with AssumeRoleWithWebIdentity. Access tokens
  *           are valid for one hour.</p>
  * @example
@@ -26,6 +31,8 @@ export interface GetAccessTokenCommandOutput extends GetAccessTokenResponse, __M
  * const response = await client.send(command);
  * ```
  *
+ * @param GetAccessTokenCommandInput - {@link GetAccessTokenCommandInput}
+ * @returns {@link GetAccessTokenCommandOutput}
  * @see {@link GetAccessTokenCommandInput} for command's `input` shape.
  * @see {@link GetAccessTokenCommandOutput} for command's `response` shape.
  * @see {@link LicenseManagerClientResolvedConfig | config} for LicenseManagerClient's `config` shape.
@@ -51,11 +58,20 @@ export interface GetAccessTokenCommandOutput extends GetAccessTokenResponse, __M
 export declare class GetAccessTokenCommand extends $Command<GetAccessTokenCommandInput, GetAccessTokenCommandOutput, LicenseManagerClientResolvedConfig> {
     readonly input: GetAccessTokenCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: GetAccessTokenCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LicenseManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetAccessTokenCommandInput, GetAccessTokenCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/GetGrantCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LicenseManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LicenseManagerClient";
 import { GetGrantRequest, GetGrantResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link GetGrantCommand}.
  */
 export interface GetGrantCommandInput extends GetGrantRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link GetGrantCommand}.
  */
 export interface GetGrantCommandOutput extends GetGrantResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Gets detailed information about the specified grant.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface GetGrantCommandOutput extends GetGrantResponse, __MetadataBeare
  * const response = await client.send(command);
  * ```
  *
+ * @param GetGrantCommandInput - {@link GetGrantCommandInput}
+ * @returns {@link GetGrantCommandOutput}
  * @see {@link GetGrantCommandInput} for command's `input` shape.
  * @see {@link GetGrantCommandOutput} for command's `response` shape.
  * @see {@link LicenseManagerClientResolvedConfig | config} for LicenseManagerClient's `config` shape.
@@ -56,11 +63,20 @@ export interface GetGrantCommandOutput extends GetGrantResponse, __MetadataBeare
 export declare class GetGrantCommand extends $Command<GetGrantCommandInput, GetGrantCommandOutput, LicenseManagerClientResolvedConfig> {
     readonly input: GetGrantCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: GetGrantCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LicenseManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetGrantCommandInput, GetGrantCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/GetLicenseCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LicenseManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LicenseManagerClient";
 import { GetLicenseRequest, GetLicenseResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link GetLicenseCommand}.
  */
 export interface GetLicenseCommandInput extends GetLicenseRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link GetLicenseCommand}.
  */
 export interface GetLicenseCommandOutput extends GetLicenseResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Gets detailed information about the specified license.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface GetLicenseCommandOutput extends GetLicenseResponse, __MetadataB
  * const response = await client.send(command);
  * ```
  *
+ * @param GetLicenseCommandInput - {@link GetLicenseCommandInput}
+ * @returns {@link GetLicenseCommandOutput}
  * @see {@link GetLicenseCommandInput} for command's `input` shape.
  * @see {@link GetLicenseCommandOutput} for command's `response` shape.
  * @see {@link LicenseManagerClientResolvedConfig | config} for LicenseManagerClient's `config` shape.
@@ -53,11 +60,20 @@ export interface GetLicenseCommandOutput extends GetLicenseResponse, __MetadataB
 export declare class GetLicenseCommand extends $Command<GetLicenseCommandInput, GetLicenseCommandOutput, LicenseManagerClientResolvedConfig> {
     readonly input: GetLicenseCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: GetLicenseCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LicenseManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetLicenseCommandInput, GetLicenseCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/GetLicenseConfigurationCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LicenseManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LicenseManagerClient";
 import { GetLicenseConfigurationRequest, GetLicenseConfigurationResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link GetLicenseConfigurationCommand}.
  */
 export interface GetLicenseConfigurationCommandInput extends GetLicenseConfigurationRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link GetLicenseConfigurationCommand}.
  */
 export interface GetLicenseConfigurationCommandOutput extends GetLicenseConfigurationResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <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.
@@ -25,6 +30,8 @@ export interface GetLicenseConfigurationCommandOutput extends GetLicenseConfigur
  * const response = await client.send(command);
  * ```
  *
+ * @param GetLicenseConfigurationCommandInput - {@link GetLicenseConfigurationCommandInput}
+ * @returns {@link GetLicenseConfigurationCommandOutput}
  * @see {@link GetLicenseConfigurationCommandInput} for command's `input` shape.
  * @see {@link GetLicenseConfigurationCommandOutput} for command's `response` shape.
  * @see {@link LicenseManagerClientResolvedConfig | config} for LicenseManagerClient's `config` shape.
@@ -50,11 +57,20 @@ export interface GetLicenseConfigurationCommandOutput extends GetLicenseConfigur
 export declare class GetLicenseConfigurationCommand extends $Command<GetLicenseConfigurationCommandInput, GetLicenseConfigurationCommandOutput, LicenseManagerClientResolvedConfig> {
     readonly input: GetLicenseConfigurationCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: GetLicenseConfigurationCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LicenseManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetLicenseConfigurationCommandInput, GetLicenseConfigurationCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LicenseManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LicenseManagerClient";
 import { GetLicenseConversionTaskRequest, GetLicenseConversionTaskResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link GetLicenseConversionTaskCommand}.
  */
 export interface GetLicenseConversionTaskCommandInput extends GetLicenseConversionTaskRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link GetLicenseConversionTaskCommand}.
  */
 export interface GetLicenseConversionTaskCommandOutput extends GetLicenseConversionTaskResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Gets information about the specified license type conversion task.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface GetLicenseConversionTaskCommandOutput extends GetLicenseConvers
  * const response = await client.send(command);
  * ```
  *
+ * @param GetLicenseConversionTaskCommandInput - {@link GetLicenseConversionTaskCommandInput}
+ * @returns {@link GetLicenseConversionTaskCommandOutput}
  * @see {@link GetLicenseConversionTaskCommandInput} for command's `input` shape.
  * @see {@link GetLicenseConversionTaskCommandOutput} for command's `response` shape.
  * @see {@link LicenseManagerClientResolvedConfig | config} for LicenseManagerClient's `config` shape.
@@ -50,11 +57,20 @@ export interface GetLicenseConversionTaskCommandOutput extends GetLicenseConvers
 export declare class GetLicenseConversionTaskCommand extends $Command<GetLicenseConversionTaskCommandInput, GetLicenseConversionTaskCommandOutput, LicenseManagerClientResolvedConfig> {
     readonly input: GetLicenseConversionTaskCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: GetLicenseConversionTaskCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LicenseManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetLicenseConversionTaskCommandInput, GetLicenseConversionTaskCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/GetLicenseManagerReportGeneratorCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LicenseManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LicenseManagerClient";
 import { GetLicenseManagerReportGeneratorRequest, GetLicenseManagerReportGeneratorResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link GetLicenseManagerReportGeneratorCommand}.
  */
 export interface GetLicenseManagerReportGeneratorCommandInput extends GetLicenseManagerReportGeneratorRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link GetLicenseManagerReportGeneratorCommand}.
  */
 export interface GetLicenseManagerReportGeneratorCommandOutput extends GetLicenseManagerReportGeneratorResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Gets information about the specified report generator.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface GetLicenseManagerReportGeneratorCommandOutput extends GetLicens
  * const response = await client.send(command);
  * ```
  *
+ * @param GetLicenseManagerReportGeneratorCommandInput - {@link GetLicenseManagerReportGeneratorCommandInput}
+ * @returns {@link GetLicenseManagerReportGeneratorCommandOutput}
  * @see {@link GetLicenseManagerReportGeneratorCommandInput} for command's `input` shape.
  * @see {@link GetLicenseManagerReportGeneratorCommandOutput} for command's `response` shape.
  * @see {@link LicenseManagerClientResolvedConfig | config} for LicenseManagerClient's `config` shape.
@@ -59,11 +66,20 @@ export interface GetLicenseManagerReportGeneratorCommandOutput extends GetLicens
 export declare class GetLicenseManagerReportGeneratorCommand extends $Command<GetLicenseManagerReportGeneratorCommandInput, GetLicenseManagerReportGeneratorCommandOutput, LicenseManagerClientResolvedConfig> {
     readonly input: GetLicenseManagerReportGeneratorCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: GetLicenseManagerReportGeneratorCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LicenseManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetLicenseManagerReportGeneratorCommandInput, GetLicenseManagerReportGeneratorCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LicenseManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LicenseManagerClient";
 import { GetLicenseUsageRequest, GetLicenseUsageResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link GetLicenseUsageCommand}.
  */
 export interface GetLicenseUsageCommandInput extends GetLicenseUsageRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link GetLicenseUsageCommand}.
  */
 export interface GetLicenseUsageCommandOutput extends GetLicenseUsageResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Gets detailed information about the usage of the specified license.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface GetLicenseUsageCommandOutput extends GetLicenseUsageResponse, _
  * const response = await client.send(command);
  * ```
  *
+ * @param GetLicenseUsageCommandInput - {@link GetLicenseUsageCommandInput}
+ * @returns {@link GetLicenseUsageCommandOutput}
  * @see {@link GetLicenseUsageCommandInput} for command's `input` shape.
  * @see {@link GetLicenseUsageCommandOutput} for command's `response` shape.
  * @see {@link LicenseManagerClientResolvedConfig | config} for LicenseManagerClient's `config` shape.
@@ -53,11 +60,20 @@ export interface GetLicenseUsageCommandOutput extends GetLicenseUsageResponse, _
 export declare class GetLicenseUsageCommand extends $Command<GetLicenseUsageCommandInput, GetLicenseUsageCommandOutput, LicenseManagerClientResolvedConfig> {
     readonly input: GetLicenseUsageCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: GetLicenseUsageCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LicenseManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetLicenseUsageCommandInput, GetLicenseUsageCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/GetServiceSettingsCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LicenseManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LicenseManagerClient";
 import { GetServiceSettingsRequest, GetServiceSettingsResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link GetServiceSettingsCommand}.
  */
 export interface GetServiceSettingsCommandInput extends GetServiceSettingsRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link GetServiceSettingsCommand}.
  */
 export interface GetServiceSettingsCommandOutput extends GetServiceSettingsResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <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.
@@ -25,6 +30,8 @@ export interface GetServiceSettingsCommandOutput extends GetServiceSettingsRespo
  * const response = await client.send(command);
  * ```
  *
+ * @param GetServiceSettingsCommandInput - {@link GetServiceSettingsCommandInput}
+ * @returns {@link GetServiceSettingsCommandOutput}
  * @see {@link GetServiceSettingsCommandInput} for command's `input` shape.
  * @see {@link GetServiceSettingsCommandOutput} for command's `response` shape.
  * @see {@link LicenseManagerClientResolvedConfig | config} for LicenseManagerClient's `config` shape.
@@ -47,11 +54,20 @@ export interface GetServiceSettingsCommandOutput extends GetServiceSettingsRespo
 export declare class GetServiceSettingsCommand extends $Command<GetServiceSettingsCommandInput, GetServiceSettingsCommandOutput, LicenseManagerClientResolvedConfig> {
     readonly input: GetServiceSettingsCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: GetServiceSettingsCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LicenseManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetServiceSettingsCommandInput, GetServiceSettingsCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LicenseManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LicenseManagerClient";
 import { ListAssociationsForLicenseConfigurationRequest, ListAssociationsForLicenseConfigurationResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link ListAssociationsForLicenseConfigurationCommand}.
  */
 export interface ListAssociationsForLicenseConfigurationCommandInput extends ListAssociationsForLicenseConfigurationRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link ListAssociationsForLicenseConfigurationCommand}.
  */
 export interface ListAssociationsForLicenseConfigurationCommandOutput extends ListAssociationsForLicenseConfigurationResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Lists the resource associations for the specified license configuration.</p>
  *          <p>Resource associations need not consume licenses from a license configuration.
  *          For example, an AMI or a stopped instance might not consume a license (depending on
@@ -28,6 +33,8 @@ export interface ListAssociationsForLicenseConfigurationCommandOutput extends Li
  * const response = await client.send(command);
  * ```
  *
+ * @param ListAssociationsForLicenseConfigurationCommandInput - {@link ListAssociationsForLicenseConfigurationCommandInput}
+ * @returns {@link ListAssociationsForLicenseConfigurationCommandOutput}
  * @see {@link ListAssociationsForLicenseConfigurationCommandInput} for command's `input` shape.
  * @see {@link ListAssociationsForLicenseConfigurationCommandOutput} for command's `response` shape.
  * @see {@link LicenseManagerClientResolvedConfig | config} for LicenseManagerClient's `config` shape.
@@ -56,11 +63,20 @@ export interface ListAssociationsForLicenseConfigurationCommandOutput extends Li
 export declare class ListAssociationsForLicenseConfigurationCommand extends $Command<ListAssociationsForLicenseConfigurationCommandInput, ListAssociationsForLicenseConfigurationCommandOutput, LicenseManagerClientResolvedConfig> {
     readonly input: ListAssociationsForLicenseConfigurationCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: ListAssociationsForLicenseConfigurationCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LicenseManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListAssociationsForLicenseConfigurationCommandInput, ListAssociationsForLicenseConfigurationCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }