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 InstanceId = string;
export type ContactId = string;
export type MaxResults = number;
export type NextToken = string;
export type TranscriptId = string;
export type ParticipantId = string;
export type ParticipantRole = string;
export type TranscriptContent = string;
export type OffsetMillis = number;
export type CharacterOffset = number;
export type CategoryName = string;
export type PostContactSummaryContent = string;
export type Message = string;
export interface ListRealtimeContactAnalysisSegmentsRequest {
    InstanceId?: string;
    ContactId?: string;
    MaxResults?: number;
    NextToken?: string;
}
export declare const ListRealtimeContactAnalysisSegmentsRequest: S.Schema<ListRealtimeContactAnalysisSegmentsRequest>;
export type SentimentValue = "POSITIVE" | "NEUTRAL" | "NEGATIVE" | (string & {});
export declare const SentimentValue: S.String;
export interface CharacterOffsets {
    BeginOffsetChar?: number;
    EndOffsetChar?: number;
}
export declare const CharacterOffsets: S.Schema<CharacterOffsets>;
export interface IssueDetected {
    CharacterOffsets?: CharacterOffsets;
}
export declare const IssueDetected: S.Schema<IssueDetected>;
export type IssuesDetected = IssueDetected[];
export declare const IssuesDetected: S.$Array<S.Schema<IssueDetected>>;
export interface Transcript {
    Id?: string;
    ParticipantId?: string;
    ParticipantRole?: string;
    Content?: string;
    BeginOffsetMillis?: number;
    EndOffsetMillis?: number;
    Sentiment?: SentimentValue;
    IssuesDetected?: IssueDetected[];
}
export declare const Transcript: S.Schema<Transcript>;
export type MatchedCategories = string[];
export declare const MatchedCategories: S.$Array<S.String>;
export interface PointOfInterest {
    BeginOffsetMillis?: number;
    EndOffsetMillis?: number;
}
export declare const PointOfInterest: S.Schema<PointOfInterest>;
export type PointsOfInterest = PointOfInterest[];
export declare const PointsOfInterest: S.$Array<S.Schema<PointOfInterest>>;
export interface CategoryDetails {
    PointsOfInterest?: PointOfInterest[];
}
export declare const CategoryDetails: S.Schema<CategoryDetails>;
export type MatchedDetails = {
    [key: string]: CategoryDetails | undefined;
};
export declare const MatchedDetails: S.$Record<S.String, S.optional<S.Schema<CategoryDetails>>>;
export interface Categories {
    MatchedCategories?: string[];
    MatchedDetails?: {
        [key: string]: CategoryDetails | undefined;
    };
}
export declare const Categories: S.Schema<Categories>;
export type PostContactSummaryStatus = "FAILED" | "COMPLETED" | (string & {});
export declare const PostContactSummaryStatus: S.String;
export type PostContactSummaryFailureCode = "QUOTA_EXCEEDED" | "INSUFFICIENT_CONVERSATION_CONTENT" | "FAILED_SAFETY_GUIDELINES" | "INVALID_ANALYSIS_CONFIGURATION" | "INTERNAL_ERROR" | (string & {});
export declare const PostContactSummaryFailureCode: S.String;
export interface PostContactSummary {
    Content?: string;
    Status?: PostContactSummaryStatus;
    FailureCode?: PostContactSummaryFailureCode;
}
export declare const PostContactSummary: S.Schema<PostContactSummary>;
export interface RealtimeContactAnalysisSegment {
    Transcript?: Transcript;
    Categories?: Categories;
    PostContactSummary?: PostContactSummary;
}
export declare const RealtimeContactAnalysisSegment: S.Schema<RealtimeContactAnalysisSegment>;
export type RealtimeContactAnalysisSegments = RealtimeContactAnalysisSegment[];
export declare const RealtimeContactAnalysisSegments: S.$Array<S.Schema<RealtimeContactAnalysisSegment>>;
export interface ListRealtimeContactAnalysisSegmentsResponse {
    Segments: (RealtimeContactAnalysisSegment & {
        Transcript: Transcript & {
            Id: TranscriptId;
            ParticipantId: ParticipantId;
            ParticipantRole: ParticipantRole;
            Content: TranscriptContent;
            BeginOffsetMillis: OffsetMillis;
            EndOffsetMillis: OffsetMillis;
            IssuesDetected: (IssueDetected & {
                CharacterOffsets: CharacterOffsets & {
                    BeginOffsetChar: CharacterOffset;
                    EndOffsetChar: CharacterOffset;
                };
            })[];
        };
        Categories: Categories & {
            MatchedCategories: MatchedCategories;
            MatchedDetails: {
                [key: string]: (CategoryDetails & {
                    PointsOfInterest: (PointOfInterest & {
                        BeginOffsetMillis: OffsetMillis;
                        EndOffsetMillis: OffsetMillis;
                    })[];
                }) | undefined;
            };
        };
        PostContactSummary: PostContactSummary & {
            Status: PostContactSummaryStatus;
        };
    })[];
    NextToken?: string;
}
export declare const ListRealtimeContactAnalysisSegmentsResponse: S.Schema<ListRealtimeContactAnalysisSegmentsResponse>;
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 InternalServiceException_base: S.Class<InternalServiceException, S.TaggedStruct<"InternalServiceException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ServerError: true;
    };
});
export declare class InternalServiceException extends InternalServiceException_base {
}
declare const InvalidRequestException_base: S.Class<InvalidRequestException, S.TaggedStruct<"InvalidRequestException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class InvalidRequestException extends InvalidRequestException_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 ThrottlingException_base: S.Class<ThrottlingException, S.TaggedStruct<"ThrottlingException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ThrottlingError: true;
    };
});
export declare class ThrottlingException extends ThrottlingException_base {
}
export type ListRealtimeContactAnalysisSegmentsError = AccessDeniedException | InternalServiceException | InvalidRequestException | ResourceNotFoundException | ThrottlingException | CommonErrors;
/**
 * Provides a list of analysis segments for a real-time analysis session.
 */
export declare const listRealtimeContactAnalysisSegments: API.OperationMethod<ListRealtimeContactAnalysisSegmentsRequest, ListRealtimeContactAnalysisSegmentsResponse, ListRealtimeContactAnalysisSegmentsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListRealtimeContactAnalysisSegmentsRequest) => stream.Stream<ListRealtimeContactAnalysisSegmentsResponse, ListRealtimeContactAnalysisSegmentsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListRealtimeContactAnalysisSegmentsRequest) => stream.Stream<unknown, ListRealtimeContactAnalysisSegmentsError, Credentials | Region | HttpClient.HttpClient>;
};
export {};
//# sourceMappingURL=connect-contact-lens.d.ts.map