import * as HttpClient from "effect/unstable/http/HttpClient";
import * as redacted from "effect/Redacted";
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 NotificationRuleName = string | redacted.Redacted<string>;
export type EventTypeId = string;
export type NotificationRuleResource = string;
export type TargetType = string;
export type TargetAddress = string | redacted.Redacted<string>;
export type ClientRequestToken = string;
export type TagKey = string;
export type TagValue = string;
export type NotificationRuleArn = string;
export type Message = string;
export type ForceUnsubscribeAll = boolean;
export type ServiceName = string;
export type EventTypeName = string;
export type ResourceType = string;
export type NotificationRuleCreatedBy = string;
export type CreatedTimestamp = Date;
export type LastModifiedTimestamp = Date;
export type ListEventTypesFilterValue = string;
export type NextToken = string;
export type MaxResults = number;
export type ListNotificationRulesFilterValue = string;
export type NotificationRuleId = string;
export type ListTargetsFilterValue = string;
export type EventTypeIds = string[];
export declare const EventTypeIds: S.$Array<S.String>;
export interface Target {
    TargetType?: string;
    TargetAddress?: string | redacted.Redacted<string>;
}
export declare const Target: S.Schema<Target>;
export type Targets = Target[];
export declare const Targets: S.$Array<S.Schema<Target>>;
export type DetailType = "BASIC" | "FULL" | (string & {});
export declare const DetailType: S.String;
export type Tags = {
    [key: string]: string | undefined;
};
export declare const Tags: S.$Record<S.String, S.optional<S.String>>;
export type NotificationRuleStatus = "ENABLED" | "DISABLED" | (string & {});
export declare const NotificationRuleStatus: S.String;
export interface CreateNotificationRuleRequest {
    Name: string | redacted.Redacted<string>;
    EventTypeIds: string[];
    Resource: string;
    Targets: Target[];
    DetailType: DetailType;
    ClientRequestToken?: string;
    Tags?: {
        [key: string]: string | undefined;
    };
    Status?: NotificationRuleStatus;
}
export declare const CreateNotificationRuleRequest: S.Schema<CreateNotificationRuleRequest>;
export interface CreateNotificationRuleResult {
    Arn?: string;
}
export declare const CreateNotificationRuleResult: S.Schema<CreateNotificationRuleResult>;
export interface DeleteNotificationRuleRequest {
    Arn: string;
}
export declare const DeleteNotificationRuleRequest: S.Schema<DeleteNotificationRuleRequest>;
export interface DeleteNotificationRuleResult {
    Arn?: string;
}
export declare const DeleteNotificationRuleResult: S.Schema<DeleteNotificationRuleResult>;
export interface DeleteTargetRequest {
    TargetAddress: string | redacted.Redacted<string>;
    ForceUnsubscribeAll?: boolean;
}
export declare const DeleteTargetRequest: S.Schema<DeleteTargetRequest>;
export interface DeleteTargetResult {
}
export declare const DeleteTargetResult: S.Schema<DeleteTargetResult>;
export interface DescribeNotificationRuleRequest {
    Arn: string;
}
export declare const DescribeNotificationRuleRequest: S.Schema<DescribeNotificationRuleRequest>;
export interface EventTypeSummary {
    EventTypeId?: string;
    ServiceName?: string;
    EventTypeName?: string;
    ResourceType?: string;
}
export declare const EventTypeSummary: S.Schema<EventTypeSummary>;
export type EventTypeBatch = EventTypeSummary[];
export declare const EventTypeBatch: S.$Array<S.Schema<EventTypeSummary>>;
export type TargetStatus = "PENDING" | "ACTIVE" | "UNREACHABLE" | "INACTIVE" | "DEACTIVATED" | (string & {});
export declare const TargetStatus: S.String;
export interface TargetSummary {
    TargetAddress?: string | redacted.Redacted<string>;
    TargetType?: string;
    TargetStatus?: TargetStatus;
}
export declare const TargetSummary: S.Schema<TargetSummary>;
export type TargetsBatch = TargetSummary[];
export declare const TargetsBatch: S.$Array<S.Schema<TargetSummary>>;
export interface DescribeNotificationRuleResult {
    Arn: string;
    Name?: string | redacted.Redacted<string>;
    EventTypes?: EventTypeSummary[];
    Resource?: string;
    Targets?: TargetSummary[];
    DetailType?: DetailType;
    CreatedBy?: string;
    Status?: NotificationRuleStatus;
    CreatedTimestamp?: Date;
    LastModifiedTimestamp?: Date;
    Tags?: {
        [key: string]: string | undefined;
    };
}
export declare const DescribeNotificationRuleResult: S.Schema<DescribeNotificationRuleResult>;
export type ListEventTypesFilterName = "RESOURCE_TYPE" | "SERVICE_NAME" | (string & {});
export declare const ListEventTypesFilterName: S.String;
export interface ListEventTypesFilter {
    Name: ListEventTypesFilterName;
    Value: string;
}
export declare const ListEventTypesFilter: S.Schema<ListEventTypesFilter>;
export type ListEventTypesFilters = ListEventTypesFilter[];
export declare const ListEventTypesFilters: S.$Array<S.Schema<ListEventTypesFilter>>;
export interface ListEventTypesRequest {
    Filters?: ListEventTypesFilter[];
    NextToken?: string;
    MaxResults?: number;
}
export declare const ListEventTypesRequest: S.Schema<ListEventTypesRequest>;
export interface ListEventTypesResult {
    EventTypes?: EventTypeSummary[];
    NextToken?: string;
}
export declare const ListEventTypesResult: S.Schema<ListEventTypesResult>;
export type ListNotificationRulesFilterName = "EVENT_TYPE_ID" | "CREATED_BY" | "RESOURCE" | "TARGET_ADDRESS" | (string & {});
export declare const ListNotificationRulesFilterName: S.String;
export interface ListNotificationRulesFilter {
    Name: ListNotificationRulesFilterName;
    Value: string;
}
export declare const ListNotificationRulesFilter: S.Schema<ListNotificationRulesFilter>;
export type ListNotificationRulesFilters = ListNotificationRulesFilter[];
export declare const ListNotificationRulesFilters: S.$Array<S.Schema<ListNotificationRulesFilter>>;
export interface ListNotificationRulesRequest {
    Filters?: ListNotificationRulesFilter[];
    NextToken?: string;
    MaxResults?: number;
}
export declare const ListNotificationRulesRequest: S.Schema<ListNotificationRulesRequest>;
export interface NotificationRuleSummary {
    Id?: string;
    Arn?: string;
}
export declare const NotificationRuleSummary: S.Schema<NotificationRuleSummary>;
export type NotificationRuleBatch = NotificationRuleSummary[];
export declare const NotificationRuleBatch: S.$Array<S.Schema<NotificationRuleSummary>>;
export interface ListNotificationRulesResult {
    NextToken?: string;
    NotificationRules?: NotificationRuleSummary[];
}
export declare const ListNotificationRulesResult: S.Schema<ListNotificationRulesResult>;
export interface ListTagsForResourceRequest {
    Arn: string;
}
export declare const ListTagsForResourceRequest: S.Schema<ListTagsForResourceRequest>;
export interface ListTagsForResourceResult {
    Tags?: {
        [key: string]: string | undefined;
    };
}
export declare const ListTagsForResourceResult: S.Schema<ListTagsForResourceResult>;
export type ListTargetsFilterName = "TARGET_TYPE" | "TARGET_ADDRESS" | "TARGET_STATUS" | (string & {});
export declare const ListTargetsFilterName: S.String;
export interface ListTargetsFilter {
    Name: ListTargetsFilterName;
    Value: string;
}
export declare const ListTargetsFilter: S.Schema<ListTargetsFilter>;
export type ListTargetsFilters = ListTargetsFilter[];
export declare const ListTargetsFilters: S.$Array<S.Schema<ListTargetsFilter>>;
export interface ListTargetsRequest {
    Filters?: ListTargetsFilter[];
    NextToken?: string;
    MaxResults?: number;
}
export declare const ListTargetsRequest: S.Schema<ListTargetsRequest>;
export interface ListTargetsResult {
    Targets?: TargetSummary[];
    NextToken?: string;
}
export declare const ListTargetsResult: S.Schema<ListTargetsResult>;
export interface SubscribeRequest {
    Arn: string;
    Target: Target;
    ClientRequestToken?: string;
}
export declare const SubscribeRequest: S.Schema<SubscribeRequest>;
export interface SubscribeResult {
    Arn?: string;
}
export declare const SubscribeResult: S.Schema<SubscribeResult>;
export interface TagResourceRequest {
    Arn: string;
    Tags: {
        [key: string]: string | undefined;
    };
}
export declare const TagResourceRequest: S.Schema<TagResourceRequest>;
export interface TagResourceResult {
    Tags?: {
        [key: string]: string | undefined;
    };
}
export declare const TagResourceResult: S.Schema<TagResourceResult>;
export interface UnsubscribeRequest {
    Arn: string;
    TargetAddress: string | redacted.Redacted<string>;
}
export declare const UnsubscribeRequest: S.Schema<UnsubscribeRequest>;
export interface UnsubscribeResult {
    Arn: string;
}
export declare const UnsubscribeResult: S.Schema<UnsubscribeResult>;
export type TagKeys = string[];
export declare const TagKeys: S.$Array<S.String>;
export interface UntagResourceRequest {
    Arn: string;
    TagKeys: string[];
}
export declare const UntagResourceRequest: S.Schema<UntagResourceRequest>;
export interface UntagResourceResult {
}
export declare const UntagResourceResult: S.Schema<UntagResourceResult>;
export interface UpdateNotificationRuleRequest {
    Arn: string;
    Name?: string | redacted.Redacted<string>;
    Status?: NotificationRuleStatus;
    EventTypeIds?: string[];
    Targets?: Target[];
    DetailType?: DetailType;
}
export declare const UpdateNotificationRuleRequest: S.Schema<UpdateNotificationRuleRequest>;
export interface UpdateNotificationRuleResult {
}
export declare const UpdateNotificationRuleResult: S.Schema<UpdateNotificationRuleResult>;
declare const AccessDeniedException_base: S.Class<AccessDeniedException, S.TaggedStruct<"AccessDeniedException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        AuthError: true;
    };
});
export declare class AccessDeniedException extends AccessDeniedException_base {
}
declare const ConcurrentModificationException_base: S.Class<ConcurrentModificationException, S.TaggedStruct<"ConcurrentModificationException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class ConcurrentModificationException extends ConcurrentModificationException_base {
}
declare const ConfigurationException_base: S.Class<ConfigurationException, S.TaggedStruct<"ConfigurationException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class ConfigurationException extends ConfigurationException_base {
}
declare const LimitExceededException_base: S.Class<LimitExceededException, S.TaggedStruct<"LimitExceededException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class LimitExceededException extends LimitExceededException_base {
}
declare const ResourceAlreadyExistsException_base: S.Class<ResourceAlreadyExistsException, S.TaggedStruct<"ResourceAlreadyExistsException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ConflictError: true;
    };
}) & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        AlreadyExistsError: true;
    };
});
export declare class ResourceAlreadyExistsException extends ResourceAlreadyExistsException_base {
}
declare const ValidationException_base: S.Class<ValidationException, S.TaggedStruct<"ValidationException", {
    readonly Message: 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 ResourceNotFoundException_base: S.Class<ResourceNotFoundException, S.TaggedStruct<"ResourceNotFoundException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class ResourceNotFoundException extends ResourceNotFoundException_base {
}
declare const InvalidNextTokenException_base: S.Class<InvalidNextTokenException, S.TaggedStruct<"InvalidNextTokenException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class InvalidNextTokenException extends InvalidNextTokenException_base {
}
export type CreateNotificationRuleError = AccessDeniedException | ConcurrentModificationException | ConfigurationException | LimitExceededException | ResourceAlreadyExistsException | ValidationException | CommonErrors;
/**
 * Creates a notification rule for a resource. The rule specifies the events you want
 * notifications about and the targets (such as Amazon Q Developer in chat applications topics or Amazon Q Developer in chat applications clients configured for Slack) where you want to receive
 * them.
 */
export declare const createNotificationRule: API.OperationMethod<CreateNotificationRuleRequest, CreateNotificationRuleResult, CreateNotificationRuleError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteNotificationRuleError = ConcurrentModificationException | LimitExceededException | ValidationException | CommonErrors;
/**
 * Deletes a notification rule for a resource.
 */
export declare const deleteNotificationRule: API.OperationMethod<DeleteNotificationRuleRequest, DeleteNotificationRuleResult, DeleteNotificationRuleError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteTargetError = ValidationException | CommonErrors;
/**
 * Deletes a specified target for notifications.
 */
export declare const deleteTarget: API.OperationMethod<DeleteTargetRequest, DeleteTargetResult, DeleteTargetError, Credentials | Region | HttpClient.HttpClient>;
export type DescribeNotificationRuleError = ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Returns information about a specified notification rule.
 */
export declare const describeNotificationRule: API.OperationMethod<DescribeNotificationRuleRequest, DescribeNotificationRuleResult, DescribeNotificationRuleError, Credentials | Region | HttpClient.HttpClient>;
export type ListEventTypesError = InvalidNextTokenException | ValidationException | CommonErrors;
/**
 * Returns information about the event types available for configuring notifications.
 */
export declare const listEventTypes: API.OperationMethod<ListEventTypesRequest, ListEventTypesResult, ListEventTypesError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListEventTypesRequest) => stream.Stream<ListEventTypesResult, ListEventTypesError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListEventTypesRequest) => stream.Stream<EventTypeSummary, ListEventTypesError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListNotificationRulesError = InvalidNextTokenException | ValidationException | CommonErrors;
/**
 * Returns a list of the notification rules for an Amazon Web Services account.
 */
export declare const listNotificationRules: API.OperationMethod<ListNotificationRulesRequest, ListNotificationRulesResult, ListNotificationRulesError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListNotificationRulesRequest) => stream.Stream<ListNotificationRulesResult, ListNotificationRulesError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListNotificationRulesRequest) => stream.Stream<NotificationRuleSummary, ListNotificationRulesError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListTagsForResourceError = ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Returns a list of the tags associated with a notification rule.
 */
export declare const listTagsForResource: API.OperationMethod<ListTagsForResourceRequest, ListTagsForResourceResult, ListTagsForResourceError, Credentials | Region | HttpClient.HttpClient>;
export type ListTargetsError = InvalidNextTokenException | ValidationException | CommonErrors;
/**
 * Returns a list of the notification rule targets for an Amazon Web Services account.
 */
export declare const listTargets: API.OperationMethod<ListTargetsRequest, ListTargetsResult, ListTargetsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListTargetsRequest) => stream.Stream<ListTargetsResult, ListTargetsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListTargetsRequest) => stream.Stream<TargetSummary, ListTargetsError, Credentials | Region | HttpClient.HttpClient>;
};
export type SubscribeError = ConfigurationException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Creates an association between a notification rule and an Amazon Q Developer in chat applications topic or Amazon Q Developer in chat applications client so that the
 * associated target can receive notifications when the events described in the rule are
 * triggered.
 */
export declare const subscribe: API.OperationMethod<SubscribeRequest, SubscribeResult, SubscribeError, Credentials | Region | HttpClient.HttpClient>;
export type TagResourceError = ConcurrentModificationException | LimitExceededException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Associates a set of provided tags with a notification rule.
 */
export declare const tagResource: API.OperationMethod<TagResourceRequest, TagResourceResult, TagResourceError, Credentials | Region | HttpClient.HttpClient>;
export type UnsubscribeError = ValidationException | CommonErrors;
/**
 * Removes an association between a notification rule and an Amazon Q Developer in chat applications topic so that
 * subscribers to that topic stop receiving notifications when the events described in the
 * rule are triggered.
 */
export declare const unsubscribe: API.OperationMethod<UnsubscribeRequest, UnsubscribeResult, UnsubscribeError, Credentials | Region | HttpClient.HttpClient>;
export type UntagResourceError = ConcurrentModificationException | LimitExceededException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Removes the association between one or more provided tags and a notification
 * rule.
 */
export declare const untagResource: API.OperationMethod<UntagResourceRequest, UntagResourceResult, UntagResourceError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateNotificationRuleError = ConfigurationException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Updates a notification rule for a resource. You can change the events that trigger the
 * notification rule, the status of the rule, and the targets that receive the
 * notifications.
 *
 * To add or remove tags for a notification rule, you must use TagResource and UntagResource.
 */
export declare const updateNotificationRule: API.OperationMethod<UpdateNotificationRuleRequest, UpdateNotificationRuleResult, UpdateNotificationRuleError, Credentials | Region | HttpClient.HttpClient>;
export {};
//# sourceMappingURL=codestar-notifications.d.ts.map