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 Arn = string;
export type TagKey = string;
export type TagValue = string;
export type CaseTitle = string | redacted.Redacted<string>;
export type CaseDescription = string | redacted.Redacted<string>;
export type AWSAccountId = string;
export type EmailAddress = string | redacted.Redacted<string>;
export type PersonName = string | redacted.Redacted<string>;
export type JobTitle = string | redacted.Redacted<string>;
export type IPAddress = string | redacted.Redacted<string>;
export type UserAgent = string;
export type AwsService = string;
export type CaseId = string;
export type CaseArn = string;
export type AttachmentId = string;
export type FileName = string | redacted.Redacted<string>;
export type PrincipalId = string;
export type CommentBody = string | redacted.Redacted<string>;
export type CommentId = string;
export type Url = string | redacted.Redacted<string>;
export type ContentLength = number;
export type CaseEditAction = string;
export type CaseEditMessage = string;
export type InvestigationId = string;
export type InvestigationTitle = string;
export type InvestigationContent = string;
export type FeedbackComment = string;
export type ResultId = string;
export type MembershipName = string | redacted.Redacted<string>;
export type IncidentResponderName = string | redacted.Redacted<string>;
export type MembershipId = string;
export type MembershipArn = string;
export type OrganizationalUnitId = string;
export interface ListTagsForResourceInput {
    resourceArn: string;
}
export declare const ListTagsForResourceInput: S.Schema<ListTagsForResourceInput>;
export type TagMap = {
    [key: string]: string | undefined;
};
export declare const TagMap: S.$Record<S.String, S.optional<S.String>>;
export interface ListTagsForResourceOutput {
    tags: {
        [key: string]: string | undefined;
    };
}
export declare const ListTagsForResourceOutput: S.Schema<ListTagsForResourceOutput>;
export type ValidationExceptionReason = "UNKNOWN_OPERATION" | "CANNOT_PARSE" | "FIELD_VALIDATION_FAILED" | "OTHER" | (string & {});
export declare const ValidationExceptionReason: S.String;
export interface ValidationExceptionField {
    name: string;
    message: string;
}
export declare const ValidationExceptionField: S.Schema<ValidationExceptionField>;
export type ValidationExceptionFieldList = ValidationExceptionField[];
export declare const ValidationExceptionFieldList: S.$Array<S.Schema<ValidationExceptionField>>;
export interface TagResourceInput {
    resourceArn: string;
    tags: {
        [key: string]: string | undefined;
    };
}
export declare const TagResourceInput: S.Schema<TagResourceInput>;
export interface TagResourceOutput {
}
export declare const TagResourceOutput: S.Schema<TagResourceOutput>;
export type TagKeys = string[];
export declare const TagKeys: S.$Array<S.String>;
export interface UntagResourceInput {
    resourceArn: string;
    tagKeys: string[];
}
export declare const UntagResourceInput: S.Schema<UntagResourceInput>;
export interface UntagResourceOutput {
}
export declare const UntagResourceOutput: S.Schema<UntagResourceOutput>;
export type ResolverType = "AWS" | "Self" | (string & {});
export declare const ResolverType: S.String;
export type EngagementType = "Security Incident" | "Investigation" | (string & {});
export declare const EngagementType: S.String;
export type ImpactedAccounts = string[];
export declare const ImpactedAccounts: S.$Array<S.String>;
export interface Watcher {
    email: string | redacted.Redacted<string>;
    name?: string | redacted.Redacted<string>;
    jobTitle?: string | redacted.Redacted<string>;
}
export declare const Watcher: S.Schema<Watcher>;
export type Watchers = Watcher[];
export declare const Watchers: S.$Array<S.Schema<Watcher>>;
export interface ThreatActorIp {
    ipAddress: string | redacted.Redacted<string>;
    userAgent?: string;
}
export declare const ThreatActorIp: S.Schema<ThreatActorIp>;
export type ThreatActorIpList = ThreatActorIp[];
export declare const ThreatActorIpList: S.$Array<S.Schema<ThreatActorIp>>;
export type ImpactedServicesList = string[];
export declare const ImpactedServicesList: S.$Array<S.String>;
export type AwsRegion = "af-south-1" | "ap-east-1" | "ap-east-2" | "ap-northeast-1" | "ap-northeast-2" | "ap-northeast-3" | "ap-south-1" | "ap-south-2" | "ap-southeast-1" | "ap-southeast-2" | "ap-southeast-3" | "ap-southeast-4" | "ap-southeast-5" | "ap-southeast-6" | "ap-southeast-7" | "ca-central-1" | "ca-west-1" | "cn-north-1" | "cn-northwest-1" | "eu-central-1" | "eu-central-2" | "eu-north-1" | "eu-south-1" | "eu-south-2" | "eu-west-1" | "eu-west-2" | "eu-west-3" | "il-central-1" | "me-central-1" | "me-south-1" | "mx-central-1" | "sa-east-1" | "us-east-1" | "us-east-2" | "us-west-1" | "us-west-2" | (string & {});
export declare const AwsRegion: S.String;
export interface ImpactedAwsRegion {
    region: AwsRegion;
}
export declare const ImpactedAwsRegion: S.Schema<ImpactedAwsRegion>;
export type ImpactedAwsRegionList = ImpactedAwsRegion[];
export declare const ImpactedAwsRegionList: S.$Array<S.Schema<ImpactedAwsRegion>>;
export interface CreateCaseRequest {
    clientToken?: string;
    resolverType: ResolverType;
    title: string | redacted.Redacted<string>;
    description: string | redacted.Redacted<string>;
    engagementType: EngagementType;
    reportedIncidentStartDate: Date;
    impactedAccounts: string[];
    watchers: Watcher[];
    threatActorIpAddresses?: ThreatActorIp[];
    impactedServices?: string[];
    impactedAwsRegions?: ImpactedAwsRegion[];
    tags?: {
        [key: string]: string | undefined;
    };
}
export declare const CreateCaseRequest: S.Schema<CreateCaseRequest>;
export interface CreateCaseResponse {
    caseId: string;
}
export declare const CreateCaseResponse: S.Schema<CreateCaseResponse>;
export interface GetCaseRequest {
    caseId: string;
}
export declare const GetCaseRequest: S.Schema<GetCaseRequest>;
export type CaseStatus = "Submitted" | "Acknowledged" | "Detection and Analysis" | "Containment, Eradication and Recovery" | "Post-incident Activities" | "Ready to Close" | "Closed" | (string & {});
export declare const CaseStatus: S.String;
export type PendingAction = "Customer" | "None" | (string & {});
export declare const PendingAction: S.String;
export type ClosureCode = "Investigation Completed" | "Not Resolved" | "False Positive" | "Duplicate" | (string & {});
export declare const ClosureCode: S.String;
export type CaseAttachmentStatus = "Verified" | "Failed" | "Pending" | (string & {});
export declare const CaseAttachmentStatus: S.String;
export interface CaseAttachmentAttributes {
    attachmentId: string;
    fileName: string | redacted.Redacted<string>;
    attachmentStatus: CaseAttachmentStatus;
    creator: string;
    createdDate: Date;
}
export declare const CaseAttachmentAttributes: S.Schema<CaseAttachmentAttributes>;
export type CaseAttachmentsList = CaseAttachmentAttributes[];
export declare const CaseAttachmentsList: S.$Array<S.Schema<CaseAttachmentAttributes>>;
export interface CaseMetadataEntry {
    key: string;
    value: string;
}
export declare const CaseMetadataEntry: S.Schema<CaseMetadataEntry>;
export type CaseMetadata = CaseMetadataEntry[];
export declare const CaseMetadata: S.$Array<S.Schema<CaseMetadataEntry>>;
export interface GetCaseResponse {
    title?: string | redacted.Redacted<string>;
    caseArn?: string;
    description?: string | redacted.Redacted<string>;
    caseStatus?: CaseStatus;
    engagementType?: EngagementType;
    reportedIncidentStartDate?: Date;
    actualIncidentStartDate?: Date;
    impactedAwsRegions?: ImpactedAwsRegion[];
    threatActorIpAddresses?: ThreatActorIp[];
    pendingAction?: PendingAction;
    impactedAccounts?: string[];
    watchers?: Watcher[];
    createdDate?: Date;
    lastUpdatedDate?: Date;
    closureCode?: ClosureCode;
    resolverType?: ResolverType;
    impactedServices?: string[];
    caseAttachments?: CaseAttachmentAttributes[];
    closedDate?: Date;
    caseMetadata?: CaseMetadataEntry[];
}
export declare const GetCaseResponse: S.Schema<GetCaseResponse>;
export interface UpdateCaseRequest {
    caseId: string;
    title?: string | redacted.Redacted<string>;
    description?: string | redacted.Redacted<string>;
    reportedIncidentStartDate?: Date;
    actualIncidentStartDate?: Date;
    engagementType?: EngagementType;
    watchersToAdd?: Watcher[];
    watchersToDelete?: Watcher[];
    threatActorIpAddressesToAdd?: ThreatActorIp[];
    threatActorIpAddressesToDelete?: ThreatActorIp[];
    impactedServicesToAdd?: string[];
    impactedServicesToDelete?: string[];
    impactedAwsRegionsToAdd?: ImpactedAwsRegion[];
    impactedAwsRegionsToDelete?: ImpactedAwsRegion[];
    impactedAccountsToAdd?: string[];
    impactedAccountsToDelete?: string[];
    caseMetadata?: CaseMetadataEntry[];
}
export declare const UpdateCaseRequest: S.Schema<UpdateCaseRequest>;
export interface UpdateCaseResponse {
}
export declare const UpdateCaseResponse: S.Schema<UpdateCaseResponse>;
export interface ListCasesRequest {
    nextToken?: string;
    maxResults?: number;
}
export declare const ListCasesRequest: S.Schema<ListCasesRequest>;
export interface ListCasesItem {
    caseId: string;
    lastUpdatedDate?: Date;
    title?: string | redacted.Redacted<string>;
    caseArn?: string;
    engagementType?: EngagementType;
    caseStatus?: CaseStatus;
    createdDate?: Date;
    closedDate?: Date;
    resolverType?: ResolverType;
    pendingAction?: PendingAction;
}
export declare const ListCasesItem: S.Schema<ListCasesItem>;
export type ListCasesItems = ListCasesItem[];
export declare const ListCasesItems: S.$Array<S.Schema<ListCasesItem>>;
export interface ListCasesResponse {
    nextToken?: string;
    items?: ListCasesItem[];
    total?: number;
}
export declare const ListCasesResponse: S.Schema<ListCasesResponse>;
export interface CloseCaseRequest {
    caseId: string;
}
export declare const CloseCaseRequest: S.Schema<CloseCaseRequest>;
export interface CloseCaseResponse {
    caseStatus?: CaseStatus;
    closedDate?: Date;
}
export declare const CloseCaseResponse: S.Schema<CloseCaseResponse>;
export interface CreateCaseCommentRequest {
    caseId: string;
    clientToken?: string;
    body: string | redacted.Redacted<string>;
}
export declare const CreateCaseCommentRequest: S.Schema<CreateCaseCommentRequest>;
export interface CreateCaseCommentResponse {
    commentId: string;
}
export declare const CreateCaseCommentResponse: S.Schema<CreateCaseCommentResponse>;
export interface GetCaseAttachmentDownloadUrlRequest {
    caseId: string;
    attachmentId: string;
}
export declare const GetCaseAttachmentDownloadUrlRequest: S.Schema<GetCaseAttachmentDownloadUrlRequest>;
export interface GetCaseAttachmentDownloadUrlResponse {
    attachmentPresignedUrl: string | redacted.Redacted<string>;
}
export declare const GetCaseAttachmentDownloadUrlResponse: S.Schema<GetCaseAttachmentDownloadUrlResponse>;
export interface GetCaseAttachmentUploadUrlRequest {
    caseId: string;
    fileName: string | redacted.Redacted<string>;
    contentLength: number;
    clientToken?: string;
}
export declare const GetCaseAttachmentUploadUrlRequest: S.Schema<GetCaseAttachmentUploadUrlRequest>;
export interface GetCaseAttachmentUploadUrlResponse {
    attachmentPresignedUrl: string | redacted.Redacted<string>;
}
export declare const GetCaseAttachmentUploadUrlResponse: S.Schema<GetCaseAttachmentUploadUrlResponse>;
export interface ListCaseEditsRequest {
    nextToken?: string;
    maxResults?: number;
    caseId: string;
}
export declare const ListCaseEditsRequest: S.Schema<ListCaseEditsRequest>;
export interface CaseEditItem {
    eventTimestamp?: Date;
    principal?: string;
    action?: string;
    message?: string;
}
export declare const CaseEditItem: S.Schema<CaseEditItem>;
export type CaseEditItems = CaseEditItem[];
export declare const CaseEditItems: S.$Array<S.Schema<CaseEditItem>>;
export interface ListCaseEditsResponse {
    nextToken?: string;
    items?: CaseEditItem[];
    total?: number;
}
export declare const ListCaseEditsResponse: S.Schema<ListCaseEditsResponse>;
export interface ListCommentsRequest {
    nextToken?: string;
    maxResults?: number;
    caseId: string;
}
export declare const ListCommentsRequest: S.Schema<ListCommentsRequest>;
export interface ListCommentsItem {
    commentId: string;
    createdDate?: Date;
    lastUpdatedDate?: Date;
    creator?: string;
    lastUpdatedBy?: string;
    body?: string | redacted.Redacted<string>;
}
export declare const ListCommentsItem: S.Schema<ListCommentsItem>;
export type ListCommentsItems = ListCommentsItem[];
export declare const ListCommentsItems: S.$Array<S.Schema<ListCommentsItem>>;
export interface ListCommentsResponse {
    nextToken?: string;
    items?: ListCommentsItem[];
    total?: number;
}
export declare const ListCommentsResponse: S.Schema<ListCommentsResponse>;
export interface ListInvestigationsRequest {
    nextToken?: string;
    maxResults?: number;
    caseId: string;
}
export declare const ListInvestigationsRequest: S.Schema<ListInvestigationsRequest>;
export type ActionType = "Evidence" | "Investigation" | "Summarization" | (string & {});
export declare const ActionType: S.String;
export type ExecutionStatus = "Pending" | "InProgress" | "Waiting" | "Completed" | "Failed" | "Cancelled" | (string & {});
export declare const ExecutionStatus: S.String;
export type UsefulnessRating = "USEFUL" | "NOT_USEFUL" | (string & {});
export declare const UsefulnessRating: S.String;
export interface InvestigationFeedback {
    usefulness?: UsefulnessRating;
    comment?: string;
    submittedAt?: Date;
}
export declare const InvestigationFeedback: S.Schema<InvestigationFeedback>;
export interface InvestigationAction {
    investigationId: string;
    actionType: ActionType;
    title: string;
    content: string;
    status: ExecutionStatus;
    lastUpdated: Date;
    feedback?: InvestigationFeedback;
}
export declare const InvestigationAction: S.Schema<InvestigationAction>;
export type InvestigationActionList = InvestigationAction[];
export declare const InvestigationActionList: S.$Array<S.Schema<InvestigationAction>>;
export interface ListInvestigationsResponse {
    nextToken?: string;
    investigationActions: InvestigationAction[];
}
export declare const ListInvestigationsResponse: S.Schema<ListInvestigationsResponse>;
export interface SendFeedbackRequest {
    caseId: string;
    resultId: string;
    usefulness: UsefulnessRating;
    comment?: string;
}
export declare const SendFeedbackRequest: S.Schema<SendFeedbackRequest>;
export interface SendFeedbackResponse {
}
export declare const SendFeedbackResponse: S.Schema<SendFeedbackResponse>;
export interface UpdateCaseCommentRequest {
    caseId: string;
    commentId: string;
    body: string | redacted.Redacted<string>;
}
export declare const UpdateCaseCommentRequest: S.Schema<UpdateCaseCommentRequest>;
export interface UpdateCaseCommentResponse {
    commentId: string;
    body?: string | redacted.Redacted<string>;
}
export declare const UpdateCaseCommentResponse: S.Schema<UpdateCaseCommentResponse>;
export type SelfManagedCaseStatus = "Submitted" | "Detection and Analysis" | "Containment, Eradication and Recovery" | "Post-incident Activities" | (string & {});
export declare const SelfManagedCaseStatus: S.String;
export interface UpdateCaseStatusRequest {
    caseId: string;
    caseStatus: SelfManagedCaseStatus;
}
export declare const UpdateCaseStatusRequest: S.Schema<UpdateCaseStatusRequest>;
export interface UpdateCaseStatusResponse {
    caseStatus?: SelfManagedCaseStatus;
}
export declare const UpdateCaseStatusResponse: S.Schema<UpdateCaseStatusResponse>;
export interface UpdateResolverTypeRequest {
    caseId: string;
    resolverType: ResolverType;
}
export declare const UpdateResolverTypeRequest: S.Schema<UpdateResolverTypeRequest>;
export interface UpdateResolverTypeResponse {
    caseId: string;
    caseStatus?: CaseStatus;
    resolverType?: ResolverType;
}
export declare const UpdateResolverTypeResponse: S.Schema<UpdateResolverTypeResponse>;
export type CommunicationType = "Case Created" | "Case Updated" | "Case Acknowledged" | "Case Closed" | "Case Updated To Service Managed" | "Case Status Updated" | "Case Pending Customer Action Reminder" | "Case Attachment Url Uploaded" | "Case Comment Added" | "Case Comment Updated" | "Membership Created" | "Membership Updated" | "Membership Cancelled" | "Register Delegated Administrator" | "Deregister Delegated Administrator" | "Disable AWS Service Access" | (string & {});
export declare const CommunicationType: S.String;
export type CommunicationPreferences = CommunicationType[];
export declare const CommunicationPreferences: S.$Array<S.String>;
export interface IncidentResponder {
    name: string | redacted.Redacted<string>;
    jobTitle: string | redacted.Redacted<string>;
    email: string | redacted.Redacted<string>;
    communicationPreferences?: CommunicationType[];
}
export declare const IncidentResponder: S.Schema<IncidentResponder>;
export type IncidentResponseTeam = IncidentResponder[];
export declare const IncidentResponseTeam: S.$Array<S.Schema<IncidentResponder>>;
export type OptInFeatureName = "Triage" | (string & {});
export declare const OptInFeatureName: S.String;
export interface OptInFeature {
    featureName: OptInFeatureName;
    isEnabled: boolean;
}
export declare const OptInFeature: S.Schema<OptInFeature>;
export type OptInFeatures = OptInFeature[];
export declare const OptInFeatures: S.$Array<S.Schema<OptInFeature>>;
export interface CreateMembershipRequest {
    clientToken?: string;
    membershipName: string | redacted.Redacted<string>;
    incidentResponseTeam: IncidentResponder[];
    optInFeatures?: OptInFeature[];
    tags?: {
        [key: string]: string | undefined;
    };
    coverEntireOrganization?: boolean;
}
export declare const CreateMembershipRequest: S.Schema<CreateMembershipRequest>;
export interface CreateMembershipResponse {
    membershipId: string;
}
export declare const CreateMembershipResponse: S.Schema<CreateMembershipResponse>;
export interface GetMembershipRequest {
    membershipId: string;
}
export declare const GetMembershipRequest: S.Schema<GetMembershipRequest>;
export type MembershipStatus = "Active" | "Cancelled" | "Terminated" | (string & {});
export declare const MembershipStatus: S.String;
export type CustomerType = "Standalone" | "Organization" | (string & {});
export declare const CustomerType: S.String;
export type OrganizationalUnits = string[];
export declare const OrganizationalUnits: S.$Array<S.String>;
export interface MembershipAccountsConfigurations {
    coverEntireOrganization?: boolean;
    organizationalUnits?: string[];
}
export declare const MembershipAccountsConfigurations: S.Schema<MembershipAccountsConfigurations>;
export interface GetMembershipResponse {
    membershipId: string;
    accountId?: string;
    region?: AwsRegion;
    membershipName?: string | redacted.Redacted<string>;
    membershipArn?: string;
    membershipStatus?: MembershipStatus;
    membershipActivationTimestamp?: Date;
    membershipDeactivationTimestamp?: Date;
    customerType?: CustomerType;
    numberOfAccountsCovered?: number;
    incidentResponseTeam?: IncidentResponder[];
    optInFeatures?: OptInFeature[];
    membershipAccountsConfigurations?: MembershipAccountsConfigurations;
}
export declare const GetMembershipResponse: S.Schema<GetMembershipResponse>;
export interface MembershipAccountsConfigurationsUpdate {
    coverEntireOrganization?: boolean;
    organizationalUnitsToAdd?: string[];
    organizationalUnitsToRemove?: string[];
}
export declare const MembershipAccountsConfigurationsUpdate: S.Schema<MembershipAccountsConfigurationsUpdate>;
export interface UpdateMembershipRequest {
    membershipId: string;
    membershipName?: string | redacted.Redacted<string>;
    incidentResponseTeam?: IncidentResponder[];
    optInFeatures?: OptInFeature[];
    membershipAccountsConfigurationsUpdate?: MembershipAccountsConfigurationsUpdate;
    undoMembershipCancellation?: boolean;
}
export declare const UpdateMembershipRequest: S.Schema<UpdateMembershipRequest>;
export interface UpdateMembershipResponse {
}
export declare const UpdateMembershipResponse: S.Schema<UpdateMembershipResponse>;
export interface ListMembershipsRequest {
    nextToken?: string;
    maxResults?: number;
}
export declare const ListMembershipsRequest: S.Schema<ListMembershipsRequest>;
export interface ListMembershipItem {
    membershipId: string;
    accountId?: string;
    region?: AwsRegion;
    membershipArn?: string;
    membershipStatus?: MembershipStatus;
}
export declare const ListMembershipItem: S.Schema<ListMembershipItem>;
export type ListMembershipItems = ListMembershipItem[];
export declare const ListMembershipItems: S.$Array<S.Schema<ListMembershipItem>>;
export interface ListMembershipsResponse {
    nextToken?: string;
    items?: ListMembershipItem[];
}
export declare const ListMembershipsResponse: S.Schema<ListMembershipsResponse>;
export type AWSAccountIds = string[];
export declare const AWSAccountIds: S.$Array<S.String>;
export interface BatchGetMemberAccountDetailsRequest {
    membershipId: string;
    accountIds: string[];
}
export declare const BatchGetMemberAccountDetailsRequest: S.Schema<BatchGetMemberAccountDetailsRequest>;
export type MembershipAccountRelationshipStatus = "Associated" | "Disassociated" | "Unassociated" | (string & {});
export declare const MembershipAccountRelationshipStatus: S.String;
export type MembershipAccountRelationshipType = "Organization" | "Unrelated" | (string & {});
export declare const MembershipAccountRelationshipType: S.String;
export interface GetMembershipAccountDetailItem {
    accountId?: string;
    relationshipStatus?: MembershipAccountRelationshipStatus;
    relationshipType?: MembershipAccountRelationshipType;
}
export declare const GetMembershipAccountDetailItem: S.Schema<GetMembershipAccountDetailItem>;
export type GetMembershipAccountDetailItems = GetMembershipAccountDetailItem[];
export declare const GetMembershipAccountDetailItems: S.$Array<S.Schema<GetMembershipAccountDetailItem>>;
export interface GetMembershipAccountDetailError {
    accountId: string;
    error: string;
    message: string;
}
export declare const GetMembershipAccountDetailError: S.Schema<GetMembershipAccountDetailError>;
export type GetMembershipAccountDetailErrors = GetMembershipAccountDetailError[];
export declare const GetMembershipAccountDetailErrors: S.$Array<S.Schema<GetMembershipAccountDetailError>>;
export interface BatchGetMemberAccountDetailsResponse {
    items?: GetMembershipAccountDetailItem[];
    errors?: GetMembershipAccountDetailError[];
}
export declare const BatchGetMemberAccountDetailsResponse: S.Schema<BatchGetMemberAccountDetailsResponse>;
export interface CancelMembershipRequest {
    membershipId: string;
}
export declare const CancelMembershipRequest: S.Schema<CancelMembershipRequest>;
export interface CancelMembershipResponse {
    membershipId: string;
}
export declare const CancelMembershipResponse: S.Schema<CancelMembershipResponse>;
declare const AccessDeniedException_base: S.Class<AccessDeniedException, S.TaggedStruct<"AccessDeniedException", {
    readonly message: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        AuthError: true;
    };
});
export declare class AccessDeniedException extends AccessDeniedException_base {
}
declare const ResourceNotFoundException_base: S.Class<ResourceNotFoundException, S.TaggedStruct<"ResourceNotFoundException", {
    readonly message: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class ResourceNotFoundException extends ResourceNotFoundException_base {
}
declare const ValidationException_base: S.Class<ValidationException, S.TaggedStruct<"ValidationException", {
    readonly message: S.String;
    readonly reason: S.String;
    readonly fieldList: S.optional<S.$Array<S.Schema<ValidationExceptionField>>>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class ValidationException extends ValidationException_base {
}
export type ListTagsForResourceError = AccessDeniedException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Returns currently configured tags on a resource.
 */
export declare const listTagsForResource: API.OperationMethod<ListTagsForResourceInput, ListTagsForResourceOutput, ListTagsForResourceError, Credentials | Region | HttpClient.HttpClient>;
export type TagResourceError = AccessDeniedException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Adds a tag(s) to a designated resource.
 */
export declare const tagResource: API.OperationMethod<TagResourceInput, TagResourceOutput, TagResourceError, Credentials | Region | HttpClient.HttpClient>;
export type UntagResourceError = AccessDeniedException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Removes a tag(s) from a designate resource.
 */
export declare const untagResource: API.OperationMethod<UntagResourceInput, UntagResourceOutput, UntagResourceError, Credentials | Region | HttpClient.HttpClient>;
export type CreateCaseError = CommonErrors;
/**
 * Creates a new case.
 */
export declare const createCase: API.OperationMethod<CreateCaseRequest, CreateCaseResponse, CreateCaseError, Credentials | Region | HttpClient.HttpClient>;
export type GetCaseError = CommonErrors;
/**
 * Returns the attributes of a case.
 */
export declare const getCase: API.OperationMethod<GetCaseRequest, GetCaseResponse, GetCaseError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateCaseError = CommonErrors;
/**
 * Updates an existing case.
 */
export declare const updateCase: API.OperationMethod<UpdateCaseRequest, UpdateCaseResponse, UpdateCaseError, Credentials | Region | HttpClient.HttpClient>;
export type ListCasesError = CommonErrors;
/**
 * Lists all cases the requester has access to.
 */
export declare const listCases: API.OperationMethod<ListCasesRequest, ListCasesResponse, ListCasesError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListCasesRequest) => stream.Stream<ListCasesResponse, ListCasesError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListCasesRequest) => stream.Stream<ListCasesItem, ListCasesError, Credentials | Region | HttpClient.HttpClient>;
};
export type CloseCaseError = CommonErrors;
/**
 * Closes an existing case.
 */
export declare const closeCase: API.OperationMethod<CloseCaseRequest, CloseCaseResponse, CloseCaseError, Credentials | Region | HttpClient.HttpClient>;
export type CreateCaseCommentError = CommonErrors;
/**
 * Adds a comment to an existing case.
 */
export declare const createCaseComment: API.OperationMethod<CreateCaseCommentRequest, CreateCaseCommentResponse, CreateCaseCommentError, Credentials | Region | HttpClient.HttpClient>;
export type GetCaseAttachmentDownloadUrlError = CommonErrors;
/**
 * Returns a Pre-Signed URL for uploading attachments into a case.
 */
export declare const getCaseAttachmentDownloadUrl: API.OperationMethod<GetCaseAttachmentDownloadUrlRequest, GetCaseAttachmentDownloadUrlResponse, GetCaseAttachmentDownloadUrlError, Credentials | Region | HttpClient.HttpClient>;
export type GetCaseAttachmentUploadUrlError = CommonErrors;
/**
 * Uploads an attachment to a case.
 */
export declare const getCaseAttachmentUploadUrl: API.OperationMethod<GetCaseAttachmentUploadUrlRequest, GetCaseAttachmentUploadUrlResponse, GetCaseAttachmentUploadUrlError, Credentials | Region | HttpClient.HttpClient>;
export type ListCaseEditsError = CommonErrors;
/**
 * Views the case history for edits made to a designated case.
 */
export declare const listCaseEdits: API.OperationMethod<ListCaseEditsRequest, ListCaseEditsResponse, ListCaseEditsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListCaseEditsRequest) => stream.Stream<ListCaseEditsResponse, ListCaseEditsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListCaseEditsRequest) => stream.Stream<CaseEditItem, ListCaseEditsError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListCommentsError = CommonErrors;
/**
 * Returns comments for a designated case.
 */
export declare const listComments: API.OperationMethod<ListCommentsRequest, ListCommentsResponse, ListCommentsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListCommentsRequest) => stream.Stream<ListCommentsResponse, ListCommentsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListCommentsRequest) => stream.Stream<ListCommentsItem, ListCommentsError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListInvestigationsError = CommonErrors;
/**
 * Investigation performed by an agent for a security incident...
 */
export declare const listInvestigations: API.OperationMethod<ListInvestigationsRequest, ListInvestigationsResponse, ListInvestigationsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListInvestigationsRequest) => stream.Stream<ListInvestigationsResponse, ListInvestigationsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListInvestigationsRequest) => stream.Stream<InvestigationAction, ListInvestigationsError, Credentials | Region | HttpClient.HttpClient>;
};
export type SendFeedbackError = CommonErrors;
/**
 * Send feedback based on response investigation action
 */
export declare const sendFeedback: API.OperationMethod<SendFeedbackRequest, SendFeedbackResponse, SendFeedbackError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateCaseCommentError = CommonErrors;
/**
 * Updates an existing case comment.
 */
export declare const updateCaseComment: API.OperationMethod<UpdateCaseCommentRequest, UpdateCaseCommentResponse, UpdateCaseCommentError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateCaseStatusError = CommonErrors;
/**
 * Updates the state transitions for a designated cases.
 *
 * **Self-managed**: the following states are available for self-managed cases.
 *
 * - Submitted → Detection and Analysis
 *
 * - Detection and Analysis → Containment, Eradication, and Recovery
 *
 * - Detection and Analysis → Post-incident Activities
 *
 * - Containment, Eradication, and Recovery → Detection and Analysis
 *
 * - Containment, Eradication, and Recovery → Post-incident Activities
 *
 * - Post-incident Activities → Containment, Eradication, and Recovery
 *
 * - Post-incident Activities → Detection and Analysis
 *
 * - Any → Closed
 *
 * **AWS supported**: You must use the `CloseCase` API to close.
 */
export declare const updateCaseStatus: API.OperationMethod<UpdateCaseStatusRequest, UpdateCaseStatusResponse, UpdateCaseStatusError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateResolverTypeError = CommonErrors;
/**
 * Updates the resolver type for a case.
 *
 * This is a one-way action and cannot be reversed.
 */
export declare const updateResolverType: API.OperationMethod<UpdateResolverTypeRequest, UpdateResolverTypeResponse, UpdateResolverTypeError, Credentials | Region | HttpClient.HttpClient>;
export type CreateMembershipError = CommonErrors;
/**
 * Creates a new membership.
 */
export declare const createMembership: API.OperationMethod<CreateMembershipRequest, CreateMembershipResponse, CreateMembershipError, Credentials | Region | HttpClient.HttpClient>;
export type GetMembershipError = CommonErrors;
/**
 * Returns the attributes of a membership.
 */
export declare const getMembership: API.OperationMethod<GetMembershipRequest, GetMembershipResponse, GetMembershipError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateMembershipError = CommonErrors;
/**
 * Updates membership configuration.
 */
export declare const updateMembership: API.OperationMethod<UpdateMembershipRequest, UpdateMembershipResponse, UpdateMembershipError, Credentials | Region | HttpClient.HttpClient>;
export type ListMembershipsError = CommonErrors;
/**
 * Returns the memberships that the calling principal can access.
 */
export declare const listMemberships: API.OperationMethod<ListMembershipsRequest, ListMembershipsResponse, ListMembershipsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListMembershipsRequest) => stream.Stream<ListMembershipsResponse, ListMembershipsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListMembershipsRequest) => stream.Stream<ListMembershipItem, ListMembershipsError, Credentials | Region | HttpClient.HttpClient>;
};
export type BatchGetMemberAccountDetailsError = CommonErrors;
/**
 * Provides information on whether the supplied account IDs are associated with a membership.
 *
 * AWS account ID's may appear less than 12 characters and need to be zero-prepended. An example would be `123123123` which is nine digits, and with zero-prepend would be `000123123123`. Not zero-prepending to 12 digits could result in errors.
 */
export declare const batchGetMemberAccountDetails: API.OperationMethod<BatchGetMemberAccountDetailsRequest, BatchGetMemberAccountDetailsResponse, BatchGetMemberAccountDetailsError, Credentials | Region | HttpClient.HttpClient>;
export type CancelMembershipError = CommonErrors;
/**
 * Cancels an existing membership.
 */
export declare const cancelMembership: API.OperationMethod<CancelMembershipRequest, CancelMembershipResponse, CancelMembershipError, Credentials | Region | HttpClient.HttpClient>;
export {};
//# sourceMappingURL=security-ir.d.ts.map