@aws-sdk/client-appflow 3.34.0 → 3.37.0

package/dist/types/ts3.4/commands/CreateConnectorProfileCommand.d.ts

@@ -1,38 +0,0 @@
-import { AppflowClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AppflowClient";
-import { CreateConnectorProfileRequest, CreateConnectorProfileResponse } 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 CreateConnectorProfileCommandInput extends CreateConnectorProfileRequest {
-}
-export interface CreateConnectorProfileCommandOutput extends CreateConnectorProfileResponse, __MetadataBearer {
-}
-/**
- * <p> Creates a new connector profile associated with your Amazon Web Services account. There is a soft quota
- *       of 100 connector profiles per Amazon Web Services account. If you need more connector profiles than this quota
- *       allows, you can submit a request to the Amazon AppFlow team through the Amazon AppFlow support
- *       channel. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AppflowClient, CreateConnectorProfileCommand } from "@aws-sdk/client-appflow"; // ES Modules import
- * // const { AppflowClient, CreateConnectorProfileCommand } = require("@aws-sdk/client-appflow"); // CommonJS import
- * const client = new AppflowClient(config);
- * const command = new CreateConnectorProfileCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateConnectorProfileCommandInput} for command's `input` shape.
- * @see {@link CreateConnectorProfileCommandOutput} for command's `response` shape.
- * @see {@link AppflowClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class CreateConnectorProfileCommand extends $Command<CreateConnectorProfileCommandInput, CreateConnectorProfileCommandOutput, AppflowClientResolvedConfig> {
-    readonly input: CreateConnectorProfileCommandInput;
-    constructor(input: CreateConnectorProfileCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AppflowClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateConnectorProfileCommandInput, CreateConnectorProfileCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/CreateFlowCommand.d.ts

@@ -1,38 +0,0 @@
-import { AppflowClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AppflowClient";
-import { CreateFlowRequest, CreateFlowResponse } 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 CreateFlowCommandInput extends CreateFlowRequest {
-}
-export interface CreateFlowCommandOutput extends CreateFlowResponse, __MetadataBearer {
-}
-/**
- * <p> Enables your application to create a new flow using Amazon AppFlow. You must create a
- *       connector profile before calling this API. Please note that the Request Syntax below shows
- *       syntax for multiple destinations, however, you can only transfer data to one item in this list
- *       at a time. Amazon AppFlow does not currently support flows to multiple destinations at once. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AppflowClient, CreateFlowCommand } from "@aws-sdk/client-appflow"; // ES Modules import
- * // const { AppflowClient, CreateFlowCommand } = require("@aws-sdk/client-appflow"); // CommonJS import
- * const client = new AppflowClient(config);
- * const command = new CreateFlowCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateFlowCommandInput} for command's `input` shape.
- * @see {@link CreateFlowCommandOutput} for command's `response` shape.
- * @see {@link AppflowClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class CreateFlowCommand extends $Command<CreateFlowCommandInput, CreateFlowCommandOutput, AppflowClientResolvedConfig> {
-    readonly input: CreateFlowCommandInput;
-    constructor(input: CreateFlowCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AppflowClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateFlowCommandInput, CreateFlowCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/DeleteFlowCommand.d.ts

@@ -1,37 +0,0 @@
-import { AppflowClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AppflowClient";
-import { DeleteFlowRequest, DeleteFlowResponse } 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 DeleteFlowCommandInput extends DeleteFlowRequest {
-}
-export interface DeleteFlowCommandOutput extends DeleteFlowResponse, __MetadataBearer {
-}
-/**
- * <p> Enables your application to delete an existing flow. Before deleting the flow, Amazon
- *       AppFlow validates the request by checking the flow configuration and status. You can delete
- *       flows one at a time. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AppflowClient, DeleteFlowCommand } from "@aws-sdk/client-appflow"; // ES Modules import
- * // const { AppflowClient, DeleteFlowCommand } = require("@aws-sdk/client-appflow"); // CommonJS import
- * const client = new AppflowClient(config);
- * const command = new DeleteFlowCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteFlowCommandInput} for command's `input` shape.
- * @see {@link DeleteFlowCommandOutput} for command's `response` shape.
- * @see {@link AppflowClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DeleteFlowCommand extends $Command<DeleteFlowCommandInput, DeleteFlowCommandOutput, AppflowClientResolvedConfig> {
-    readonly input: DeleteFlowCommandInput;
-    constructor(input: DeleteFlowCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AppflowClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteFlowCommandInput, DeleteFlowCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/DescribeConnectorEntityCommand.d.ts

@@ -1,36 +0,0 @@
-import { AppflowClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AppflowClient";
-import { DescribeConnectorEntityRequest, DescribeConnectorEntityResponse } 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 DescribeConnectorEntityCommandInput extends DescribeConnectorEntityRequest {
-}
-export interface DescribeConnectorEntityCommandOutput extends DescribeConnectorEntityResponse, __MetadataBearer {
-}
-/**
- * <p> Provides details regarding the entity used with the connector, with a description of the
- *       data model for each entity. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AppflowClient, DescribeConnectorEntityCommand } from "@aws-sdk/client-appflow"; // ES Modules import
- * // const { AppflowClient, DescribeConnectorEntityCommand } = require("@aws-sdk/client-appflow"); // CommonJS import
- * const client = new AppflowClient(config);
- * const command = new DescribeConnectorEntityCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeConnectorEntityCommandInput} for command's `input` shape.
- * @see {@link DescribeConnectorEntityCommandOutput} for command's `response` shape.
- * @see {@link AppflowClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DescribeConnectorEntityCommand extends $Command<DescribeConnectorEntityCommandInput, DescribeConnectorEntityCommandOutput, AppflowClientResolvedConfig> {
-    readonly input: DescribeConnectorEntityCommandInput;
-    constructor(input: DescribeConnectorEntityCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AppflowClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeConnectorEntityCommandInput, DescribeConnectorEntityCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/DescribeConnectorProfilesCommand.d.ts

@@ -1,39 +0,0 @@
-import { AppflowClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AppflowClient";
-import { DescribeConnectorProfilesRequest, DescribeConnectorProfilesResponse } 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 DescribeConnectorProfilesCommandInput extends DescribeConnectorProfilesRequest {
-}
-export interface DescribeConnectorProfilesCommandOutput extends DescribeConnectorProfilesResponse, __MetadataBearer {
-}
-/**
- * <p> Returns a list of <code>connector-profile</code> details matching the provided
- *         <code>connector-profile</code> names and <code>connector-types</code>. Both input lists are
- *       optional, and you can use them to filter the result. </p>
- *          <p>If no names or <code>connector-types</code> are provided, returns all connector profiles
- *       in a paginated form. If there is no match, this operation returns an empty list.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AppflowClient, DescribeConnectorProfilesCommand } from "@aws-sdk/client-appflow"; // ES Modules import
- * // const { AppflowClient, DescribeConnectorProfilesCommand } = require("@aws-sdk/client-appflow"); // CommonJS import
- * const client = new AppflowClient(config);
- * const command = new DescribeConnectorProfilesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeConnectorProfilesCommandInput} for command's `input` shape.
- * @see {@link DescribeConnectorProfilesCommandOutput} for command's `response` shape.
- * @see {@link AppflowClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DescribeConnectorProfilesCommand extends $Command<DescribeConnectorProfilesCommandInput, DescribeConnectorProfilesCommandOutput, AppflowClientResolvedConfig> {
-    readonly input: DescribeConnectorProfilesCommandInput;
-    constructor(input: DescribeConnectorProfilesCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AppflowClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeConnectorProfilesCommandInput, DescribeConnectorProfilesCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/DescribeConnectorsCommand.d.ts

@@ -1,39 +0,0 @@
-import { AppflowClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AppflowClient";
-import { DescribeConnectorsRequest, DescribeConnectorsResponse } 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 DescribeConnectorsCommandInput extends DescribeConnectorsRequest {
-}
-export interface DescribeConnectorsCommandOutput extends DescribeConnectorsResponse, __MetadataBearer {
-}
-/**
- * <p> Describes the connectors vended by Amazon AppFlow for specified connector types. If you
- *       don't specify a connector type, this operation describes all connectors vended by Amazon
- *       AppFlow. If there are more connectors than can be returned in one page, the response contains
- *       a <code>nextToken</code> object, which can be be passed in to the next call to the
- *         <code>DescribeConnectors</code> API operation to retrieve the next page. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AppflowClient, DescribeConnectorsCommand } from "@aws-sdk/client-appflow"; // ES Modules import
- * // const { AppflowClient, DescribeConnectorsCommand } = require("@aws-sdk/client-appflow"); // CommonJS import
- * const client = new AppflowClient(config);
- * const command = new DescribeConnectorsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeConnectorsCommandInput} for command's `input` shape.
- * @see {@link DescribeConnectorsCommandOutput} for command's `response` shape.
- * @see {@link AppflowClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DescribeConnectorsCommand extends $Command<DescribeConnectorsCommandInput, DescribeConnectorsCommandOutput, AppflowClientResolvedConfig> {
-    readonly input: DescribeConnectorsCommandInput;
-    constructor(input: DescribeConnectorsCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AppflowClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeConnectorsCommandInput, DescribeConnectorsCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/DescribeFlowCommand.d.ts

@@ -1,35 +0,0 @@
-import { AppflowClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AppflowClient";
-import { DescribeFlowRequest, DescribeFlowResponse } 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 DescribeFlowCommandInput extends DescribeFlowRequest {
-}
-export interface DescribeFlowCommandOutput extends DescribeFlowResponse, __MetadataBearer {
-}
-/**
- * <p> Provides a description of the specified flow. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AppflowClient, DescribeFlowCommand } from "@aws-sdk/client-appflow"; // ES Modules import
- * // const { AppflowClient, DescribeFlowCommand } = require("@aws-sdk/client-appflow"); // CommonJS import
- * const client = new AppflowClient(config);
- * const command = new DescribeFlowCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeFlowCommandInput} for command's `input` shape.
- * @see {@link DescribeFlowCommandOutput} for command's `response` shape.
- * @see {@link AppflowClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DescribeFlowCommand extends $Command<DescribeFlowCommandInput, DescribeFlowCommandOutput, AppflowClientResolvedConfig> {
-    readonly input: DescribeFlowCommandInput;
-    constructor(input: DescribeFlowCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AppflowClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeFlowCommandInput, DescribeFlowCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/ListConnectorEntitiesCommand.d.ts

@@ -1,38 +0,0 @@
-import { AppflowClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AppflowClient";
-import { ListConnectorEntitiesRequest, ListConnectorEntitiesResponse } 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 ListConnectorEntitiesCommandInput extends ListConnectorEntitiesRequest {
-}
-export interface ListConnectorEntitiesCommandOutput extends ListConnectorEntitiesResponse, __MetadataBearer {
-}
-/**
- * <p> Returns the list of available connector entities supported by Amazon AppFlow. For
- *       example, you can query Salesforce for <i>Account</i> and
- *         <i>Opportunity</i> entities, or query ServiceNow for the
- *         <i>Incident</i> entity. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AppflowClient, ListConnectorEntitiesCommand } from "@aws-sdk/client-appflow"; // ES Modules import
- * // const { AppflowClient, ListConnectorEntitiesCommand } = require("@aws-sdk/client-appflow"); // CommonJS import
- * const client = new AppflowClient(config);
- * const command = new ListConnectorEntitiesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListConnectorEntitiesCommandInput} for command's `input` shape.
- * @see {@link ListConnectorEntitiesCommandOutput} for command's `response` shape.
- * @see {@link AppflowClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class ListConnectorEntitiesCommand extends $Command<ListConnectorEntitiesCommandInput, ListConnectorEntitiesCommandOutput, AppflowClientResolvedConfig> {
-    readonly input: ListConnectorEntitiesCommandInput;
-    constructor(input: ListConnectorEntitiesCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AppflowClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListConnectorEntitiesCommandInput, ListConnectorEntitiesCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/ListFlowsCommand.d.ts

@@ -1,35 +0,0 @@
-import { AppflowClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AppflowClient";
-import { ListFlowsRequest, ListFlowsResponse } 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 ListFlowsCommandInput extends ListFlowsRequest {
-}
-export interface ListFlowsCommandOutput extends ListFlowsResponse, __MetadataBearer {
-}
-/**
- * <p> Lists all of the flows associated with your account. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AppflowClient, ListFlowsCommand } from "@aws-sdk/client-appflow"; // ES Modules import
- * // const { AppflowClient, ListFlowsCommand } = require("@aws-sdk/client-appflow"); // CommonJS import
- * const client = new AppflowClient(config);
- * const command = new ListFlowsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListFlowsCommandInput} for command's `input` shape.
- * @see {@link ListFlowsCommandOutput} for command's `response` shape.
- * @see {@link AppflowClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class ListFlowsCommand extends $Command<ListFlowsCommandInput, ListFlowsCommandOutput, AppflowClientResolvedConfig> {
-    readonly input: ListFlowsCommandInput;
-    constructor(input: ListFlowsCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AppflowClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListFlowsCommandInput, ListFlowsCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/StartFlowCommand.d.ts

@@ -1,36 +0,0 @@
-import { AppflowClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AppflowClient";
-import { StartFlowRequest, StartFlowResponse } 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 StartFlowCommandInput extends StartFlowRequest {
-}
-export interface StartFlowCommandOutput extends StartFlowResponse, __MetadataBearer {
-}
-/**
- * <p> Activates an existing flow. For on-demand flows, this operation runs the flow
- *       immediately. For schedule and event-triggered flows, this operation activates the flow. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AppflowClient, StartFlowCommand } from "@aws-sdk/client-appflow"; // ES Modules import
- * // const { AppflowClient, StartFlowCommand } = require("@aws-sdk/client-appflow"); // CommonJS import
- * const client = new AppflowClient(config);
- * const command = new StartFlowCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StartFlowCommandInput} for command's `input` shape.
- * @see {@link StartFlowCommandOutput} for command's `response` shape.
- * @see {@link AppflowClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class StartFlowCommand extends $Command<StartFlowCommandInput, StartFlowCommandOutput, AppflowClientResolvedConfig> {
-    readonly input: StartFlowCommandInput;
-    constructor(input: StartFlowCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AppflowClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartFlowCommandInput, StartFlowCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/StopFlowCommand.d.ts

@@ -1,37 +0,0 @@
-import { AppflowClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AppflowClient";
-import { StopFlowRequest, StopFlowResponse } 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 StopFlowCommandInput extends StopFlowRequest {
-}
-export interface StopFlowCommandOutput extends StopFlowResponse, __MetadataBearer {
-}
-/**
- * <p> Deactivates the existing flow. For on-demand flows, this operation returns an
- *         <code>unsupportedOperationException</code> error message. For schedule and event-triggered
- *       flows, this operation deactivates the flow. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AppflowClient, StopFlowCommand } from "@aws-sdk/client-appflow"; // ES Modules import
- * // const { AppflowClient, StopFlowCommand } = require("@aws-sdk/client-appflow"); // CommonJS import
- * const client = new AppflowClient(config);
- * const command = new StopFlowCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StopFlowCommandInput} for command's `input` shape.
- * @see {@link StopFlowCommandOutput} for command's `response` shape.
- * @see {@link AppflowClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class StopFlowCommand extends $Command<StopFlowCommandInput, StopFlowCommandOutput, AppflowClientResolvedConfig> {
-    readonly input: StopFlowCommandInput;
-    constructor(input: StopFlowCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AppflowClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StopFlowCommandInput, StopFlowCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/TagResourceCommand.d.ts

@@ -1,35 +0,0 @@
-import { AppflowClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AppflowClient";
-import { TagResourceRequest, TagResourceResponse } 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 TagResourceCommandInput extends TagResourceRequest {
-}
-export interface TagResourceCommandOutput extends TagResourceResponse, __MetadataBearer {
-}
-/**
- * <p> Applies a tag to the specified flow. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AppflowClient, TagResourceCommand } from "@aws-sdk/client-appflow"; // ES Modules import
- * // const { AppflowClient, TagResourceCommand } = require("@aws-sdk/client-appflow"); // CommonJS import
- * const client = new AppflowClient(config);
- * const command = new TagResourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link TagResourceCommandInput} for command's `input` shape.
- * @see {@link TagResourceCommandOutput} for command's `response` shape.
- * @see {@link AppflowClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class TagResourceCommand extends $Command<TagResourceCommandInput, TagResourceCommandOutput, AppflowClientResolvedConfig> {
-    readonly input: TagResourceCommandInput;
-    constructor(input: TagResourceCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AppflowClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TagResourceCommandInput, TagResourceCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/UpdateFlowCommand.d.ts

@@ -1,35 +0,0 @@
-import { AppflowClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AppflowClient";
-import { UpdateFlowRequest, UpdateFlowResponse } 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 UpdateFlowCommandInput extends UpdateFlowRequest {
-}
-export interface UpdateFlowCommandOutput extends UpdateFlowResponse, __MetadataBearer {
-}
-/**
- * <p> Updates an existing flow. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AppflowClient, UpdateFlowCommand } from "@aws-sdk/client-appflow"; // ES Modules import
- * // const { AppflowClient, UpdateFlowCommand } = require("@aws-sdk/client-appflow"); // CommonJS import
- * const client = new AppflowClient(config);
- * const command = new UpdateFlowCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateFlowCommandInput} for command's `input` shape.
- * @see {@link UpdateFlowCommandOutput} for command's `response` shape.
- * @see {@link AppflowClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class UpdateFlowCommand extends $Command<UpdateFlowCommandInput, UpdateFlowCommandOutput, AppflowClientResolvedConfig> {
-    readonly input: UpdateFlowCommandInput;
-    constructor(input: UpdateFlowCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AppflowClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateFlowCommandInput, UpdateFlowCommandOutput>;
-    private serialize;
-    private deserialize;
-}