@aws-sdk/client-amplifybackend 3.296.0 → 3.298.0

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

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

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { AmplifyBackendClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AmplifyBackendClient";
 import { CreateBackendAuthRequest, CreateBackendAuthResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link CreateBackendAuthCommand}.
  */
 export interface CreateBackendAuthCommandInput extends CreateBackendAuthRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateBackendAuthCommand}.
  */
 export interface CreateBackendAuthCommandOutput extends CreateBackendAuthResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a new backend authentication resource.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface CreateBackendAuthCommandOutput extends CreateBackendAuthRespons
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateBackendAuthCommandInput - {@link CreateBackendAuthCommandInput}
+ * @returns {@link CreateBackendAuthCommandOutput}
  * @see {@link CreateBackendAuthCommandInput} for command's `input` shape.
  * @see {@link CreateBackendAuthCommandOutput} for command's `response` shape.
  * @see {@link AmplifyBackendClientResolvedConfig | config} for AmplifyBackendClient's `config` shape.
@@ -46,11 +53,20 @@ export interface CreateBackendAuthCommandOutput extends CreateBackendAuthRespons
 export declare class CreateBackendAuthCommand extends $Command<CreateBackendAuthCommandInput, CreateBackendAuthCommandOutput, AmplifyBackendClientResolvedConfig> {
     readonly input: CreateBackendAuthCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateBackendAuthCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AmplifyBackendClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateBackendAuthCommandInput, CreateBackendAuthCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { AmplifyBackendClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AmplifyBackendClient";
 import { CreateBackendRequest, CreateBackendResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link CreateBackendCommand}.
  */
 export interface CreateBackendCommandInput extends CreateBackendRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateBackendCommand}.
  */
 export interface CreateBackendCommandOutput extends CreateBackendResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>This operation creates a backend for an Amplify app. Backends are automatically created at the time of app creation.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface CreateBackendCommandOutput extends CreateBackendResponse, __Met
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateBackendCommandInput - {@link CreateBackendCommandInput}
+ * @returns {@link CreateBackendCommandOutput}
  * @see {@link CreateBackendCommandInput} for command's `input` shape.
  * @see {@link CreateBackendCommandOutput} for command's `response` shape.
  * @see {@link AmplifyBackendClientResolvedConfig | config} for AmplifyBackendClient's `config` shape.
@@ -46,11 +53,20 @@ export interface CreateBackendCommandOutput extends CreateBackendResponse, __Met
 export declare class CreateBackendCommand extends $Command<CreateBackendCommandInput, CreateBackendCommandOutput, AmplifyBackendClientResolvedConfig> {
     readonly input: CreateBackendCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateBackendCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AmplifyBackendClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateBackendCommandInput, CreateBackendCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

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

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { AmplifyBackendClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AmplifyBackendClient";
 import { CreateBackendStorageRequest, CreateBackendStorageResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link CreateBackendStorageCommand}.
  */
 export interface CreateBackendStorageCommandInput extends CreateBackendStorageRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateBackendStorageCommand}.
  */
 export interface CreateBackendStorageCommandOutput extends CreateBackendStorageResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a backend storage resource.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface CreateBackendStorageCommandOutput extends CreateBackendStorageR
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateBackendStorageCommandInput - {@link CreateBackendStorageCommandInput}
+ * @returns {@link CreateBackendStorageCommandOutput}
  * @see {@link CreateBackendStorageCommandInput} for command's `input` shape.
  * @see {@link CreateBackendStorageCommandOutput} for command's `response` shape.
  * @see {@link AmplifyBackendClientResolvedConfig | config} for AmplifyBackendClient's `config` shape.
@@ -46,11 +53,20 @@ export interface CreateBackendStorageCommandOutput extends CreateBackendStorageR
 export declare class CreateBackendStorageCommand extends $Command<CreateBackendStorageCommandInput, CreateBackendStorageCommandOutput, AmplifyBackendClientResolvedConfig> {
     readonly input: CreateBackendStorageCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateBackendStorageCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AmplifyBackendClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateBackendStorageCommandInput, CreateBackendStorageCommandOutput>;
+    /**
+     * @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 { AmplifyBackendClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AmplifyBackendClient";
 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>Generates a one-time challenge code to authenticate a user into your Amplify Admin UI.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,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 AmplifyBackendClientResolvedConfig | config} for AmplifyBackendClient's `config` shape.
@@ -46,11 +53,20 @@ export interface CreateTokenCommandOutput extends CreateTokenResponse, __Metadat
 export declare class CreateTokenCommand extends $Command<CreateTokenCommandInput, CreateTokenCommandOutput, AmplifyBackendClientResolvedConfig> {
     readonly input: CreateTokenCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateTokenCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AmplifyBackendClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateTokenCommandInput, CreateTokenCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { AmplifyBackendClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AmplifyBackendClient";
 import { DeleteBackendAPIRequest, DeleteBackendAPIResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link DeleteBackendAPICommand}.
  */
 export interface DeleteBackendAPICommandInput extends DeleteBackendAPIRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DeleteBackendAPICommand}.
  */
 export interface DeleteBackendAPICommandOutput extends DeleteBackendAPIResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Deletes an existing backend API resource.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface DeleteBackendAPICommandOutput extends DeleteBackendAPIResponse,
  * const response = await client.send(command);
  * ```
  *
+ * @param DeleteBackendAPICommandInput - {@link DeleteBackendAPICommandInput}
+ * @returns {@link DeleteBackendAPICommandOutput}
  * @see {@link DeleteBackendAPICommandInput} for command's `input` shape.
  * @see {@link DeleteBackendAPICommandOutput} for command's `response` shape.
  * @see {@link AmplifyBackendClientResolvedConfig | config} for AmplifyBackendClient's `config` shape.
@@ -46,11 +53,20 @@ export interface DeleteBackendAPICommandOutput extends DeleteBackendAPIResponse,
 export declare class DeleteBackendAPICommand extends $Command<DeleteBackendAPICommandInput, DeleteBackendAPICommandOutput, AmplifyBackendClientResolvedConfig> {
     readonly input: DeleteBackendAPICommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeleteBackendAPICommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AmplifyBackendClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteBackendAPICommandInput, DeleteBackendAPICommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { AmplifyBackendClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AmplifyBackendClient";
 import { DeleteBackendAuthRequest, DeleteBackendAuthResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link DeleteBackendAuthCommand}.
  */
 export interface DeleteBackendAuthCommandInput extends DeleteBackendAuthRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DeleteBackendAuthCommand}.
  */
 export interface DeleteBackendAuthCommandOutput extends DeleteBackendAuthResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Deletes an existing backend authentication resource.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface DeleteBackendAuthCommandOutput extends DeleteBackendAuthRespons
  * const response = await client.send(command);
  * ```
  *
+ * @param DeleteBackendAuthCommandInput - {@link DeleteBackendAuthCommandInput}
+ * @returns {@link DeleteBackendAuthCommandOutput}
  * @see {@link DeleteBackendAuthCommandInput} for command's `input` shape.
  * @see {@link DeleteBackendAuthCommandOutput} for command's `response` shape.
  * @see {@link AmplifyBackendClientResolvedConfig | config} for AmplifyBackendClient's `config` shape.
@@ -46,11 +53,20 @@ export interface DeleteBackendAuthCommandOutput extends DeleteBackendAuthRespons
 export declare class DeleteBackendAuthCommand extends $Command<DeleteBackendAuthCommandInput, DeleteBackendAuthCommandOutput, AmplifyBackendClientResolvedConfig> {
     readonly input: DeleteBackendAuthCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeleteBackendAuthCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AmplifyBackendClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteBackendAuthCommandInput, DeleteBackendAuthCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { AmplifyBackendClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AmplifyBackendClient";
 import { DeleteBackendRequest, DeleteBackendResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link DeleteBackendCommand}.
  */
 export interface DeleteBackendCommandInput extends DeleteBackendRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DeleteBackendCommand}.
  */
 export interface DeleteBackendCommandOutput extends DeleteBackendResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Removes an existing environment from your Amplify project.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface DeleteBackendCommandOutput extends DeleteBackendResponse, __Met
  * const response = await client.send(command);
  * ```
  *
+ * @param DeleteBackendCommandInput - {@link DeleteBackendCommandInput}
+ * @returns {@link DeleteBackendCommandOutput}
  * @see {@link DeleteBackendCommandInput} for command's `input` shape.
  * @see {@link DeleteBackendCommandOutput} for command's `response` shape.
  * @see {@link AmplifyBackendClientResolvedConfig | config} for AmplifyBackendClient's `config` shape.
@@ -46,11 +53,20 @@ export interface DeleteBackendCommandOutput extends DeleteBackendResponse, __Met
 export declare class DeleteBackendCommand extends $Command<DeleteBackendCommandInput, DeleteBackendCommandOutput, AmplifyBackendClientResolvedConfig> {
     readonly input: DeleteBackendCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeleteBackendCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AmplifyBackendClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteBackendCommandInput, DeleteBackendCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { AmplifyBackendClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AmplifyBackendClient";
 import { DeleteBackendStorageRequest, DeleteBackendStorageResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link DeleteBackendStorageCommand}.
  */
 export interface DeleteBackendStorageCommandInput extends DeleteBackendStorageRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DeleteBackendStorageCommand}.
  */
 export interface DeleteBackendStorageCommandOutput extends DeleteBackendStorageResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Removes the specified backend storage resource.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface DeleteBackendStorageCommandOutput extends DeleteBackendStorageR
  * const response = await client.send(command);
  * ```
  *
+ * @param DeleteBackendStorageCommandInput - {@link DeleteBackendStorageCommandInput}
+ * @returns {@link DeleteBackendStorageCommandOutput}
  * @see {@link DeleteBackendStorageCommandInput} for command's `input` shape.
  * @see {@link DeleteBackendStorageCommandOutput} for command's `response` shape.
  * @see {@link AmplifyBackendClientResolvedConfig | config} for AmplifyBackendClient's `config` shape.
@@ -46,11 +53,20 @@ export interface DeleteBackendStorageCommandOutput extends DeleteBackendStorageR
 export declare class DeleteBackendStorageCommand extends $Command<DeleteBackendStorageCommandInput, DeleteBackendStorageCommandOutput, AmplifyBackendClientResolvedConfig> {
     readonly input: DeleteBackendStorageCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeleteBackendStorageCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AmplifyBackendClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteBackendStorageCommandInput, DeleteBackendStorageCommandOutput>;
+    /**
+     * @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 { AmplifyBackendClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AmplifyBackendClient";
 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 challenge token based on the given appId and sessionId.</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 AmplifyBackendClientResolvedConfig | config} for AmplifyBackendClient's `config` shape.
@@ -46,11 +53,20 @@ export interface DeleteTokenCommandOutput extends DeleteTokenResponse, __Metadat
 export declare class DeleteTokenCommand extends $Command<DeleteTokenCommandInput, DeleteTokenCommandOutput, AmplifyBackendClientResolvedConfig> {
     readonly input: DeleteTokenCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeleteTokenCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AmplifyBackendClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteTokenCommandInput, DeleteTokenCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { AmplifyBackendClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AmplifyBackendClient";
 import { GenerateBackendAPIModelsRequest, GenerateBackendAPIModelsResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link GenerateBackendAPIModelsCommand}.
  */
 export interface GenerateBackendAPIModelsCommandInput extends GenerateBackendAPIModelsRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link GenerateBackendAPIModelsCommand}.
  */
 export interface GenerateBackendAPIModelsCommandOutput extends GenerateBackendAPIModelsResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Generates a model schema for an existing backend API resource.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface GenerateBackendAPIModelsCommandOutput extends GenerateBackendAP
  * const response = await client.send(command);
  * ```
  *
+ * @param GenerateBackendAPIModelsCommandInput - {@link GenerateBackendAPIModelsCommandInput}
+ * @returns {@link GenerateBackendAPIModelsCommandOutput}
  * @see {@link GenerateBackendAPIModelsCommandInput} for command's `input` shape.
  * @see {@link GenerateBackendAPIModelsCommandOutput} for command's `response` shape.
  * @see {@link AmplifyBackendClientResolvedConfig | config} for AmplifyBackendClient's `config` shape.
@@ -46,11 +53,20 @@ export interface GenerateBackendAPIModelsCommandOutput extends GenerateBackendAP
 export declare class GenerateBackendAPIModelsCommand extends $Command<GenerateBackendAPIModelsCommandInput, GenerateBackendAPIModelsCommandOutput, AmplifyBackendClientResolvedConfig> {
     readonly input: GenerateBackendAPIModelsCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: GenerateBackendAPIModelsCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AmplifyBackendClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GenerateBackendAPIModelsCommandInput, GenerateBackendAPIModelsCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

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