import type { ExceptionOptionType as __ExceptionOptionType } from "@smithy/core/client";
import { IoTServiceException as __BaseException } from "./IoTServiceException";
/**
 * <p>An unexpected error has occurred.</p>
 * @public
 */
export declare class InternalFailureException extends __BaseException {
    readonly name: "InternalFailureException";
    readonly $fault: "server";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InternalFailureException, __BaseException>);
}
/**
 * <p>The request is not valid.</p>
 * @public
 */
export declare class InvalidRequestException extends __BaseException {
    readonly name: "InvalidRequestException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidRequestException, __BaseException>);
}
/**
 * <p>The specified resource does not exist.</p>
 * @public
 */
export declare class ResourceNotFoundException extends __BaseException {
    readonly name: "ResourceNotFoundException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<ResourceNotFoundException, __BaseException>);
}
/**
 * <p>The service is temporarily unavailable.</p>
 * @public
 */
export declare class ServiceUnavailableException extends __BaseException {
    readonly name: "ServiceUnavailableException";
    readonly $fault: "server";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<ServiceUnavailableException, __BaseException>);
}
/**
 * <p>The rate exceeds the limit.</p>
 * @public
 */
export declare class ThrottlingException extends __BaseException {
    readonly name: "ThrottlingException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<ThrottlingException, __BaseException>);
}
/**
 * <p>You can't revert the certificate transfer because the transfer is already
 *          complete.</p>
 * @public
 */
export declare class TransferAlreadyCompletedException extends __BaseException {
    readonly name: "TransferAlreadyCompletedException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<TransferAlreadyCompletedException, __BaseException>);
}
/**
 * <p>You are not authorized to perform this operation.</p>
 * @public
 */
export declare class UnauthorizedException extends __BaseException {
    readonly name: "UnauthorizedException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<UnauthorizedException, __BaseException>);
}
/**
 * <p>The request conflicts with the current state of the resource.</p>
 * @public
 */
export declare class ConflictException extends __BaseException {
    readonly name: "ConflictException";
    readonly $fault: "client";
    /**
     * <p>A resource with the same name already exists.</p>
     * @public
     */
    resourceId?: string | undefined;
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<ConflictException, __BaseException>);
}
/**
 * <p>Internal error from the service that indicates an unexpected error or that the service
 *             is unavailable.</p>
 * @public
 */
export declare class InternalServerException extends __BaseException {
    readonly name: "InternalServerException";
    readonly $fault: "server";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InternalServerException, __BaseException>);
}
/**
 * <p>Service quota has been exceeded.</p>
 * @public
 */
export declare class ServiceQuotaExceededException extends __BaseException {
    readonly name: "ServiceQuotaExceededException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<ServiceQuotaExceededException, __BaseException>);
}
/**
 * <p>The request is not valid.</p>
 * @public
 */
export declare class ValidationException extends __BaseException {
    readonly name: "ValidationException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<ValidationException, __BaseException>);
}
/**
 * <p>A limit has been exceeded.</p>
 * @public
 */
export declare class LimitExceededException extends __BaseException {
    readonly name: "LimitExceededException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<LimitExceededException, __BaseException>);
}
/**
 * <p>An exception thrown when the version of an entity specified with the
 *             <code>expectedVersion</code> parameter does not match the latest version in the
 *          system.</p>
 * @public
 */
export declare class VersionConflictException extends __BaseException {
    readonly name: "VersionConflictException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<VersionConflictException, __BaseException>);
}
/**
 * <p>An attempt was made to change to an invalid state, for example by deleting a job or a
 *          job execution which is "IN_PROGRESS" without setting the <code>force</code>
 *          parameter.</p>
 * @public
 */
export declare class InvalidStateTransitionException extends __BaseException {
    readonly name: "InvalidStateTransitionException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidStateTransitionException, __BaseException>);
}
/**
 * <p>A conflicting resource update exception. This exception is thrown when two pending
 *          updates cause a conflict.</p>
 * @public
 */
export declare class ConflictingResourceUpdateException extends __BaseException {
    readonly name: "ConflictingResourceUpdateException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<ConflictingResourceUpdateException, __BaseException>);
}
/**
 * <p>An unexpected error has occurred.</p>
 * @public
 */
export declare class InternalException extends __BaseException {
    readonly name: "InternalException";
    readonly $fault: "server";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InternalException, __BaseException>);
}
/**
 * <p>The resource already exists.</p>
 * @public
 */
export declare class ResourceAlreadyExistsException extends __BaseException {
    readonly name: "ResourceAlreadyExistsException";
    readonly $fault: "client";
    /**
     * <p>The ID of the resource that caused the exception.</p>
     * @public
     */
    resourceId?: string | undefined;
    /**
     * <p>The ARN of the resource that caused the exception.</p>
     * @public
     */
    resourceArn?: string | undefined;
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<ResourceAlreadyExistsException, __BaseException>);
}
/**
 * <p>The certificate is invalid.</p>
 * @public
 */
export declare class CertificateValidationException extends __BaseException {
    readonly name: "CertificateValidationException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<CertificateValidationException, __BaseException>);
}
/**
 * <p>The query is invalid.</p>
 * @public
 */
export declare class InvalidQueryException extends __BaseException {
    readonly name: "InvalidQueryException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidQueryException, __BaseException>);
}
/**
 * <p>The index is not ready.</p>
 * @public
 */
export declare class IndexNotReadyException extends __BaseException {
    readonly name: "IndexNotReadyException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<IndexNotReadyException, __BaseException>);
}
/**
 * <p>The aggregation is invalid.</p>
 * @public
 */
export declare class InvalidAggregationException extends __BaseException {
    readonly name: "InvalidAggregationException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidAggregationException, __BaseException>);
}
/**
 * <p>The policy documentation is not valid.</p>
 * @public
 */
export declare class MalformedPolicyException extends __BaseException {
    readonly name: "MalformedPolicyException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<MalformedPolicyException, __BaseException>);
}
/**
 * <p>The number of policy versions exceeds the limit.</p>
 * @public
 */
export declare class VersionsLimitExceededException extends __BaseException {
    readonly name: "VersionsLimitExceededException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<VersionsLimitExceededException, __BaseException>);
}
/**
 * <p>The Rule-SQL expression can't be parsed correctly.</p>
 * @public
 */
export declare class SqlParseException extends __BaseException {
    readonly name: "SqlParseException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<SqlParseException, __BaseException>);
}
/**
 * <p>You can't delete the resource because it is attached to one or more
 *          resources.</p>
 * @public
 */
export declare class DeleteConflictException extends __BaseException {
    readonly name: "DeleteConflictException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DeleteConflictException, __BaseException>);
}
/**
 * <p>The certificate operation is not allowed.</p>
 * @public
 */
export declare class CertificateStateException extends __BaseException {
    readonly name: "CertificateStateException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<CertificateStateException, __BaseException>);
}
/**
 * <p>The resource is not configured.</p>
 * @public
 */
export declare class NotConfiguredException extends __BaseException {
    readonly name: "NotConfiguredException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<NotConfiguredException, __BaseException>);
}
/**
 * <p>The registration code is invalid.</p>
 * @public
 */
export declare class RegistrationCodeValidationException extends __BaseException {
    readonly name: "RegistrationCodeValidationException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<RegistrationCodeValidationException, __BaseException>);
}
/**
 * <p>Unable to verify the CA certificate used to sign the device certificate you are
 *          attempting to register. This is happens when you have registered more than one CA
 *          certificate that has the same subject field and public key.</p>
 * @public
 */
export declare class CertificateConflictException extends __BaseException {
    readonly name: "CertificateConflictException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<CertificateConflictException, __BaseException>);
}
/**
 * <p>The resource registration failed.</p>
 * @public
 */
export declare class ResourceRegistrationFailureException extends __BaseException {
    readonly name: "ResourceRegistrationFailureException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<ResourceRegistrationFailureException, __BaseException>);
}
/**
 * <p>
 *             This exception occurs if you attempt to start a task with the same task-id as an existing task but with a different clientRequestToken.
 *         </p>
 * @public
 */
export declare class TaskAlreadyExistsException extends __BaseException {
    readonly name: "TaskAlreadyExistsException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<TaskAlreadyExistsException, __BaseException>);
}
/**
 * <p>The response is invalid.</p>
 * @public
 */
export declare class InvalidResponseException extends __BaseException {
    readonly name: "InvalidResponseException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidResponseException, __BaseException>);
}
/**
 * <p>You can't transfer the certificate because authorization policies are still
 *          attached.</p>
 * @public
 */
export declare class TransferConflictException extends __BaseException {
    readonly name: "TransferConflictException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<TransferConflictException, __BaseException>);
}