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 __timestampIso8601 = Date;
export type MaxResults = number;
export type __integerMin5Max100 = number;
export type AuthenticationStrategy = "SIMPLE" | "LDAP" | "CONFIG_MANAGED" | (string & {});
export declare const AuthenticationStrategy: S.String;
export interface ConfigurationId {
    Id?: string;
    Revision?: number;
}
export declare const ConfigurationId: S.Schema<ConfigurationId>;
export type DeploymentMode = "SINGLE_INSTANCE" | "ACTIVE_STANDBY_MULTI_AZ" | "CLUSTER_MULTI_AZ" | (string & {});
export declare const DeploymentMode: S.String;
export interface EncryptionOptions {
    KmsKeyId?: string;
    UseAwsOwnedKey?: boolean;
}
export declare const EncryptionOptions: S.Schema<EncryptionOptions>;
export type EngineType = "ACTIVEMQ" | "RABBITMQ" | (string & {});
export declare const EngineType: S.String;
export type __listOf__string = string[];
export declare const __listOf__string: S.$Array<S.String>;
export interface LdapServerMetadataInput {
    Hosts?: string[];
    RoleBase?: string;
    RoleName?: string;
    RoleSearchMatching?: string;
    RoleSearchSubtree?: boolean;
    ServiceAccountPassword?: string;
    ServiceAccountUsername?: string;
    UserBase?: string;
    UserRoleName?: string;
    UserSearchMatching?: string;
    UserSearchSubtree?: boolean;
}
export declare const LdapServerMetadataInput: S.Schema<LdapServerMetadataInput>;
export interface Logs {
    Audit?: boolean;
    General?: boolean;
}
export declare const Logs: S.Schema<Logs>;
export type DayOfWeek = "MONDAY" | "TUESDAY" | "WEDNESDAY" | "THURSDAY" | "FRIDAY" | "SATURDAY" | "SUNDAY" | (string & {});
export declare const DayOfWeek: S.String;
export interface WeeklyStartTime {
    DayOfWeek?: DayOfWeek;
    TimeOfDay?: string;
    TimeZone?: string;
}
export declare const WeeklyStartTime: S.Schema<WeeklyStartTime>;
export type BrokerStorageType = "EBS" | "EFS" | (string & {});
export declare const BrokerStorageType: S.String;
export type __mapOf__string = {
    [key: string]: string | undefined;
};
export declare const __mapOf__string: S.$Record<S.String, S.optional<S.String>>;
export interface User {
    ConsoleAccess?: boolean;
    Groups?: string[];
    Password?: string;
    Username?: string;
    ReplicationUser?: boolean;
}
export declare const User: S.Schema<User>;
export type __listOfUser = User[];
export declare const __listOfUser: S.$Array<S.Schema<User>>;
export type DataReplicationMode = "NONE" | "CRDR" | (string & {});
export declare const DataReplicationMode: S.String;
export interface CreateBrokerRequest {
    AuthenticationStrategy?: AuthenticationStrategy;
    AutoMinorVersionUpgrade?: boolean;
    BrokerName?: string;
    Configuration?: ConfigurationId;
    CreatorRequestId?: string;
    DeploymentMode?: DeploymentMode;
    EncryptionOptions?: EncryptionOptions;
    EngineType?: EngineType;
    EngineVersion?: string;
    HostInstanceType?: string;
    LdapServerMetadata?: LdapServerMetadataInput;
    Logs?: Logs;
    MaintenanceWindowStartTime?: WeeklyStartTime;
    PubliclyAccessible?: boolean;
    SecurityGroups?: string[];
    StorageType?: BrokerStorageType;
    SubnetIds?: string[];
    Tags?: {
        [key: string]: string | undefined;
    };
    Users?: User[];
    DataReplicationMode?: DataReplicationMode;
    DataReplicationPrimaryBrokerArn?: string;
}
export declare const CreateBrokerRequest: S.Schema<CreateBrokerRequest>;
export interface CreateBrokerResponse {
    BrokerArn?: string;
    BrokerId?: string;
}
export declare const CreateBrokerResponse: S.Schema<CreateBrokerResponse>;
export interface CreateConfigurationRequest {
    AuthenticationStrategy?: AuthenticationStrategy;
    EngineType?: EngineType;
    EngineVersion?: string;
    Name?: string;
    Tags?: {
        [key: string]: string | undefined;
    };
}
export declare const CreateConfigurationRequest: S.Schema<CreateConfigurationRequest>;
export interface ConfigurationRevision {
    Created?: Date;
    Description?: string;
    Revision?: number;
}
export declare const ConfigurationRevision: S.Schema<ConfigurationRevision>;
export interface CreateConfigurationResponse {
    Arn?: string;
    AuthenticationStrategy?: AuthenticationStrategy;
    Created?: Date;
    Id?: string;
    LatestRevision?: ConfigurationRevision & {
        Created: __timestampIso8601;
        Revision: number;
    };
    Name?: string;
}
export declare const CreateConfigurationResponse: S.Schema<CreateConfigurationResponse>;
export interface CreateTagsRequest {
    ResourceArn: string;
    Tags?: {
        [key: string]: string | undefined;
    };
}
export declare const CreateTagsRequest: S.Schema<CreateTagsRequest>;
export interface CreateTagsResponse {
}
export declare const CreateTagsResponse: S.Schema<CreateTagsResponse>;
export interface CreateUserRequest {
    BrokerId: string;
    ConsoleAccess?: boolean;
    Groups?: string[];
    Password?: string;
    Username: string;
    ReplicationUser?: boolean;
}
export declare const CreateUserRequest: S.Schema<CreateUserRequest>;
export interface CreateUserResponse {
}
export declare const CreateUserResponse: S.Schema<CreateUserResponse>;
export interface DeleteBrokerRequest {
    BrokerId: string;
}
export declare const DeleteBrokerRequest: S.Schema<DeleteBrokerRequest>;
export interface DeleteBrokerResponse {
    BrokerId?: string;
}
export declare const DeleteBrokerResponse: S.Schema<DeleteBrokerResponse>;
export interface DeleteConfigurationRequest {
    ConfigurationId: string;
}
export declare const DeleteConfigurationRequest: S.Schema<DeleteConfigurationRequest>;
export interface DeleteConfigurationResponse {
    ConfigurationId?: string;
}
export declare const DeleteConfigurationResponse: S.Schema<DeleteConfigurationResponse>;
export interface DeleteTagsRequest {
    ResourceArn: string;
    TagKeys?: string[];
}
export declare const DeleteTagsRequest: S.Schema<DeleteTagsRequest>;
export interface DeleteTagsResponse {
}
export declare const DeleteTagsResponse: S.Schema<DeleteTagsResponse>;
export interface DeleteUserRequest {
    BrokerId: string;
    Username: string;
}
export declare const DeleteUserRequest: S.Schema<DeleteUserRequest>;
export interface DeleteUserResponse {
}
export declare const DeleteUserResponse: S.Schema<DeleteUserResponse>;
export interface DescribeBrokerRequest {
    BrokerId: string;
}
export declare const DescribeBrokerRequest: S.Schema<DescribeBrokerRequest>;
export interface ActionRequired {
    ActionRequiredCode?: string;
    ActionRequiredInfo?: string;
}
export declare const ActionRequired: S.Schema<ActionRequired>;
export type __listOfActionRequired = ActionRequired[];
export declare const __listOfActionRequired: S.$Array<S.Schema<ActionRequired>>;
export interface BrokerInstance {
    ConsoleURL?: string;
    Endpoints?: string[];
    IpAddress?: string;
}
export declare const BrokerInstance: S.Schema<BrokerInstance>;
export type __listOfBrokerInstance = BrokerInstance[];
export declare const __listOfBrokerInstance: S.$Array<S.Schema<BrokerInstance>>;
export type BrokerState = "CREATION_IN_PROGRESS" | "CREATION_FAILED" | "DELETION_IN_PROGRESS" | "RUNNING" | "REBOOT_IN_PROGRESS" | "CRITICAL_ACTION_REQUIRED" | "REPLICA" | (string & {});
export declare const BrokerState: S.String;
export type __listOfConfigurationId = ConfigurationId[];
export declare const __listOfConfigurationId: S.$Array<S.Schema<ConfigurationId>>;
export interface Configurations {
    Current?: ConfigurationId;
    History?: ConfigurationId[];
    Pending?: ConfigurationId;
}
export declare const Configurations: S.Schema<Configurations>;
export interface LdapServerMetadataOutput {
    Hosts?: string[];
    RoleBase?: string;
    RoleName?: string;
    RoleSearchMatching?: string;
    RoleSearchSubtree?: boolean;
    ServiceAccountUsername?: string;
    UserBase?: string;
    UserRoleName?: string;
    UserSearchMatching?: string;
    UserSearchSubtree?: boolean;
}
export declare const LdapServerMetadataOutput: S.Schema<LdapServerMetadataOutput>;
export interface PendingLogs {
    Audit?: boolean;
    General?: boolean;
}
export declare const PendingLogs: S.Schema<PendingLogs>;
export interface LogsSummary {
    Audit?: boolean;
    AuditLogGroup?: string;
    General?: boolean;
    GeneralLogGroup?: string;
    Pending?: PendingLogs;
}
export declare const LogsSummary: S.Schema<LogsSummary>;
export type ChangeType = "CREATE" | "UPDATE" | "DELETE" | (string & {});
export declare const ChangeType: S.String;
export interface UserSummary {
    PendingChange?: ChangeType;
    Username?: string;
}
export declare const UserSummary: S.Schema<UserSummary>;
export type __listOfUserSummary = UserSummary[];
export declare const __listOfUserSummary: S.$Array<S.Schema<UserSummary>>;
export interface DataReplicationCounterpart {
    BrokerId?: string;
    Region?: string;
}
export declare const DataReplicationCounterpart: S.Schema<DataReplicationCounterpart>;
export interface DataReplicationMetadataOutput {
    DataReplicationCounterpart?: DataReplicationCounterpart;
    DataReplicationRole?: string;
}
export declare const DataReplicationMetadataOutput: S.Schema<DataReplicationMetadataOutput>;
export interface DescribeBrokerResponse {
    ActionsRequired?: ActionRequired[];
    AuthenticationStrategy?: AuthenticationStrategy;
    AutoMinorVersionUpgrade?: boolean;
    BrokerArn?: string;
    BrokerId?: string;
    BrokerInstances?: BrokerInstance[];
    BrokerName?: string;
    BrokerState?: BrokerState;
    Configurations?: Configurations & {
        Current: ConfigurationId & {
            Id: string;
        };
        History: (ConfigurationId & {
            Id: string;
        })[];
        Pending: ConfigurationId & {
            Id: string;
        };
    };
    Created?: Date;
    DeploymentMode?: DeploymentMode;
    EncryptionOptions?: EncryptionOptions & {
        UseAwsOwnedKey: boolean;
    };
    EngineType?: EngineType;
    EngineVersion?: string;
    HostInstanceType?: string;
    LdapServerMetadata?: LdapServerMetadataOutput & {
        Hosts: __listOf__string;
        RoleBase: string;
        RoleSearchMatching: string;
        ServiceAccountUsername: string;
        UserBase: string;
        UserSearchMatching: string;
    };
    Logs?: LogsSummary & {
        General: boolean;
        GeneralLogGroup: string;
    };
    MaintenanceWindowStartTime?: WeeklyStartTime & {
        DayOfWeek: DayOfWeek;
        TimeOfDay: string;
    };
    PendingAuthenticationStrategy?: AuthenticationStrategy;
    PendingEngineVersion?: string;
    PendingHostInstanceType?: string;
    PendingLdapServerMetadata?: LdapServerMetadataOutput & {
        Hosts: __listOf__string;
        RoleBase: string;
        RoleSearchMatching: string;
        ServiceAccountUsername: string;
        UserBase: string;
        UserSearchMatching: string;
    };
    PendingSecurityGroups?: string[];
    PubliclyAccessible?: boolean;
    SecurityGroups?: string[];
    StorageType?: BrokerStorageType;
    SubnetIds?: string[];
    Tags?: {
        [key: string]: string | undefined;
    };
    Users?: (UserSummary & {
        Username: string;
    })[];
    DataReplicationMetadata?: DataReplicationMetadataOutput & {
        DataReplicationRole: string;
        DataReplicationCounterpart: DataReplicationCounterpart & {
            BrokerId: string;
            Region: string;
        };
    };
    DataReplicationMode?: DataReplicationMode;
    PendingDataReplicationMetadata?: DataReplicationMetadataOutput & {
        DataReplicationRole: string;
        DataReplicationCounterpart: DataReplicationCounterpart & {
            BrokerId: string;
            Region: string;
        };
    };
    PendingDataReplicationMode?: DataReplicationMode;
}
export declare const DescribeBrokerResponse: S.Schema<DescribeBrokerResponse>;
export interface DescribeBrokerEngineTypesRequest {
    EngineType?: string;
    MaxResults?: number;
    NextToken?: string;
}
export declare const DescribeBrokerEngineTypesRequest: S.Schema<DescribeBrokerEngineTypesRequest>;
export interface EngineVersion {
    Name?: string;
}
export declare const EngineVersion: S.Schema<EngineVersion>;
export type __listOfEngineVersion = EngineVersion[];
export declare const __listOfEngineVersion: S.$Array<S.Schema<EngineVersion>>;
export interface BrokerEngineType {
    EngineType?: EngineType;
    EngineVersions?: EngineVersion[];
}
export declare const BrokerEngineType: S.Schema<BrokerEngineType>;
export type __listOfBrokerEngineType = BrokerEngineType[];
export declare const __listOfBrokerEngineType: S.$Array<S.Schema<BrokerEngineType>>;
export interface DescribeBrokerEngineTypesResponse {
    BrokerEngineTypes?: BrokerEngineType[];
    MaxResults?: number;
    NextToken?: string;
}
export declare const DescribeBrokerEngineTypesResponse: S.Schema<DescribeBrokerEngineTypesResponse>;
export interface DescribeBrokerInstanceOptionsRequest {
    EngineType?: string;
    HostInstanceType?: string;
    MaxResults?: number;
    NextToken?: string;
    StorageType?: string;
}
export declare const DescribeBrokerInstanceOptionsRequest: S.Schema<DescribeBrokerInstanceOptionsRequest>;
export interface AvailabilityZone {
    Name?: string;
}
export declare const AvailabilityZone: S.Schema<AvailabilityZone>;
export type __listOfAvailabilityZone = AvailabilityZone[];
export declare const __listOfAvailabilityZone: S.$Array<S.Schema<AvailabilityZone>>;
export type __listOfDeploymentMode = DeploymentMode[];
export declare const __listOfDeploymentMode: S.$Array<S.String>;
export interface BrokerInstanceOption {
    AvailabilityZones?: AvailabilityZone[];
    EngineType?: EngineType;
    HostInstanceType?: string;
    StorageType?: BrokerStorageType;
    SupportedDeploymentModes?: DeploymentMode[];
    SupportedEngineVersions?: string[];
}
export declare const BrokerInstanceOption: S.Schema<BrokerInstanceOption>;
export type __listOfBrokerInstanceOption = BrokerInstanceOption[];
export declare const __listOfBrokerInstanceOption: S.$Array<S.Schema<BrokerInstanceOption>>;
export interface DescribeBrokerInstanceOptionsResponse {
    BrokerInstanceOptions?: BrokerInstanceOption[];
    MaxResults?: number;
    NextToken?: string;
}
export declare const DescribeBrokerInstanceOptionsResponse: S.Schema<DescribeBrokerInstanceOptionsResponse>;
export interface DescribeConfigurationRequest {
    ConfigurationId: string;
}
export declare const DescribeConfigurationRequest: S.Schema<DescribeConfigurationRequest>;
export interface DescribeConfigurationResponse {
    Arn?: string;
    AuthenticationStrategy?: AuthenticationStrategy;
    Created?: Date;
    Description?: string;
    EngineType?: EngineType;
    EngineVersion?: string;
    Id?: string;
    LatestRevision?: ConfigurationRevision & {
        Created: __timestampIso8601;
        Revision: number;
    };
    Name?: string;
    Tags?: {
        [key: string]: string | undefined;
    };
}
export declare const DescribeConfigurationResponse: S.Schema<DescribeConfigurationResponse>;
export interface DescribeConfigurationRevisionRequest {
    ConfigurationId: string;
    ConfigurationRevision: string;
}
export declare const DescribeConfigurationRevisionRequest: S.Schema<DescribeConfigurationRevisionRequest>;
export interface DescribeConfigurationRevisionResponse {
    ConfigurationId?: string;
    Created?: Date;
    Data?: string;
    Description?: string;
}
export declare const DescribeConfigurationRevisionResponse: S.Schema<DescribeConfigurationRevisionResponse>;
export interface DescribeUserRequest {
    BrokerId: string;
    Username: string;
}
export declare const DescribeUserRequest: S.Schema<DescribeUserRequest>;
export interface UserPendingChanges {
    ConsoleAccess?: boolean;
    Groups?: string[];
    PendingChange?: ChangeType;
}
export declare const UserPendingChanges: S.Schema<UserPendingChanges>;
export interface DescribeUserResponse {
    BrokerId?: string;
    ConsoleAccess?: boolean;
    Groups?: string[];
    Pending?: UserPendingChanges & {
        PendingChange: ChangeType;
    };
    Username?: string;
    ReplicationUser?: boolean;
}
export declare const DescribeUserResponse: S.Schema<DescribeUserResponse>;
export interface ListBrokersRequest {
    MaxResults?: number;
    NextToken?: string;
}
export declare const ListBrokersRequest: S.Schema<ListBrokersRequest>;
export interface BrokerSummary {
    BrokerArn?: string;
    BrokerId?: string;
    BrokerName?: string;
    BrokerState?: BrokerState;
    Created?: Date;
    DeploymentMode?: DeploymentMode;
    EngineType?: EngineType;
    HostInstanceType?: string;
}
export declare const BrokerSummary: S.Schema<BrokerSummary>;
export type __listOfBrokerSummary = BrokerSummary[];
export declare const __listOfBrokerSummary: S.$Array<S.Schema<BrokerSummary>>;
export interface ListBrokersResponse {
    BrokerSummaries?: (BrokerSummary & {
        DeploymentMode: DeploymentMode;
        EngineType: EngineType;
    })[];
    NextToken?: string;
}
export declare const ListBrokersResponse: S.Schema<ListBrokersResponse>;
export interface ListConfigurationRevisionsRequest {
    ConfigurationId: string;
    MaxResults?: number;
    NextToken?: string;
}
export declare const ListConfigurationRevisionsRequest: S.Schema<ListConfigurationRevisionsRequest>;
export type __listOfConfigurationRevision = ConfigurationRevision[];
export declare const __listOfConfigurationRevision: S.$Array<S.Schema<ConfigurationRevision>>;
export interface ListConfigurationRevisionsResponse {
    ConfigurationId?: string;
    MaxResults?: number;
    NextToken?: string;
    Revisions?: (ConfigurationRevision & {
        Created: __timestampIso8601;
        Revision: number;
    })[];
}
export declare const ListConfigurationRevisionsResponse: S.Schema<ListConfigurationRevisionsResponse>;
export interface ListConfigurationsRequest {
    MaxResults?: number;
    NextToken?: string;
}
export declare const ListConfigurationsRequest: S.Schema<ListConfigurationsRequest>;
export interface Configuration {
    Arn?: string;
    AuthenticationStrategy?: AuthenticationStrategy;
    Created?: Date;
    Description?: string;
    EngineType?: EngineType;
    EngineVersion?: string;
    Id?: string;
    LatestRevision?: ConfigurationRevision;
    Name?: string;
    Tags?: {
        [key: string]: string | undefined;
    };
}
export declare const Configuration: S.Schema<Configuration>;
export type __listOfConfiguration = Configuration[];
export declare const __listOfConfiguration: S.$Array<S.Schema<Configuration>>;
export interface ListConfigurationsResponse {
    Configurations?: (Configuration & {
        Arn: string;
        AuthenticationStrategy: AuthenticationStrategy;
        Created: __timestampIso8601;
        Description: string;
        EngineType: EngineType;
        EngineVersion: string;
        Id: string;
        LatestRevision: ConfigurationRevision & {
            Created: __timestampIso8601;
            Revision: number;
        };
        Name: string;
    })[];
    MaxResults?: number;
    NextToken?: string;
}
export declare const ListConfigurationsResponse: S.Schema<ListConfigurationsResponse>;
export interface ListTagsRequest {
    ResourceArn: string;
}
export declare const ListTagsRequest: S.Schema<ListTagsRequest>;
export interface ListTagsResponse {
    Tags?: {
        [key: string]: string | undefined;
    };
}
export declare const ListTagsResponse: S.Schema<ListTagsResponse>;
export interface ListUsersRequest {
    BrokerId: string;
    MaxResults?: number;
    NextToken?: string;
}
export declare const ListUsersRequest: S.Schema<ListUsersRequest>;
export interface ListUsersResponse {
    BrokerId?: string;
    MaxResults?: number;
    NextToken?: string;
    Users?: (UserSummary & {
        Username: string;
    })[];
}
export declare const ListUsersResponse: S.Schema<ListUsersResponse>;
export type PromoteMode = "SWITCHOVER" | "FAILOVER" | (string & {});
export declare const PromoteMode: S.String;
export interface PromoteRequest {
    BrokerId: string;
    Mode?: PromoteMode;
}
export declare const PromoteRequest: S.Schema<PromoteRequest>;
export interface PromoteResponse {
    BrokerId?: string;
}
export declare const PromoteResponse: S.Schema<PromoteResponse>;
export interface RebootBrokerRequest {
    BrokerId: string;
}
export declare const RebootBrokerRequest: S.Schema<RebootBrokerRequest>;
export interface RebootBrokerResponse {
}
export declare const RebootBrokerResponse: S.Schema<RebootBrokerResponse>;
export interface UpdateBrokerRequest {
    AuthenticationStrategy?: AuthenticationStrategy;
    AutoMinorVersionUpgrade?: boolean;
    BrokerId: string;
    Configuration?: ConfigurationId;
    EngineVersion?: string;
    HostInstanceType?: string;
    LdapServerMetadata?: LdapServerMetadataInput;
    Logs?: Logs;
    MaintenanceWindowStartTime?: WeeklyStartTime;
    SecurityGroups?: string[];
    DataReplicationMode?: DataReplicationMode;
}
export declare const UpdateBrokerRequest: S.Schema<UpdateBrokerRequest>;
export interface UpdateBrokerResponse {
    AuthenticationStrategy?: AuthenticationStrategy;
    AutoMinorVersionUpgrade?: boolean;
    BrokerId?: string;
    Configuration?: ConfigurationId & {
        Id: string;
    };
    EngineVersion?: string;
    HostInstanceType?: string;
    LdapServerMetadata?: LdapServerMetadataOutput & {
        Hosts: __listOf__string;
        RoleBase: string;
        RoleSearchMatching: string;
        ServiceAccountUsername: string;
        UserBase: string;
        UserSearchMatching: string;
    };
    Logs?: Logs;
    MaintenanceWindowStartTime?: WeeklyStartTime & {
        DayOfWeek: DayOfWeek;
        TimeOfDay: string;
    };
    SecurityGroups?: string[];
    DataReplicationMetadata?: DataReplicationMetadataOutput & {
        DataReplicationRole: string;
        DataReplicationCounterpart: DataReplicationCounterpart & {
            BrokerId: string;
            Region: string;
        };
    };
    DataReplicationMode?: DataReplicationMode;
    PendingDataReplicationMetadata?: DataReplicationMetadataOutput & {
        DataReplicationRole: string;
        DataReplicationCounterpart: DataReplicationCounterpart & {
            BrokerId: string;
            Region: string;
        };
    };
    PendingDataReplicationMode?: DataReplicationMode;
}
export declare const UpdateBrokerResponse: S.Schema<UpdateBrokerResponse>;
export interface UpdateConfigurationRequest {
    ConfigurationId: string;
    Data?: string;
    Description?: string;
}
export declare const UpdateConfigurationRequest: S.Schema<UpdateConfigurationRequest>;
export type SanitizationWarningReason = "DISALLOWED_ELEMENT_REMOVED" | "DISALLOWED_ATTRIBUTE_REMOVED" | "INVALID_ATTRIBUTE_VALUE_REMOVED" | (string & {});
export declare const SanitizationWarningReason: S.String;
export interface SanitizationWarning {
    AttributeName?: string;
    ElementName?: string;
    Reason?: SanitizationWarningReason;
}
export declare const SanitizationWarning: S.Schema<SanitizationWarning>;
export type __listOfSanitizationWarning = SanitizationWarning[];
export declare const __listOfSanitizationWarning: S.$Array<S.Schema<SanitizationWarning>>;
export interface UpdateConfigurationResponse {
    Arn?: string;
    Created?: Date;
    Id?: string;
    LatestRevision?: ConfigurationRevision & {
        Created: __timestampIso8601;
        Revision: number;
    };
    Name?: string;
    Warnings?: (SanitizationWarning & {
        Reason: SanitizationWarningReason;
    })[];
}
export declare const UpdateConfigurationResponse: S.Schema<UpdateConfigurationResponse>;
export interface UpdateUserRequest {
    BrokerId: string;
    ConsoleAccess?: boolean;
    Groups?: string[];
    Password?: string;
    Username: string;
    ReplicationUser?: boolean;
}
export declare const UpdateUserRequest: S.Schema<UpdateUserRequest>;
export interface UpdateUserResponse {
}
export declare const UpdateUserResponse: S.Schema<UpdateUserResponse>;
declare const BadRequestException_base: S.Class<BadRequestException, S.TaggedStruct<"BadRequestException", {
    readonly ErrorAttribute: S.optional<S.String>;
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class BadRequestException extends BadRequestException_base {
}
declare const ConflictException_base: S.Class<ConflictException, S.TaggedStruct<"ConflictException", {
    readonly ErrorAttribute: S.optional<S.String>;
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ConflictError: true;
    };
});
export declare class ConflictException extends ConflictException_base {
}
declare const ForbiddenException_base: S.Class<ForbiddenException, S.TaggedStruct<"ForbiddenException", {
    readonly ErrorAttribute: S.optional<S.String>;
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        AuthError: true;
    };
});
export declare class ForbiddenException extends ForbiddenException_base {
}
declare const InternalServerErrorException_base: S.Class<InternalServerErrorException, S.TaggedStruct<"InternalServerErrorException", {
    readonly ErrorAttribute: S.optional<S.String>;
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ServerError: true;
    };
});
export declare class InternalServerErrorException extends InternalServerErrorException_base {
}
declare const UnauthorizedException_base: S.Class<UnauthorizedException, S.TaggedStruct<"UnauthorizedException", {
    readonly ErrorAttribute: S.optional<S.String>;
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        AuthError: true;
    };
});
export declare class UnauthorizedException extends UnauthorizedException_base {
}
declare const NotFoundException_base: S.Class<NotFoundException, S.TaggedStruct<"NotFoundException", {
    readonly ErrorAttribute: S.optional<S.String>;
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class NotFoundException extends NotFoundException_base {
}
export type CreateBrokerError = BadRequestException | ConflictException | ForbiddenException | InternalServerErrorException | UnauthorizedException | CommonErrors;
/**
 * Creates a broker. Note: This API is asynchronous.
 *
 * To create a broker, you must either use the AmazonMQFullAccess IAM policy or include the following EC2 permissions in your IAM policy.
 *
 * - ec2:CreateNetworkInterface
 *
 * This permission is required to allow Amazon MQ to create an elastic network interface (ENI) on behalf of your account.
 *
 * - ec2:CreateNetworkInterfacePermission
 *
 * This permission is required to attach the ENI to the broker instance.
 *
 * - ec2:DeleteNetworkInterface
 *
 * - ec2:DeleteNetworkInterfacePermission
 *
 * - ec2:DetachNetworkInterface
 *
 * - ec2:DescribeInternetGateways
 *
 * - ec2:DescribeNetworkInterfaces
 *
 * - ec2:DescribeNetworkInterfacePermissions
 *
 * - ec2:DescribeRouteTables
 *
 * - ec2:DescribeSecurityGroups
 *
 * - ec2:DescribeSubnets
 *
 * - ec2:DescribeVpcs
 *
 * For more information, see Create an IAM User and Get Your Amazon Web Services Credentials and Never Modify or Delete the Amazon MQ Elastic Network Interface in the *Amazon MQ Developer Guide*.
 */
export declare const createBroker: API.OperationMethod<CreateBrokerRequest, CreateBrokerResponse, CreateBrokerError, Credentials | Region | HttpClient.HttpClient>;
export type CreateConfigurationError = BadRequestException | ConflictException | ForbiddenException | InternalServerErrorException | CommonErrors;
/**
 * Creates a new configuration for the specified configuration name. Amazon MQ uses the default configuration (the engine type and version).
 */
export declare const createConfiguration: API.OperationMethod<CreateConfigurationRequest, CreateConfigurationResponse, CreateConfigurationError, Credentials | Region | HttpClient.HttpClient>;
export type CreateTagsError = BadRequestException | ForbiddenException | InternalServerErrorException | NotFoundException | CommonErrors;
/**
 * Add a tag to a resource.
 */
export declare const createTags: API.OperationMethod<CreateTagsRequest, CreateTagsResponse, CreateTagsError, Credentials | Region | HttpClient.HttpClient>;
export type CreateUserError = BadRequestException | ConflictException | ForbiddenException | InternalServerErrorException | NotFoundException | CommonErrors;
/**
 * Creates an ActiveMQ user.
 *
 * Do not add personally identifiable information (PII) or other confidential or sensitive information in broker usernames. Broker usernames are accessible to other Amazon Web Services services, including CloudWatch Logs. Broker usernames are not intended to be used for private or sensitive data.
 */
export declare const createUser: API.OperationMethod<CreateUserRequest, CreateUserResponse, CreateUserError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteBrokerError = BadRequestException | ForbiddenException | InternalServerErrorException | NotFoundException | CommonErrors;
/**
 * Deletes a broker. Note: This API is asynchronous.
 */
export declare const deleteBroker: API.OperationMethod<DeleteBrokerRequest, DeleteBrokerResponse, DeleteBrokerError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteConfigurationError = BadRequestException | ConflictException | ForbiddenException | InternalServerErrorException | NotFoundException | CommonErrors;
/**
 * Deletes the specified configuration.
 */
export declare const deleteConfiguration: API.OperationMethod<DeleteConfigurationRequest, DeleteConfigurationResponse, DeleteConfigurationError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteTagsError = BadRequestException | ForbiddenException | InternalServerErrorException | NotFoundException | CommonErrors;
/**
 * Removes a tag from a resource.
 */
export declare const deleteTags: API.OperationMethod<DeleteTagsRequest, DeleteTagsResponse, DeleteTagsError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteUserError = BadRequestException | ForbiddenException | InternalServerErrorException | NotFoundException | CommonErrors;
/**
 * Deletes an ActiveMQ user.
 */
export declare const deleteUser: API.OperationMethod<DeleteUserRequest, DeleteUserResponse, DeleteUserError, Credentials | Region | HttpClient.HttpClient>;
export type DescribeBrokerError = BadRequestException | ForbiddenException | InternalServerErrorException | NotFoundException | CommonErrors;
/**
 * Returns information about the specified broker.
 */
export declare const describeBroker: API.OperationMethod<DescribeBrokerRequest, DescribeBrokerResponse, DescribeBrokerError, Credentials | Region | HttpClient.HttpClient>;
export type DescribeBrokerEngineTypesError = BadRequestException | ForbiddenException | InternalServerErrorException | CommonErrors;
/**
 * Describe available engine types and versions.
 */
export declare const describeBrokerEngineTypes: API.OperationMethod<DescribeBrokerEngineTypesRequest, DescribeBrokerEngineTypesResponse, DescribeBrokerEngineTypesError, Credentials | Region | HttpClient.HttpClient>;
export type DescribeBrokerInstanceOptionsError = BadRequestException | ForbiddenException | InternalServerErrorException | CommonErrors;
/**
 * Describe available broker instance options.
 */
export declare const describeBrokerInstanceOptions: API.OperationMethod<DescribeBrokerInstanceOptionsRequest, DescribeBrokerInstanceOptionsResponse, DescribeBrokerInstanceOptionsError, Credentials | Region | HttpClient.HttpClient>;
export type DescribeConfigurationError = BadRequestException | ForbiddenException | InternalServerErrorException | NotFoundException | CommonErrors;
/**
 * Returns information about the specified configuration.
 */
export declare const describeConfiguration: API.OperationMethod<DescribeConfigurationRequest, DescribeConfigurationResponse, DescribeConfigurationError, Credentials | Region | HttpClient.HttpClient>;
export type DescribeConfigurationRevisionError = BadRequestException | ForbiddenException | InternalServerErrorException | NotFoundException | CommonErrors;
/**
 * Returns the specified configuration revision for the specified configuration.
 */
export declare const describeConfigurationRevision: API.OperationMethod<DescribeConfigurationRevisionRequest, DescribeConfigurationRevisionResponse, DescribeConfigurationRevisionError, Credentials | Region | HttpClient.HttpClient>;
export type DescribeUserError = BadRequestException | ForbiddenException | InternalServerErrorException | NotFoundException | CommonErrors;
/**
 * Returns information about an ActiveMQ user.
 */
export declare const describeUser: API.OperationMethod<DescribeUserRequest, DescribeUserResponse, DescribeUserError, Credentials | Region | HttpClient.HttpClient>;
export type ListBrokersError = BadRequestException | ForbiddenException | InternalServerErrorException | CommonErrors;
/**
 * Returns a list of all brokers.
 */
export declare const listBrokers: API.OperationMethod<ListBrokersRequest, ListBrokersResponse, ListBrokersError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListBrokersRequest) => stream.Stream<ListBrokersResponse, ListBrokersError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListBrokersRequest) => stream.Stream<BrokerSummary, ListBrokersError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListConfigurationRevisionsError = BadRequestException | ForbiddenException | InternalServerErrorException | NotFoundException | CommonErrors;
/**
 * Returns a list of all revisions for the specified configuration.
 */
export declare const listConfigurationRevisions: API.OperationMethod<ListConfigurationRevisionsRequest, ListConfigurationRevisionsResponse, ListConfigurationRevisionsError, Credentials | Region | HttpClient.HttpClient>;
export type ListConfigurationsError = BadRequestException | ForbiddenException | InternalServerErrorException | CommonErrors;
/**
 * Returns a list of all configurations.
 */
export declare const listConfigurations: API.OperationMethod<ListConfigurationsRequest, ListConfigurationsResponse, ListConfigurationsError, Credentials | Region | HttpClient.HttpClient>;
export type ListTagsError = BadRequestException | ForbiddenException | InternalServerErrorException | NotFoundException | CommonErrors;
/**
 * Lists tags for a resource.
 */
export declare const listTags: API.OperationMethod<ListTagsRequest, ListTagsResponse, ListTagsError, Credentials | Region | HttpClient.HttpClient>;
export type ListUsersError = BadRequestException | ForbiddenException | InternalServerErrorException | NotFoundException | CommonErrors;
/**
 * Returns a list of all ActiveMQ users.
 */
export declare const listUsers: API.OperationMethod<ListUsersRequest, ListUsersResponse, ListUsersError, Credentials | Region | HttpClient.HttpClient>;
export type PromoteError = BadRequestException | ForbiddenException | InternalServerErrorException | NotFoundException | CommonErrors;
/**
 * Promotes a data replication replica broker to the primary broker role.
 */
export declare const promote: API.OperationMethod<PromoteRequest, PromoteResponse, PromoteError, Credentials | Region | HttpClient.HttpClient>;
export type RebootBrokerError = BadRequestException | ForbiddenException | InternalServerErrorException | NotFoundException | CommonErrors;
/**
 * Reboots a broker. Note: This API is asynchronous.
 */
export declare const rebootBroker: API.OperationMethod<RebootBrokerRequest, RebootBrokerResponse, RebootBrokerError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateBrokerError = BadRequestException | ConflictException | ForbiddenException | InternalServerErrorException | NotFoundException | CommonErrors;
/**
 * Adds a pending configuration change to a broker.
 */
export declare const updateBroker: API.OperationMethod<UpdateBrokerRequest, UpdateBrokerResponse, UpdateBrokerError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateConfigurationError = BadRequestException | ConflictException | ForbiddenException | InternalServerErrorException | NotFoundException | CommonErrors;
/**
 * Updates the specified configuration.
 */
export declare const updateConfiguration: API.OperationMethod<UpdateConfigurationRequest, UpdateConfigurationResponse, UpdateConfigurationError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateUserError = BadRequestException | ConflictException | ForbiddenException | InternalServerErrorException | NotFoundException | CommonErrors;
/**
 * Updates the information for an ActiveMQ user.
 */
export declare const updateUser: API.OperationMethod<UpdateUserRequest, UpdateUserResponse, UpdateUserError, Credentials | Region | HttpClient.HttpClient>;
export {};
//# sourceMappingURL=mq.d.ts.map