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

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LicenseManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LicenseManagerClient";
 import { CheckoutLicenseRequest, CheckoutLicenseResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link CheckoutLicenseCommand}.
  */
 export interface CheckoutLicenseCommandInput extends CheckoutLicenseRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CheckoutLicenseCommand}.
  */
 export interface CheckoutLicenseCommandOutput extends CheckoutLicenseResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Checks out the specified license.</p>
  *          <note>
  *             <p>If the account that created the license is the same that is performing the check out, you must
@@ -29,6 +34,8 @@ export interface CheckoutLicenseCommandOutput extends CheckoutLicenseResponse, _
  * const response = await client.send(command);
  * ```
  *
+ * @param CheckoutLicenseCommandInput - {@link CheckoutLicenseCommandInput}
+ * @returns {@link CheckoutLicenseCommandOutput}
  * @see {@link CheckoutLicenseCommandInput} for command's `input` shape.
  * @see {@link CheckoutLicenseCommandOutput} for command's `response` shape.
  * @see {@link LicenseManagerClientResolvedConfig | config} for LicenseManagerClient's `config` shape.
@@ -69,11 +76,20 @@ export interface CheckoutLicenseCommandOutput extends CheckoutLicenseResponse, _
 export declare class CheckoutLicenseCommand extends $Command<CheckoutLicenseCommandInput, CheckoutLicenseCommandOutput, LicenseManagerClientResolvedConfig> {
     readonly input: CheckoutLicenseCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CheckoutLicenseCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LicenseManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CheckoutLicenseCommandInput, CheckoutLicenseCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

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

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

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

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

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

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

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

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LicenseManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LicenseManagerClient";
 import { CreateLicenseConversionTaskForResourceRequest, CreateLicenseConversionTaskForResourceResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link CreateLicenseConversionTaskForResourceCommand}.
  */
 export interface CreateLicenseConversionTaskForResourceCommandInput extends CreateLicenseConversionTaskForResourceRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateLicenseConversionTaskForResourceCommand}.
  */
 export interface CreateLicenseConversionTaskForResourceCommandOutput extends CreateLicenseConversionTaskForResourceResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a new license 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 CreateLicenseConversionTaskForResourceCommandOutput extends Cre
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateLicenseConversionTaskForResourceCommandInput - {@link CreateLicenseConversionTaskForResourceCommandInput}
+ * @returns {@link CreateLicenseConversionTaskForResourceCommandOutput}
  * @see {@link CreateLicenseConversionTaskForResourceCommandInput} for command's `input` shape.
  * @see {@link CreateLicenseConversionTaskForResourceCommandOutput} for command's `response` shape.
  * @see {@link LicenseManagerClientResolvedConfig | config} for LicenseManagerClient's `config` shape.
@@ -53,11 +60,20 @@ export interface CreateLicenseConversionTaskForResourceCommandOutput extends Cre
 export declare class CreateLicenseConversionTaskForResourceCommand extends $Command<CreateLicenseConversionTaskForResourceCommandInput, CreateLicenseConversionTaskForResourceCommandOutput, LicenseManagerClientResolvedConfig> {
     readonly input: CreateLicenseConversionTaskForResourceCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateLicenseConversionTaskForResourceCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LicenseManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateLicenseConversionTaskForResourceCommandInput, CreateLicenseConversionTaskForResourceCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LicenseManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LicenseManagerClient";
 import { CreateLicenseManagerReportGeneratorRequest, CreateLicenseManagerReportGeneratorResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link CreateLicenseManagerReportGeneratorCommand}.
  */
 export interface CreateLicenseManagerReportGeneratorCommandInput extends CreateLicenseManagerReportGeneratorRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateLicenseManagerReportGeneratorCommand}.
  */
 export interface CreateLicenseManagerReportGeneratorCommandOutput extends CreateLicenseManagerReportGeneratorResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a 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 CreateLicenseManagerReportGeneratorCommandOutput extends Create
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateLicenseManagerReportGeneratorCommandInput - {@link CreateLicenseManagerReportGeneratorCommandInput}
+ * @returns {@link CreateLicenseManagerReportGeneratorCommandOutput}
  * @see {@link CreateLicenseManagerReportGeneratorCommandInput} for command's `input` shape.
  * @see {@link CreateLicenseManagerReportGeneratorCommandOutput} for command's `response` shape.
  * @see {@link LicenseManagerClientResolvedConfig | config} for LicenseManagerClient's `config` shape.
@@ -59,11 +66,20 @@ export interface CreateLicenseManagerReportGeneratorCommandOutput extends Create
 export declare class CreateLicenseManagerReportGeneratorCommand extends $Command<CreateLicenseManagerReportGeneratorCommandInput, CreateLicenseManagerReportGeneratorCommandOutput, LicenseManagerClientResolvedConfig> {
     readonly input: CreateLicenseManagerReportGeneratorCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateLicenseManagerReportGeneratorCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LicenseManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateLicenseManagerReportGeneratorCommandInput, CreateLicenseManagerReportGeneratorCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

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

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

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

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

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

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LicenseManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LicenseManagerClient";
 import { DeleteLicenseRequest, DeleteLicenseResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link DeleteLicenseCommand}.
  */
 export interface DeleteLicenseCommandInput extends DeleteLicenseRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DeleteLicenseCommand}.
  */
 export interface DeleteLicenseCommandOutput extends DeleteLicenseResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Deletes 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 DeleteLicenseCommandOutput extends DeleteLicenseResponse, __Met
  * const response = await client.send(command);
  * ```
  *
+ * @param DeleteLicenseCommandInput - {@link DeleteLicenseCommandInput}
+ * @returns {@link DeleteLicenseCommandOutput}
  * @see {@link DeleteLicenseCommandInput} for command's `input` shape.
  * @see {@link DeleteLicenseCommandOutput} for command's `response` shape.
  * @see {@link LicenseManagerClientResolvedConfig | config} for LicenseManagerClient's `config` shape.
@@ -59,11 +66,20 @@ export interface DeleteLicenseCommandOutput extends DeleteLicenseResponse, __Met
 export declare class DeleteLicenseCommand extends $Command<DeleteLicenseCommandInput, DeleteLicenseCommandOutput, LicenseManagerClientResolvedConfig> {
     readonly input: DeleteLicenseCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeleteLicenseCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LicenseManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteLicenseCommandInput, DeleteLicenseCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LicenseManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LicenseManagerClient";
 import { DeleteLicenseConfigurationRequest, DeleteLicenseConfigurationResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link DeleteLicenseConfigurationCommand}.
  */
 export interface DeleteLicenseConfigurationCommandInput extends DeleteLicenseConfigurationRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DeleteLicenseConfigurationCommand}.
  */
 export interface DeleteLicenseConfigurationCommandOutput extends DeleteLicenseConfigurationResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Deletes the specified license configuration.</p>
  *          <p>You cannot delete a license configuration that is in use.</p>
  * @example
@@ -26,6 +31,8 @@ export interface DeleteLicenseConfigurationCommandOutput extends DeleteLicenseCo
  * const response = await client.send(command);
  * ```
  *
+ * @param DeleteLicenseConfigurationCommandInput - {@link DeleteLicenseConfigurationCommandInput}
+ * @returns {@link DeleteLicenseConfigurationCommandOutput}
  * @see {@link DeleteLicenseConfigurationCommandInput} for command's `input` shape.
  * @see {@link DeleteLicenseConfigurationCommandOutput} for command's `response` shape.
  * @see {@link LicenseManagerClientResolvedConfig | config} for LicenseManagerClient's `config` shape.
@@ -51,11 +58,20 @@ export interface DeleteLicenseConfigurationCommandOutput extends DeleteLicenseCo
 export declare class DeleteLicenseConfigurationCommand extends $Command<DeleteLicenseConfigurationCommandInput, DeleteLicenseConfigurationCommandOutput, LicenseManagerClientResolvedConfig> {
     readonly input: DeleteLicenseConfigurationCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeleteLicenseConfigurationCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LicenseManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteLicenseConfigurationCommandInput, DeleteLicenseConfigurationCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }