import * as HttpClient from "effect/unstable/http/HttpClient";
import * as S from "effect/Schema";
import * as stream from "effect/Stream";
import * as API from "../client/api.ts";
import type { Credentials } from "../credentials.ts";
import type { CommonErrors } from "../errors.ts";
import type { Region } from "../region.ts";
export type TaggableResourceArn = string;
export type TagKey = string;
export type TagValue = string;
export type ErrorMessage = string;
export type WorkflowArn = string;
export type IdString = string;
export type VersionId = string;
export type TimestampValue = Date;
export type NameString = string;
export type IdempotencyTokenString = string;
export type RoleARN = string;
export type DescriptionString = string;
export type SecurityGroupString = string;
export type SubnetString = string;
export type WorkflowVersion = string;
export type IsLatestVersion = boolean;
export interface ListTagsForResourceRequest {
    ResourceArn: string;
}
export declare const ListTagsForResourceRequest: S.Schema<ListTagsForResourceRequest>;
export type Tags = {
    [key: string]: string | undefined;
};
export declare const Tags: S.$Record<S.String, S.optional<S.String>>;
export interface ListTagsForResourceResponse {
    Tags?: {
        [key: string]: string | undefined;
    };
}
export declare const ListTagsForResourceResponse: S.Schema<ListTagsForResourceResponse>;
export type ValidationExceptionReason = "unknownOperation" | "cannotParse" | "fieldValidationFailed" | "other" | (string & {});
export declare const ValidationExceptionReason: S.String;
export interface ValidationExceptionField {
    Name: string;
    Message: string;
}
export declare const ValidationExceptionField: S.Schema<ValidationExceptionField>;
export type ValidationExceptionFields = ValidationExceptionField[];
export declare const ValidationExceptionFields: S.$Array<S.Schema<ValidationExceptionField>>;
export interface TagResourceRequest {
    ResourceArn: string;
    Tags: {
        [key: string]: string | undefined;
    };
}
export declare const TagResourceRequest: S.Schema<TagResourceRequest>;
export interface TagResourceResponse {
}
export declare const TagResourceResponse: S.Schema<TagResourceResponse>;
export type TagKeys = string[];
export declare const TagKeys: S.$Array<S.String>;
export interface UntagResourceRequest {
    ResourceArn: string;
    TagKeys: string[];
}
export declare const UntagResourceRequest: S.Schema<UntagResourceRequest>;
export interface UntagResourceResponse {
}
export declare const UntagResourceResponse: S.Schema<UntagResourceResponse>;
export interface GetTaskInstanceRequest {
    WorkflowArn: string;
    TaskInstanceId: string;
    RunId: string;
}
export declare const GetTaskInstanceRequest: S.Schema<GetTaskInstanceRequest>;
export type TaskInstanceStatus = "QUEUED" | "FAILED" | "SCHEDULED" | "RUNNING" | "SUCCESS" | "UP_FOR_RESCHEDULE" | "UP_FOR_RETRY" | "UPSTREAM_FAILED" | "REMOVED" | "RESTARTING" | "DEFERRED" | "NONE" | "CANCELLED" | "TIMEOUT" | (string & {});
export declare const TaskInstanceStatus: S.String;
export type GenericMap = {
    [key: string]: string | undefined;
};
export declare const GenericMap: S.$Record<S.String, S.optional<S.String>>;
export interface GetTaskInstanceResponse {
    WorkflowArn: string;
    RunId: string;
    TaskInstanceId: string;
    WorkflowVersion?: string;
    Status?: TaskInstanceStatus;
    DurationInSeconds?: number;
    OperatorName?: string;
    ModifiedAt?: Date;
    EndedAt?: Date;
    StartedAt?: Date;
    AttemptNumber?: number;
    ErrorMessage?: string;
    TaskId?: string;
    LogStream?: string;
    Xcom?: {
        [key: string]: string | undefined;
    };
}
export declare const GetTaskInstanceResponse: S.Schema<GetTaskInstanceResponse>;
export interface ListTaskInstancesRequest {
    WorkflowArn: string;
    RunId: string;
    MaxResults?: number;
    NextToken?: string;
}
export declare const ListTaskInstancesRequest: S.Schema<ListTaskInstancesRequest>;
export interface TaskInstanceSummary {
    WorkflowArn?: string;
    WorkflowVersion?: string;
    RunId?: string;
    TaskInstanceId?: string;
    Status?: TaskInstanceStatus;
    DurationInSeconds?: number;
    OperatorName?: string;
}
export declare const TaskInstanceSummary: S.Schema<TaskInstanceSummary>;
export type TaskInstanceSummaries = TaskInstanceSummary[];
export declare const TaskInstanceSummaries: S.$Array<S.Schema<TaskInstanceSummary>>;
export interface ListTaskInstancesResponse {
    TaskInstances?: TaskInstanceSummary[];
    NextToken?: string;
}
export declare const ListTaskInstancesResponse: S.Schema<ListTaskInstancesResponse>;
export interface DefinitionS3Location {
    Bucket: string;
    ObjectKey: string;
    VersionId?: string;
}
export declare const DefinitionS3Location: S.Schema<DefinitionS3Location>;
export type EncryptionType = "AWS_MANAGED_KEY" | "CUSTOMER_MANAGED_KEY" | (string & {});
export declare const EncryptionType: S.String;
export interface EncryptionConfiguration {
    Type: EncryptionType;
    KmsKeyId?: string;
}
export declare const EncryptionConfiguration: S.Schema<EncryptionConfiguration>;
export interface LoggingConfiguration {
    LogGroupName: string;
}
export declare const LoggingConfiguration: S.Schema<LoggingConfiguration>;
export type EngineVersion = 1;
export declare const EngineVersion: S.Literals<readonly [1]>;
export type SecurityGroupIds = string[];
export declare const SecurityGroupIds: S.$Array<S.String>;
export type SubnetIds = string[];
export declare const SubnetIds: S.$Array<S.String>;
export interface NetworkConfiguration {
    SecurityGroupIds?: string[];
    SubnetIds?: string[];
}
export declare const NetworkConfiguration: S.Schema<NetworkConfiguration>;
export interface CreateWorkflowRequest {
    Name: string;
    ClientToken?: string;
    DefinitionS3Location: DefinitionS3Location;
    RoleArn: string;
    Description?: string;
    EncryptionConfiguration?: EncryptionConfiguration;
    LoggingConfiguration?: LoggingConfiguration;
    EngineVersion?: EngineVersion;
    NetworkConfiguration?: NetworkConfiguration;
    Tags?: {
        [key: string]: string | undefined;
    };
    TriggerMode?: string;
}
export declare const CreateWorkflowRequest: S.Schema<CreateWorkflowRequest>;
export type WorkflowStatus = "READY" | "DELETING" | (string & {});
export declare const WorkflowStatus: S.String;
export type WarningMessages = string[];
export declare const WarningMessages: S.$Array<S.String>;
export interface CreateWorkflowResponse {
    WorkflowArn: string;
    CreatedAt?: Date;
    RevisionId?: string;
    WorkflowStatus?: WorkflowStatus;
    WorkflowVersion?: string;
    IsLatestVersion?: boolean;
    Warnings?: string[];
}
export declare const CreateWorkflowResponse: S.Schema<CreateWorkflowResponse>;
export interface GetWorkflowRequest {
    WorkflowArn: string;
    WorkflowVersion?: string;
}
export declare const GetWorkflowRequest: S.Schema<GetWorkflowRequest>;
export interface ScheduleConfiguration {
    CronExpression?: string;
}
export declare const ScheduleConfiguration: S.Schema<ScheduleConfiguration>;
export interface GetWorkflowResponse {
    WorkflowArn: string;
    WorkflowVersion?: string;
    Name?: string;
    Description?: string;
    CreatedAt?: Date;
    ModifiedAt?: Date;
    EncryptionConfiguration?: EncryptionConfiguration;
    LoggingConfiguration?: LoggingConfiguration;
    EngineVersion?: EngineVersion;
    WorkflowStatus?: WorkflowStatus;
    DefinitionS3Location?: DefinitionS3Location;
    ScheduleConfiguration?: ScheduleConfiguration;
    RoleArn?: string;
    NetworkConfiguration?: NetworkConfiguration;
    TriggerMode?: string;
    WorkflowDefinition?: string;
}
export declare const GetWorkflowResponse: S.Schema<GetWorkflowResponse>;
export interface UpdateWorkflowRequest {
    WorkflowArn: string;
    DefinitionS3Location: DefinitionS3Location;
    RoleArn: string;
    Description?: string;
    LoggingConfiguration?: LoggingConfiguration;
    EngineVersion?: EngineVersion;
    NetworkConfiguration?: NetworkConfiguration;
    TriggerMode?: string;
}
export declare const UpdateWorkflowRequest: S.Schema<UpdateWorkflowRequest>;
export interface UpdateWorkflowResponse {
    WorkflowArn: string;
    ModifiedAt?: Date;
    WorkflowVersion?: string;
    Warnings?: string[];
}
export declare const UpdateWorkflowResponse: S.Schema<UpdateWorkflowResponse>;
export interface DeleteWorkflowRequest {
    WorkflowArn: string;
    WorkflowVersion?: string;
}
export declare const DeleteWorkflowRequest: S.Schema<DeleteWorkflowRequest>;
export interface DeleteWorkflowResponse {
    WorkflowArn: string;
    WorkflowVersion?: string;
}
export declare const DeleteWorkflowResponse: S.Schema<DeleteWorkflowResponse>;
export interface ListWorkflowsRequest {
    MaxResults?: number;
    NextToken?: string;
}
export declare const ListWorkflowsRequest: S.Schema<ListWorkflowsRequest>;
export interface WorkflowSummary {
    WorkflowArn: string;
    WorkflowVersion?: string;
    Name?: string;
    Description?: string;
    CreatedAt?: Date;
    ModifiedAt?: Date;
    WorkflowStatus?: WorkflowStatus;
    TriggerMode?: string;
}
export declare const WorkflowSummary: S.Schema<WorkflowSummary>;
export type WorkflowSummaries = WorkflowSummary[];
export declare const WorkflowSummaries: S.$Array<S.Schema<WorkflowSummary>>;
export interface ListWorkflowsResponse {
    Workflows: WorkflowSummary[];
    NextToken?: string;
}
export declare const ListWorkflowsResponse: S.Schema<ListWorkflowsResponse>;
export type ObjectMap = {
    [key: string]: any | undefined;
};
export declare const ObjectMap: S.$Record<S.String, S.optional<S.Any>>;
export interface StartWorkflowRunRequest {
    WorkflowArn: string;
    ClientToken?: string;
    OverrideParameters?: {
        [key: string]: any | undefined;
    };
    WorkflowVersion?: string;
}
export declare const StartWorkflowRunRequest: S.Schema<StartWorkflowRunRequest>;
export type WorkflowRunStatus = "STARTING" | "QUEUED" | "RUNNING" | "SUCCESS" | "FAILED" | "TIMEOUT" | "STOPPING" | "STOPPED" | (string & {});
export declare const WorkflowRunStatus: S.String;
export interface StartWorkflowRunResponse {
    RunId?: string;
    Status?: WorkflowRunStatus;
    StartedAt?: Date;
}
export declare const StartWorkflowRunResponse: S.Schema<StartWorkflowRunResponse>;
export interface GetWorkflowRunRequest {
    WorkflowArn: string;
    RunId: string;
}
export declare const GetWorkflowRunRequest: S.Schema<GetWorkflowRunRequest>;
export type RunType = "ON_DEMAND" | "SCHEDULED" | (string & {});
export declare const RunType: S.String;
export type TaskInstanceIds = string[];
export declare const TaskInstanceIds: S.$Array<S.String>;
export interface WorkflowRunDetail {
    WorkflowArn?: string;
    WorkflowVersion?: string;
    RunId?: string;
    RunType?: RunType;
    StartedOn?: Date;
    CreatedAt?: Date;
    CompletedOn?: Date;
    ModifiedAt?: Date;
    Duration?: number;
    ErrorMessage?: string;
    TaskInstances?: string[];
    RunState?: WorkflowRunStatus;
}
export declare const WorkflowRunDetail: S.Schema<WorkflowRunDetail>;
export interface GetWorkflowRunResponse {
    WorkflowArn?: string;
    WorkflowVersion?: string;
    RunId?: string;
    RunType?: RunType;
    OverrideParameters?: {
        [key: string]: any | undefined;
    };
    RunDetail?: WorkflowRunDetail;
}
export declare const GetWorkflowRunResponse: S.Schema<GetWorkflowRunResponse>;
export interface StopWorkflowRunRequest {
    WorkflowArn: string;
    RunId: string;
}
export declare const StopWorkflowRunRequest: S.Schema<StopWorkflowRunRequest>;
export interface StopWorkflowRunResponse {
    WorkflowArn?: string;
    WorkflowVersion?: string;
    RunId?: string;
    Status?: WorkflowRunStatus;
}
export declare const StopWorkflowRunResponse: S.Schema<StopWorkflowRunResponse>;
export interface ListWorkflowRunsRequest {
    MaxResults?: number;
    NextToken?: string;
    WorkflowArn: string;
    WorkflowVersion?: string;
}
export declare const ListWorkflowRunsRequest: S.Schema<ListWorkflowRunsRequest>;
export interface RunDetailSummary {
    Status?: WorkflowRunStatus;
    CreatedOn?: Date;
    StartedAt?: Date;
    EndedAt?: Date;
}
export declare const RunDetailSummary: S.Schema<RunDetailSummary>;
export interface WorkflowRunSummary {
    RunId?: string;
    WorkflowArn?: string;
    WorkflowVersion?: string;
    RunType?: RunType;
    RunDetailSummary?: RunDetailSummary;
}
export declare const WorkflowRunSummary: S.Schema<WorkflowRunSummary>;
export type WorkflowRunSummaries = WorkflowRunSummary[];
export declare const WorkflowRunSummaries: S.$Array<S.Schema<WorkflowRunSummary>>;
export interface ListWorkflowRunsResponse {
    WorkflowRuns?: WorkflowRunSummary[];
    NextToken?: string;
}
export declare const ListWorkflowRunsResponse: S.Schema<ListWorkflowRunsResponse>;
export interface ListWorkflowVersionsRequest {
    MaxResults?: number;
    NextToken?: string;
    WorkflowArn: string;
}
export declare const ListWorkflowVersionsRequest: S.Schema<ListWorkflowVersionsRequest>;
export interface WorkflowVersionSummary {
    WorkflowVersion: string;
    WorkflowArn: string;
    IsLatestVersion?: boolean;
    CreatedAt?: Date;
    ModifiedAt?: Date;
    DefinitionS3Location?: DefinitionS3Location;
    ScheduleConfiguration?: ScheduleConfiguration;
    TriggerMode?: string;
}
export declare const WorkflowVersionSummary: S.Schema<WorkflowVersionSummary>;
export type WorkflowVersionSummaries = WorkflowVersionSummary[];
export declare const WorkflowVersionSummaries: S.$Array<S.Schema<WorkflowVersionSummary>>;
export interface ListWorkflowVersionsResponse {
    WorkflowVersions?: WorkflowVersionSummary[];
    NextToken?: string;
}
export declare const ListWorkflowVersionsResponse: S.Schema<ListWorkflowVersionsResponse>;
declare const AccessDeniedException_base: S.Class<AccessDeniedException, S.TaggedStruct<"AccessDeniedException", {
    readonly Message: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        AuthError: true;
    };
});
export declare class AccessDeniedException extends AccessDeniedException_base {
}
declare const InternalServerException_base: S.Class<InternalServerException, S.TaggedStruct<"InternalServerException", {
    readonly Message: S.String;
    readonly RetryAfterSeconds: S.optional<S.Number>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ServerError: true;
    };
}) & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        RetryableError: true;
    };
});
export declare class InternalServerException extends InternalServerException_base {
}
declare const OperationTimeoutException_base: S.Class<OperationTimeoutException, S.TaggedStruct<"OperationTimeoutException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        TimeoutError: true;
    };
});
export declare class OperationTimeoutException extends OperationTimeoutException_base {
}
declare const ResourceNotFoundException_base: S.Class<ResourceNotFoundException, S.TaggedStruct<"ResourceNotFoundException", {
    readonly Message: S.String;
    readonly ResourceId: S.String;
    readonly ResourceType: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class ResourceNotFoundException extends ResourceNotFoundException_base {
}
declare const ThrottlingException_base: S.Class<ThrottlingException, S.TaggedStruct<"ThrottlingException", {
    readonly Message: S.String;
    readonly ServiceCode: S.String;
    readonly QuotaCode: S.String;
    readonly RetryAfterSeconds: S.optional<S.Number>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ThrottlingError: true;
    };
}) & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        RetryableError: true;
    };
});
export declare class ThrottlingException extends ThrottlingException_base {
}
declare const ValidationException_base: S.Class<ValidationException, S.TaggedStruct<"ValidationException", {
    readonly Message: S.String;
    readonly Reason: S.String;
    readonly FieldList: S.optional<S.$Array<S.Schema<ValidationExceptionField>>>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class ValidationException extends ValidationException_base {
}
declare const ConflictException_base: S.Class<ConflictException, S.TaggedStruct<"ConflictException", {
    readonly Message: S.String;
    readonly ResourceId: S.String;
    readonly ResourceType: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ConflictError: true;
    };
});
export declare class ConflictException extends ConflictException_base {
}
declare const ServiceQuotaExceededException_base: S.Class<ServiceQuotaExceededException, S.TaggedStruct<"ServiceQuotaExceededException", {
    readonly Message: S.String;
    readonly ResourceId: S.String;
    readonly ResourceType: S.String;
    readonly ServiceCode: S.String;
    readonly QuotaCode: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        QuotaError: true;
    };
});
export declare class ServiceQuotaExceededException extends ServiceQuotaExceededException_base {
}
export type ListTagsForResourceError = AccessDeniedException | InternalServerException | OperationTimeoutException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Lists all tags that are associated with a specified Amazon Managed Workflows for Apache Airflow Serverless resource.
 */
export declare const listTagsForResource: API.OperationMethod<ListTagsForResourceRequest, ListTagsForResourceResponse, ListTagsForResourceError, Credentials | Region | HttpClient.HttpClient>;
export type TagResourceError = AccessDeniedException | InternalServerException | OperationTimeoutException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Adds tags to an Amazon Managed Workflows for Apache Airflow Serverless resource. Tags are key-value pairs that help you organize and categorize your resources.
 */
export declare const tagResource: API.OperationMethod<TagResourceRequest, TagResourceResponse, TagResourceError, Credentials | Region | HttpClient.HttpClient>;
export type UntagResourceError = AccessDeniedException | InternalServerException | OperationTimeoutException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Removes tags from an Amazon Managed Workflows for Apache Airflow Serverless resource. This operation removes the specified tags from the resource.
 */
export declare const untagResource: API.OperationMethod<UntagResourceRequest, UntagResourceResponse, UntagResourceError, Credentials | Region | HttpClient.HttpClient>;
export type GetTaskInstanceError = AccessDeniedException | InternalServerException | OperationTimeoutException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Retrieves detailed information about a specific task instance within a workflow run. Task instances represent individual tasks that are executed as part of a workflow in the Amazon Managed Workflows for Apache Airflow Serverless environment. Each task instance runs in an isolated ECS container with dedicated resources and security boundaries. The service tracks task execution state, retry attempts, and provides detailed timing and error information for troubleshooting and monitoring purposes.
 */
export declare const getTaskInstance: API.OperationMethod<GetTaskInstanceRequest, GetTaskInstanceResponse, GetTaskInstanceError, Credentials | Region | HttpClient.HttpClient>;
export type ListTaskInstancesError = AccessDeniedException | InternalServerException | OperationTimeoutException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Lists all task instances for a specific workflow run, with optional pagination support.
 */
export declare const listTaskInstances: API.OperationMethod<ListTaskInstancesRequest, ListTaskInstancesResponse, ListTaskInstancesError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListTaskInstancesRequest) => stream.Stream<ListTaskInstancesResponse, ListTaskInstancesError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListTaskInstancesRequest) => stream.Stream<TaskInstanceSummary, ListTaskInstancesError, Credentials | Region | HttpClient.HttpClient>;
};
export type CreateWorkflowError = AccessDeniedException | ConflictException | InternalServerException | OperationTimeoutException | ServiceQuotaExceededException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Creates a new workflow in Amazon Managed Workflows for Apache Airflow Serverless. This operation initializes a workflow with the specified configuration including the workflow definition, execution role, and optional settings for encryption, logging, and networking. You must provide the workflow definition as a YAML file stored in Amazon S3 that defines the DAG structure using supported Amazon Web Services operators. Amazon Managed Workflows for Apache Airflow Serverless automatically creates the first version of the workflow and sets up the necessary execution environment with multi-tenant isolation and security controls.
 */
export declare const createWorkflow: API.OperationMethod<CreateWorkflowRequest, CreateWorkflowResponse, CreateWorkflowError, Credentials | Region | HttpClient.HttpClient>;
export type GetWorkflowError = AccessDeniedException | InternalServerException | OperationTimeoutException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Retrieves detailed information about a workflow, including its configuration, status, and metadata.
 */
export declare const getWorkflow: API.OperationMethod<GetWorkflowRequest, GetWorkflowResponse, GetWorkflowError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateWorkflowError = AccessDeniedException | ConflictException | InternalServerException | OperationTimeoutException | ResourceNotFoundException | ServiceQuotaExceededException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Updates an existing workflow with new configuration settings. This operation allows you to modify the workflow definition, role, and other settings. When you update a workflow, Amazon Managed Workflows for Apache Airflow Serverless automatically creates a new version with the updated configuration and disables scheduling on all previous versions to ensure only one version is actively scheduled at a time. The update operation maintains workflow history while providing a clean transition to the new configuration.
 */
export declare const updateWorkflow: API.OperationMethod<UpdateWorkflowRequest, UpdateWorkflowResponse, UpdateWorkflowError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteWorkflowError = AccessDeniedException | InternalServerException | OperationTimeoutException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Deletes a workflow and all its versions. This operation permanently removes the workflow and cannot be undone. Amazon Managed Workflows for Apache Airflow Serverless ensures that all associated resources are properly cleaned up, including stopping any running executions, removing scheduled triggers, and cleaning up execution history. The deletion process respects the multi-tenant isolation boundaries and ensures that no residual data or configurations remain that could affect other customers or workflows.
 */
export declare const deleteWorkflow: API.OperationMethod<DeleteWorkflowRequest, DeleteWorkflowResponse, DeleteWorkflowError, Credentials | Region | HttpClient.HttpClient>;
export type ListWorkflowsError = AccessDeniedException | InternalServerException | OperationTimeoutException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Lists all workflows in your account, with optional pagination support. This operation returns summary information for workflows, showing only the most recently created version of each workflow. Amazon Managed Workflows for Apache Airflow Serverless maintains workflow metadata in a highly available, distributed storage system that enables efficient querying and filtering. The service implements proper access controls to ensure you can only view workflows that you have permissions to access, supporting both individual and team-based workflow management scenarios.
 */
export declare const listWorkflows: API.OperationMethod<ListWorkflowsRequest, ListWorkflowsResponse, ListWorkflowsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListWorkflowsRequest) => stream.Stream<ListWorkflowsResponse, ListWorkflowsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListWorkflowsRequest) => stream.Stream<WorkflowSummary, ListWorkflowsError, Credentials | Region | HttpClient.HttpClient>;
};
export type StartWorkflowRunError = AccessDeniedException | ConflictException | InternalServerException | OperationTimeoutException | ResourceNotFoundException | ServiceQuotaExceededException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Starts a new execution of a workflow. This operation creates a workflow run that executes the tasks that are defined in the workflow. Amazon Managed Workflows for Apache Airflow Serverless schedules the workflow execution across its managed Airflow environment, automatically scaling ECS worker tasks based on the workload. The service handles task isolation, dependency resolution, and provides comprehensive monitoring and logging throughout the execution lifecycle.
 */
export declare const startWorkflowRun: API.OperationMethod<StartWorkflowRunRequest, StartWorkflowRunResponse, StartWorkflowRunError, Credentials | Region | HttpClient.HttpClient>;
export type GetWorkflowRunError = AccessDeniedException | InternalServerException | OperationTimeoutException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Retrieves detailed information about a specific workflow run, including its status, execution details, and task instances.
 */
export declare const getWorkflowRun: API.OperationMethod<GetWorkflowRunRequest, GetWorkflowRunResponse, GetWorkflowRunError, Credentials | Region | HttpClient.HttpClient>;
export type StopWorkflowRunError = AccessDeniedException | InternalServerException | OperationTimeoutException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Stops a running workflow execution. This operation terminates all running tasks and prevents new tasks from starting. Amazon Managed Workflows for Apache Airflow Serverless gracefully shuts down the workflow execution by stopping task scheduling and terminating active ECS worker containers. The operation transitions the workflow run to a `STOPPING` state and then to `STOPPED` once all cleanup is complete. In-flight tasks may complete or be terminated depending on their current execution state.
 */
export declare const stopWorkflowRun: API.OperationMethod<StopWorkflowRunRequest, StopWorkflowRunResponse, StopWorkflowRunError, Credentials | Region | HttpClient.HttpClient>;
export type ListWorkflowRunsError = AccessDeniedException | InternalServerException | OperationTimeoutException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Lists all runs for a specified workflow, with optional pagination and filtering support.
 */
export declare const listWorkflowRuns: API.OperationMethod<ListWorkflowRunsRequest, ListWorkflowRunsResponse, ListWorkflowRunsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListWorkflowRunsRequest) => stream.Stream<ListWorkflowRunsResponse, ListWorkflowRunsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListWorkflowRunsRequest) => stream.Stream<WorkflowRunSummary, ListWorkflowRunsError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListWorkflowVersionsError = AccessDeniedException | InternalServerException | OperationTimeoutException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Lists all versions of a specified workflow, with optional pagination support.
 */
export declare const listWorkflowVersions: API.OperationMethod<ListWorkflowVersionsRequest, ListWorkflowVersionsResponse, ListWorkflowVersionsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListWorkflowVersionsRequest) => stream.Stream<ListWorkflowVersionsResponse, ListWorkflowVersionsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListWorkflowVersionsRequest) => stream.Stream<WorkflowVersionSummary, ListWorkflowVersionsError, Credentials | Region | HttpClient.HttpClient>;
};
export {};
//# sourceMappingURL=mwaa-serverless.d.ts.map