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 RetentionPeriodValue = number;
export type Description = string;
export type TagKey = string;
export type TagValue = string;
export type ResourceTagKey = string;
export type ResourceTagValue = string;
export type UnlockDelayValue = number;
export type RuleIdentifier = string;
export type RuleArn = string;
export type ErrorMessage = string;
export type MaxResults = number;
export type NextToken = string;
export type RetentionPeriodUnit = "DAYS" | (string & {});
export declare const RetentionPeriodUnit: S.String;
export interface RetentionPeriod {
    RetentionPeriodValue: number;
    RetentionPeriodUnit: RetentionPeriodUnit;
}
export declare const RetentionPeriod: S.Schema<RetentionPeriod>;
export interface Tag {
    Key: string;
    Value: string;
}
export declare const Tag: S.Schema<Tag>;
export type TagList = Tag[];
export declare const TagList: S.$Array<S.Schema<Tag>>;
export type ResourceType = "EBS_SNAPSHOT" | "EC2_IMAGE" | "EBS_VOLUME" | (string & {});
export declare const ResourceType: S.String;
export interface ResourceTag {
    ResourceTagKey: string;
    ResourceTagValue?: string;
}
export declare const ResourceTag: S.Schema<ResourceTag>;
export type ResourceTags = ResourceTag[];
export declare const ResourceTags: S.$Array<S.Schema<ResourceTag>>;
export type UnlockDelayUnit = "DAYS" | (string & {});
export declare const UnlockDelayUnit: S.String;
export interface UnlockDelay {
    UnlockDelayValue: number;
    UnlockDelayUnit: UnlockDelayUnit;
}
export declare const UnlockDelay: S.Schema<UnlockDelay>;
export interface LockConfiguration {
    UnlockDelay: UnlockDelay;
}
export declare const LockConfiguration: S.Schema<LockConfiguration>;
export type ExcludeResourceTags = ResourceTag[];
export declare const ExcludeResourceTags: S.$Array<S.Schema<ResourceTag>>;
export interface CreateRuleRequest {
    RetentionPeriod: RetentionPeriod;
    Description?: string;
    Tags?: Tag[];
    ResourceType: ResourceType;
    ResourceTags?: ResourceTag[];
    LockConfiguration?: LockConfiguration;
    ExcludeResourceTags?: ResourceTag[];
}
export declare const CreateRuleRequest: S.Schema<CreateRuleRequest>;
export type RuleStatus = "pending" | "available" | (string & {});
export declare const RuleStatus: S.String;
export type LockState = "locked" | "pending_unlock" | "unlocked" | (string & {});
export declare const LockState: S.String;
export interface CreateRuleResponse {
    Identifier?: string;
    RetentionPeriod?: RetentionPeriod;
    Description?: string;
    Tags?: Tag[];
    ResourceType?: ResourceType;
    ResourceTags?: ResourceTag[];
    Status?: RuleStatus;
    LockConfiguration?: LockConfiguration;
    LockState?: LockState;
    RuleArn?: string;
    ExcludeResourceTags?: ResourceTag[];
}
export declare const CreateRuleResponse: S.Schema<CreateRuleResponse>;
export type ServiceQuotaExceededExceptionReason = "SERVICE_QUOTA_EXCEEDED" | (string & {});
export declare const ServiceQuotaExceededExceptionReason: S.String;
export type ValidationExceptionReason = "INVALID_PAGE_TOKEN" | "INVALID_PARAMETER_VALUE" | (string & {});
export declare const ValidationExceptionReason: S.String;
export interface DeleteRuleRequest {
    Identifier: string;
}
export declare const DeleteRuleRequest: S.Schema<DeleteRuleRequest>;
export interface DeleteRuleResponse {
}
export declare const DeleteRuleResponse: S.Schema<DeleteRuleResponse>;
export type ConflictExceptionReason = "INVALID_RULE_STATE" | (string & {});
export declare const ConflictExceptionReason: S.String;
export type ResourceNotFoundExceptionReason = "RULE_NOT_FOUND" | (string & {});
export declare const ResourceNotFoundExceptionReason: S.String;
export interface GetRuleRequest {
    Identifier: string;
}
export declare const GetRuleRequest: S.Schema<GetRuleRequest>;
export interface GetRuleResponse {
    Identifier?: string;
    Description?: string;
    ResourceType?: ResourceType;
    RetentionPeriod?: RetentionPeriod;
    ResourceTags?: ResourceTag[];
    Status?: RuleStatus;
    LockConfiguration?: LockConfiguration;
    LockState?: LockState;
    LockEndTime?: Date;
    RuleArn?: string;
    ExcludeResourceTags?: ResourceTag[];
}
export declare const GetRuleResponse: S.Schema<GetRuleResponse>;
export interface ListRulesRequest {
    MaxResults?: number;
    NextToken?: string;
    ResourceType: ResourceType;
    ResourceTags?: ResourceTag[];
    LockState?: LockState;
    ExcludeResourceTags?: ResourceTag[];
}
export declare const ListRulesRequest: S.Schema<ListRulesRequest>;
export interface RuleSummary {
    Identifier?: string;
    Description?: string;
    RetentionPeriod?: RetentionPeriod;
    LockState?: LockState;
    RuleArn?: string;
}
export declare const RuleSummary: S.Schema<RuleSummary>;
export type RuleSummaryList = RuleSummary[];
export declare const RuleSummaryList: S.$Array<S.Schema<RuleSummary>>;
export interface ListRulesResponse {
    Rules?: RuleSummary[];
    NextToken?: string;
}
export declare const ListRulesResponse: S.Schema<ListRulesResponse>;
export interface ListTagsForResourceRequest {
    ResourceArn: string;
}
export declare const ListTagsForResourceRequest: S.Schema<ListTagsForResourceRequest>;
export interface ListTagsForResourceResponse {
    Tags?: Tag[];
}
export declare const ListTagsForResourceResponse: S.Schema<ListTagsForResourceResponse>;
export interface LockRuleRequest {
    Identifier: string;
    LockConfiguration: LockConfiguration;
}
export declare const LockRuleRequest: S.Schema<LockRuleRequest>;
export interface LockRuleResponse {
    Identifier?: string;
    Description?: string;
    ResourceType?: ResourceType;
    RetentionPeriod?: RetentionPeriod;
    ResourceTags?: ResourceTag[];
    Status?: RuleStatus;
    LockConfiguration?: LockConfiguration;
    LockState?: LockState;
    RuleArn?: string;
    ExcludeResourceTags?: ResourceTag[];
}
export declare const LockRuleResponse: S.Schema<LockRuleResponse>;
export interface TagResourceRequest {
    ResourceArn: string;
    Tags: Tag[];
}
export declare const TagResourceRequest: S.Schema<TagResourceRequest>;
export interface TagResourceResponse {
}
export declare const TagResourceResponse: S.Schema<TagResourceResponse>;
export interface UnlockRuleRequest {
    Identifier: string;
}
export declare const UnlockRuleRequest: S.Schema<UnlockRuleRequest>;
export interface UnlockRuleResponse {
    Identifier?: string;
    Description?: string;
    ResourceType?: ResourceType;
    RetentionPeriod?: RetentionPeriod;
    ResourceTags?: ResourceTag[];
    Status?: RuleStatus;
    LockConfiguration?: LockConfiguration;
    LockState?: LockState;
    LockEndTime?: Date;
    RuleArn?: string;
    ExcludeResourceTags?: ResourceTag[];
}
export declare const UnlockRuleResponse: S.Schema<UnlockRuleResponse>;
export type TagKeyList = string[];
export declare const TagKeyList: S.$Array<S.String>;
export interface UntagResourceRequest {
    ResourceArn: string;
    TagKeys: string[];
}
export declare const UntagResourceRequest: S.Schema<UntagResourceRequest>;
export interface UntagResourceResponse {
}
export declare const UntagResourceResponse: S.Schema<UntagResourceResponse>;
export interface UpdateRuleRequest {
    Identifier: string;
    RetentionPeriod?: RetentionPeriod;
    Description?: string;
    ResourceType?: ResourceType;
    ResourceTags?: ResourceTag[];
    ExcludeResourceTags?: ResourceTag[];
}
export declare const UpdateRuleRequest: S.Schema<UpdateRuleRequest>;
export interface UpdateRuleResponse {
    Identifier?: string;
    RetentionPeriod?: RetentionPeriod;
    Description?: string;
    ResourceType?: ResourceType;
    ResourceTags?: ResourceTag[];
    Status?: RuleStatus;
    LockState?: LockState;
    LockEndTime?: Date;
    RuleArn?: string;
    ExcludeResourceTags?: ResourceTag[];
}
export declare const UpdateRuleResponse: S.Schema<UpdateRuleResponse>;
declare const InternalServerException_base: S.Class<InternalServerException, S.TaggedStruct<"InternalServerException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ServerError: true;
    };
});
export declare class InternalServerException extends InternalServerException_base {
}
declare const ServiceQuotaExceededException_base: S.Class<ServiceQuotaExceededException, S.TaggedStruct<"ServiceQuotaExceededException", {
    readonly Message: S.optional<S.String>;
    readonly Reason: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        QuotaError: true;
    };
});
export declare class ServiceQuotaExceededException extends ServiceQuotaExceededException_base {
}
declare const ValidationException_base: S.Class<ValidationException, S.TaggedStruct<"ValidationException", {
    readonly Message: S.optional<S.String>;
    readonly Reason: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class ValidationException extends ValidationException_base {
}
declare const ConflictException_base: S.Class<ConflictException, S.TaggedStruct<"ConflictException", {
    readonly Message: S.optional<S.String>;
    readonly Reason: 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 ResourceNotFoundException_base: S.Class<ResourceNotFoundException, S.TaggedStruct<"ResourceNotFoundException", {
    readonly Message: S.optional<S.String>;
    readonly Reason: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class ResourceNotFoundException extends ResourceNotFoundException_base {
}
export type CreateRuleError = InternalServerException | ServiceQuotaExceededException | ValidationException | CommonErrors;
/**
 * Creates a Recycle Bin retention rule. You can create two types of retention rules:
 *
 * - **Tag-level retention rules** - These retention rules use
 * resource tags to identify the resources to protect. For each retention rule, you specify one or
 * more tag key and value pairs. Resources (of the specified type) that have at least one of these
 * tag key and value pairs are automatically retained in the Recycle Bin upon deletion. Use this
 * type of retention rule to protect specific resources in your account based on their tags.
 *
 * - **Region-level retention rules** - These retention rules,
 * by default, apply to all of the resources (of the specified type) in the Region, even if the
 * resources are not tagged. However, you can specify exclusion tags to exclude resources that have
 * specific tags. Use this type of retention rule to protect all resources of a specific type in a
 * Region.
 *
 * For more information, see
 * Create Recycle Bin retention rules in the *Amazon EBS User Guide*.
 */
export declare const createRule: API.OperationMethod<CreateRuleRequest, CreateRuleResponse, CreateRuleError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteRuleError = ConflictException | InternalServerException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Deletes a Recycle Bin retention rule. For more information, see
 * Delete Recycle Bin retention rules in the *Amazon Elastic Compute Cloud User Guide*.
 */
export declare const deleteRule: API.OperationMethod<DeleteRuleRequest, DeleteRuleResponse, DeleteRuleError, Credentials | Region | HttpClient.HttpClient>;
export type GetRuleError = InternalServerException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Gets information about a Recycle Bin retention rule.
 */
export declare const getRule: API.OperationMethod<GetRuleRequest, GetRuleResponse, GetRuleError, Credentials | Region | HttpClient.HttpClient>;
export type ListRulesError = InternalServerException | ValidationException | CommonErrors;
/**
 * Lists the Recycle Bin retention rules in the Region.
 */
export declare const listRules: API.OperationMethod<ListRulesRequest, ListRulesResponse, ListRulesError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListRulesRequest) => stream.Stream<ListRulesResponse, ListRulesError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListRulesRequest) => stream.Stream<RuleSummary, ListRulesError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListTagsForResourceError = InternalServerException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Lists the tags assigned to a retention rule.
 */
export declare const listTagsForResource: API.OperationMethod<ListTagsForResourceRequest, ListTagsForResourceResponse, ListTagsForResourceError, Credentials | Region | HttpClient.HttpClient>;
export type LockRuleError = ConflictException | InternalServerException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Locks a Region-level retention rule. A locked retention rule can't be modified or
 * deleted.
 *
 * You can't lock tag-level retention rules, or Region-level retention rules that
 * have exclusion tags.
 */
export declare const lockRule: API.OperationMethod<LockRuleRequest, LockRuleResponse, LockRuleError, Credentials | Region | HttpClient.HttpClient>;
export type TagResourceError = InternalServerException | ResourceNotFoundException | ServiceQuotaExceededException | ValidationException | CommonErrors;
/**
 * Assigns tags to the specified retention rule.
 */
export declare const tagResource: API.OperationMethod<TagResourceRequest, TagResourceResponse, TagResourceError, Credentials | Region | HttpClient.HttpClient>;
export type UnlockRuleError = ConflictException | InternalServerException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Unlocks a retention rule. After a retention rule is unlocked, it can be modified or deleted
 * only after the unlock delay period expires.
 */
export declare const unlockRule: API.OperationMethod<UnlockRuleRequest, UnlockRuleResponse, UnlockRuleError, Credentials | Region | HttpClient.HttpClient>;
export type UntagResourceError = InternalServerException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Unassigns a tag from a retention rule.
 */
export declare const untagResource: API.OperationMethod<UntagResourceRequest, UntagResourceResponse, UntagResourceError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateRuleError = ConflictException | InternalServerException | ResourceNotFoundException | ServiceQuotaExceededException | ValidationException | CommonErrors;
/**
 * Updates an existing Recycle Bin retention rule. You can update a retention rule's description,
 * resource tags, and retention period at any time after creation. You can't update a retention rule's
 * resource type after creation. For more information, see
 * Update Recycle Bin retention rules in the *Amazon Elastic Compute Cloud User Guide*.
 */
export declare const updateRule: API.OperationMethod<UpdateRuleRequest, UpdateRuleResponse, UpdateRuleError, Credentials | Region | HttpClient.HttpClient>;
export {};
//# sourceMappingURL=rbin.d.ts.map