@aws-sdk/client-amplify 3.34.0 → 3.37.0

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { AmplifyClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AmplifyClient";
+import { CreateAppRequest, CreateAppResult } from "../models/models_0";
+export interface CreateAppCommandInput extends CreateAppRequest {
+}
+export interface CreateAppCommandOutput extends CreateAppResult, __MetadataBearer {
+}
+
+export declare class CreateAppCommand extends $Command<CreateAppCommandInput, CreateAppCommandOutput, AmplifyClientResolvedConfig> {
+    readonly input: CreateAppCommandInput;
+    constructor(input: CreateAppCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AmplifyClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateAppCommandInput, CreateAppCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/{dist/types → dist-types}/ts3.4/commands/CreateBackendEnvironmentCommand.d.ts

@@ -1,34 +1,16 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
 import { AmplifyClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AmplifyClient";
 import { CreateBackendEnvironmentRequest, CreateBackendEnvironmentResult } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
 export interface CreateBackendEnvironmentCommandInput extends CreateBackendEnvironmentRequest {
 }
 export interface CreateBackendEnvironmentCommandOutput extends CreateBackendEnvironmentResult, __MetadataBearer {
 }
-/**
- * <p> Creates a new backend environment for an Amplify app. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AmplifyClient, CreateBackendEnvironmentCommand } from "@aws-sdk/client-amplify"; // ES Modules import
- * // const { AmplifyClient, CreateBackendEnvironmentCommand } = require("@aws-sdk/client-amplify"); // CommonJS import
- * const client = new AmplifyClient(config);
- * const command = new CreateBackendEnvironmentCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateBackendEnvironmentCommandInput} for command's `input` shape.
- * @see {@link CreateBackendEnvironmentCommandOutput} for command's `response` shape.
- * @see {@link AmplifyClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateBackendEnvironmentCommand extends $Command<CreateBackendEnvironmentCommandInput, CreateBackendEnvironmentCommandOutput, AmplifyClientResolvedConfig> {
     readonly input: CreateBackendEnvironmentCommandInput;
     constructor(input: CreateBackendEnvironmentCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AmplifyClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateBackendEnvironmentCommandInput, CreateBackendEnvironmentCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { AmplifyClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AmplifyClient";
+import { CreateBranchRequest, CreateBranchResult } from "../models/models_0";
+export interface CreateBranchCommandInput extends CreateBranchRequest {
+}
+export interface CreateBranchCommandOutput extends CreateBranchResult, __MetadataBearer {
+}
+
+export declare class CreateBranchCommand extends $Command<CreateBranchCommandInput, CreateBranchCommandOutput, AmplifyClientResolvedConfig> {
+    readonly input: CreateBranchCommandInput;
+    constructor(input: CreateBranchCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AmplifyClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateBranchCommandInput, CreateBranchCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { AmplifyClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AmplifyClient";
+import { CreateDeploymentRequest, CreateDeploymentResult } from "../models/models_0";
+export interface CreateDeploymentCommandInput extends CreateDeploymentRequest {
+}
+export interface CreateDeploymentCommandOutput extends CreateDeploymentResult, __MetadataBearer {
+}
+
+export declare class CreateDeploymentCommand extends $Command<CreateDeploymentCommandInput, CreateDeploymentCommandOutput, AmplifyClientResolvedConfig> {
+    readonly input: CreateDeploymentCommandInput;
+    constructor(input: CreateDeploymentCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AmplifyClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateDeploymentCommandInput, CreateDeploymentCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { AmplifyClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AmplifyClient";
+import { CreateDomainAssociationRequest, CreateDomainAssociationResult } from "../models/models_0";
+export interface CreateDomainAssociationCommandInput extends CreateDomainAssociationRequest {
+}
+export interface CreateDomainAssociationCommandOutput extends CreateDomainAssociationResult, __MetadataBearer {
+}
+
+export declare class CreateDomainAssociationCommand extends $Command<CreateDomainAssociationCommandInput, CreateDomainAssociationCommandOutput, AmplifyClientResolvedConfig> {
+    readonly input: CreateDomainAssociationCommandInput;
+    constructor(input: CreateDomainAssociationCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AmplifyClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateDomainAssociationCommandInput, CreateDomainAssociationCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { AmplifyClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AmplifyClient";
+import { CreateWebhookRequest, CreateWebhookResult } from "../models/models_0";
+export interface CreateWebhookCommandInput extends CreateWebhookRequest {
+}
+export interface CreateWebhookCommandOutput extends CreateWebhookResult, __MetadataBearer {
+}
+
+export declare class CreateWebhookCommand extends $Command<CreateWebhookCommandInput, CreateWebhookCommandOutput, AmplifyClientResolvedConfig> {
+    readonly input: CreateWebhookCommandInput;
+    constructor(input: CreateWebhookCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AmplifyClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateWebhookCommandInput, CreateWebhookCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { AmplifyClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AmplifyClient";
+import { DeleteAppRequest, DeleteAppResult } from "../models/models_0";
+export interface DeleteAppCommandInput extends DeleteAppRequest {
+}
+export interface DeleteAppCommandOutput extends DeleteAppResult, __MetadataBearer {
+}
+
+export declare class DeleteAppCommand extends $Command<DeleteAppCommandInput, DeleteAppCommandOutput, AmplifyClientResolvedConfig> {
+    readonly input: DeleteAppCommandInput;
+    constructor(input: DeleteAppCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AmplifyClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteAppCommandInput, DeleteAppCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/{dist/types → dist-types}/ts3.4/commands/DeleteBackendEnvironmentCommand.d.ts

@@ -1,34 +1,16 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
 import { AmplifyClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AmplifyClient";
 import { DeleteBackendEnvironmentRequest, DeleteBackendEnvironmentResult } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
 export interface DeleteBackendEnvironmentCommandInput extends DeleteBackendEnvironmentRequest {
 }
 export interface DeleteBackendEnvironmentCommandOutput extends DeleteBackendEnvironmentResult, __MetadataBearer {
 }
-/**
- * <p> Deletes a backend environment for an Amplify app. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AmplifyClient, DeleteBackendEnvironmentCommand } from "@aws-sdk/client-amplify"; // ES Modules import
- * // const { AmplifyClient, DeleteBackendEnvironmentCommand } = require("@aws-sdk/client-amplify"); // CommonJS import
- * const client = new AmplifyClient(config);
- * const command = new DeleteBackendEnvironmentCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteBackendEnvironmentCommandInput} for command's `input` shape.
- * @see {@link DeleteBackendEnvironmentCommandOutput} for command's `response` shape.
- * @see {@link AmplifyClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteBackendEnvironmentCommand extends $Command<DeleteBackendEnvironmentCommandInput, DeleteBackendEnvironmentCommandOutput, AmplifyClientResolvedConfig> {
     readonly input: DeleteBackendEnvironmentCommandInput;
     constructor(input: DeleteBackendEnvironmentCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AmplifyClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteBackendEnvironmentCommandInput, DeleteBackendEnvironmentCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { AmplifyClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AmplifyClient";
+import { DeleteBranchRequest, DeleteBranchResult } from "../models/models_0";
+export interface DeleteBranchCommandInput extends DeleteBranchRequest {
+}
+export interface DeleteBranchCommandOutput extends DeleteBranchResult, __MetadataBearer {
+}
+
+export declare class DeleteBranchCommand extends $Command<DeleteBranchCommandInput, DeleteBranchCommandOutput, AmplifyClientResolvedConfig> {
+    readonly input: DeleteBranchCommandInput;
+    constructor(input: DeleteBranchCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AmplifyClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteBranchCommandInput, DeleteBranchCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/{dist/types → dist-types}/ts3.4/commands/DeleteDomainAssociationCommand.d.ts

@@ -1,34 +1,16 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
 import { AmplifyClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AmplifyClient";
 import { DeleteDomainAssociationRequest, DeleteDomainAssociationResult } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
 export interface DeleteDomainAssociationCommandInput extends DeleteDomainAssociationRequest {
 }
 export interface DeleteDomainAssociationCommandOutput extends DeleteDomainAssociationResult, __MetadataBearer {
 }
-/**
- * <p> Deletes a domain association for an Amplify app. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AmplifyClient, DeleteDomainAssociationCommand } from "@aws-sdk/client-amplify"; // ES Modules import
- * // const { AmplifyClient, DeleteDomainAssociationCommand } = require("@aws-sdk/client-amplify"); // CommonJS import
- * const client = new AmplifyClient(config);
- * const command = new DeleteDomainAssociationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteDomainAssociationCommandInput} for command's `input` shape.
- * @see {@link DeleteDomainAssociationCommandOutput} for command's `response` shape.
- * @see {@link AmplifyClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteDomainAssociationCommand extends $Command<DeleteDomainAssociationCommandInput, DeleteDomainAssociationCommandOutput, AmplifyClientResolvedConfig> {
     readonly input: DeleteDomainAssociationCommandInput;
     constructor(input: DeleteDomainAssociationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AmplifyClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteDomainAssociationCommandInput, DeleteDomainAssociationCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { AmplifyClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AmplifyClient";
+import { DeleteJobRequest, DeleteJobResult } from "../models/models_0";
+export interface DeleteJobCommandInput extends DeleteJobRequest {
+}
+export interface DeleteJobCommandOutput extends DeleteJobResult, __MetadataBearer {
+}
+
+export declare class DeleteJobCommand extends $Command<DeleteJobCommandInput, DeleteJobCommandOutput, AmplifyClientResolvedConfig> {
+    readonly input: DeleteJobCommandInput;
+    constructor(input: DeleteJobCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AmplifyClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteJobCommandInput, DeleteJobCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/{dist/types → dist-types}/ts3.4/commands/DeleteWebhookCommand.d.ts

@@ -1,34 +1,16 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
 import { AmplifyClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AmplifyClient";
 import { DeleteWebhookRequest, DeleteWebhookResult } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
 export interface DeleteWebhookCommandInput extends DeleteWebhookRequest {
 }
 export interface DeleteWebhookCommandOutput extends DeleteWebhookResult, __MetadataBearer {
 }
-/**
- * <p> Deletes a webhook. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AmplifyClient, DeleteWebhookCommand } from "@aws-sdk/client-amplify"; // ES Modules import
- * // const { AmplifyClient, DeleteWebhookCommand } = require("@aws-sdk/client-amplify"); // CommonJS import
- * const client = new AmplifyClient(config);
- * const command = new DeleteWebhookCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteWebhookCommandInput} for command's `input` shape.
- * @see {@link DeleteWebhookCommandOutput} for command's `response` shape.
- * @see {@link AmplifyClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteWebhookCommand extends $Command<DeleteWebhookCommandInput, DeleteWebhookCommandOutput, AmplifyClientResolvedConfig> {
     readonly input: DeleteWebhookCommandInput;
     constructor(input: DeleteWebhookCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AmplifyClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteWebhookCommandInput, DeleteWebhookCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { AmplifyClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AmplifyClient";
+import { GenerateAccessLogsRequest, GenerateAccessLogsResult } from "../models/models_0";
+export interface GenerateAccessLogsCommandInput extends GenerateAccessLogsRequest {
+}
+export interface GenerateAccessLogsCommandOutput extends GenerateAccessLogsResult, __MetadataBearer {
+}
+
+export declare class GenerateAccessLogsCommand extends $Command<GenerateAccessLogsCommandInput, GenerateAccessLogsCommandOutput, AmplifyClientResolvedConfig> {
+    readonly input: GenerateAccessLogsCommandInput;
+    constructor(input: GenerateAccessLogsCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AmplifyClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GenerateAccessLogsCommandInput, GenerateAccessLogsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { AmplifyClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AmplifyClient";
+import { GetAppRequest, GetAppResult } from "../models/models_0";
+export interface GetAppCommandInput extends GetAppRequest {
+}
+export interface GetAppCommandOutput extends GetAppResult, __MetadataBearer {
+}
+
+export declare class GetAppCommand extends $Command<GetAppCommandInput, GetAppCommandOutput, AmplifyClientResolvedConfig> {
+    readonly input: GetAppCommandInput;
+    constructor(input: GetAppCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AmplifyClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetAppCommandInput, GetAppCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { AmplifyClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AmplifyClient";
+import { GetArtifactUrlRequest, GetArtifactUrlResult } from "../models/models_0";
+export interface GetArtifactUrlCommandInput extends GetArtifactUrlRequest {
+}
+export interface GetArtifactUrlCommandOutput extends GetArtifactUrlResult, __MetadataBearer {
+}
+
+export declare class GetArtifactUrlCommand extends $Command<GetArtifactUrlCommandInput, GetArtifactUrlCommandOutput, AmplifyClientResolvedConfig> {
+    readonly input: GetArtifactUrlCommandInput;
+    constructor(input: GetArtifactUrlCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AmplifyClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetArtifactUrlCommandInput, GetArtifactUrlCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/{dist/types → dist-types}/ts3.4/commands/GetBackendEnvironmentCommand.d.ts

@@ -1,34 +1,16 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
 import { AmplifyClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AmplifyClient";
 import { GetBackendEnvironmentRequest, GetBackendEnvironmentResult } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
 export interface GetBackendEnvironmentCommandInput extends GetBackendEnvironmentRequest {
 }
 export interface GetBackendEnvironmentCommandOutput extends GetBackendEnvironmentResult, __MetadataBearer {
 }
-/**
- * <p> Returns a backend environment for an Amplify app. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AmplifyClient, GetBackendEnvironmentCommand } from "@aws-sdk/client-amplify"; // ES Modules import
- * // const { AmplifyClient, GetBackendEnvironmentCommand } = require("@aws-sdk/client-amplify"); // CommonJS import
- * const client = new AmplifyClient(config);
- * const command = new GetBackendEnvironmentCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetBackendEnvironmentCommandInput} for command's `input` shape.
- * @see {@link GetBackendEnvironmentCommandOutput} for command's `response` shape.
- * @see {@link AmplifyClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetBackendEnvironmentCommand extends $Command<GetBackendEnvironmentCommandInput, GetBackendEnvironmentCommandOutput, AmplifyClientResolvedConfig> {
     readonly input: GetBackendEnvironmentCommandInput;
     constructor(input: GetBackendEnvironmentCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AmplifyClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetBackendEnvironmentCommandInput, GetBackendEnvironmentCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { AmplifyClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AmplifyClient";
+import { GetBranchRequest, GetBranchResult } from "../models/models_0";
+export interface GetBranchCommandInput extends GetBranchRequest {
+}
+export interface GetBranchCommandOutput extends GetBranchResult, __MetadataBearer {
+}
+
+export declare class GetBranchCommand extends $Command<GetBranchCommandInput, GetBranchCommandOutput, AmplifyClientResolvedConfig> {
+    readonly input: GetBranchCommandInput;
+    constructor(input: GetBranchCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AmplifyClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetBranchCommandInput, GetBranchCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/{dist/types → dist-types}/ts3.4/commands/GetDomainAssociationCommand.d.ts

@@ -1,34 +1,16 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
 import { AmplifyClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AmplifyClient";
 import { GetDomainAssociationRequest, GetDomainAssociationResult } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
 export interface GetDomainAssociationCommandInput extends GetDomainAssociationRequest {
 }
 export interface GetDomainAssociationCommandOutput extends GetDomainAssociationResult, __MetadataBearer {
 }
-/**
- * <p> Returns the domain information for an Amplify app. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AmplifyClient, GetDomainAssociationCommand } from "@aws-sdk/client-amplify"; // ES Modules import
- * // const { AmplifyClient, GetDomainAssociationCommand } = require("@aws-sdk/client-amplify"); // CommonJS import
- * const client = new AmplifyClient(config);
- * const command = new GetDomainAssociationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetDomainAssociationCommandInput} for command's `input` shape.
- * @see {@link GetDomainAssociationCommandOutput} for command's `response` shape.
- * @see {@link AmplifyClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetDomainAssociationCommand extends $Command<GetDomainAssociationCommandInput, GetDomainAssociationCommandOutput, AmplifyClientResolvedConfig> {
     readonly input: GetDomainAssociationCommandInput;
     constructor(input: GetDomainAssociationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AmplifyClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetDomainAssociationCommandInput, GetDomainAssociationCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { AmplifyClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AmplifyClient";
+import { GetJobRequest, GetJobResult } from "../models/models_0";
+export interface GetJobCommandInput extends GetJobRequest {
+}
+export interface GetJobCommandOutput extends GetJobResult, __MetadataBearer {
+}
+
+export declare class GetJobCommand extends $Command<GetJobCommandInput, GetJobCommandOutput, AmplifyClientResolvedConfig> {
+    readonly input: GetJobCommandInput;
+    constructor(input: GetJobCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AmplifyClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetJobCommandInput, GetJobCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { AmplifyClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AmplifyClient";
+import { GetWebhookRequest, GetWebhookResult } from "../models/models_0";
+export interface GetWebhookCommandInput extends GetWebhookRequest {
+}
+export interface GetWebhookCommandOutput extends GetWebhookResult, __MetadataBearer {
+}
+
+export declare class GetWebhookCommand extends $Command<GetWebhookCommandInput, GetWebhookCommandOutput, AmplifyClientResolvedConfig> {
+    readonly input: GetWebhookCommandInput;
+    constructor(input: GetWebhookCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AmplifyClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetWebhookCommandInput, GetWebhookCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { AmplifyClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AmplifyClient";
+import { ListAppsRequest, ListAppsResult } from "../models/models_0";
+export interface ListAppsCommandInput extends ListAppsRequest {
+}
+export interface ListAppsCommandOutput extends ListAppsResult, __MetadataBearer {
+}
+
+export declare class ListAppsCommand extends $Command<ListAppsCommandInput, ListAppsCommandOutput, AmplifyClientResolvedConfig> {
+    readonly input: ListAppsCommandInput;
+    constructor(input: ListAppsCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AmplifyClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListAppsCommandInput, ListAppsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { AmplifyClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AmplifyClient";
+import { ListArtifactsRequest, ListArtifactsResult } from "../models/models_0";
+export interface ListArtifactsCommandInput extends ListArtifactsRequest {
+}
+export interface ListArtifactsCommandOutput extends ListArtifactsResult, __MetadataBearer {
+}
+
+export declare class ListArtifactsCommand extends $Command<ListArtifactsCommandInput, ListArtifactsCommandOutput, AmplifyClientResolvedConfig> {
+    readonly input: ListArtifactsCommandInput;
+    constructor(input: ListArtifactsCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AmplifyClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListArtifactsCommandInput, ListArtifactsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/{dist/types → dist-types}/ts3.4/commands/ListBackendEnvironmentsCommand.d.ts

@@ -1,34 +1,16 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
 import { AmplifyClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AmplifyClient";
 import { ListBackendEnvironmentsRequest, ListBackendEnvironmentsResult } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
 export interface ListBackendEnvironmentsCommandInput extends ListBackendEnvironmentsRequest {
 }
 export interface ListBackendEnvironmentsCommandOutput extends ListBackendEnvironmentsResult, __MetadataBearer {
 }
-/**
- * <p> Lists the backend environments for an Amplify app. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AmplifyClient, ListBackendEnvironmentsCommand } from "@aws-sdk/client-amplify"; // ES Modules import
- * // const { AmplifyClient, ListBackendEnvironmentsCommand } = require("@aws-sdk/client-amplify"); // CommonJS import
- * const client = new AmplifyClient(config);
- * const command = new ListBackendEnvironmentsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListBackendEnvironmentsCommandInput} for command's `input` shape.
- * @see {@link ListBackendEnvironmentsCommandOutput} for command's `response` shape.
- * @see {@link AmplifyClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListBackendEnvironmentsCommand extends $Command<ListBackendEnvironmentsCommandInput, ListBackendEnvironmentsCommandOutput, AmplifyClientResolvedConfig> {
     readonly input: ListBackendEnvironmentsCommandInput;
     constructor(input: ListBackendEnvironmentsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AmplifyClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListBackendEnvironmentsCommandInput, ListBackendEnvironmentsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { AmplifyClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AmplifyClient";
+import { ListBranchesRequest, ListBranchesResult } from "../models/models_0";
+export interface ListBranchesCommandInput extends ListBranchesRequest {
+}
+export interface ListBranchesCommandOutput extends ListBranchesResult, __MetadataBearer {
+}
+
+export declare class ListBranchesCommand extends $Command<ListBranchesCommandInput, ListBranchesCommandOutput, AmplifyClientResolvedConfig> {
+    readonly input: ListBranchesCommandInput;
+    constructor(input: ListBranchesCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AmplifyClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListBranchesCommandInput, ListBranchesCommandOutput>;
+    private serialize;
+    private deserialize;
+}