@lpextend/node-sdk 1.1.2

package/dist/index.d.mts

@@ -0,0 +1,2989 @@
+/**
+ * Account Configuration Types
+ *
+ * TypeScript interfaces for LP Account Configuration APIs.
+ * These use standard Bearer authentication.
+ */
+interface LPSkill {
+    id: number;
+    name: string;
+    description?: string;
+    deleted?: boolean;
+    maxWaitTime?: number;
+    skillOrder?: number;
+    canTransfer?: boolean;
+    skillRoutingConfiguration?: LPSkillRoutingConfig[];
+    dateUpdated?: string;
+}
+interface LPSkillRoutingConfig {
+    priority?: number;
+    autoAccept?: boolean;
+    maxNumberOfChats?: number;
+}
+interface CreateSkillRequest {
+    name: string;
+    description?: string;
+    maxWaitTime?: number;
+    skillOrder?: number;
+    canTransfer?: boolean;
+}
+interface UpdateSkillRequest {
+    name?: string;
+    description?: string;
+    maxWaitTime?: number;
+    skillOrder?: number;
+    canTransfer?: boolean;
+    deleted?: boolean;
+}
+interface LPUser {
+    id: string;
+    pid?: string;
+    loginName: string;
+    fullName?: string;
+    nickname?: string;
+    email?: string;
+    employeeId?: string;
+    isEnabled?: boolean;
+    deleted?: boolean;
+    userTypeId?: string;
+    skillIds?: number[];
+    profileIds?: number[];
+    maxChats?: number;
+    maxAsyncChats?: number;
+    memberOf?: MemberOf;
+    managerOf?: number[];
+    dateUpdated?: string;
+}
+interface MemberOf {
+    agentGroupId: number;
+    assignmentDate?: string;
+}
+interface CreateUserRequest {
+    loginName: string;
+    password?: string;
+    fullName?: string;
+    nickname?: string;
+    email?: string;
+    employeeId?: string;
+    skillIds?: number[];
+    profileIds?: number[];
+    maxChats?: number;
+    maxAsyncChats?: number;
+    memberOf?: MemberOf;
+}
+interface UpdateUserRequest {
+    fullName?: string;
+    nickname?: string;
+    email?: string;
+    employeeId?: string;
+    skillIds?: number[];
+    profileIds?: number[];
+    isEnabled?: boolean;
+    maxChats?: number;
+    maxAsyncChats?: number;
+    memberOf?: MemberOf;
+    managerOf?: number[];
+    deleted?: boolean;
+}
+interface LPAgentGroup {
+    id: number;
+    name: string;
+    description?: string;
+    parentGroupId?: number;
+    isEnabled?: boolean;
+    deleted?: boolean;
+    dateUpdated?: string;
+}
+interface CreateAgentGroupRequest {
+    name: string;
+    description?: string;
+    parentGroupId?: number;
+}
+interface UpdateAgentGroupRequest {
+    name?: string;
+    description?: string;
+    parentGroupId?: number;
+    isEnabled?: boolean;
+    deleted?: boolean;
+}
+interface LPProfile {
+    id: number;
+    name: string;
+    description?: string;
+    roleTypeId?: number;
+    roleTypeName?: string;
+    permissions?: LPPermission[];
+    dateUpdated?: string;
+}
+interface LPPermission {
+    id: number;
+    name: string;
+    value: boolean;
+}
+interface CreateProfileRequest {
+    name: string;
+    description?: string;
+    roleTypeId: number;
+    permissions?: Array<{
+        id: number;
+        value: boolean;
+    }>;
+}
+interface UpdateProfileRequest {
+    name?: string;
+    description?: string;
+    permissions?: Array<{
+        id: number;
+        value: boolean;
+    }>;
+}
+interface LPLOB {
+    id: number;
+    name: string;
+    description?: string;
+    deleted?: boolean;
+    dateUpdated?: string;
+}
+interface CreateLOBRequest {
+    name: string;
+    description?: string;
+}
+interface UpdateLOBRequest {
+    name?: string;
+    description?: string;
+    deleted?: boolean;
+}
+interface LPCampaign {
+    id: number;
+    name: string;
+    description?: string;
+    lobId?: number;
+    status?: 'active' | 'inactive';
+    goalId?: number;
+    dateUpdated?: string;
+}
+interface CreateCampaignRequest {
+    name: string;
+    description?: string;
+    lobId?: number;
+    goalId?: number;
+}
+interface UpdateCampaignRequest {
+    name?: string;
+    description?: string;
+    lobId?: number;
+    status?: 'active' | 'inactive';
+    goalId?: number;
+}
+interface LPEngagement {
+    id: number;
+    name: string;
+    campaignId: number;
+    type?: string;
+    skillId?: number;
+    skillName?: string;
+    status?: 'active' | 'inactive';
+    dateUpdated?: string;
+}
+interface CreateEngagementRequest {
+    name: string;
+    campaignId: number;
+    type?: string;
+    skillId?: number;
+}
+interface UpdateEngagementRequest {
+    name?: string;
+    type?: string;
+    skillId?: number;
+    status?: 'active' | 'inactive';
+}
+interface LPPredefinedContent {
+    id: number;
+    title: string;
+    data: LPPredefinedContentData[];
+    categories?: string[];
+    hotkey?: string;
+    deleted?: boolean;
+    dateUpdated?: string;
+}
+interface LPPredefinedContentData {
+    text: string;
+    lang?: string;
+    isDefault?: boolean;
+}
+interface CreatePredefinedContentRequest {
+    title: string;
+    data: LPPredefinedContentData[];
+    categories?: string[];
+    hotkey?: string;
+}
+interface UpdatePredefinedContentRequest {
+    title?: string;
+    data?: LPPredefinedContentData[];
+    categories?: string[];
+    hotkey?: string;
+    deleted?: boolean;
+}
+interface LPAutomaticMessage {
+    id: number;
+    name: string;
+    messageEventId: string;
+    data: LPAutomaticMessageData[];
+    deleted?: boolean;
+    dateUpdated?: string;
+}
+interface LPAutomaticMessageData {
+    text: string;
+    lang?: string;
+}
+interface CreateAutomaticMessageRequest {
+    name: string;
+    messageEventId: string;
+    data: LPAutomaticMessageData[];
+}
+interface UpdateAutomaticMessageRequest {
+    name?: string;
+    data?: LPAutomaticMessageData[];
+    deleted?: boolean;
+}
+interface LPWorkingHours {
+    id: number;
+    name: string;
+    deleted?: boolean;
+    isDefault?: boolean;
+    dateUpdated?: string;
+    days: LPWorkingDay[];
+}
+interface LPWorkingDay {
+    day: 'SUNDAY' | 'MONDAY' | 'TUESDAY' | 'WEDNESDAY' | 'THURSDAY' | 'FRIDAY' | 'SATURDAY';
+    isOpen: boolean;
+    shifts?: LPShift[];
+}
+interface LPShift {
+    start: string;
+    end: string;
+}
+interface CreateWorkingHoursRequest {
+    name: string;
+    days: LPWorkingDay[];
+    isDefault?: boolean;
+}
+interface UpdateWorkingHoursRequest {
+    name?: string;
+    days?: LPWorkingDay[];
+    isDefault?: boolean;
+    deleted?: boolean;
+}
+interface LPSpecialOccasion {
+    id: number;
+    name: string;
+    deleted?: boolean;
+    isDefault?: boolean;
+    dateUpdated?: string;
+    events: LPSpecialOccasionEvent[];
+}
+interface LPSpecialOccasionEvent {
+    name: string;
+    startDate: string;
+    endDate: string;
+    isOpen: boolean;
+    shifts?: LPShift[];
+}
+interface CreateSpecialOccasionRequest {
+    name: string;
+    events: LPSpecialOccasionEvent[];
+    isDefault?: boolean;
+}
+interface UpdateSpecialOccasionRequest {
+    name?: string;
+    events?: LPSpecialOccasionEvent[];
+    isDefault?: boolean;
+    deleted?: boolean;
+}
+
+/**
+ * Sentinel (LivePerson IDP) Types
+ *
+ * Types for authentication and user management via LivePerson's Sentinel API.
+ * Sentinel handles OAuth token exchange, user verification, and session management.
+ */
+/**
+ * OAuth token exchange request
+ */
+interface SentinelAuthRequest {
+    /** OAuth authorization code from redirect */
+    code: string;
+    /** Redirect URI used in the authorization request */
+    redirect: string;
+    /** Application name */
+    appname: string;
+}
+/**
+ * Token response from Sentinel OAuth exchange
+ */
+interface SentinelTokenExchange {
+    /** OAuth access token */
+    access_token: string;
+    /** Token type (usually "Bearer") */
+    token_type: string;
+    /** OAuth refresh token */
+    refresh_token: string;
+    /** JWT ID token containing user claims */
+    id_token: string;
+    /** Token expiration time in seconds */
+    expires_in: number;
+    /** User data (optional) */
+    UserData?: SentinelUserData;
+    /** Expiry timestamp string */
+    expiry?: string;
+    /** Timestamp string */
+    timestamp?: string;
+}
+/**
+ * Stored LP token document
+ */
+interface SentinelToken {
+    /** Token document ID (same as access token) */
+    id: string;
+    /** JWT ID token */
+    idToken?: string;
+    /** User ID from JWT sub claim */
+    uid: string;
+    /** OAuth access token */
+    accessToken: string;
+    /** OAuth refresh token */
+    refreshToken: string;
+    /** Token expiration in hours */
+    expiresIn: number;
+    /** Expiry timestamp (Unix ms) */
+    expiry?: number;
+    /** Conversation Builder API token */
+    cbToken?: string;
+    /** Conversation Builder organization ID */
+    cbOrg?: string;
+    /** LP Account ID */
+    accountId?: string;
+}
+/**
+ * LP Token document stored in Firestore
+ */
+interface SentinelLpToken {
+    /** LP Account ID */
+    accountId: string;
+    /** Access token (legacy snake_case) */
+    access_token?: string;
+    /** CB organization ID */
+    cbOrg: string;
+    /** CB API token */
+    cbToken: string;
+    /** Document ID */
+    id: string;
+    /** User ID */
+    uid: string;
+    /** Token string */
+    token: string;
+    /** Access token (camelCase) */
+    accessToken?: string;
+    /** User data */
+    userData: SentinelUserData;
+}
+/**
+ * Basic user data from Sentinel
+ */
+interface SentinelUserData {
+    uid?: string;
+    id: number | string;
+    email: string;
+    first_name: string;
+    last_name: string;
+    role: string;
+    roles?: string[];
+    permissions?: string[];
+    active: boolean;
+    created_by: string;
+    updated_by: string;
+    created_at: number;
+    updated_at: number;
+    isLPA?: boolean;
+}
+/**
+ * User profile information
+ */
+interface SentinelProfile {
+    roleTypeId: number;
+    name: string;
+    id: number;
+}
+/**
+ * Agent group membership
+ */
+interface SentinelMemberOf {
+    agentGroupId: string;
+    assignmentDate: string;
+}
+/**
+ * Agent group management assignment
+ */
+interface SentinelManagerOf {
+    agentGroupId: string;
+    assignmentDate: string;
+}
+/**
+ * User skill assignment
+ */
+interface SentinelUserSkill {
+    name: string;
+    id: number;
+}
+/**
+ * LivePerson user from Account Config API
+ */
+interface SentinelLpUser {
+    id: string;
+    deleted: boolean;
+    loginName: string;
+    fullName: string;
+    nickname: string;
+    passwordSh: string;
+    isEnabled: boolean;
+    maxChats: number;
+    email: string;
+    pictureUrl?: string;
+    disabledManually: boolean;
+    skillIds: number[];
+    profiles: SentinelProfile[];
+    profileIds: number[];
+    lobIds: number[];
+    changePwdNextLogin: boolean;
+    memberOf: SentinelMemberOf;
+    managerOf: SentinelManagerOf[];
+    permissionGroups: string[];
+    description: string;
+    mobileNumber: string;
+    employeeId: string;
+    maxAsyncChats: number;
+    backgndImgUri: string;
+    pnCertName: string;
+    dateUpdated: string;
+    lastPwdChangeDate: string;
+    isApiUser: boolean;
+    userTypeId: number;
+}
+/**
+ * Application user stored in Firestore
+ */
+interface SentinelAppUser extends SentinelLpUser {
+    /** Creator user ID */
+    createdBy: string;
+    /** Updater user ID */
+    updatedBy: string;
+    /** Creation timestamp */
+    createdAt?: number;
+    /** Update timestamp */
+    updatedAt: number;
+    /** Primary LP account ID (first account user logged in with) */
+    accountId: string;
+    /** Default LP account ID for auto-login after Firebase auth */
+    defaultAccountId?: string;
+    /** List of LP account IDs the user has access to */
+    linkedAccountIds?: string[];
+    /** Display name */
+    displayName: string;
+    /** User roles */
+    roles: string[];
+    /** User permissions */
+    permissions: string[];
+    /** Profile photo URL */
+    photoUrl: string;
+    /** Whether user is a LivePerson Administrator */
+    isLPA: boolean;
+    /** Whether user has agreed to terms */
+    termsAgreed: boolean;
+    /** List of installed app IDs */
+    installedApps: string[];
+    /** App-specific permissions */
+    appPermissions: string[];
+}
+/**
+ * CC User DTO from LivePerson
+ */
+interface SentinelCCUser {
+    userTypeId: number;
+    isApiUser: boolean;
+    profileIds: number[];
+    permissionGroups: number[];
+    pid: string;
+    allowedAppKeys: string;
+    skills: SentinelUserSkill[];
+    dateCreated: string;
+    maxChats: number;
+    skillIds: number[];
+    loginName: string;
+    nickname: string;
+    uid: string;
+    memberOf: any;
+    email: string;
+    lobs: string[];
+    managerOf: any;
+    pictureUrl: string;
+    fullName: string;
+    employeeId: string;
+    managedAgentGroups: any;
+    dateUpdated: string;
+    deleted: boolean;
+    isEnabled: boolean;
+}
+/**
+ * Chat bot platform user info
+ */
+interface CBChatBotPlatformUser {
+    username: string;
+    password: string;
+    creationTime: string;
+    modificationTime: string;
+    cb2Enabled: boolean;
+}
+/**
+ * Conversation Builder authentication success result
+ */
+interface CBSuccessResult {
+    /** Chat bot platform user info */
+    chatBotPlatformUser: CBChatBotPlatformUser;
+    /** CB API access token */
+    apiAccessToken: string;
+    /** CB API permanent access token */
+    apiAccessPermToken: string;
+    /** CB configuration */
+    config: any;
+    /** CB session organization ID */
+    sessionOrganizationId: string;
+    /** LiveEngage account ID */
+    leAccountId: string;
+    /** CB region */
+    cbRegion: string;
+    /** List of enabled features */
+    enabledFeatures: string[];
+    /** Site settings */
+    siteSettings: any[];
+    /** LiveEngage user ID */
+    leUserId: string;
+    /** User privileges */
+    privileges: number[];
+    /** Whether user is elevated LPA */
+    isElevatedLpa: boolean;
+}
+/**
+ * Conversation Builder authentication response
+ */
+interface CBAuthInfo {
+    /** Whether authentication was successful */
+    success: boolean;
+    /** Success result with tokens and user info */
+    successResult: CBSuccessResult;
+    /** Status message */
+    message: string;
+}
+/**
+ * Application setting entry
+ */
+interface SentinelAppSetting {
+    name: string;
+    value: string | number | boolean | object;
+    createdBy?: string;
+    updatedBy?: string;
+    createdAt?: number;
+    updatedAt?: number;
+}
+/**
+ * Application settings document
+ */
+interface SentinelAppSettings {
+    id?: string;
+    accountId: string;
+    settings: SentinelAppSetting[];
+    created_by?: string;
+    updated_by?: string;
+    created_at?: number;
+    updated_at?: number;
+}
+/**
+ * Login URL response
+ */
+interface SentinelLoginUrlResponse {
+    url: string;
+}
+/**
+ * Domain lookup response
+ */
+interface SentinelDomainsResponse {
+    [service: string]: string;
+}
+
+/**
+ * LP Prompt Library Types
+ *
+ * Types for LivePerson Prompt Library API (domain: promptlibrary)
+ * Note: This is different from AI Studio Prompt Library API
+ */
+/**
+ * Source types for prompt variables
+ */
+type LPPromptVariableSourceType = 'PROMPT_LIBRARY_RESERVED_KEYWORD' | 'INTERNAL_VARIABLES' | 'SITE_SETTINGS' | 'BOT_CONTEXT';
+/**
+ * Variable configuration in a prompt
+ */
+interface LPPromptVariable {
+    name: string;
+    sourceType: LPPromptVariableSourceType;
+    value?: string;
+}
+/**
+ * Generic LLM configuration
+ */
+interface LPPromptGenericConfig {
+    llmProvider: string;
+    llm: string;
+    llmSubscriptionName?: string;
+    samplingTemperature?: number;
+    maxResponseTokens?: number;
+    maxPromptTokens?: number;
+    completionsNumber?: number;
+}
+/**
+ * Client-specific configuration
+ */
+interface LPPromptClientConfig {
+    maxConversationTurns?: number;
+    maxConversationMessages?: number;
+    maxConversationTokens?: number;
+    includeLastUserMessage?: boolean;
+    piiMaskingEnabled?: boolean;
+}
+/**
+ * Complete prompt configuration
+ */
+interface LPPromptConfiguration {
+    genericConfig: LPPromptGenericConfig;
+    clientConfig: LPPromptClientConfig;
+    variables: LPPromptVariable[];
+}
+/**
+ * Version detail for a prompt
+ */
+interface LPPromptVersionDetail {
+    version: number;
+    createdBy: string;
+    createdAt: number;
+}
+/**
+ * Client types for prompts
+ */
+type LPPromptClientType = 'AUTO_SUMMARIZATION' | 'MESSAGING_BOT' | 'CONV_ASSIST' | 'COPILOT_REWRITE' | 'VOICE_BOT' | 'VOICE_AGENT' | 'ROUTING_AI_AGENT_MESSAGING_BOT' | 'ROUTING_AI_AGENT_VOICE_BOT' | 'LANGUAGE_DETECTION' | 'TRANSLATION';
+/**
+ * Prompt status
+ */
+type LPPromptStatus = 'ACTIVE' | 'INACTIVE' | 'DRAFT';
+/**
+ * Prompt entity returned by LivePerson Prompt Library API
+ */
+interface LPPrompt {
+    accountId: string;
+    id: string;
+    name: string;
+    clientType: LPPromptClientType;
+    description: string;
+    langCode: string;
+    promptHeader: string;
+    createdBy: string;
+    createdAt: number;
+    updatedBy?: string;
+    updatedAt: number;
+    version: number;
+    status: LPPromptStatus;
+    default: boolean;
+    configuration: LPPromptConfiguration;
+    versionDetails: LPPromptVersionDetail[];
+}
+/**
+ * LLM Provider subscription models
+ */
+interface LPLLMProviderModels {
+    [modelName: string]: 'ENABLED' | 'DISABLED';
+}
+/**
+ * LLM Type
+ */
+type LPLLMType = 'INTERNAL' | 'EXTERNAL';
+/**
+ * LLM Provider subscription
+ */
+interface LPLLMProviderSubscription {
+    models: LPLLMProviderModels;
+    account_id: string;
+    provider_name: string;
+    subscription_name: string;
+    enable_subscription: boolean;
+    llmType: LPLLMType;
+    supported_clients?: LPPromptClientType[];
+    created_at: number;
+    updated_at: number;
+}
+/**
+ * Data for creating a new prompt
+ */
+interface CreateLPPromptRequest {
+    name: string;
+    clientType: LPPromptClientType;
+    description?: string;
+    langCode?: string;
+    promptHeader: string;
+    status?: LPPromptStatus;
+    default?: boolean;
+    configuration: LPPromptConfiguration;
+}
+/**
+ * Data for updating a prompt
+ */
+interface UpdateLPPromptRequest {
+    name?: string;
+    description?: string;
+    langCode?: string;
+    promptHeader?: string;
+    status?: LPPromptStatus;
+    default?: boolean;
+    configuration?: Partial<LPPromptConfiguration>;
+}
+/**
+ * Query parameters for prompts API
+ */
+interface LPPromptsQueryParams {
+    /** Source of the request (default: 'ccui') */
+    source?: string;
+    /** Filter by client type */
+    clientType?: LPPromptClientType;
+    /** Filter by status */
+    status?: LPPromptStatus;
+}
+
+/**
+ * AI Studio Types
+ *
+ * TypeScript interfaces for LP AI Studio APIs.
+ * These use CC-Bearer authentication.
+ */
+interface AIStudioCategory {
+    id: string;
+    name: string;
+    description?: string;
+    parentId?: string;
+    createdAt?: string;
+    updatedAt?: string;
+}
+interface CreateCategoryRequest {
+    name: string;
+    description?: string;
+    parentId?: string;
+}
+interface UpdateCategoryRequest {
+    name?: string;
+    description?: string;
+    parentId?: string;
+}
+interface AIStudioConversation {
+    id: string;
+    categoryId?: string;
+    title?: string;
+    messages: AIStudioMessage[];
+    attributes?: Record<string, unknown>;
+    status?: 'open' | 'closed';
+    createdAt?: string;
+    updatedAt?: string;
+}
+interface AIStudioMessage {
+    role: 'user' | 'assistant' | 'system';
+    content: string;
+    timestamp?: string;
+}
+interface CreateConversationRequest$1 {
+    categoryId?: string;
+    title?: string;
+    messages?: AIStudioMessage[];
+    attributes?: Record<string, unknown>;
+}
+interface UpdateConversationRequest {
+    categoryId?: string;
+    title?: string;
+    messages?: AIStudioMessage[];
+    attributes?: Record<string, unknown>;
+}
+interface ConversationQueryParams {
+    categoryId?: string;
+    status?: 'open' | 'closed';
+    limit?: number;
+    offset?: number;
+}
+interface UpdateConversationAttributesRequest {
+    attributes: Record<string, unknown>;
+}
+interface SummaryRequest {
+    conversationId: string;
+    type?: 'short' | 'detailed';
+}
+interface BatchSummaryRequest {
+    conversationIds: string[];
+    type?: 'short' | 'detailed';
+}
+interface AIStudioSummary {
+    id: string;
+    conversationId: string;
+    summary: string;
+    type: string;
+    createdAt?: string;
+}
+interface QueryGenerateRequest {
+    prompt: string;
+    context?: Record<string, unknown>;
+}
+interface QueryGenerateResponse {
+    query: string;
+    confidence?: number;
+}
+interface AIStudioSimulation {
+    id: string;
+    name: string;
+    description?: string;
+    status: 'draft' | 'running' | 'completed' | 'failed' | 'cancelled';
+    config?: SimulationConfig;
+    results?: SimulationResults;
+    createdAt?: string;
+    updatedAt?: string;
+}
+interface SimulationConfig {
+    flowId?: string;
+    iterations?: number;
+    testCases?: SimulationTestCase[];
+}
+interface SimulationTestCase {
+    input: string;
+    expectedOutput?: string;
+}
+interface SimulationResults {
+    totalTests: number;
+    passed: number;
+    failed: number;
+    accuracy?: number;
+}
+interface CreateSimulationRequest {
+    name: string;
+    description?: string;
+    config: SimulationConfig;
+}
+interface UpdateSimulationRequest {
+    name?: string;
+    description?: string;
+    config?: SimulationConfig;
+}
+interface SimulationQueryParams {
+    status?: string;
+    limit?: number;
+    offset?: number;
+}
+interface SimulationJobResult {
+    jobId: string;
+    status: string;
+    results?: Record<string, unknown>;
+}
+interface TranscriptAnalysis {
+    id: string;
+    name?: string;
+    owner?: string;
+    status: 'pending' | 'processing' | 'completed' | 'failed';
+    conversations?: TranscriptConversation[];
+    questions?: TranscriptQuestion[];
+    createdAt?: string;
+    updatedAt?: string;
+}
+interface TranscriptConversation {
+    id: string;
+    transcript: string;
+    analysis?: Record<string, unknown>;
+}
+interface TranscriptQuestion {
+    question: string;
+    answer?: string;
+}
+interface CreateTranscriptAnalysisRequest {
+    name?: string;
+    conversations: TranscriptConversation[];
+    questions?: string[];
+}
+interface UpdateTranscriptAnalysisRequest {
+    name?: string;
+    conversations?: TranscriptConversation[];
+    questions?: string[];
+}
+interface Knowledgebase {
+    id: string;
+    name: string;
+    description?: string;
+    type?: 'standard' | 'kai';
+    itemCount?: number;
+    health?: KnowledgebaseHealth;
+    createdAt?: string;
+    updatedAt?: string;
+}
+interface KnowledgebaseHealth {
+    status: 'healthy' | 'warning' | 'error';
+    score?: number;
+    issues?: string[];
+}
+interface KnowledgebaseSearchRequest {
+    query: string;
+    limit?: number;
+    threshold?: number;
+    filters?: Record<string, unknown>;
+}
+interface KnowledgebaseSearchResult {
+    id: string;
+    content: string;
+    score: number;
+    metadata?: Record<string, unknown>;
+}
+interface KnowledgebaseItem {
+    id: string;
+    sourceId: string;
+    content: string;
+    metadata?: Record<string, unknown>;
+    createdAt?: string;
+    updatedAt?: string;
+}
+interface KnowledgebaseTextItem {
+    id?: string;
+    content: string;
+    metadata?: Record<string, unknown>;
+}
+interface SimilarityEvaluationRequest {
+    text1: string;
+    text2: string;
+    model?: string;
+}
+interface SimilarityEvaluationResponse {
+    similarity: number;
+    model: string;
+}
+interface ResolutionEvaluationRequest {
+    conversation: AIStudioMessage[];
+    expectedResolution?: string;
+}
+interface ResolutionEvaluationResponse {
+    resolved: boolean;
+    confidence: number;
+    explanation?: string;
+}
+interface GuidedRoutingEvaluationRequest {
+    input: string;
+    routes: GuidedRoute[];
+}
+interface GuidedRoute {
+    id: string;
+    name: string;
+    description?: string;
+}
+interface GuidedRoutingEvaluationResponse {
+    selectedRoute: string;
+    confidence: number;
+    reasoning?: string;
+}
+interface QuestionGeneratorRequest {
+    context: string;
+    count?: number;
+    style?: 'simple' | 'complex';
+}
+interface QuestionGeneratorResponse {
+    questions: GeneratedQuestion[];
+}
+interface GeneratedQuestion {
+    question: string;
+    answer?: string;
+    confidence?: number;
+}
+interface KAIRouteGeneratorRequest {
+    flowId: string;
+    inputData?: Record<string, unknown>;
+    useLlm?: boolean;
+}
+interface KAIRouteGeneratorResponse {
+    routes: GeneratedRoute[];
+    status?: string;
+}
+interface GeneratedRoute {
+    id: string;
+    name: string;
+    conditions?: string[];
+}
+interface KAIRouteGenerationStatus {
+    flowId: string;
+    status: 'pending' | 'processing' | 'completed' | 'failed';
+    progress?: number;
+    routes?: GeneratedRoute[];
+}
+interface Prompt {
+    id: string;
+    name: string;
+    description?: string;
+    content: string;
+    type?: 'system' | 'user' | 'custom';
+    variables?: PromptVariable[];
+    createdAt?: string;
+    updatedAt?: string;
+}
+interface PromptVariable {
+    name: string;
+    type: 'string' | 'number' | 'boolean';
+    required?: boolean;
+    defaultValue?: unknown;
+}
+interface CreatePromptRequest {
+    name: string;
+    description?: string;
+    content: string;
+    type?: 'system' | 'user' | 'custom';
+    variables?: PromptVariable[];
+}
+interface UpdatePromptRequest {
+    name?: string;
+    description?: string;
+    content?: string;
+    variables?: PromptVariable[];
+}
+interface LLMProvider {
+    id: string;
+    name: string;
+    models: LLMModel[];
+}
+interface LLMModel {
+    id: string;
+    name: string;
+    contextWindow?: number;
+    capabilities?: string[];
+}
+interface AIStudioUser {
+    id: string;
+    email?: string;
+    name?: string;
+    role?: string;
+    models?: string[];
+    termsAgreed?: boolean;
+    createdAt?: string;
+    updatedAt?: string;
+}
+interface CreateAIStudioUserRequest {
+    email: string;
+    name?: string;
+    role?: string;
+    models?: string[];
+}
+interface UpdateAIStudioUserRequest {
+    name?: string;
+    role?: string;
+}
+interface UpdateAIStudioUserModelsRequest {
+    models: string[];
+}
+interface AIStudioFlow {
+    id: string;
+    name: string;
+    description?: string;
+    status: 'draft' | 'published' | 'archived';
+    version?: string;
+    config?: Record<string, unknown>;
+    createdAt?: string;
+    updatedAt?: string;
+}
+interface InvokeFlowRequest {
+    input: Record<string, unknown>;
+    variables?: Record<string, unknown>;
+}
+interface InvokeFlowResponse {
+    executionId: string;
+    output: Record<string, unknown>;
+    status: 'completed' | 'failed';
+    error?: string;
+    duration?: number;
+}
+
+/**
+ * Messaging & Conversation Types
+ *
+ * TypeScript interfaces for LP Messaging APIs.
+ */
+interface MessagingConversation {
+    conversationId: string;
+    brandId: string;
+    status: 'OPEN' | 'CLOSE';
+    startTs?: number;
+    endTs?: number;
+    closeReason?: string;
+    closeReasonDescription?: string;
+    firstConversation?: boolean;
+    participants?: ConversationParticipant[];
+    consumerParticipants?: ConsumerParticipant[];
+    transfers?: ConversationTransfer[];
+    interactions?: ConversationInteraction[];
+    messageRecords?: MessageRecord[];
+    agentParticipants?: AgentParticipant[];
+    summary?: ConversationSummary;
+    sdes?: SDERecord;
+    coBrowseSessions?: CoBrowseSession[];
+    surveys?: SurveyRecord[];
+}
+interface ConversationParticipant {
+    id: string;
+    role: 'CONSUMER' | 'AGENT' | 'MANAGER' | 'SYSTEM';
+}
+interface ConsumerParticipant {
+    participantId: string;
+    firstName?: string;
+    lastName?: string;
+    phone?: string;
+    email?: string;
+    avatarURL?: string;
+    consumerName?: string;
+    token?: string;
+    time?: string;
+    timeL?: number;
+    joinTime?: string;
+    joinTimeL?: number;
+}
+interface AgentParticipant {
+    agentId: string;
+    agentLoginName?: string;
+    agentNickname?: string;
+    agentFullName?: string;
+    agentPid?: string;
+    userType?: string;
+    userTypeName?: string;
+    role?: string;
+    agentGroupId?: number;
+    agentGroupName?: string;
+    time?: string;
+    timeL?: number;
+    permission?: string;
+}
+interface ConversationTransfer {
+    sourceSkillId?: number;
+    sourceSkillName?: string;
+    sourceAgentId?: string;
+    sourceAgentLoginName?: string;
+    sourceAgentNickname?: string;
+    sourceAgentFullName?: string;
+    targetSkillId?: number;
+    targetSkillName?: string;
+    reason?: string;
+    time?: string;
+    timeL?: number;
+    by?: string;
+    contextData?: Record<string, unknown>;
+}
+interface ConversationInteraction {
+    assignedAgentId?: string;
+    assignedAgentLoginName?: string;
+    assignedAgentNickname?: string;
+    assignedAgentFullName?: string;
+    agentGroupId?: number;
+    agentGroupName?: string;
+    interactionTime?: string;
+    interactionTimeL?: number;
+    interactiveSequence?: number;
+}
+interface MessageRecord {
+    type: 'TEXT_PLAIN' | 'TEXT_HTML' | 'HOSTED_FILE' | 'EXTERNAL_FILE' | 'LINE_ITEM' | 'RICH_CONTENT';
+    messageData?: MessageData;
+    messageId?: string;
+    seq?: number;
+    dialogId?: string;
+    participantId?: string;
+    source?: string;
+    time?: string;
+    timeL?: number;
+    device?: string;
+    sentBy?: string;
+    contextData?: Record<string, unknown>;
+}
+interface MessageData {
+    msg?: TextMessage;
+    file?: FileMessage;
+    richContent?: RichContentMessage;
+}
+interface TextMessage {
+    text?: string;
+}
+interface FileMessage {
+    relativePath?: string;
+    fileType?: string;
+    caption?: string;
+}
+interface RichContentMessage {
+    content: Record<string, unknown>;
+}
+interface ConversationSummary {
+    text?: string;
+    lastUpdatedTime?: number;
+}
+interface SDERecord {
+    events: SDEEvent[];
+}
+interface SDEEvent {
+    sdeType: string;
+    serverTimeStamp?: string;
+    customerInfo?: Record<string, unknown>;
+    personalInfo?: Record<string, unknown>;
+    marketingCampaignInfo?: Record<string, unknown>;
+    lead?: Record<string, unknown>;
+    transaction?: Record<string, unknown>;
+    viewedProduct?: Record<string, unknown>[];
+    cartStatus?: Record<string, unknown>;
+    serviceActivity?: Record<string, unknown>;
+    visitorError?: Record<string, unknown>;
+    searchContent?: Record<string, unknown>;
+}
+interface CoBrowseSession {
+    sessionId: string;
+    startTime?: string;
+    startTimeL?: number;
+    endTime?: string;
+    endTimeL?: number;
+    interactiveTime?: string;
+    interactiveTimeL?: number;
+    endReason?: string;
+    duration?: number;
+    type?: string;
+    agentId?: string;
+}
+interface SurveyRecord {
+    surveyType?: string;
+    surveyData?: Record<string, unknown>[];
+    surveyStatus?: string;
+}
+interface MessagingHistoryQuery {
+    start: {
+        from: number;
+        to: number;
+    };
+    status?: ('OPEN' | 'CLOSE')[];
+    skillIds?: number[];
+    agentIds?: string[];
+    agentGroupIds?: number[];
+    keyword?: string;
+    summary?: boolean;
+    contentToRetrieve?: ContentToRetrieve[];
+    sort?: 'start:asc' | 'start:desc' | 'end:asc' | 'end:desc';
+    offset?: number;
+    limit?: number;
+}
+type ContentToRetrieve = 'campaign' | 'messageRecords' | 'agentParticipants' | 'agentParticipantsLeave' | 'agentParticipantsActive' | 'consumerParticipants' | 'transfers' | 'interactions' | 'messageStatuses' | 'messageScores' | 'conversationSurveys' | 'coBrowseSessions' | 'summary' | 'sdes' | 'responseTime' | 'skillsInfo' | 'dialogs' | 'intents';
+interface MessagingHistoryResponse {
+    _metadata: {
+        count: number;
+        self: {
+            rel: string;
+            href: string;
+        };
+        next?: {
+            rel: string;
+            href: string;
+        };
+        prev?: {
+            rel: string;
+            href: string;
+        };
+        shardsStatusResult?: {
+            partialResult: boolean;
+        };
+    };
+    conversationHistoryRecords: MessagingConversation[];
+}
+interface MessagingInteraction {
+    consumerMessages?: number;
+    agentMessages?: number;
+    transfers?: number;
+    duration?: number;
+    effectiveDuration?: number;
+    mcs?: number;
+    alertedMcs?: number;
+    csat?: number;
+    csatRate?: number;
+}
+interface AgentMetrics {
+    agentId: string;
+    loginName?: string;
+    currentStatusDuration?: number;
+    currentAvailabilityState?: string;
+    currentStatus?: AgentStatus;
+    load?: number;
+    ringingSlots?: number;
+    configuredMaxSlots?: number;
+    openAssignedConversations?: number;
+    intenseConversations?: number;
+}
+interface AgentStatus {
+    statusId: number;
+    statusName?: string;
+    statusChangedTimestamp?: number;
+    statusReasonId?: number;
+    statusReasonName?: string;
+}
+interface AgentMetricsQuery {
+    agentIds?: string[];
+    skillIds?: number[];
+    agentGroupIds?: number[];
+    includeAgentMetadata?: boolean;
+}
+interface AgentActivity {
+    agentId: string;
+    loginName?: string;
+    activities: ActivityRecord[];
+}
+interface ActivityRecord {
+    timestamp: number;
+    activityType: 'LOGIN' | 'LOGOUT' | 'STATUS_CHANGE' | 'CONVERSATION_ASSIGNED' | 'CONVERSATION_CLOSED';
+    details?: Record<string, unknown>;
+}
+interface AgentActivityQuery {
+    agentIds?: string[];
+    from: number;
+    to: number;
+    activityTypes?: string[];
+}
+interface TransferConversationRequest {
+    conversationId: string;
+    targetSkillId?: number;
+    targetAgentId?: string;
+    reason?: string;
+}
+interface CloseConversationRequest {
+    conversationId: string;
+    closeReason?: string;
+}
+interface SendMessageRequest {
+    conversationId: string;
+    message: string;
+    contentType?: 'text/plain' | 'text/html';
+    richContent?: Record<string, unknown>;
+}
+interface CreateConversationRequest {
+    campaignId: number;
+    engagementId: number;
+    skillId?: number;
+    consumerProfile?: ConsumerProfile;
+    context?: ConversationContext;
+}
+interface ConsumerProfile {
+    firstName?: string;
+    lastName?: string;
+    email?: string;
+    phone?: string;
+    avatarURL?: string;
+}
+interface ConversationContext {
+    type?: string;
+    name?: string;
+    engagementAttributes?: Record<string, unknown>[];
+}
+interface CreateConversationResponse {
+    conversationId: string;
+    status: string;
+}
+interface OutboundCampaignReport {
+    campaignId: string;
+    campaignName?: string;
+    sent?: number;
+    delivered?: number;
+    opened?: number;
+    clicked?: number;
+    bounced?: number;
+    unsubscribed?: number;
+    complaints?: number;
+}
+interface OutboundReportQuery {
+    campaignIds?: string[];
+    from: number;
+    to: number;
+    aggregation?: 'hourly' | 'daily' | 'weekly';
+}
+
+/**
+ * LP Extend Client SDK - Type Definitions Index
+ *
+ * Re-exports all types from domain-specific type files.
+ */
+
+/**
+ * Configuration options for initializing the SDK
+ */
+interface LPExtendSDKConfig {
+    /**
+     * Your registered app ID from LP Extend
+     * @example 'my-qa-app'
+     */
+    appId: string;
+    /**
+     * LivePerson account ID
+     * @example '12345678'
+     */
+    accountId: string;
+    /**
+     * LP Access token (obtained from shell auth)
+     * This is the user's LP bearer token passed to the child app.
+     *
+     * Either provide this directly OR provide extendToken OR provide shellToken.
+     */
+    accessToken?: string;
+    /**
+     * ExtendJWT token (NEW - preferred method)
+     * Encrypted JWT from shell containing all auth data.
+     * SDK will verify with shell and get LP access token.
+     *
+     * @example Received via URL params: ?extendToken=xxx
+     */
+    extendToken?: string;
+    /**
+     * Shell JWT token (X-Shell-Token) - LEGACY
+     * If provided instead of accessToken, the SDK will automatically
+     * fetch the LP access token from the shell during initialization.
+     *
+     * @example Received via URL params: ?shellToken=xxx
+     * @deprecated Use extendToken instead
+     */
+    shellToken?: string;
+    /**
+     * Shell backend base URL
+     * Required when using extendToken or shellToken for automatic token retrieval.
+     * @default Derived from window.location.origin or parent frame
+     * @example 'https://lp-extend.example.com'
+     */
+    shellBaseUrl?: string;
+    /**
+     * Scopes your app requests access to
+     * These are validated against app registration
+     * @example ['skills', 'users', 'agentGroups']
+     */
+    scopes?: string[];
+    /**
+     * Enable debug logging
+     * @default false
+     */
+    debug?: boolean;
+    /**
+     * Request timeout in milliseconds
+     * @default 30000
+     */
+    timeout?: number;
+}
+/**
+ * SDK initialization result
+ */
+interface SDKInitResult {
+    /** App ID confirmed by shell */
+    appId: string;
+    /** Account ID */
+    accountId: string;
+    /** Scopes granted based on app registration */
+    grantedScopes: string[];
+    /** App name from registration */
+    appName: string;
+    /** App version */
+    version?: string;
+}
+/**
+ * Standard API response wrapper
+ */
+interface APIResponse<T> {
+    /** Response data */
+    data: T;
+    /** Revision number for optimistic locking (used for updates/deletes) */
+    revision?: string;
+}
+/**
+ * Paginated response
+ */
+interface PaginatedResponse<T> {
+    /** Array of items */
+    items: T[];
+    /** Total count */
+    total: number;
+    /** Current offset */
+    offset: number;
+    /** Page size */
+    limit: number;
+    /** Next page token if available */
+    nextOffset?: number;
+}
+/**
+ * SDK Error
+ */
+declare class LPExtendSDKError extends Error {
+    readonly code: string;
+    readonly status?: number | undefined;
+    readonly details?: Record<string, unknown> | undefined;
+    constructor(message: string, code: string, status?: number | undefined, details?: Record<string, unknown> | undefined);
+}
+/**
+ * Error codes
+ */
+declare const ErrorCodes: {
+    /** Not running inside shell iframe */
+    readonly NOT_IN_SHELL: "NOT_IN_SHELL";
+    /** SDK initialization failed */
+    readonly INIT_FAILED: "INIT_FAILED";
+    /** App not registered or disabled */
+    readonly APP_NOT_REGISTERED: "APP_NOT_REGISTERED";
+    /** Authentication failed */
+    readonly UNAUTHORIZED: "UNAUTHORIZED";
+    /** Scope not granted - update app registration */
+    readonly SCOPE_DENIED: "SCOPE_DENIED";
+    /** Resource not found */
+    readonly NOT_FOUND: "NOT_FOUND";
+    /** API call failed */
+    readonly API_ERROR: "API_ERROR";
+    /** Request timeout */
+    readonly TIMEOUT: "TIMEOUT";
+    /** Invalid configuration */
+    readonly INVALID_CONFIG: "INVALID_CONFIG";
+    /** Revision conflict - resource was modified */
+    readonly REVISION_CONFLICT: "REVISION_CONFLICT";
+    /** Rate limit exceeded */
+    readonly RATE_LIMITED: "RATE_LIMITED";
+};
+type ErrorCode = (typeof ErrorCodes)[keyof typeof ErrorCodes];
+/**
+ * Configuration for retrieving LP token from shell
+ */
+interface ShellTokenConfig {
+    /**
+     * Shell backend base URL
+     * @example 'https://lp-extend.example.com'
+     */
+    shellBaseUrl: string;
+    /**
+     * LP Account ID
+     * @example '12345678'
+     */
+    accountId: string;
+    /**
+     * Shell JWT token (X-Shell-Token)
+     * Received from shell via postMessage or URL params
+     */
+    shellToken: string;
+    /**
+     * Your registered app ID
+     * @example 'my-qa-app'
+     */
+    appId: string;
+    /**
+     * Optional scopes to request validation for
+     */
+    scopes?: string[];
+    /**
+     * Request timeout in milliseconds
+     * @default 10000
+     */
+    timeout?: number;
+}
+/**
+ * User profile data returned with LP token
+ */
+interface ShellTokenUser {
+    id: string;
+    fullName?: string;
+    email?: string;
+    loginName?: string;
+    profileIds?: number[];
+    skillIds?: number[];
+}
+/**
+ * Response from shell token retrieval
+ */
+interface ShellTokenResponse {
+    /** LP Bearer access token for API calls */
+    accessToken: string;
+    /** Token expiration timestamp (Unix ms) */
+    expiresAt: number;
+    /** LP Account ID */
+    accountId: string;
+    /** LP User ID */
+    userId: string;
+    /** User profile data */
+    user?: ShellTokenUser;
+    /**
+     * Conversation Builder API token
+     * Used for authenticating CB API calls
+     */
+    cbToken?: string;
+    /**
+     * Conversation Builder organization ID
+     * Required for CB API calls
+     */
+    cbOrg?: string;
+}
+
+/**
+ * HTTP Client
+ *
+ * Makes HTTP requests directly to LivePerson APIs.
+ * Handles domain resolution, authentication, and revision management.
+ * Supports both Bearer (standard LP) and CC-Bearer (AI Studio) auth modes.
+ */
+
+/**
+ * Auth mode for LP APIs
+ */
+type AuthMode = 'bearer' | 'cc-bearer';
+/**
+ * Request options
+ */
+interface RequestOptions {
+    body?: unknown;
+    headers?: Record<string, string>;
+    params?: Record<string, string | number | boolean | undefined>;
+    /** Revision for optimistic locking (If-Match header) */
+    revision?: string;
+    /** Auth mode override (default: bearer) */
+    authMode?: AuthMode;
+    /** Custom timeout for this request */
+    timeout?: number;
+}
+/**
+ * HTTP Client for direct LP API calls
+ *
+ * All requests go directly to LivePerson APIs.
+ * Domain resolution is handled via CSDS.
+ * The shell is only consulted for scope validation during SDK init.
+ */
+declare class HTTPClient {
+    private readonly accountId;
+    private readonly accessToken;
+    private readonly defaultTimeout;
+    private readonly debug;
+    private readonly domainResolver;
+    constructor(accountId: string, accessToken: string, defaultTimeout: number, debug: boolean);
+    /**
+     * Make a GET request
+     */
+    get<T>(path: string, options?: RequestOptions): Promise<APIResponse<T>>;
+    /**
+     * Make a POST request
+     */
+    post<T>(path: string, body?: unknown, options?: RequestOptions): Promise<APIResponse<T>>;
+    /**
+     * Make a PUT request
+     */
+    put<T>(path: string, body?: unknown, options?: RequestOptions): Promise<APIResponse<T>>;
+    /**
+     * Make a DELETE request
+     */
+    delete<T>(path: string, options?: RequestOptions): Promise<APIResponse<T>>;
+    /**
+     * Make a PATCH request
+     */
+    patch<T>(path: string, body?: unknown, options?: RequestOptions): Promise<APIResponse<T>>;
+    /**
+     * Create a scoped client for a specific API domain
+     * This allows setting default options like authMode for all requests
+     */
+    withDefaults(defaults: Partial<RequestOptions>): ScopedHTTPClient;
+    /**
+     * Build the full URL for an LP API endpoint
+     */
+    private buildUrl;
+    /**
+     * Determine scope from path
+     */
+    private getScopeFromPath;
+    /**
+     * Make HTTP request to LP API
+     */
+    private request;
+    /**
+     * Strip the scope prefix from the path
+     */
+    private stripScopeFromPath;
+    /**
+     * Handle HTTP error responses
+     */
+    private handleError;
+    /**
+     * Debug logging
+     */
+    private log;
+}
+/**
+ * Scoped HTTP client with preset defaults
+ * Used for API modules that need specific auth modes
+ */
+declare class ScopedHTTPClient {
+    private readonly client;
+    private readonly defaults;
+    constructor(client: HTTPClient, defaults: Partial<RequestOptions>);
+    get<T>(path: string, options?: RequestOptions): Promise<APIResponse<T>>;
+    post<T>(path: string, body?: unknown, options?: RequestOptions): Promise<APIResponse<T>>;
+    put<T>(path: string, body?: unknown, options?: RequestOptions): Promise<APIResponse<T>>;
+    delete<T>(path: string, options?: RequestOptions): Promise<APIResponse<T>>;
+    patch<T>(path: string, body?: unknown, options?: RequestOptions): Promise<APIResponse<T>>;
+    private mergeOptions;
+}
+
+/**
+ * Account Configuration API Module
+ *
+ * Provides access to LivePerson Account Configuration APIs.
+ * These include Skills, Users, Agent Groups, Profiles, LOBs, Campaigns, etc.
+ * Uses standard Bearer authentication.
+ */
+
+/**
+ * Skills API
+ *
+ * Manage LivePerson skills for routing conversations.
+ */
+declare class SkillsAPI {
+    private http;
+    constructor(http: HTTPClient);
+    /**
+     * Get all skills
+     */
+    getAll(): Promise<APIResponse<LPSkill[]>>;
+    /**
+     * Get a skill by ID
+     */
+    getById(skillId: number): Promise<APIResponse<LPSkill>>;
+    /**
+     * Create a new skill
+     */
+    create(skill: CreateSkillRequest): Promise<APIResponse<LPSkill>>;
+    /**
+     * Update a skill
+     * @param skillId - The skill ID
+     * @param skill - Updated skill data
+     * @param revision - Optional revision for optimistic locking (auto-fetched if not provided)
+     */
+    update(skillId: number, skill: UpdateSkillRequest, revision?: string): Promise<APIResponse<LPSkill>>;
+    /**
+     * Delete a skill
+     * @param skillId - The skill ID
+     * @param revision - Optional revision for optimistic locking (auto-fetched if not provided)
+     */
+    delete(skillId: number, revision?: string): Promise<APIResponse<void>>;
+}
+/**
+ * Users API
+ *
+ * Manage LivePerson users and agents.
+ */
+declare class UsersAPI {
+    private http;
+    constructor(http: HTTPClient);
+    /**
+     * Get all users
+     */
+    getAll(): Promise<APIResponse<LPUser[]>>;
+    /**
+     * Get a user by ID
+     */
+    getById(userId: string): Promise<APIResponse<LPUser>>;
+    /**
+     * Create a new user
+     */
+    create(user: CreateUserRequest): Promise<APIResponse<LPUser>>;
+    /**
+     * Update a user
+     * @param userId - The user ID
+     * @param user - Updated user data
+     * @param revision - Optional revision for optimistic locking (auto-fetched if not provided)
+     */
+    update(userId: string, user: UpdateUserRequest, revision?: string): Promise<APIResponse<LPUser>>;
+    /**
+     * Delete a user
+     * @param userId - The user ID
+     * @param revision - Optional revision for optimistic locking (auto-fetched if not provided)
+     */
+    delete(userId: string, revision?: string): Promise<APIResponse<void>>;
+    /**
+     * Get the current authenticated user
+     */
+    getSelf(): Promise<APIResponse<LPUser>>;
+}
+/**
+ * Agent Groups API
+ */
+declare class AgentGroupsAPI {
+    private http;
+    constructor(http: HTTPClient);
+    /**
+     * Get all agent groups
+     */
+    getAll(): Promise<APIResponse<LPAgentGroup[]>>;
+    /**
+     * Get an agent group by ID
+     */
+    getById(groupId: number): Promise<APIResponse<LPAgentGroup>>;
+    /**
+     * Create a new agent group
+     */
+    create(group: CreateAgentGroupRequest): Promise<APIResponse<LPAgentGroup>>;
+    /**
+     * Update an agent group
+     * @param revision - Optional revision for optimistic locking (auto-fetched if not provided)
+     */
+    update(groupId: number, group: UpdateAgentGroupRequest, revision?: string): Promise<APIResponse<LPAgentGroup>>;
+    /**
+     * Delete an agent group
+     * @param revision - Optional revision for optimistic locking (auto-fetched if not provided)
+     */
+    delete(groupId: number, revision?: string): Promise<APIResponse<void>>;
+}
+/**
+ * Profiles API
+ */
+declare class ProfilesAPI {
+    private http;
+    constructor(http: HTTPClient);
+    /**
+     * Get all profiles
+     */
+    getAll(): Promise<APIResponse<LPProfile[]>>;
+    /**
+     * Get a profile by ID
+     */
+    getById(profileId: number): Promise<APIResponse<LPProfile>>;
+    /**
+     * Create a new profile
+     */
+    create(profile: CreateProfileRequest): Promise<APIResponse<LPProfile>>;
+    /**
+     * Update a profile
+     * @param revision - Optional revision for optimistic locking (auto-fetched if not provided)
+     */
+    update(profileId: number, profile: UpdateProfileRequest, revision?: string): Promise<APIResponse<LPProfile>>;
+    /**
+     * Delete a profile
+     * @param revision - Optional revision for optimistic locking (auto-fetched if not provided)
+     */
+    delete(profileId: number, revision?: string): Promise<APIResponse<void>>;
+}
+/**
+ * LOBs (Lines of Business) API
+ */
+declare class LOBsAPI {
+    private http;
+    constructor(http: HTTPClient);
+    /**
+     * Get all LOBs
+     */
+    getAll(): Promise<APIResponse<LPLOB[]>>;
+    /**
+     * Get a LOB by ID
+     */
+    getById(lobId: number): Promise<APIResponse<LPLOB>>;
+    /**
+     * Create a new LOB
+     */
+    create(lob: CreateLOBRequest): Promise<APIResponse<LPLOB>>;
+    /**
+     * Update a LOB
+     * @param revision - Optional revision for optimistic locking (auto-fetched if not provided)
+     */
+    update(lobId: number, lob: UpdateLOBRequest, revision?: string): Promise<APIResponse<LPLOB>>;
+    /**
+     * Delete a LOB
+     * @param revision - Optional revision for optimistic locking (auto-fetched if not provided)
+     */
+    delete(lobId: number, revision?: string): Promise<APIResponse<void>>;
+}
+/**
+ * Campaigns API
+ */
+declare class CampaignsAPI {
+    private http;
+    constructor(http: HTTPClient);
+    /**
+     * Get all campaigns
+     */
+    getAll(): Promise<APIResponse<LPCampaign[]>>;
+    /**
+     * Get a campaign by ID
+     */
+    getById(campaignId: number): Promise<APIResponse<LPCampaign>>;
+    /**
+     * Create a new campaign
+     */
+    create(campaign: CreateCampaignRequest): Promise<APIResponse<LPCampaign>>;
+    /**
+     * Update a campaign
+     * @param revision - Optional revision for optimistic locking (auto-fetched if not provided)
+     */
+    update(campaignId: number, campaign: UpdateCampaignRequest, revision?: string): Promise<APIResponse<LPCampaign>>;
+    /**
+     * Delete a campaign
+     * @param revision - Optional revision for optimistic locking (auto-fetched if not provided)
+     */
+    delete(campaignId: number, revision?: string): Promise<APIResponse<void>>;
+}
+/**
+ * Engagements API
+ */
+declare class EngagementsAPI {
+    private http;
+    constructor(http: HTTPClient);
+    /**
+     * Get all engagements for a campaign
+     */
+    getByCampaign(campaignId: number): Promise<APIResponse<LPEngagement[]>>;
+    /**
+     * Get an engagement by ID
+     */
+    getById(campaignId: number, engagementId: number): Promise<APIResponse<LPEngagement>>;
+    /**
+     * Create a new engagement
+     */
+    create(engagement: CreateEngagementRequest): Promise<APIResponse<LPEngagement>>;
+    /**
+     * Update an engagement
+     * @param revision - Optional revision for optimistic locking (auto-fetched if not provided)
+     */
+    update(campaignId: number, engagementId: number, engagement: UpdateEngagementRequest, revision?: string): Promise<APIResponse<LPEngagement>>;
+    /**
+     * Delete an engagement
+     * @param revision - Optional revision for optimistic locking (auto-fetched if not provided)
+     */
+    delete(campaignId: number, engagementId: number, revision?: string): Promise<APIResponse<void>>;
+}
+/**
+ * Predefined Content (Canned Responses) API
+ */
+declare class PredefinedContentAPI {
+    private http;
+    constructor(http: HTTPClient);
+    /**
+     * Get all predefined content
+     */
+    getAll(): Promise<APIResponse<LPPredefinedContent[]>>;
+    /**
+     * Get predefined content by ID
+     */
+    getById(contentId: number): Promise<APIResponse<LPPredefinedContent>>;
+    /**
+     * Create new predefined content
+     */
+    create(content: CreatePredefinedContentRequest): Promise<APIResponse<LPPredefinedContent>>;
+    /**
+     * Update predefined content
+     * @param revision - Optional revision for optimistic locking (auto-fetched if not provided)
+     */
+    update(contentId: number, content: UpdatePredefinedContentRequest, revision?: string): Promise<APIResponse<LPPredefinedContent>>;
+    /**
+     * Delete predefined content
+     * @param revision - Optional revision for optimistic locking (auto-fetched if not provided)
+     */
+    delete(contentId: number, revision?: string): Promise<APIResponse<void>>;
+}
+/**
+ * Automatic Messages API
+ */
+declare class AutomaticMessagesAPI {
+    private http;
+    constructor(http: HTTPClient);
+    /**
+     * Get all automatic messages
+     */
+    getAll(): Promise<APIResponse<LPAutomaticMessage[]>>;
+    /**
+     * Get an automatic message by ID
+     */
+    getById(messageId: number): Promise<APIResponse<LPAutomaticMessage>>;
+    /**
+     * Create a new automatic message
+     */
+    create(message: CreateAutomaticMessageRequest): Promise<APIResponse<LPAutomaticMessage>>;
+    /**
+     * Update an automatic message
+     * @param revision - Optional revision for optimistic locking (auto-fetched if not provided)
+     */
+    update(messageId: number, message: UpdateAutomaticMessageRequest, revision?: string): Promise<APIResponse<LPAutomaticMessage>>;
+    /**
+     * Delete an automatic message
+     * @param revision - Optional revision for optimistic locking (auto-fetched if not provided)
+     */
+    delete(messageId: number, revision?: string): Promise<APIResponse<void>>;
+}
+/**
+ * Working Hours API
+ */
+declare class WorkingHoursAPI {
+    private http;
+    constructor(http: HTTPClient);
+    /**
+     * Get all working hours schedules
+     */
+    getAll(): Promise<APIResponse<LPWorkingHours[]>>;
+    /**
+     * Get working hours by ID
+     */
+    getById(scheduleId: number): Promise<APIResponse<LPWorkingHours>>;
+    /**
+     * Create new working hours schedule
+     */
+    create(schedule: CreateWorkingHoursRequest): Promise<APIResponse<LPWorkingHours>>;
+    /**
+     * Update working hours schedule
+     * @param revision - Optional revision for optimistic locking (auto-fetched if not provided)
+     */
+    update(scheduleId: number, schedule: UpdateWorkingHoursRequest, revision?: string): Promise<APIResponse<LPWorkingHours>>;
+    /**
+     * Delete working hours schedule
+     * @param revision - Optional revision for optimistic locking (auto-fetched if not provided)
+     */
+    delete(scheduleId: number, revision?: string): Promise<APIResponse<void>>;
+}
+/**
+ * Special Occasions API
+ */
+declare class SpecialOccasionsAPI {
+    private http;
+    constructor(http: HTTPClient);
+    /**
+     * Get all special occasions
+     */
+    getAll(): Promise<APIResponse<LPSpecialOccasion[]>>;
+    /**
+     * Get a special occasion by ID
+     */
+    getById(occasionId: number): Promise<APIResponse<LPSpecialOccasion>>;
+    /**
+     * Create a new special occasion
+     */
+    create(occasion: CreateSpecialOccasionRequest): Promise<APIResponse<LPSpecialOccasion>>;
+    /**
+     * Update a special occasion
+     * @param revision - Optional revision for optimistic locking (auto-fetched if not provided)
+     */
+    update(occasionId: number, occasion: UpdateSpecialOccasionRequest, revision?: string): Promise<APIResponse<LPSpecialOccasion>>;
+    /**
+     * Delete a special occasion
+     * @param revision - Optional revision for optimistic locking (auto-fetched if not provided)
+     */
+    delete(occasionId: number, revision?: string): Promise<APIResponse<void>>;
+}
+
+/**
+ * AI Studio API Module
+ *
+ * Provides access to LivePerson AI Studio APIs.
+ * Uses CC-Bearer authentication mode.
+ */
+
+/**
+ * AI Studio Categories API
+ */
+declare class CategoriesAPI {
+    private http;
+    constructor(http: ScopedHTTPClient);
+    getAll(): Promise<APIResponse<AIStudioCategory[]>>;
+    create(data: CreateCategoryRequest): Promise<APIResponse<AIStudioCategory>>;
+    update(categoryId: string, data: UpdateCategoryRequest): Promise<APIResponse<AIStudioCategory>>;
+    delete(categoryId: string): Promise<APIResponse<void>>;
+}
+/**
+ * AI Studio Conversations API
+ */
+declare class ConversationsAPI {
+    private http;
+    constructor(http: ScopedHTTPClient);
+    getAll(params?: ConversationQueryParams): Promise<APIResponse<AIStudioConversation[]>>;
+    getById(convId: string): Promise<APIResponse<AIStudioConversation>>;
+    create(data: CreateConversationRequest$1): Promise<APIResponse<AIStudioConversation>>;
+    update(convId: string, data: UpdateConversationRequest): Promise<APIResponse<AIStudioConversation>>;
+    delete(convId: string): Promise<APIResponse<void>>;
+    updateAttributes(convId: string, data: UpdateConversationAttributesRequest): Promise<APIResponse<AIStudioConversation>>;
+    close(convId: string): Promise<APIResponse<void>>;
+    export(params?: ConversationQueryParams): Promise<APIResponse<AIStudioConversation[]>>;
+    upload(conversations: AIStudioConversation[]): Promise<APIResponse<AIStudioConversation[]>>;
+}
+/**
+ * AI Studio Summary API
+ */
+declare class SummaryAPI {
+    private http;
+    constructor(http: ScopedHTTPClient);
+    create(data: SummaryRequest): Promise<APIResponse<AIStudioSummary>>;
+    createBatch(data: BatchSummaryRequest): Promise<APIResponse<AIStudioSummary>>;
+    getBatch(offset?: number, limit?: number): Promise<APIResponse<AIStudioSummary[]>>;
+    getBatchById(summaryId: string): Promise<APIResponse<AIStudioSummary>>;
+    deleteBatch(summaryId: string): Promise<APIResponse<void>>;
+}
+/**
+ * AI Studio Query API
+ */
+declare class QueryAPI {
+    private http;
+    constructor(http: ScopedHTTPClient);
+    generate(data: QueryGenerateRequest): Promise<APIResponse<QueryGenerateResponse>>;
+}
+/**
+ * AI Studio Simulations API
+ */
+declare class SimulationsAPI {
+    private http;
+    constructor(http: ScopedHTTPClient);
+    getAll(params?: SimulationQueryParams): Promise<APIResponse<AIStudioSimulation[]>>;
+    getById(simulationId: string): Promise<APIResponse<AIStudioSimulation>>;
+    create(data: CreateSimulationRequest): Promise<APIResponse<AIStudioSimulation>>;
+    update(simulationId: string, data: UpdateSimulationRequest): Promise<APIResponse<AIStudioSimulation>>;
+    delete(simulationId: string): Promise<APIResponse<void>>;
+    getStatus(simulationId: string): Promise<APIResponse<AIStudioSimulation>>;
+    getJobResults(simulationId: string, jobId: string): Promise<APIResponse<SimulationJobResult>>;
+    cancel(simulationId: string): Promise<APIResponse<void>>;
+}
+/**
+ * AI Studio Transcript Analysis API
+ */
+declare class TranscriptAnalysisAPI {
+    private http;
+    constructor(http: ScopedHTTPClient);
+    getAll(owner?: string, limit?: number, startAfterId?: string): Promise<APIResponse<TranscriptAnalysis[]>>;
+    getById(analysisId: string, excludeConversations?: boolean, excludeQuestions?: boolean): Promise<APIResponse<TranscriptAnalysis>>;
+    create(data: CreateTranscriptAnalysisRequest): Promise<APIResponse<TranscriptAnalysis>>;
+    update(analysisId: string, data: UpdateTranscriptAnalysisRequest): Promise<APIResponse<TranscriptAnalysis>>;
+    delete(analysisId: string): Promise<APIResponse<void>>;
+}
+/**
+ * AI Studio Knowledgebases API
+ */
+declare class KnowledgebasesAPI {
+    private http;
+    constructor(http: ScopedHTTPClient);
+    getAll(): Promise<APIResponse<Knowledgebase[]>>;
+    getKai(): Promise<APIResponse<Knowledgebase[]>>;
+    getById(kbId: string): Promise<APIResponse<Knowledgebase>>;
+    delete(kbId: string): Promise<APIResponse<void>>;
+    getHealth(kbId: string): Promise<APIResponse<KnowledgebaseHealth>>;
+    refresh(kbId: string): Promise<APIResponse<Knowledgebase>>;
+    search(kbId: string, data: KnowledgebaseSearchRequest): Promise<APIResponse<KnowledgebaseSearchResult[]>>;
+    getItems(kbId: string): Promise<APIResponse<KnowledgebaseItem[]>>;
+    getItemsBySource(kbId: string, sourceId: string): Promise<APIResponse<KnowledgebaseItem[]>>;
+    createItems(kbId: string, sourceId: string, items: KnowledgebaseTextItem[]): Promise<APIResponse<KnowledgebaseItem[]>>;
+    updateItems(kbId: string, sourceId: string, items: KnowledgebaseTextItem[]): Promise<APIResponse<KnowledgebaseItem[]>>;
+    deleteItems(kbId: string, sourceId: string, itemIds: string[]): Promise<APIResponse<string[]>>;
+}
+/**
+ * AI Studio Evaluators API
+ */
+declare class EvaluatorsAPI {
+    private http;
+    constructor(http: ScopedHTTPClient);
+    similarity(evaluationType: string, data: SimilarityEvaluationRequest): Promise<APIResponse<SimilarityEvaluationResponse>>;
+    resolution(data: ResolutionEvaluationRequest): Promise<APIResponse<ResolutionEvaluationResponse>>;
+    guidedRouting(data: GuidedRoutingEvaluationRequest): Promise<APIResponse<GuidedRoutingEvaluationResponse>>;
+}
+/**
+ * AI Studio Generators API
+ */
+declare class GeneratorsAPI {
+    private http;
+    constructor(http: ScopedHTTPClient);
+    qaFromModel(modelId: string): Promise<APIResponse<QuestionGeneratorResponse>>;
+    qaFromKnowledgebase(kbIds: string[], generateAnswers?: boolean, useRandomSections?: boolean): Promise<APIResponse<QuestionGeneratorResponse>>;
+    qaFromConversationCloud(data: QuestionGeneratorRequest): Promise<APIResponse<QuestionGeneratorResponse>>;
+    kaiRoutesLlm(data: KAIRouteGeneratorRequest): Promise<APIResponse<KAIRouteGeneratorResponse>>;
+    kaiRoutes(data: KAIRouteGeneratorRequest): Promise<APIResponse<number>>;
+    kaiRoutesStatus(flowId: string): Promise<APIResponse<KAIRouteGenerationStatus>>;
+}
+/**
+ * AI Studio Prompt Library API
+ */
+declare class PromptLibraryAPI {
+    private http;
+    constructor(http: ScopedHTTPClient);
+    getAll(): Promise<APIResponse<Prompt[]>>;
+    create(data: CreatePromptRequest): Promise<APIResponse<Prompt>>;
+    update(promptId: string, data: UpdatePromptRequest): Promise<APIResponse<Prompt>>;
+    getProviders(): Promise<APIResponse<LLMProvider[]>>;
+    getSystemPrompts(): Promise<APIResponse<Prompt[]>>;
+}
+/**
+ * AI Studio Users API
+ */
+declare class AIStudioUsersAPI {
+    private http;
+    constructor(http: ScopedHTTPClient);
+    getSelf(): Promise<APIResponse<AIStudioUser>>;
+    getAll(): Promise<APIResponse<AIStudioUser[]>>;
+    getDetails(): Promise<APIResponse<AIStudioUser[]>>;
+    create(data: CreateAIStudioUserRequest): Promise<APIResponse<AIStudioUser>>;
+    update(userId: string, data: UpdateAIStudioUserRequest): Promise<APIResponse<AIStudioUser>>;
+    delete(userId: string): Promise<APIResponse<void>>;
+    updateModels(userId: string, data: UpdateAIStudioUserModelsRequest): Promise<APIResponse<AIStudioUser>>;
+    agreeToTerms(userId: string): Promise<APIResponse<AIStudioUser>>;
+}
+/**
+ * AI Studio Flows API
+ *
+ * Uses /api/v2/flows endpoints.
+ * Reference: ai-studio.service.ts in lp-demo
+ */
+declare class FlowsAPI {
+    private http;
+    private accountId;
+    constructor(http: ScopedHTTPClient, accountId: string);
+    /**
+     * List all flows for the account
+     * GET /api/v2/flows?account_id={accountId}
+     */
+    getAll(): Promise<APIResponse<AIStudioFlow[]>>;
+    /**
+     * Get a specific flow by ID
+     * GET /api/v2/flows/{flowId}
+     */
+    getById(flowId: string): Promise<APIResponse<AIStudioFlow>>;
+    /**
+     * Invoke a flow
+     * POST /api/v2/flows/{flowId}
+     */
+    invoke(flowId: string, data: InvokeFlowRequest): Promise<APIResponse<InvokeFlowResponse>>;
+    /**
+     * Invoke a promptless flow (quick response)
+     * POST /api/v2/flows/response
+     */
+    invokeWithResponse(prompt: string, messages?: Array<{
+        text: string;
+        speaker: string;
+    }>, text?: string): Promise<APIResponse<InvokeFlowResponse>>;
+}
+/**
+ * Main AI Studio API
+ *
+ * Provides access to all AI Studio sub-APIs.
+ * Uses CC-Bearer authentication.
+ */
+declare class AIStudioAPI {
+    readonly categories: CategoriesAPI;
+    readonly conversations: ConversationsAPI;
+    readonly summary: SummaryAPI;
+    readonly query: QueryAPI;
+    readonly simulations: SimulationsAPI;
+    readonly transcriptAnalysis: TranscriptAnalysisAPI;
+    readonly knowledgebases: KnowledgebasesAPI;
+    readonly evaluators: EvaluatorsAPI;
+    readonly generators: GeneratorsAPI;
+    readonly promptLibrary: PromptLibraryAPI;
+    readonly users: AIStudioUsersAPI;
+    readonly flows: FlowsAPI;
+    constructor(http: HTTPClient, accountId: string);
+}
+
+/**
+ * Messaging API Module
+ *
+ * Provides access to LivePerson Messaging APIs.
+ * Includes Messaging History, Agent Metrics, Agent Activity, and Operations.
+ */
+
+/**
+ * Messaging History API
+ *
+ * Access conversation history and transcripts.
+ */
+declare class MessagingHistoryAPI {
+    private http;
+    constructor(http: HTTPClient);
+    /**
+     * Query messaging conversations
+     */
+    query(params: MessagingHistoryQuery): Promise<APIResponse<MessagingHistoryResponse>>;
+    /**
+     * Get a single conversation by ID
+     */
+    getConversation(conversationId: string): Promise<APIResponse<MessagingConversation>>;
+    /**
+     * Get conversations by IDs (batch)
+     */
+    getConversations(conversationIds: string[]): Promise<APIResponse<MessagingConversation[]>>;
+    /**
+     * Export conversations matching criteria
+     */
+    export(params: MessagingHistoryQuery): Promise<APIResponse<MessagingHistoryResponse>>;
+}
+/**
+ * Agent Metrics API
+ *
+ * Real-time agent metrics and status.
+ */
+declare class AgentMetricsAPI {
+    private http;
+    constructor(http: HTTPClient);
+    /**
+     * Get current metrics for agents
+     */
+    getMetrics(params?: AgentMetricsQuery): Promise<APIResponse<AgentMetrics[]>>;
+    /**
+     * Get metrics for a specific agent
+     */
+    getAgentMetrics(agentId: string): Promise<APIResponse<AgentMetrics>>;
+    /**
+     * Get metrics summary by skill
+     */
+    getBySkill(skillId: number): Promise<APIResponse<AgentMetrics[]>>;
+    /**
+     * Get metrics summary by agent group
+     */
+    getByAgentGroup(groupId: number): Promise<APIResponse<AgentMetrics[]>>;
+}
+/**
+ * Agent Activity API
+ *
+ * Historical agent activity and session data.
+ */
+declare class AgentActivityAPI {
+    private http;
+    constructor(http: HTTPClient);
+    /**
+     * Query agent activity
+     */
+    query(params: AgentActivityQuery): Promise<APIResponse<AgentActivity[]>>;
+    /**
+     * Get activity for a specific agent
+     */
+    getAgentActivity(agentId: string, from: number, to: number): Promise<APIResponse<AgentActivity>>;
+}
+/**
+ * Messaging Operations API
+ *
+ * Perform actions on conversations.
+ */
+declare class MessagingOperationsAPI {
+    private http;
+    constructor(http: HTTPClient);
+    /**
+     * Transfer a conversation to another skill or agent
+     */
+    transfer(request: TransferConversationRequest): Promise<APIResponse<void>>;
+    /**
+     * Close a conversation
+     */
+    close(request: CloseConversationRequest): Promise<APIResponse<void>>;
+    /**
+     * Send a message to a conversation
+     */
+    sendMessage(request: SendMessageRequest): Promise<APIResponse<void>>;
+    /**
+     * Set conversation priority
+     */
+    setPriority(conversationId: string, priority: number): Promise<APIResponse<void>>;
+    /**
+     * Set conversation TTR (Time To Respond)
+     */
+    setTTR(conversationId: string, ttrType: 'URGENT' | 'NORMAL' | 'PRIORITIZED', value?: number): Promise<APIResponse<void>>;
+}
+/**
+ * Connect to Messaging API
+ *
+ * Create new messaging conversations programmatically.
+ */
+declare class ConnectToMessagingAPI {
+    private http;
+    constructor(http: HTTPClient);
+    /**
+     * Create a new conversation
+     */
+    createConversation(request: CreateConversationRequest): Promise<APIResponse<CreateConversationResponse>>;
+    /**
+     * Get available campaigns and engagements for creating conversations
+     */
+    getAvailableEngagements(): Promise<APIResponse<{
+        campaigns: Array<{
+            id: number;
+            name: string;
+            engagements: Array<{
+                id: number;
+                name: string;
+            }>;
+        }>;
+    }>>;
+}
+/**
+ * Outbound Reporting API
+ *
+ * Reports on outbound messaging campaigns.
+ */
+declare class OutboundReportingAPI {
+    private http;
+    constructor(http: HTTPClient);
+    /**
+     * Query outbound campaign reports
+     */
+    query(params: OutboundReportQuery): Promise<APIResponse<OutboundCampaignReport[]>>;
+    /**
+     * Get report for a specific campaign
+     */
+    getCampaignReport(campaignId: string, from: number, to: number): Promise<APIResponse<OutboundCampaignReport>>;
+    /**
+     * Get aggregate outbound stats
+     */
+    getAggregateStats(from: number, to: number): Promise<APIResponse<OutboundCampaignReport>>;
+}
+/**
+ * Main Messaging API
+ *
+ * Provides access to all Messaging sub-APIs.
+ */
+declare class MessagingAPI {
+    readonly history: MessagingHistoryAPI;
+    readonly agentMetrics: AgentMetricsAPI;
+    readonly agentActivity: AgentActivityAPI;
+    readonly operations: MessagingOperationsAPI;
+    readonly connect: ConnectToMessagingAPI;
+    readonly outbound: OutboundReportingAPI;
+    constructor(http: HTTPClient);
+}
+
+/**
+ * Sentinel API Module
+ *
+ * Provides access to LivePerson's Sentinel (IDP) authentication APIs.
+ * Handles OAuth token exchange, login URL generation, and session management.
+ */
+
+/**
+ * Sentinel Authentication API
+ *
+ * Handles LivePerson OAuth authentication flow via the Sentinel service.
+ *
+ * @example
+ * ```typescript
+ * // Get login URL for OAuth redirect
+ * const { url } = await sdk.sentinel.getLoginUrl();
+ * window.location.href = url;
+ *
+ * // After redirect, exchange code for token
+ * const token = await sdk.sentinel.exchangeToken({
+ *   code: authCode,
+ *   redirect: window.location.origin + '/callback',
+ *   appname: 'my-app',
+ * });
+ * ```
+ */
+declare class SentinelAPI {
+    private http;
+    constructor(http: HTTPClient);
+    /**
+     * Get login URL for OAuth redirect
+     *
+     * Returns a URL to redirect the user to for LivePerson authentication.
+     * After successful auth, user is redirected back with an authorization code.
+     *
+     * @returns Login URL for OAuth redirect
+     *
+     * @example
+     * ```typescript
+     * const { url } = await sdk.sentinel.getLoginUrl();
+     * // Redirect user to LP login
+     * window.location.href = url;
+     * ```
+     */
+    getLoginUrl(): Promise<SentinelLoginUrlResponse>;
+    /**
+     * Exchange OAuth authorization code for access token
+     *
+     * After the user completes LP authentication and is redirected back,
+     * use this method to exchange the authorization code for tokens.
+     *
+     * @param request - Token exchange request with code and redirect URI
+     * @returns Token object with access token, refresh token, and user info
+     *
+     * @example
+     * ```typescript
+     * // Get code from URL params after redirect
+     * const urlParams = new URLSearchParams(window.location.search);
+     * const code = urlParams.get('code');
+     *
+     * const token = await sdk.sentinel.exchangeToken({
+     *   code,
+     *   redirect: window.location.origin + '/callback',
+     *   appname: 'my-app',
+     * });
+     *
+     * // Store token for API calls
+     * localStorage.setItem('lpToken', token.accessToken);
+     * ```
+     */
+    exchangeToken(request: SentinelAuthRequest): Promise<SentinelToken>;
+    /**
+     * Logout and revoke token
+     *
+     * Revokes the current access token, ending the user's session.
+     *
+     * @example
+     * ```typescript
+     * await sdk.sentinel.logout();
+     * // Clear local storage and redirect to login
+     * localStorage.removeItem('lpToken');
+     * window.location.href = '/login';
+     * ```
+     */
+    logout(): Promise<void>;
+    /**
+     * Get LivePerson domains for the account
+     *
+     * Returns the domain URLs for various LP services.
+     * Useful for making direct API calls to specific LP services.
+     *
+     * @returns Map of service names to domain URLs
+     *
+     * @example
+     * ```typescript
+     * const domains = await sdk.sentinel.getDomains();
+     * console.log('Sentinel domain:', domains.sentinel);
+     * console.log('Account Config domain:', domains.accountConfigReadOnly);
+     * ```
+     */
+    getDomains(): Promise<SentinelDomainsResponse>;
+    /**
+     * Authenticate with Conversation Builder
+     *
+     * Exchanges the LP access token for a CB-specific token.
+     * Required for making Conversation Builder API calls.
+     *
+     * @returns CB authentication info with token and organization ID
+     *
+     * @example
+     * ```typescript
+     * const cbAuth = await sdk.sentinel.authenticateCB();
+     * if (cbAuth.success) {
+     *   const cbToken = cbAuth.successResult.apiAccessToken;
+     *   const cbOrg = cbAuth.successResult.sessionOrganizationId;
+     *   // Use cbToken for CB API calls
+     * }
+     * ```
+     */
+    authenticateCB(): Promise<CBAuthInfo>;
+}
+
+/**
+ * LP Prompts API Module
+ *
+ * Provides access to LivePerson Prompt Library API.
+ * Domain: promptlibrary
+ * Note: This is different from AI Studio Prompt Library API.
+ */
+
+/**
+ * LP Prompts API
+ *
+ * Manage LivePerson Prompt Library prompts.
+ * Uses Bearer authentication and the promptlibrary domain.
+ */
+declare class LPPromptsAPI {
+    private readonly scopedHttp;
+    constructor(http: HTTPClient);
+    /**
+     * Get all system prompts (read-only, provided by LivePerson)
+     */
+    getSystemPrompts(params?: LPPromptsQueryParams): Promise<APIResponse<LPPrompt[]>>;
+    /**
+     * Get all account prompts
+     */
+    getAccountPrompts(params?: LPPromptsQueryParams): Promise<APIResponse<LPPrompt[]>>;
+    /**
+     * Get a single account prompt by ID
+     */
+    getById(promptId: string): Promise<APIResponse<LPPrompt>>;
+    /**
+     * Create a new account prompt
+     */
+    create(prompt: CreateLPPromptRequest): Promise<APIResponse<LPPrompt>>;
+    /**
+     * Update an account prompt
+     * @param promptId - The prompt ID
+     * @param prompt - Updated prompt data
+     */
+    update(promptId: string, prompt: UpdateLPPromptRequest): Promise<APIResponse<LPPrompt>>;
+    /**
+     * Delete an account prompt
+     * @param promptId - The prompt ID
+     */
+    delete(promptId: string): Promise<APIResponse<void>>;
+    /**
+     * Get LLM provider subscriptions for the account
+     */
+    getLLMProviders(): Promise<APIResponse<LPLLMProviderSubscription[]>>;
+}
+
+/**
+ * LP Extend Client SDK
+ *
+ * Main SDK class providing typed access to LivePerson APIs.
+ * The SDK calls LP APIs directly after verifying scopes with the shell.
+ *
+ * @example
+ * ```typescript
+ * import { initializeSDK } from '@lpextend/client-sdk';
+ *
+ * // Initialize the SDK
+ * const sdk = await initializeSDK({
+ *   appId: 'my-app',
+ *   accountId: '12345678',
+ *   accessToken: 'user-lp-token',
+ *   scopes: ['skills', 'users', 'aiStudio'],
+ * });
+ *
+ * // Check granted scopes
+ * console.log('Granted scopes:', sdk.grantedScopes);
+ *
+ * // Use the typed APIs - calls LP APIs directly
+ * const { data: skills, revision } = await sdk.skills.getAll();
+ *
+ * // Update with revision for optimistic locking
+ * await sdk.skills.update(skills[0].id, { name: 'New Name' }, revision);
+ *
+ * // AI Studio (uses CC-Bearer auth automatically)
+ * const { data: flows } = await sdk.aiStudio.flows.getAll();
+ * ```
+ */
+
+/**
+ * LP Extend Client SDK
+ *
+ * Main SDK instance providing access to all LivePerson APIs.
+ * Calls LP APIs directly after verifying scopes with the shell.
+ *
+ * Account Configuration APIs (Bearer auth):
+ * - skills: Manage routing skills
+ * - users: Manage users and agents
+ * - agentGroups: Manage agent groups
+ * - profiles: Manage permission profiles
+ * - lobs: Manage lines of business
+ * - campaigns: Manage campaigns
+ * - engagements: Manage campaign engagements
+ * - predefinedContent: Manage canned responses
+ * - automaticMessages: Manage automatic messages
+ * - workingHours: Manage working hours schedules
+ * - specialOccasions: Manage special occasions
+ *
+ * AI Studio APIs (CC-Bearer auth):
+ * - aiStudio.categories: Manage categories
+ * - aiStudio.conversations: Manage conversations
+ * - aiStudio.summary: Generate summaries
+ * - aiStudio.simulations: Run simulations
+ * - aiStudio.knowledgebases: Manage knowledge bases
+ * - aiStudio.flows: Invoke AI flows
+ * - aiStudio.promptLibrary: Manage prompts
+ * - And more...
+ *
+ * Messaging APIs:
+ * - messaging.history: Query conversation history
+ * - messaging.agentMetrics: Get agent metrics
+ * - messaging.operations: Transfer, close, send messages
+ * - messaging.connect: Create new conversations
+ */
+declare class LPExtendSDK {
+    private readonly config;
+    /** Skills API - Manage routing skills */
+    readonly skills: SkillsAPI;
+    /** Users API - Manage users and agents */
+    readonly users: UsersAPI;
+    /** Agent Groups API - Manage agent groups */
+    readonly agentGroups: AgentGroupsAPI;
+    /** Profiles API - Manage permission profiles */
+    readonly profiles: ProfilesAPI;
+    /** LOBs API - Manage lines of business */
+    readonly lobs: LOBsAPI;
+    /** Campaigns API - Manage campaigns */
+    readonly campaigns: CampaignsAPI;
+    /** Engagements API - Manage campaign engagements */
+    readonly engagements: EngagementsAPI;
+    /** Predefined Content API - Manage canned responses */
+    readonly predefinedContent: PredefinedContentAPI;
+    /** Automatic Messages API - Manage automatic messages */
+    readonly automaticMessages: AutomaticMessagesAPI;
+    /** Working Hours API - Manage working hours schedules */
+    readonly workingHours: WorkingHoursAPI;
+    /** Special Occasions API - Manage special occasions */
+    readonly specialOccasions: SpecialOccasionsAPI;
+    /** AI Studio API - Access AI Studio features */
+    readonly aiStudio: AIStudioAPI;
+    /** Messaging API - History, metrics, operations */
+    readonly messaging: MessagingAPI;
+    /** Sentinel API - Authentication, login, token management */
+    readonly sentinel: SentinelAPI;
+    /** LP Prompts API - Manage prompts from LivePerson Prompt Library */
+    readonly prompts: LPPromptsAPI;
+    /** Scopes granted by app registration */
+    readonly grantedScopes: string[];
+    /** App name from registration */
+    readonly appName: string;
+    private readonly http;
+    private readonly debug;
+    /**
+     * Create SDK instance (use initializeSDK() instead for async init)
+     */
+    constructor(config: LPExtendSDKConfig, initResult: SDKInitResult);
+    /**
+     * Get the current account ID
+     */
+    get accountId(): string;
+    /**
+     * Get the app ID
+     */
+    get appId(): string;
+    /**
+     * Check if a scope was granted
+     */
+    hasScope(scope: string): boolean;
+    /**
+     * Check if multiple scopes were granted
+     */
+    hasScopes(scopes: string[]): boolean;
+    /**
+     * Check if any of the specified scopes were granted
+     */
+    hasAnyScope(scopes: string[]): boolean;
+    /**
+     * Debug logging
+     */
+    private log;
+}
+/**
+ * Initialize the SDK with async init call
+ *
+ * This calls the shell backend to verify app registration and get granted scopes,
+ * then creates an SDK that calls LP APIs directly.
+ *
+ * Supports three authentication modes (in order of preference):
+ * 1. ExtendJWT token (NEW): Provide `extendToken` - SDK verifies with shell and gets LP token
+ * 2. Direct access token: Provide `accessToken` directly
+ * 3. Shell token (LEGACY): Provide `shellToken` to fetch the LP token from the shell
+ */
+declare function createSDK(config: LPExtendSDKConfig): Promise<LPExtendSDK>;
+
+/**
+ * LP Extend Node SDK
+ *
+ * A TypeScript SDK for building Node.js/backend applications on the LivePerson Extend platform.
+ * Provides typed access to LivePerson APIs through the shell backend proxy.
+ * The shell handles authentication and scope enforcement.
+ *
+ * For browser/frontend authentication, use @lpextend/client-sdk instead.
+ *
+ * @packageDocumentation
+ *
+ * @example Basic Usage
+ * ```typescript
+ * import { initializeSDK, Scopes } from '@lpextend/node-sdk';
+ *
+ * // Initialize the SDK (async - verifies app registration)
+ * const sdk = await initializeSDK({
+ *   appId: 'my-app',
+ *   accountId: '12345678',
+ *   accessToken: 'user-lp-bearer-token',
+ *   scopes: [Scopes.SKILLS, Scopes.USERS, Scopes.AI_STUDIO],
+ * });
+ *
+ * // Check granted scopes
+ * if (sdk.hasScope(Scopes.SKILLS)) {
+ *   const { data: skills, revision } = await sdk.skills.getAll();
+ *   console.log('Skills:', skills);
+ *
+ *   // Update with revision for optimistic locking
+ *   await sdk.skills.update(skills[0].id, { name: 'Updated' }, revision);
+ * }
+ *
+ * // AI Studio APIs (automatically uses CC-Bearer auth)
+ * if (sdk.hasScope(Scopes.AI_STUDIO)) {
+ *   const { data: flows } = await sdk.aiStudio.flows.getAll();
+ *   const result = await sdk.aiStudio.flows.invoke(flows[0].id, { input: { query: 'Hello' } });
+ * }
+ *
+ * // Messaging History
+ * if (sdk.hasScope(Scopes.MESSAGING_HISTORY)) {
+ *   const { data: history } = await sdk.messaging.history.query({
+ *     start: { from: Date.now() - 86400000, to: Date.now() },
+ *     status: ['CLOSE'],
+ *   });
+ * }
+ * ```
+ *
+ * @example Error Handling
+ * ```typescript
+ * import { initializeSDK, ErrorCodes, LPExtendSDKError } from '@lpextend/client-sdk';
+ *
+ * try {
+ *   const sdk = await initializeSDK(config);
+ *   const { data, revision } = await sdk.skills.getAll();
+ *
+ *   // Try to update
+ *   await sdk.skills.update(data[0].id, { name: 'New' }, revision);
+ * } catch (error) {
+ *   if (error instanceof LPExtendSDKError) {
+ *     switch (error.code) {
+ *       case ErrorCodes.SCOPE_DENIED:
+ *         console.error('App does not have access. Update app registration.');
+ *         break;
+ *       case ErrorCodes.APP_NOT_REGISTERED:
+ *         console.error('App is not installed for this account.');
+ *         break;
+ *       case ErrorCodes.REVISION_CONFLICT:
+ *         console.error('Resource was modified. Refresh and try again.');
+ *         break;
+ *       default:
+ *         console.error('API Error:', error.message);
+ *     }
+ *   }
+ * }
+ * ```
+ */
+
+/**
+ * Initialize the LP Extend SDK
+ *
+ * Creates and returns an SDK instance after verifying app registration with the shell.
+ * This is an async function that validates the app is registered and gets granted scopes.
+ *
+ * @param config - SDK configuration options
+ * @returns Promise resolving to initialized SDK instance
+ *
+ * @example
+ * ```typescript
+ * import { initializeSDK, Scopes } from '@lpextend/node-sdk';
+ *
+ * const sdk = await initializeSDK({
+ *   appId: 'my-analytics-app',
+ *   accountId: '12345678',
+ *   accessToken: lpAccessToken, // From shell auth
+ *   scopes: [Scopes.SKILLS, Scopes.USERS, Scopes.AI_STUDIO],
+ *   debug: true,
+ * });
+ *
+ * // Check what scopes were granted
+ * console.log('Granted:', sdk.grantedScopes);
+ *
+ * // Access Account Config APIs (Bearer auth)
+ * if (sdk.hasScope(Scopes.SKILLS)) {
+ *   const { data: skills, revision } = await sdk.skills.getAll();
+ *   // Update with revision
+ *   await sdk.skills.update(skills[0].id, { name: 'New Name' }, revision);
+ * }
+ *
+ * // Access AI Studio APIs (CC-Bearer auth - handled automatically)
+ * if (sdk.hasScope(Scopes.AI_STUDIO)) {
+ *   const { data: flows } = await sdk.aiStudio.flows.getAll();
+ *   const result = await sdk.aiStudio.flows.invoke(flows[0].id, {
+ *     input: { query: 'What is your return policy?' },
+ *   });
+ * }
+ *
+ * // Access Messaging APIs
+ * if (sdk.hasScope(Scopes.MESSAGING_HISTORY)) {
+ *   const { data: history } = await sdk.messaging.history.query({
+ *     start: { from: Date.now() - 86400000, to: Date.now() },
+ *     status: ['CLOSE'],
+ *     contentToRetrieve: ['messageRecords', 'summary'],
+ *   });
+ * }
+ * ```
+ */
+declare function initializeSDK(config: LPExtendSDKConfig): Promise<LPExtendSDK>;
+/**
+ * SDK Version
+ */
+declare const VERSION = "1.0.0";
+/**
+ * Available API Scopes
+ *
+ * These map to lpApiAccess fields in app registration.
+ * Request these scopes when initializing the SDK.
+ *
+ * @example
+ * ```typescript
+ * import { initializeSDK, Scopes } from '@lpextend/node-sdk';
+ *
+ * const sdk = await initializeSDK({
+ *   appId: 'my-app',
+ *   accountId: '12345678',
+ *   accessToken: token,
+ *   scopes: [
+ *     Scopes.SKILLS,
+ *     Scopes.USERS,
+ *     Scopes.AGENT_GROUPS,
+ *     Scopes.AI_STUDIO,
+ *     Scopes.MESSAGING_HISTORY,
+ *   ],
+ * });
+ * ```
+ */
+declare const Scopes: {
+    readonly SKILLS: "skills";
+    readonly USERS: "users";
+    readonly AGENT_GROUPS: "agentGroups";
+    readonly PROFILES: "profiles";
+    readonly LOBS: "lobs";
+    readonly PREDEFINED_CONTENT: "predefinedContent";
+    readonly AUTOMATIC_MESSAGES: "automaticMessages";
+    readonly WORKING_HOURS: "workingHours";
+    readonly SPECIAL_OCCASIONS: "specialOccasions";
+    readonly CAMPAIGNS: "campaigns";
+    readonly ENGAGEMENTS: "engagements";
+    readonly MESSAGING_HISTORY: "messagingHistory";
+    readonly MESSAGING_OPERATIONS: "messagingOperations";
+    readonly CONNECT_TO_MESSAGING: "connectToMessaging";
+    readonly AGENT_METRICS: "agentMetrics";
+    readonly AGENT_ACTIVITY: "agentActivity";
+    readonly OUTBOUND_REPORTING: "outboundReporting";
+    readonly AI_STUDIO: "aiStudio";
+    readonly CONVERSATION_BUILDER: "conversationBuilder";
+    readonly CONVERSATION_ORCHESTRATOR: "conversationOrchestrator";
+    /** AI Studio Prompt Library (different from LP Prompts) */
+    readonly PROMPT_LIBRARY: "promptLibrary";
+    /** LP Prompts API (Prompt Library) */
+    readonly LP_PROMPTS: "prompts";
+    readonly FAAS: "faas";
+    readonly PROACTIVE_MESSAGING: "proactiveMessaging";
+};
+type Scope = (typeof Scopes)[keyof typeof Scopes];
+
+/**
+ * Retrieve LP Bearer token from the shell
+ *
+ * Child apps call this function to get the LP access token for making
+ * direct LP API calls. The shell stores tokens on user login and provides
+ * them to authenticated child apps.
+ *
+ * @param config - Shell token configuration
+ * @returns Promise resolving to LP token data
+ * @throws LPExtendSDKError if retrieval fails
+ *
+ * @example
+ * ```typescript
+ * import { getShellToken } from '@lpextend/client-sdk';
+ *
+ * // Get shell token from URL params or postMessage
+ * const shellToken = new URLSearchParams(window.location.search).get('shellToken');
+ *
+ * const lpToken = await getShellToken({
+ *   shellBaseUrl: 'https://lp-extend.example.com',
+ *   accountId: '12345678',
+ *   shellToken: shellToken,
+ *   appId: 'my-app',
+ * });
+ *
+ * // Now use the LP token to initialize the SDK
+ * const sdk = await initializeSDK({
+ *   appId: 'my-app',
+ *   accountId: lpToken.accountId,
+ *   accessToken: lpToken.accessToken,
+ *   scopes: [Scopes.SKILLS, Scopes.USERS],
+ * });
+ * ```
+ */
+declare function getShellToken(config: ShellTokenConfig): Promise<ShellTokenResponse>;
+
+export { type CreateConversationRequest$1 as AICreateConversationRequest, AIStudioAPI, type AIStudioCategory, type AIStudioConversation, type AIStudioFlow, type AIStudioMessage, type AIStudioSimulation, type AIStudioSummary, type AIStudioUser, AIStudioUsersAPI, type UpdateConversationRequest as AIUpdateConversationRequest, type APIResponse, type ActivityRecord, type AgentActivity, AgentActivityAPI, type AgentActivityQuery, AgentGroupsAPI, type AgentMetrics, AgentMetricsAPI, type AgentMetricsQuery, type AgentParticipant, type AgentStatus, AutomaticMessagesAPI, type BatchSummaryRequest, type CBAuthInfo, type CBChatBotPlatformUser, type CBSuccessResult, CampaignsAPI, CategoriesAPI, type CloseConversationRequest, type CoBrowseSession, ConnectToMessagingAPI, type ConsumerParticipant, type ConsumerProfile, type ContentToRetrieve, type ConversationContext, type ConversationInteraction, type ConversationParticipant, type ConversationQueryParams, type ConversationSummary, type ConversationTransfer, ConversationsAPI, type CreateAIStudioUserRequest, type CreateAgentGroupRequest, type CreateAutomaticMessageRequest, type CreateCampaignRequest, type CreateCategoryRequest, type CreateConversationResponse, type CreateEngagementRequest, type CreateLOBRequest, type CreateLPPromptRequest, type CreatePredefinedContentRequest, type CreateProfileRequest, type CreatePromptRequest, type CreateSimulationRequest, type CreateSkillRequest, type CreateSpecialOccasionRequest, type CreateTranscriptAnalysisRequest, type CreateUserRequest, type CreateWorkingHoursRequest, EngagementsAPI, type ErrorCode, ErrorCodes, EvaluatorsAPI, type FileMessage, FlowsAPI, type GeneratedQuestion, type GeneratedRoute, GeneratorsAPI, type GuidedRoute, type GuidedRoutingEvaluationRequest, type GuidedRoutingEvaluationResponse, type InvokeFlowRequest, type InvokeFlowResponse, type KAIRouteGenerationStatus, type KAIRouteGeneratorRequest, type KAIRouteGeneratorResponse, type Knowledgebase, type KnowledgebaseHealth, type KnowledgebaseItem, type KnowledgebaseSearchRequest, type KnowledgebaseSearchResult, type KnowledgebaseTextItem, KnowledgebasesAPI, type LLMModel, type LLMProvider, LOBsAPI, type LPAgentGroup, type LPAutomaticMessage, type LPAutomaticMessageData, type LPCampaign, type LPEngagement, LPExtendSDK, type LPExtendSDKConfig, LPExtendSDKError, type LPLLMProviderModels, type LPLLMProviderSubscription, type LPLLMType, type LPLOB, type LPPermission, type LPPredefinedContent, type LPPredefinedContentData, type LPProfile, type LPPrompt, type LPPromptClientConfig, type LPPromptClientType, type LPPromptConfiguration, type LPPromptGenericConfig, type LPPromptStatus, type LPPromptVariable, type LPPromptVariableSourceType, type LPPromptVersionDetail, LPPromptsAPI, type LPPromptsQueryParams, type LPShift, type LPSkill, type LPSkillRoutingConfig, type LPSpecialOccasion, type LPSpecialOccasionEvent, type LPUser, type LPWorkingDay, type LPWorkingHours, type MemberOf, type MessageData, type MessageRecord, MessagingAPI, type MessagingConversation, type CreateConversationRequest as MessagingCreateConversationRequest, MessagingHistoryAPI, type MessagingHistoryQuery, type MessagingHistoryResponse, type MessagingInteraction, MessagingOperationsAPI, type OutboundCampaignReport, type OutboundReportQuery, OutboundReportingAPI, type PaginatedResponse, PredefinedContentAPI, ProfilesAPI, type Prompt, PromptLibraryAPI, type PromptVariable, QueryAPI, type QueryGenerateRequest, type QueryGenerateResponse, type QuestionGeneratorRequest, type QuestionGeneratorResponse, type ResolutionEvaluationRequest, type ResolutionEvaluationResponse, type RichContentMessage, type SDEEvent, type SDERecord, type SDKInitResult, type Scope, Scopes, type SendMessageRequest, SentinelAPI, type SentinelAppSetting, type SentinelAppSettings, type SentinelAppUser, type SentinelAuthRequest, type SentinelCCUser, type SentinelDomainsResponse, type SentinelLoginUrlResponse, type SentinelLpToken, type SentinelLpUser, type SentinelManagerOf, type SentinelMemberOf, type SentinelProfile, type SentinelToken, type SentinelTokenExchange, type SentinelUserData, type SentinelUserSkill, type ShellTokenConfig, type ShellTokenResponse, type ShellTokenUser, type SimilarityEvaluationRequest, type SimilarityEvaluationResponse, type SimulationConfig, type SimulationJobResult, type SimulationQueryParams, type SimulationResults, type SimulationTestCase, SimulationsAPI, SkillsAPI, SpecialOccasionsAPI, SummaryAPI, type SummaryRequest, type SurveyRecord, type TextMessage, type TranscriptAnalysis, TranscriptAnalysisAPI, type TranscriptConversation, type TranscriptQuestion, type TransferConversationRequest, type UpdateAIStudioUserModelsRequest, type UpdateAIStudioUserRequest, type UpdateAgentGroupRequest, type UpdateAutomaticMessageRequest, type UpdateCampaignRequest, type UpdateCategoryRequest, type UpdateConversationAttributesRequest, type UpdateEngagementRequest, type UpdateLOBRequest, type UpdateLPPromptRequest, type UpdatePredefinedContentRequest, type UpdateProfileRequest, type UpdatePromptRequest, type UpdateSimulationRequest, type UpdateSkillRequest, type UpdateSpecialOccasionRequest, type UpdateTranscriptAnalysisRequest, type UpdateUserRequest, type UpdateWorkingHoursRequest, UsersAPI, VERSION, WorkingHoursAPI, createSDK, getShellToken, initializeSDK };