import type { ExceptionOptionType as __ExceptionOptionType } from "@smithy/smithy-client";
import { RedshiftServiceException as __BaseException } from "./RedshiftServiceException";
/**
 * <p>Your request cannot be completed because a dependent internal service is
 *             temporarily unavailable. Wait 30 to 60 seconds and try again.</p>
 * @public
 */
export declare class DependentServiceUnavailableFault extends __BaseException {
    readonly name: "DependentServiceUnavailableFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DependentServiceUnavailableFault, __BaseException>);
}
/**
 * <p>Indicates that the Reserved Node being exchanged is not in an active state.</p>
 * @public
 */
export declare class InvalidReservedNodeStateFault extends __BaseException {
    readonly name: "InvalidReservedNodeStateFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidReservedNodeStateFault, __BaseException>);
}
/**
 * <p>User already has a reservation with the given identifier.</p>
 * @public
 */
export declare class ReservedNodeAlreadyExistsFault extends __BaseException {
    readonly name: "ReservedNodeAlreadyExistsFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<ReservedNodeAlreadyExistsFault, __BaseException>);
}
/**
 * <p>Indicates that the reserved node has already been exchanged.</p>
 * @public
 */
export declare class ReservedNodeAlreadyMigratedFault extends __BaseException {
    readonly name: "ReservedNodeAlreadyMigratedFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<ReservedNodeAlreadyMigratedFault, __BaseException>);
}
/**
 * <p>The specified reserved compute node not found.</p>
 * @public
 */
export declare class ReservedNodeNotFoundFault extends __BaseException {
    readonly name: "ReservedNodeNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<ReservedNodeNotFoundFault, __BaseException>);
}
/**
 * <p>Specified offering does not exist.</p>
 * @public
 */
export declare class ReservedNodeOfferingNotFoundFault extends __BaseException {
    readonly name: "ReservedNodeOfferingNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<ReservedNodeOfferingNotFoundFault, __BaseException>);
}
/**
 * <p>The requested operation isn't supported.</p>
 * @public
 */
export declare class UnsupportedOperationFault extends __BaseException {
    readonly name: "UnsupportedOperationFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<UnsupportedOperationFault, __BaseException>);
}
/**
 * <p>You are not authorized to access the cluster.</p>
 * @public
 */
export declare class AccessToClusterDeniedFault extends __BaseException {
    readonly name: "AccessToClusterDeniedFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<AccessToClusterDeniedFault, __BaseException>);
}
/**
 * <p>The owner of the specified snapshot has not authorized your account to access the
 *             snapshot.</p>
 * @public
 */
export declare class AccessToSnapshotDeniedFault extends __BaseException {
    readonly name: "AccessToSnapshotDeniedFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<AccessToSnapshotDeniedFault, __BaseException>);
}
/**
 * <p>The <code>ClusterIdentifier</code> parameter does not refer to an existing cluster.
 *         </p>
 * @public
 */
export declare class ClusterNotFoundFault extends __BaseException {
    readonly name: "ClusterNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<ClusterNotFoundFault, __BaseException>);
}
/**
 * <p>The name of the partner was not found.</p>
 * @public
 */
export declare class PartnerNotFoundFault extends __BaseException {
    readonly name: "PartnerNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<PartnerNotFoundFault, __BaseException>);
}
/**
 * <p>The partner integration is not authorized.</p>
 * @public
 */
export declare class UnauthorizedPartnerIntegrationFault extends __BaseException {
    readonly name: "UnauthorizedPartnerIntegrationFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<UnauthorizedPartnerIntegrationFault, __BaseException>);
}
/**
 * <p>There is an error with the datashare.</p>
 * @public
 */
export declare class InvalidDataShareFault extends __BaseException {
    readonly name: "InvalidDataShareFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidDataShareFault, __BaseException>);
}
/**
 * <p>The namespace isn't valid because the namespace doesn't exist. Provide a valid namespace.</p>
 * @public
 */
export declare class InvalidNamespaceFault extends __BaseException {
    readonly name: "InvalidNamespaceFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidNamespaceFault, __BaseException>);
}
/**
 * <p>The authentication profile already exists.</p>
 * @public
 */
export declare class AuthenticationProfileAlreadyExistsFault extends __BaseException {
    readonly name: "AuthenticationProfileAlreadyExistsFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<AuthenticationProfileAlreadyExistsFault, __BaseException>);
}
/**
 * <p>The authentication profile can't be found.</p>
 * @public
 */
export declare class AuthenticationProfileNotFoundFault extends __BaseException {
    readonly name: "AuthenticationProfileNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<AuthenticationProfileNotFoundFault, __BaseException>);
}
/**
 * <p>The size or number of authentication profiles has exceeded the quota.
 *             The maximum length of the JSON string and maximum number of authentication profiles is determined by a quota for your account.</p>
 * @public
 */
export declare class AuthenticationProfileQuotaExceededFault extends __BaseException {
    readonly name: "AuthenticationProfileQuotaExceededFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<AuthenticationProfileQuotaExceededFault, __BaseException>);
}
/**
 * <p>The specified CIDR block or EC2 security group is already authorized for the
 *             specified cluster security group.</p>
 * @public
 */
export declare class AuthorizationAlreadyExistsFault extends __BaseException {
    readonly name: "AuthorizationAlreadyExistsFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<AuthorizationAlreadyExistsFault, __BaseException>);
}
/**
 * <p>The specified CIDR IP range or EC2 security group is not authorized for the
 *             specified cluster security group.</p>
 * @public
 */
export declare class AuthorizationNotFoundFault extends __BaseException {
    readonly name: "AuthorizationNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<AuthorizationNotFoundFault, __BaseException>);
}
/**
 * <p>The authorization quota for the cluster security group has been reached.</p>
 * @public
 */
export declare class AuthorizationQuotaExceededFault extends __BaseException {
    readonly name: "AuthorizationQuotaExceededFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<AuthorizationQuotaExceededFault, __BaseException>);
}
/**
 * <p>The cluster security group name does not refer to an existing cluster security
 *             group.</p>
 * @public
 */
export declare class ClusterSecurityGroupNotFoundFault extends __BaseException {
    readonly name: "ClusterSecurityGroupNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<ClusterSecurityGroupNotFoundFault, __BaseException>);
}
/**
 * <p>The state of the cluster security group is not <code>available</code>. </p>
 * @public
 */
export declare class InvalidClusterSecurityGroupStateFault extends __BaseException {
    readonly name: "InvalidClusterSecurityGroupStateFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidClusterSecurityGroupStateFault, __BaseException>);
}
/**
 * <p>The authorization already exists for this endpoint.</p>
 * @public
 */
export declare class EndpointAuthorizationAlreadyExistsFault extends __BaseException {
    readonly name: "EndpointAuthorizationAlreadyExistsFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<EndpointAuthorizationAlreadyExistsFault, __BaseException>);
}
/**
 * <p>The number of endpoint authorizations per cluster has exceeded its limit.</p>
 * @public
 */
export declare class EndpointAuthorizationsPerClusterLimitExceededFault extends __BaseException {
    readonly name: "EndpointAuthorizationsPerClusterLimitExceededFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<EndpointAuthorizationsPerClusterLimitExceededFault, __BaseException>);
}
/**
 * <p>The status of the authorization is not valid.</p>
 * @public
 */
export declare class InvalidAuthorizationStateFault extends __BaseException {
    readonly name: "InvalidAuthorizationStateFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidAuthorizationStateFault, __BaseException>);
}
/**
 * <p>The specified cluster is not in the <code>available</code> state. </p>
 * @public
 */
export declare class InvalidClusterStateFault extends __BaseException {
    readonly name: "InvalidClusterStateFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidClusterStateFault, __BaseException>);
}
/**
 * <p>The snapshot identifier does not refer to an existing cluster snapshot.</p>
 * @public
 */
export declare class ClusterSnapshotNotFoundFault extends __BaseException {
    readonly name: "ClusterSnapshotNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<ClusterSnapshotNotFoundFault, __BaseException>);
}
/**
 * <p>The request cannot be completed because a dependent service is throttling requests
 *             made by Amazon Redshift on your behalf. Wait and retry the request.</p>
 * @public
 */
export declare class DependentServiceRequestThrottlingFault extends __BaseException {
    readonly name: "DependentServiceRequestThrottlingFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DependentServiceRequestThrottlingFault, __BaseException>);
}
/**
 * <p>The specified cluster snapshot is not in the <code>available</code> state, or other
 *             accounts are authorized to access the snapshot. </p>
 * @public
 */
export declare class InvalidClusterSnapshotStateFault extends __BaseException {
    readonly name: "InvalidClusterSnapshotStateFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidClusterSnapshotStateFault, __BaseException>);
}
/**
 * <p>The encryption key has exceeded its grant limit in Amazon Web Services KMS.</p>
 * @public
 */
export declare class LimitExceededFault extends __BaseException {
    readonly name: "LimitExceededFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<LimitExceededFault, __BaseException>);
}
/**
 * <p>The maximum number for a batch delete of snapshots has been reached. The limit is
 *             100. </p>
 * @public
 */
export declare class BatchDeleteRequestSizeExceededFault extends __BaseException {
    readonly name: "BatchDeleteRequestSizeExceededFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<BatchDeleteRequestSizeExceededFault, __BaseException>);
}
/**
 * <p>The maximum number for snapshot identifiers has been reached. The limit is 100.
 *         </p>
 * @public
 */
export declare class BatchModifyClusterSnapshotsLimitExceededFault extends __BaseException {
    readonly name: "BatchModifyClusterSnapshotsLimitExceededFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<BatchModifyClusterSnapshotsLimitExceededFault, __BaseException>);
}
/**
 * <p>The retention period specified is either in the past or is not a valid value.</p>
 *          <p>The value must be either -1 or an integer between 1 and 3,653.</p>
 * @public
 */
export declare class InvalidRetentionPeriodFault extends __BaseException {
    readonly name: "InvalidRetentionPeriodFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidRetentionPeriodFault, __BaseException>);
}
/**
 * <p>Could not find the specified S3 bucket.</p>
 * @public
 */
export declare class BucketNotFoundFault extends __BaseException {
    readonly name: "BucketNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<BucketNotFoundFault, __BaseException>);
}
/**
 * <p>A resize operation for the specified cluster is not found.</p>
 * @public
 */
export declare class ResizeNotFoundFault extends __BaseException {
    readonly name: "ResizeNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<ResizeNotFoundFault, __BaseException>);
}
/**
 * <p>The account already has a cluster with the given identifier.</p>
 * @public
 */
export declare class ClusterAlreadyExistsFault extends __BaseException {
    readonly name: "ClusterAlreadyExistsFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<ClusterAlreadyExistsFault, __BaseException>);
}
/**
 * <p>Cluster is already on the latest database revision.</p>
 * @public
 */
export declare class ClusterOnLatestRevisionFault extends __BaseException {
    readonly name: "ClusterOnLatestRevisionFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<ClusterOnLatestRevisionFault, __BaseException>);
}
/**
 * <p>A cluster parameter group with the same name already exists.</p>
 * @public
 */
export declare class ClusterParameterGroupAlreadyExistsFault extends __BaseException {
    readonly name: "ClusterParameterGroupAlreadyExistsFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<ClusterParameterGroupAlreadyExistsFault, __BaseException>);
}
/**
 * <p>The parameter group name does not refer to an existing parameter group.</p>
 * @public
 */
export declare class ClusterParameterGroupNotFoundFault extends __BaseException {
    readonly name: "ClusterParameterGroupNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<ClusterParameterGroupNotFoundFault, __BaseException>);
}
/**
 * <p>The request would result in the user exceeding the allowed number of cluster
 *             parameter groups.
 * For information about increasing your quota, go to <a href="https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html">Limits in Amazon Redshift</a>
 * in the <i>Amazon Redshift Cluster Management Guide</i>.
 * </p>
 * @public
 */
export declare class ClusterParameterGroupQuotaExceededFault extends __BaseException {
    readonly name: "ClusterParameterGroupQuotaExceededFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<ClusterParameterGroupQuotaExceededFault, __BaseException>);
}
/**
 * <p>The request would exceed the allowed number of cluster instances for this account.
 *
 * For information about increasing your quota, go to <a href="https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html">Limits in Amazon Redshift</a>
 * in the <i>Amazon Redshift Cluster Management Guide</i>.
 * </p>
 * @public
 */
export declare class ClusterQuotaExceededFault extends __BaseException {
    readonly name: "ClusterQuotaExceededFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<ClusterQuotaExceededFault, __BaseException>);
}
/**
 * <p>A cluster security group with the same name already exists.</p>
 * @public
 */
export declare class ClusterSecurityGroupAlreadyExistsFault extends __BaseException {
    readonly name: "ClusterSecurityGroupAlreadyExistsFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<ClusterSecurityGroupAlreadyExistsFault, __BaseException>);
}
/**
 * <p>The request would result in the user exceeding the allowed number of cluster
 *             security groups.
 * For information about increasing your quota, go to <a href="https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html">Limits in Amazon Redshift</a>
 * in the <i>Amazon Redshift Cluster Management Guide</i>.
 * </p>
 * @public
 */
export declare class ClusterSecurityGroupQuotaExceededFault extends __BaseException {
    readonly name: "ClusterSecurityGroupQuotaExceededFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<ClusterSecurityGroupQuotaExceededFault, __BaseException>);
}
/**
 * <p>The value specified as a snapshot identifier is already used by an existing
 *             snapshot.</p>
 * @public
 */
export declare class ClusterSnapshotAlreadyExistsFault extends __BaseException {
    readonly name: "ClusterSnapshotAlreadyExistsFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<ClusterSnapshotAlreadyExistsFault, __BaseException>);
}
/**
 * <p>The request would result in the user exceeding the allowed number of cluster
 *             snapshots.</p>
 * @public
 */
export declare class ClusterSnapshotQuotaExceededFault extends __BaseException {
    readonly name: "ClusterSnapshotQuotaExceededFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<ClusterSnapshotQuotaExceededFault, __BaseException>);
}
/**
 * <p>A <i>ClusterSubnetGroupName</i> is already used by an existing
 *             cluster subnet group. </p>
 * @public
 */
export declare class ClusterSubnetGroupAlreadyExistsFault extends __BaseException {
    readonly name: "ClusterSubnetGroupAlreadyExistsFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<ClusterSubnetGroupAlreadyExistsFault, __BaseException>);
}
/**
 * <p>The cluster subnet group name does not refer to an existing cluster subnet
 *             group.</p>
 * @public
 */
export declare class ClusterSubnetGroupNotFoundFault extends __BaseException {
    readonly name: "ClusterSubnetGroupNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<ClusterSubnetGroupNotFoundFault, __BaseException>);
}
/**
 * <p>The request would result in user exceeding the allowed number of cluster subnet
 *             groups.
 * For information about increasing your quota, go to <a href="https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html">Limits in Amazon Redshift</a>
 * in the <i>Amazon Redshift Cluster Management Guide</i>.
 * </p>
 * @public
 */
export declare class ClusterSubnetGroupQuotaExceededFault extends __BaseException {
    readonly name: "ClusterSubnetGroupQuotaExceededFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<ClusterSubnetGroupQuotaExceededFault, __BaseException>);
}
/**
 * <p>The request would result in user exceeding the allowed number of subnets in a
 *             cluster subnet groups.
 * For information about increasing your quota, go to <a href="https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html">Limits in Amazon Redshift</a>
 * in the <i>Amazon Redshift Cluster Management Guide</i>.
 * </p>
 * @public
 */
export declare class ClusterSubnetQuotaExceededFault extends __BaseException {
    readonly name: "ClusterSubnetQuotaExceededFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<ClusterSubnetQuotaExceededFault, __BaseException>);
}
/**
 * <p>There is a conflict while updating the resource policy.</p>
 * @public
 */
export declare class ConflictPolicyUpdateFault extends __BaseException {
    readonly name: "ConflictPolicyUpdateFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<ConflictPolicyUpdateFault, __BaseException>);
}
/**
 * <p>Cross-region snapshot copy was temporarily disabled. Try your request
 *             again.</p>
 * @public
 */
export declare class CopyToRegionDisabledFault extends __BaseException {
    readonly name: "CopyToRegionDisabledFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<CopyToRegionDisabledFault, __BaseException>);
}
/**
 * <p>The authentication profile request is not valid. The profile name can't be null or empty.
 *             The authentication profile API operation must be available in the Amazon Web Services Region.</p>
 * @public
 */
export declare class InvalidAuthenticationProfileRequestFault extends __BaseException {
    readonly name: "InvalidAuthenticationProfileRequestFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidAuthenticationProfileRequestFault, __BaseException>);
}
/**
 * <p>A dependent service denied access for the integration.</p>
 * @public
 */
export declare class DependentServiceAccessDeniedFault extends __BaseException {
    readonly name: "DependentServiceAccessDeniedFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DependentServiceAccessDeniedFault, __BaseException>);
}
/**
 * <p>There is no Amazon Redshift HSM client certificate with the specified
 *             identifier.</p>
 * @public
 */
export declare class HsmClientCertificateNotFoundFault extends __BaseException {
    readonly name: "HsmClientCertificateNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<HsmClientCertificateNotFoundFault, __BaseException>);
}
/**
 * <p>There is no Amazon Redshift HSM configuration with the specified identifier.</p>
 * @public
 */
export declare class HsmConfigurationNotFoundFault extends __BaseException {
    readonly name: "HsmConfigurationNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<HsmConfigurationNotFoundFault, __BaseException>);
}
/**
 * <p>The number of nodes specified exceeds the allotted capacity of the
 *             cluster.</p>
 * @public
 */
export declare class InsufficientClusterCapacityFault extends __BaseException {
    readonly name: "InsufficientClusterCapacityFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InsufficientClusterCapacityFault, __BaseException>);
}
/**
 * <p>The cluster subnet group cannot be deleted because it is in use.</p>
 * @public
 */
export declare class InvalidClusterSubnetGroupStateFault extends __BaseException {
    readonly name: "InvalidClusterSubnetGroupStateFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidClusterSubnetGroupStateFault, __BaseException>);
}
/**
 * <p>The provided cluster track name is not valid.</p>
 * @public
 */
export declare class InvalidClusterTrackFault extends __BaseException {
    readonly name: "InvalidClusterTrackFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidClusterTrackFault, __BaseException>);
}
/**
 * <p>The Elastic IP (EIP) is invalid or cannot be found.</p>
 * @public
 */
export declare class InvalidElasticIpFault extends __BaseException {
    readonly name: "InvalidElasticIpFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidElasticIpFault, __BaseException>);
}
/**
 * <p>The requested subnet is not valid, or not all of the subnets are in the same
 *             VPC.</p>
 * @public
 */
export declare class InvalidSubnet extends __BaseException {
    readonly name: "InvalidSubnet";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidSubnet, __BaseException>);
}
/**
 * <p>The tag is invalid.</p>
 * @public
 */
export declare class InvalidTagFault extends __BaseException {
    readonly name: "InvalidTagFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidTagFault, __BaseException>);
}
/**
 * <p>The cluster subnet group does not cover all Availability Zones.</p>
 * @public
 */
export declare class InvalidVPCNetworkStateFault extends __BaseException {
    readonly name: "InvalidVPCNetworkStateFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidVPCNetworkStateFault, __BaseException>);
}
/**
 * <p>There are no subnets in your VPC with associated IPv6 CIDR blocks. To use dual-stack mode,
 *             associate an IPv6 CIDR block with each subnet in your VPC.</p>
 * @public
 */
export declare class Ipv6CidrBlockNotFoundFault extends __BaseException {
    readonly name: "Ipv6CidrBlockNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<Ipv6CidrBlockNotFoundFault, __BaseException>);
}
/**
 * <p>The operation would exceed the number of nodes allowed for a cluster.</p>
 * @public
 */
export declare class NumberOfNodesPerClusterLimitExceededFault extends __BaseException {
    readonly name: "NumberOfNodesPerClusterLimitExceededFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<NumberOfNodesPerClusterLimitExceededFault, __BaseException>);
}
/**
 * <p>The operation would exceed the number of nodes allotted to the account.
 *
 * For information about increasing your quota, go to <a href="https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html">Limits in Amazon Redshift</a>
 * in the <i>Amazon Redshift Cluster Management Guide</i>.
 * </p>
 * @public
 */
export declare class NumberOfNodesQuotaExceededFault extends __BaseException {
    readonly name: "NumberOfNodesQuotaExceededFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<NumberOfNodesQuotaExceededFault, __BaseException>);
}
/**
 * <p>The application you attempted to find doesn't exist.</p>
 * @public
 */
export declare class RedshiftIdcApplicationNotExistsFault extends __BaseException {
    readonly name: "RedshiftIdcApplicationNotExistsFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<RedshiftIdcApplicationNotExistsFault, __BaseException>);
}
/**
 * <p>We could not find the specified snapshot schedule. </p>
 * @public
 */
export declare class SnapshotScheduleNotFoundFault extends __BaseException {
    readonly name: "SnapshotScheduleNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<SnapshotScheduleNotFoundFault, __BaseException>);
}
/**
 * <p>You have exceeded the number of tags allowed.</p>
 * @public
 */
export declare class TagLimitExceededFault extends __BaseException {
    readonly name: "TagLimitExceededFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<TagLimitExceededFault, __BaseException>);
}
/**
 * <p>Your account is not authorized to perform the requested operation.</p>
 * @public
 */
export declare class UnauthorizedOperation extends __BaseException {
    readonly name: "UnauthorizedOperation";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<UnauthorizedOperation, __BaseException>);
}
/**
 * <p>An error occurred when an attempt was made to change the custom domain association.</p>
 * @public
 */
export declare class CustomCnameAssociationFault extends __BaseException {
    readonly name: "CustomCnameAssociationFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<CustomCnameAssociationFault, __BaseException>);
}
/**
 * <p>The account already has a Redshift-managed VPC endpoint with the given identifier.</p>
 * @public
 */
export declare class EndpointAlreadyExistsFault extends __BaseException {
    readonly name: "EndpointAlreadyExistsFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<EndpointAlreadyExistsFault, __BaseException>);
}
/**
 * <p>The number of Redshift-managed VPC endpoints per authorization has exceeded its limit.</p>
 * @public
 */
export declare class EndpointsPerAuthorizationLimitExceededFault extends __BaseException {
    readonly name: "EndpointsPerAuthorizationLimitExceededFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<EndpointsPerAuthorizationLimitExceededFault, __BaseException>);
}
/**
 * <p>The number of Redshift-managed VPC endpoints per cluster has exceeded its limit.</p>
 * @public
 */
export declare class EndpointsPerClusterLimitExceededFault extends __BaseException {
    readonly name: "EndpointsPerClusterLimitExceededFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<EndpointsPerClusterLimitExceededFault, __BaseException>);
}
/**
 * <p>The request would exceed the allowed number of event subscriptions for this
 *             account.
 * For information about increasing your quota, go to <a href="https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html">Limits in Amazon Redshift</a>
 * in the <i>Amazon Redshift Cluster Management Guide</i>.
 * </p>
 * @public
 */
export declare class EventSubscriptionQuotaExceededFault extends __BaseException {
    readonly name: "EventSubscriptionQuotaExceededFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<EventSubscriptionQuotaExceededFault, __BaseException>);
}
/**
 * <p>Amazon SNS has responded that there is a problem with the specified Amazon SNS
 *             topic.</p>
 * @public
 */
export declare class SNSInvalidTopicFault extends __BaseException {
    readonly name: "SNSInvalidTopicFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<SNSInvalidTopicFault, __BaseException>);
}
/**
 * <p>You do not have permission to publish to the specified Amazon SNS topic.</p>
 * @public
 */
export declare class SNSNoAuthorizationFault extends __BaseException {
    readonly name: "SNSNoAuthorizationFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<SNSNoAuthorizationFault, __BaseException>);
}
/**
 * <p>An Amazon SNS topic with the specified Amazon Resource Name (ARN) does not
 *             exist.</p>
 * @public
 */
export declare class SNSTopicArnNotFoundFault extends __BaseException {
    readonly name: "SNSTopicArnNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<SNSTopicArnNotFoundFault, __BaseException>);
}
/**
 * <p>The specified Amazon Redshift event source could not be found.</p>
 * @public
 */
export declare class SourceNotFoundFault extends __BaseException {
    readonly name: "SourceNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<SourceNotFoundFault, __BaseException>);
}
/**
 * <p>There is already an existing event notification subscription with the specified
 *             name.</p>
 * @public
 */
export declare class SubscriptionAlreadyExistFault extends __BaseException {
    readonly name: "SubscriptionAlreadyExistFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<SubscriptionAlreadyExistFault, __BaseException>);
}
/**
 * <p>The value specified for the event category was not one of the allowed values, or it
 *             specified a category that does not apply to the specified source type. The allowed
 *             values are Configuration, Management, Monitoring, and Security.</p>
 * @public
 */
export declare class SubscriptionCategoryNotFoundFault extends __BaseException {
    readonly name: "SubscriptionCategoryNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<SubscriptionCategoryNotFoundFault, __BaseException>);
}
/**
 * <p>An Amazon Redshift event with the specified event ID does not exist.</p>
 * @public
 */
export declare class SubscriptionEventIdNotFoundFault extends __BaseException {
    readonly name: "SubscriptionEventIdNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<SubscriptionEventIdNotFoundFault, __BaseException>);
}
/**
 * <p>The value specified for the event severity was not one of the allowed values, or it
 *             specified a severity that does not apply to the specified source type. The allowed
 *             values are ERROR and INFO.</p>
 * @public
 */
export declare class SubscriptionSeverityNotFoundFault extends __BaseException {
    readonly name: "SubscriptionSeverityNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<SubscriptionSeverityNotFoundFault, __BaseException>);
}
/**
 * <p>There is already an existing Amazon Redshift HSM client certificate with the specified
 *             identifier.</p>
 * @public
 */
export declare class HsmClientCertificateAlreadyExistsFault extends __BaseException {
    readonly name: "HsmClientCertificateAlreadyExistsFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<HsmClientCertificateAlreadyExistsFault, __BaseException>);
}
/**
 * <p>The quota for HSM client certificates has been reached.
 * For information about increasing your quota, go to <a href="https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html">Limits in Amazon Redshift</a>
 * in the <i>Amazon Redshift Cluster Management Guide</i>.
 * </p>
 * @public
 */
export declare class HsmClientCertificateQuotaExceededFault extends __BaseException {
    readonly name: "HsmClientCertificateQuotaExceededFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<HsmClientCertificateQuotaExceededFault, __BaseException>);
}
/**
 * <p>There is already an existing Amazon Redshift HSM configuration with the specified
 *             identifier.</p>
 * @public
 */
export declare class HsmConfigurationAlreadyExistsFault extends __BaseException {
    readonly name: "HsmConfigurationAlreadyExistsFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<HsmConfigurationAlreadyExistsFault, __BaseException>);
}
/**
 * <p>The quota for HSM configurations has been reached.
 * For information about increasing your quota, go to <a href="https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html">Limits in Amazon Redshift</a>
 * in the <i>Amazon Redshift Cluster Management Guide</i>.
 * </p>
 * @public
 */
export declare class HsmConfigurationQuotaExceededFault extends __BaseException {
    readonly name: "HsmConfigurationQuotaExceededFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<HsmConfigurationQuotaExceededFault, __BaseException>);
}
/**
 * <p>The integration you are trying to create already exists.</p>
 * @public
 */
export declare class IntegrationAlreadyExistsFault extends __BaseException {
    readonly name: "IntegrationAlreadyExistsFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<IntegrationAlreadyExistsFault, __BaseException>);
}
/**
 * <p>A conflicting conditional operation is currently in progress against this resource.
 *             This typically occurs when there are multiple requests being made to the same resource at the same time,
 *             and these requests conflict with each other.</p>
 * @public
 */
export declare class IntegrationConflictOperationFault extends __BaseException {
    readonly name: "IntegrationConflictOperationFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<IntegrationConflictOperationFault, __BaseException>);
}
/**
 * <p>You can't create any more zero-ETL or S3 event integrations because the quota has been reached.</p>
 * @public
 */
export declare class IntegrationQuotaExceededFault extends __BaseException {
    readonly name: "IntegrationQuotaExceededFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<IntegrationQuotaExceededFault, __BaseException>);
}
/**
 * <p>The specified integration source can't be found.</p>
 * @public
 */
export declare class IntegrationSourceNotFoundFault extends __BaseException {
    readonly name: "IntegrationSourceNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<IntegrationSourceNotFoundFault, __BaseException>);
}
/**
 * <p>The specified integration target can't be found.</p>
 * @public
 */
export declare class IntegrationTargetNotFoundFault extends __BaseException {
    readonly name: "IntegrationTargetNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<IntegrationTargetNotFoundFault, __BaseException>);
}
/**
 * <p>The application you attempted to add already exists.</p>
 * @public
 */
export declare class RedshiftIdcApplicationAlreadyExistsFault extends __BaseException {
    readonly name: "RedshiftIdcApplicationAlreadyExistsFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<RedshiftIdcApplicationAlreadyExistsFault, __BaseException>);
}
/**
 * <p>The maximum number of Redshift IAM Identity Center applications was exceeded.</p>
 * @public
 */
export declare class RedshiftIdcApplicationQuotaExceededFault extends __BaseException {
    readonly name: "RedshiftIdcApplicationQuotaExceededFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<RedshiftIdcApplicationQuotaExceededFault, __BaseException>);
}
/**
 * <p>The scheduled action is not valid. </p>
 * @public
 */
export declare class InvalidScheduledActionFault extends __BaseException {
    readonly name: "InvalidScheduledActionFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidScheduledActionFault, __BaseException>);
}
/**
 * <p>The schedule you submitted isn't valid.</p>
 * @public
 */
export declare class InvalidScheduleFault extends __BaseException {
    readonly name: "InvalidScheduleFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidScheduleFault, __BaseException>);
}
/**
 * <p>The scheduled action already exists. </p>
 * @public
 */
export declare class ScheduledActionAlreadyExistsFault extends __BaseException {
    readonly name: "ScheduledActionAlreadyExistsFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<ScheduledActionAlreadyExistsFault, __BaseException>);
}
/**
 * <p>The quota for scheduled actions exceeded. </p>
 * @public
 */
export declare class ScheduledActionQuotaExceededFault extends __BaseException {
    readonly name: "ScheduledActionQuotaExceededFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<ScheduledActionQuotaExceededFault, __BaseException>);
}
/**
 * <p>The action type specified for a scheduled action is not supported. </p>
 * @public
 */
export declare class ScheduledActionTypeUnsupportedFault extends __BaseException {
    readonly name: "ScheduledActionTypeUnsupportedFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<ScheduledActionTypeUnsupportedFault, __BaseException>);
}
/**
 * <p>The snapshot copy grant can't be created because a grant with the same name already
 *             exists.</p>
 * @public
 */
export declare class SnapshotCopyGrantAlreadyExistsFault extends __BaseException {
    readonly name: "SnapshotCopyGrantAlreadyExistsFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<SnapshotCopyGrantAlreadyExistsFault, __BaseException>);
}
/**
 * <p>The Amazon Web Services account has exceeded the maximum number of snapshot copy grants in this
 *             region.</p>
 * @public
 */
export declare class SnapshotCopyGrantQuotaExceededFault extends __BaseException {
    readonly name: "SnapshotCopyGrantQuotaExceededFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<SnapshotCopyGrantQuotaExceededFault, __BaseException>);
}
/**
 * <p>The definition you submitted is not supported.</p>
 * @public
 */
export declare class ScheduleDefinitionTypeUnsupportedFault extends __BaseException {
    readonly name: "ScheduleDefinitionTypeUnsupportedFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<ScheduleDefinitionTypeUnsupportedFault, __BaseException>);
}
/**
 * <p>The specified snapshot schedule already exists. </p>
 * @public
 */
export declare class SnapshotScheduleAlreadyExistsFault extends __BaseException {
    readonly name: "SnapshotScheduleAlreadyExistsFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<SnapshotScheduleAlreadyExistsFault, __BaseException>);
}
/**
 * <p>You have exceeded the quota of snapshot schedules. </p>
 * @public
 */
export declare class SnapshotScheduleQuotaExceededFault extends __BaseException {
    readonly name: "SnapshotScheduleQuotaExceededFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<SnapshotScheduleQuotaExceededFault, __BaseException>);
}
/**
 * <p>The resource could not be found.</p>
 * @public
 */
export declare class ResourceNotFoundFault extends __BaseException {
    readonly name: "ResourceNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<ResourceNotFoundFault, __BaseException>);
}
/**
 * <p>The usage limit is not valid.</p>
 * @public
 */
export declare class InvalidUsageLimitFault extends __BaseException {
    readonly name: "InvalidUsageLimitFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidUsageLimitFault, __BaseException>);
}
/**
 * <p>The usage limit already exists. </p>
 * @public
 */
export declare class UsageLimitAlreadyExistsFault extends __BaseException {
    readonly name: "UsageLimitAlreadyExistsFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<UsageLimitAlreadyExistsFault, __BaseException>);
}
/**
 * <p>An error occurred. The custom domain name couldn't be found.</p>
 * @public
 */
export declare class CustomDomainAssociationNotFoundFault extends __BaseException {
    readonly name: "CustomDomainAssociationNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<CustomDomainAssociationNotFoundFault, __BaseException>);
}
/**
 * <p>The cluster parameter group action can not be completed because another task is in
 *             progress that involves the parameter group. Wait a few moments and try the operation
 *             again.</p>
 * @public
 */
export declare class InvalidClusterParameterGroupStateFault extends __BaseException {
    readonly name: "InvalidClusterParameterGroupStateFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidClusterParameterGroupStateFault, __BaseException>);
}
/**
 * <p>The state of the subnet is invalid.</p>
 * @public
 */
export declare class InvalidClusterSubnetStateFault extends __BaseException {
    readonly name: "InvalidClusterSubnetStateFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidClusterSubnetStateFault, __BaseException>);
}
/**
 * <p>The endpoint name doesn't refer to an existing endpoint.</p>
 * @public
 */
export declare class EndpointNotFoundFault extends __BaseException {
    readonly name: "EndpointNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<EndpointNotFoundFault, __BaseException>);
}
/**
 * <p>The status of the endpoint is not valid.</p>
 * @public
 */
export declare class InvalidEndpointStateFault extends __BaseException {
    readonly name: "InvalidEndpointStateFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidEndpointStateFault, __BaseException>);
}
/**
 * <p>The subscription request is invalid because it is a duplicate request. This
 *             subscription request is already in progress.</p>
 * @public
 */
export declare class InvalidSubscriptionStateFault extends __BaseException {
    readonly name: "InvalidSubscriptionStateFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidSubscriptionStateFault, __BaseException>);
}
/**
 * <p>An Amazon Redshift event notification subscription with the specified name does not
 *             exist.</p>
 * @public
 */
export declare class SubscriptionNotFoundFault extends __BaseException {
    readonly name: "SubscriptionNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<SubscriptionNotFoundFault, __BaseException>);
}
/**
 * <p>The specified HSM client certificate is not in the <code>available</code> state, or
 *             it is still in use by one or more Amazon Redshift clusters.</p>
 * @public
 */
export declare class InvalidHsmClientCertificateStateFault extends __BaseException {
    readonly name: "InvalidHsmClientCertificateStateFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidHsmClientCertificateStateFault, __BaseException>);
}
/**
 * <p>The specified HSM configuration is not in the <code>available</code> state, or it
 *             is still in use by one or more Amazon Redshift clusters.</p>
 * @public
 */
export declare class InvalidHsmConfigurationStateFault extends __BaseException {
    readonly name: "InvalidHsmConfigurationStateFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidHsmConfigurationStateFault, __BaseException>);
}
/**
 * <p>The integration is in an invalid state and can't perform the requested operation.</p>
 * @public
 */
export declare class IntegrationConflictStateFault extends __BaseException {
    readonly name: "IntegrationConflictStateFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<IntegrationConflictStateFault, __BaseException>);
}
/**
 * <p>The integration can't be found.</p>
 * @public
 */
export declare class IntegrationNotFoundFault extends __BaseException {
    readonly name: "IntegrationNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<IntegrationNotFoundFault, __BaseException>);
}
/**
 * <p>The scheduled action cannot be found. </p>
 * @public
 */
export declare class ScheduledActionNotFoundFault extends __BaseException {
    readonly name: "ScheduledActionNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<ScheduledActionNotFoundFault, __BaseException>);
}
/**
 * <p>The snapshot copy grant can't be deleted because it is used by one or more
 *             clusters.</p>
 * @public
 */
export declare class InvalidSnapshotCopyGrantStateFault extends __BaseException {
    readonly name: "InvalidSnapshotCopyGrantStateFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidSnapshotCopyGrantStateFault, __BaseException>);
}
/**
 * <p>The specified snapshot copy grant can't be found. Make sure that the name is typed
 *             correctly and that the grant exists in the destination region.</p>
 * @public
 */
export declare class SnapshotCopyGrantNotFoundFault extends __BaseException {
    readonly name: "SnapshotCopyGrantNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<SnapshotCopyGrantNotFoundFault, __BaseException>);
}
/**
 * <p>The cluster snapshot schedule state is not valid.</p>
 * @public
 */
export declare class InvalidClusterSnapshotScheduleStateFault extends __BaseException {
    readonly name: "InvalidClusterSnapshotScheduleStateFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidClusterSnapshotScheduleStateFault, __BaseException>);
}
/**
 * <p>The usage limit identifier can't be found.</p>
 * @public
 */
export declare class UsageLimitNotFoundFault extends __BaseException {
    readonly name: "UsageLimitNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<UsageLimitNotFoundFault, __BaseException>);
}
/**
 * <p>The reserved-node exchange status wasn't found.</p>
 * @public
 */
export declare class ReservedNodeExchangeNotFoundFault extends __BaseException {
    readonly name: "ReservedNodeExchangeNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<ReservedNodeExchangeNotFoundFault, __BaseException>);
}
/**
 * <p>The specified <code>TableRestoreRequestId</code> value was not found.</p>
 * @public
 */
export declare class TableRestoreNotFoundFault extends __BaseException {
    readonly name: "TableRestoreNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<TableRestoreNotFoundFault, __BaseException>);
}
/**
 * <p>The cluster already has cross-region snapshot copy disabled.</p>
 * @public
 */
export declare class SnapshotCopyAlreadyDisabledFault extends __BaseException {
    readonly name: "SnapshotCopyAlreadyDisabledFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<SnapshotCopyAlreadyDisabledFault, __BaseException>);
}
/**
 * <p>The cluster does not have read bucket or put object permissions on the S3 bucket
 *             specified when enabling logging.</p>
 * @public
 */
export declare class InsufficientS3BucketPolicyFault extends __BaseException {
    readonly name: "InsufficientS3BucketPolicyFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InsufficientS3BucketPolicyFault, __BaseException>);
}
/**
 * <p>The S3 bucket name is invalid. For more information about naming rules, go to
 *                 <a href="https://docs.aws.amazon.com/AmazonS3/latest/dev/BucketRestrictions.html">Bucket
 *                 Restrictions and Limitations</a> in the Amazon Simple Storage Service (S3)
 *             Developer Guide.</p>
 * @public
 */
export declare class InvalidS3BucketNameFault extends __BaseException {
    readonly name: "InvalidS3BucketNameFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidS3BucketNameFault, __BaseException>);
}
/**
 * <p>The string specified for the logging S3 key prefix does not comply with the
 *             documented constraints.</p>
 * @public
 */
export declare class InvalidS3KeyPrefixFault extends __BaseException {
    readonly name: "InvalidS3KeyPrefixFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidS3KeyPrefixFault, __BaseException>);
}
/**
 * <p>The specified options are incompatible.</p>
 * @public
 */
export declare class IncompatibleOrderableOptions extends __BaseException {
    readonly name: "IncompatibleOrderableOptions";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<IncompatibleOrderableOptions, __BaseException>);
}
/**
 * <p>The cluster already has cross-region snapshot copy enabled.</p>
 * @public
 */
export declare class SnapshotCopyAlreadyEnabledFault extends __BaseException {
    readonly name: "SnapshotCopyAlreadyEnabledFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<SnapshotCopyAlreadyEnabledFault, __BaseException>);
}
/**
 * <p>The specified region is incorrect or does not exist.</p>
 * @public
 */
export declare class UnknownSnapshotCopyRegionFault extends __BaseException {
    readonly name: "UnknownSnapshotCopyRegionFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<UnknownSnapshotCopyRegionFault, __BaseException>);
}
/**
 * <p>The authorization for this endpoint can't be found.</p>
 * @public
 */
export declare class EndpointAuthorizationNotFoundFault extends __BaseException {
    readonly name: "EndpointAuthorizationNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<EndpointAuthorizationNotFoundFault, __BaseException>);
}
/**
 * <p>The request contains one or more invalid parameters.
 *             This error occurs when required parameters are missing,
 *             parameter values are outside acceptable ranges,
 *             or parameter formats are incorrect.</p>
 * @public
 */
export declare class RedshiftInvalidParameterFault extends __BaseException {
    readonly name: "RedshiftInvalidParameterFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<RedshiftInvalidParameterFault, __BaseException>);
}
/**
 * <p>The resource policy isn't valid.</p>
 * @public
 */
export declare class InvalidPolicyFault extends __BaseException {
    readonly name: "InvalidPolicyFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidPolicyFault, __BaseException>);
}
/**
 * <p>You have exceeded the allowed number of table restore requests. Wait for your
 *             current table restore requests to complete before making a new request.</p>
 * @public
 */
export declare class InProgressTableRestoreQuotaExceededFault extends __BaseException {
    readonly name: "InProgressTableRestoreQuotaExceededFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InProgressTableRestoreQuotaExceededFault, __BaseException>);
}
/**
 * <p>The restore is invalid.</p>
 * @public
 */
export declare class InvalidRestoreFault extends __BaseException {
    readonly name: "InvalidRestoreFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidRestoreFault, __BaseException>);
}
/**
 * <p>The value specified for the <code>sourceDatabaseName</code>,
 *                 <code>sourceSchemaName</code>, or <code>sourceTableName</code> parameter, or a
 *             combination of these, doesn't exist in the snapshot.</p>
 * @public
 */
export declare class InvalidTableRestoreArgumentFault extends __BaseException {
    readonly name: "InvalidTableRestoreArgumentFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidTableRestoreArgumentFault, __BaseException>);
}
/**
 * <p>The number of tables in the cluster exceeds the limit for the requested new cluster
 *             node type. </p>
 * @public
 */
export declare class TableLimitExceededFault extends __BaseException {
    readonly name: "TableLimitExceededFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<TableLimitExceededFault, __BaseException>);
}
/**
 * <p>A request option was specified that is not supported.</p>
 * @public
 */
export declare class UnsupportedOptionFault extends __BaseException {
    readonly name: "UnsupportedOptionFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<UnsupportedOptionFault, __BaseException>);
}
/**
 * <p>A specified subnet is already in use by another cluster.</p>
 * @public
 */
export declare class SubnetAlreadyInUse extends __BaseException {
    readonly name: "SubnetAlreadyInUse";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<SubnetAlreadyInUse, __BaseException>);
}
/**
 * <p>Cross-region snapshot copy was temporarily disabled. Try your request
 *             again.</p>
 * @public
 */
export declare class SnapshotCopyDisabledFault extends __BaseException {
    readonly name: "SnapshotCopyDisabledFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<SnapshotCopyDisabledFault, __BaseException>);
}
/**
 * <p>The specified snapshot schedule is already being updated.</p>
 * @public
 */
export declare class SnapshotScheduleUpdateInProgressFault extends __BaseException {
    readonly name: "SnapshotScheduleUpdateInProgressFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<SnapshotScheduleUpdateInProgressFault, __BaseException>);
}
/**
 * <p>Request would exceed the user's compute node quota.
 * For information about increasing your quota, go to <a href="https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html">Limits in Amazon Redshift</a>
 * in the <i>Amazon Redshift Cluster Management Guide</i>.
 * </p>
 * @public
 */
export declare class ReservedNodeQuotaExceededFault extends __BaseException {
    readonly name: "ReservedNodeQuotaExceededFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<ReservedNodeQuotaExceededFault, __BaseException>);
}