lumnisai 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,1065 @@
+interface PaginationParams {
+    page?: number;
+    pageSize?: number;
+    limit?: number;
+    offset?: number;
+    skip?: number;
+}
+interface PaginationInfo {
+    page: number;
+    pageSize: number;
+    total: number;
+    totalPages: number;
+    hasNext: boolean;
+    hasPrev: boolean;
+}
+interface ErrorResponse {
+    error: {
+        code: string;
+        message: string;
+        details?: Record<string, any>;
+    };
+}
+interface Message {
+    role: 'system' | 'user' | 'assistant';
+    content: string;
+}
+type Scope = 'user' | 'tenant';
+type UUID = string;
+type Email = string;
+type UserIdentifier = UUID | Email;
+interface BaseResource {
+    createdAt: string;
+    updatedAt?: string;
+}
+
+type Plan = 'shared';
+type DatabaseStatus = 'provisioning' | 'active' | 'suspended' | 'failed';
+type BillingStatus = 'trial' | 'active' | 'past_due' | 'canceled';
+type ApiKeyMode = 'platform' | 'byo_keys';
+interface TenantDetailsResponse {
+    id: UUID;
+    name: string;
+    developerId: UUID;
+    developerEmail: string;
+    plan: Plan;
+    dbStatus: DatabaseStatus;
+    billingStatus: BillingStatus;
+    apiKeyMode: ApiKeyMode;
+    createdAt: string;
+    updatedAt: string;
+}
+
+type ApiProvider = 'OPENAI_API_KEY' | 'ANTHROPIC_API_KEY' | 'EXA_API_KEY' | 'COHERE_API_KEY' | 'GOOGLE_API_KEY' | 'SERPAPI_API_KEY' | 'GROQ_API_KEY' | 'NVIDIA_API_KEY' | 'FIREWORKS_API_KEY' | 'MISTRAL_API_KEY' | 'TOGETHER_API_KEY' | 'XAI_API_KEY' | 'PPLX_API_KEY' | 'HUGGINGFACE_API_KEY' | 'DEEPSEEK_API_KEY' | 'IBM_API_KEY' | 'E2B_API_KEY';
+interface StoreApiKeyRequest {
+    provider: ApiProvider;
+    apiKey: string;
+}
+interface ExternalApiKeyResponse {
+    keyId: string;
+    provider: string;
+    isActive: boolean;
+    createdAt?: string | null;
+    updatedAt?: string | null;
+    createdBy?: string | null;
+}
+interface ApiKeyModeResponse {
+    apiKeyMode: ApiKeyMode;
+}
+interface ApiKeyModeRequest {
+    mode: ApiKeyMode;
+}
+interface DeleteApiKeyResponse {
+    message: string;
+}
+
+type ConnectionStatus = 'pending' | 'active' | 'failed' | 'expired' | 'not_connected';
+interface InitiateConnectionRequest {
+    userId: string;
+    appName: string;
+    redirectUrl?: string;
+    authMode?: string;
+    connectionParams?: Record<string, any>;
+}
+interface InitiateConnectionResponse {
+    redirectUrl?: string | null;
+    status: string;
+    message?: string | null;
+}
+interface ConnectionStatusResponse {
+    appName: string;
+    status: ConnectionStatus;
+    connectedAt?: string | null;
+    errorMessage?: string | null;
+}
+interface ConnectionInfo {
+    appName: string;
+    status: ConnectionStatus;
+    connectedAt?: string | null;
+    errorMessage?: string | null;
+}
+interface UserConnectionsResponse {
+    userId: string;
+    connections: ConnectionInfo[];
+}
+interface GetToolsRequest {
+    userId: string;
+    appFilter?: string[];
+}
+interface ToolInfo {
+    name: string;
+    description: string;
+    appName: string;
+    parameters?: Record<string, any> | null;
+}
+interface GetToolsResponse {
+    userId: string;
+    tools: ToolInfo[];
+    toolCount: number;
+}
+interface DisconnectRequest {
+    userId: string;
+    appName: string;
+}
+interface DisconnectResponse {
+    success: boolean;
+    message: string;
+}
+interface ConnectionCallbackRequest {
+    connectionId: string;
+    code?: string;
+    state?: string;
+    error?: string;
+}
+interface ConnectionCallbackResponse {
+    success: boolean;
+    status: string;
+    message: string;
+}
+interface AppsListResponse {
+    enabledApps: string[];
+    totalEnabled: number;
+    availableApps?: string[];
+    totalAvailable?: number;
+}
+interface AppEnabledResponse {
+    appName: string;
+    enabled: boolean;
+    message: string;
+}
+interface UpdateAppStatusResponse {
+    appName: string;
+    enabled: boolean;
+    message: string;
+    updatedAt: string;
+}
+
+type MCPTransport = 'stdio' | 'streamable_http' | 'sse';
+type MCPScope = 'tenant' | 'user';
+interface MCPServerCreateRequest {
+    name: string;
+    description?: string;
+    transport: MCPTransport;
+    scope: MCPScope;
+    userIdentifier?: string;
+    command?: string;
+    args?: string[];
+    url?: string;
+    env?: Record<string, string>;
+    headers?: Record<string, string>;
+}
+interface MCPServerResponse {
+    id: UUID;
+    tenantId: UUID;
+    userId?: UUID | null;
+    scope: MCPScope;
+    name: string;
+    description?: string | null;
+    transport: MCPTransport;
+    command?: string | null;
+    args?: string[] | null;
+    url?: string | null;
+    isActive: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+interface MCPServerUpdateRequest {
+    name?: string;
+    description?: string;
+    url?: string;
+    env?: Record<string, string>;
+    headers?: Record<string, string>;
+    isActive?: boolean;
+}
+interface MCPServerListResponse {
+    servers: MCPServerResponse[];
+    total: number;
+    skip: number;
+    limit: number;
+}
+interface MCPToolResponse {
+    name: string;
+    description: string;
+    inputSchema?: Record<string, any> | null;
+}
+interface MCPToolListResponse {
+    serverId: UUID;
+    serverName: string;
+    tools: MCPToolResponse[];
+    total: number;
+}
+interface TestConnectionResponse {
+    success: boolean;
+    message: string;
+    toolCount?: number | null;
+    errorDetails?: string | null;
+}
+
+type ModelType = 'CHEAP_MODEL' | 'FAST_MODEL' | 'SMART_MODEL' | 'REASONING_MODEL' | 'VISION_MODEL';
+type ModelProvider = 'openai' | 'anthropic' | 'azure_openai' | 'azure_ai' | 'google_vertexai' | 'google_genai' | 'google_anthropic_vertex' | 'bedrock' | 'bedrock_converse' | 'cohere' | 'fireworks' | 'together' | 'mistralai' | 'huggingface' | 'groq' | 'ollama' | 'deepseek' | 'ibm' | 'nvidia' | 'xai' | 'perplexity';
+interface TenantModelPreference {
+    tenantId: string;
+    modelType: ModelType;
+    provider: ModelProvider;
+    modelName: string;
+    isActive: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+interface TenantModelPreferencesResponse {
+    tenantId: string;
+    preferences: TenantModelPreference[];
+    defaultsApplied: ModelType[];
+}
+interface ModelPreferenceCreate {
+    modelType: ModelType;
+    provider: ModelProvider;
+    modelName: string;
+}
+interface ModelPreferencesBulkUpdate {
+    preferences: Record<ModelType, {
+        provider: ModelProvider;
+        modelName: string;
+    }>;
+}
+interface ModelAvailability {
+    modelType: ModelType;
+    provider: ModelProvider;
+    modelName: string;
+    isAvailable: boolean;
+    reason?: string | null;
+    requiresApiKey: boolean;
+}
+
+type ResponseStatus = 'queued' | 'in_progress' | 'succeeded' | 'failed' | 'cancelled';
+type AgentEffort = 'low' | 'medium' | 'high';
+interface FileAttachment {
+    name: string;
+    uri: string;
+    mimeType?: string | null;
+    sizeBytes?: number | null;
+}
+interface AgentConfig {
+    planStrategy?: 'llm_io' | string;
+    plannerModelType?: 'SMART_MODEL' | 'REASONING_MODEL' | string;
+    coordinatorModelType?: 'SMART_MODEL' | 'REASONING_MODEL' | string;
+    orchestratorModelType?: 'SMART_MODEL' | 'REASONING_MODEL' | string | null;
+    plannerModelName?: string | null;
+    coordinatorModelName?: string | null;
+    orchestratorModelName?: string | null;
+    finalResponseModelName?: string | null;
+    fastModelName?: string | null;
+    useCognitiveTools?: boolean;
+    enableTaskValidation?: boolean;
+    generateComprehensiveOutput?: boolean;
+}
+interface ModelOverrides {
+    [key: string]: string;
+}
+interface CreateResponseRequest {
+    threadId?: UUID;
+    messages: Message[];
+    agentEffort?: AgentEffort;
+    costCapUsd?: number;
+    files?: FileAttachment[];
+    options?: Record<string, any>;
+    priority?: number;
+    userId?: string;
+    agentConfig?: AgentConfig;
+    responseFormat?: Record<string, any>;
+    responseFormatInstructions?: string;
+    modelOverrides?: ModelOverrides;
+}
+interface ProgressEntry {
+    ts: string;
+    state: string;
+    message: string;
+    toolCalls?: Array<Record<string, any>> | null;
+    outputText?: string | null;
+}
+interface ResponseArtifact {
+    type: string;
+    language?: string;
+    content: string;
+    [key: string]: any;
+}
+interface ResponseObject {
+    responseId: UUID;
+    threadId: UUID;
+    tenantId: UUID;
+    userId?: UUID | null;
+    status: ResponseStatus;
+    progress: ProgressEntry[];
+    inputMessages: Message[];
+    outputText?: string | null;
+    content?: string | null;
+    structuredResponse?: Record<string, any> | null;
+    artifacts?: ResponseArtifact[] | null;
+    createdAt: string;
+    completedAt?: string | null;
+    error?: Record<string, any> | null;
+    options?: Record<string, any> | null;
+}
+interface CreateResponseResponse {
+    responseId: UUID;
+    threadId: UUID;
+    status: ResponseStatus;
+    tenantId: UUID;
+    createdAt: string;
+}
+interface CancelResponseResponse {
+    status: string;
+    message: string;
+}
+interface ArtifactObject {
+    artifactId: UUID;
+    responseId: UUID;
+    name: string;
+    uri: string;
+    mimeType: string;
+    bytes: number;
+    createdAt: string;
+}
+interface ArtifactsListResponse {
+    artifacts: ArtifactObject[];
+    total: number;
+    limit: number;
+    offset: number;
+}
+interface ResponseListResponse {
+    responses: ResponseObject[];
+    total: number;
+    limit: number;
+    offset: number;
+}
+
+interface ThreadObject {
+    threadId: UUID;
+    tenantId: UUID;
+    userId?: UUID | null;
+    title?: string | null;
+    createdAt: string;
+    updatedAt?: string | null;
+    responseCount: number;
+    lastResponseAt?: string | null;
+}
+interface ThreadListResponse {
+    threads: ThreadObject[];
+    total: number;
+    limit: number;
+    offset: number;
+}
+interface UpdateThreadRequest {
+    title?: string | null;
+}
+interface CreateThreadRequest {
+    userId?: string | null;
+    title?: string | null;
+}
+interface ThreadResponsesParams {
+    limit?: number;
+    offset?: number;
+}
+
+interface UserResponse {
+    id: UUID;
+    email: string;
+    tenantId: UUID;
+    firstName?: string | null;
+    lastName?: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+interface UserCreateRequest {
+    email: string;
+    firstName?: string;
+    lastName?: string;
+}
+interface UserUpdateRequest {
+    firstName?: string;
+    lastName?: string;
+}
+interface UserListResponse {
+    users: UserResponse[];
+    pagination: PaginationInfo;
+}
+interface UserDeleteResponse {
+    message: string;
+}
+
+interface HttpOptions {
+    baseUrl: string;
+    apiPrefix?: string;
+    headers?: Record<string, string>;
+    timeoutMs?: number;
+    maxRetries?: number;
+    backoffFactor?: number;
+}
+interface RequestOptions extends Omit<RequestInit, 'body'> {
+    body?: unknown;
+    idempotencyKey?: string;
+    params?: Record<string, any>;
+}
+declare class Http {
+    private readonly options;
+    constructor(options: HttpOptions);
+    private _handleResponse;
+    request<T = unknown>(path: string, init?: RequestOptions): Promise<T>;
+    get<T = unknown>(path: string, options?: RequestOptions): Promise<T>;
+    post<T = unknown>(path: string, body?: unknown, options?: RequestOptions): Promise<T>;
+    put<T = unknown>(path: string, body?: unknown, options?: RequestOptions): Promise<T>;
+    patch<T = unknown>(path: string, body?: unknown, options?: RequestOptions): Promise<T>;
+    delete<T = unknown>(path: string, options?: RequestOptions): Promise<T>;
+    warnTenantScope(): Promise<void>;
+}
+
+declare class ExternalAPIKeysResource {
+    private readonly http;
+    constructor(http: Http);
+    /**
+     * Store a new external API key (encrypted)
+     */
+    store(data: StoreApiKeyRequest): Promise<ExternalApiKeyResponse>;
+    /**
+     * Create a new external API key (alias for store)
+     */
+    create(data: StoreApiKeyRequest): Promise<ExternalApiKeyResponse>;
+    /**
+     * List all configured external API keys (metadata only, no key values)
+     */
+    list(): Promise<ExternalApiKeyResponse[]>;
+    /**
+     * Get details for a specific external API key (no key value)
+     */
+    get(keyId: string): Promise<ExternalApiKeyResponse>;
+    /**
+     * Delete an external API key for a specific provider
+     */
+    delete(provider: ApiProvider): Promise<DeleteApiKeyResponse>;
+    /**
+     * Get the current API key mode
+     */
+    getMode(): Promise<ApiKeyModeResponse>;
+    /**
+     * Update the API key mode
+     */
+    updateMode(data: ApiKeyModeRequest): Promise<ApiKeyModeResponse>;
+    /**
+     * Set the API key mode (alias for updateMode)
+     */
+    setMode(data: ApiKeyModeRequest): Promise<ApiKeyModeResponse>;
+}
+
+type ProcessingStatus = 'pending' | 'parsing' | 'embedding' | 'completed' | 'partial_success' | 'error';
+type FileScope = 'user' | 'tenant';
+type ContentType = 'text' | 'transcript' | 'summary' | 'structured';
+type DuplicateHandling = 'error' | 'skip' | 'replace' | 'suffix';
+type ChunkingStrategy = 'sentence' | 'paragraph' | 'code' | 'markdown' | 'table';
+interface FileMetadata {
+    id: UUID;
+    tenantId: UUID;
+    userId?: UUID | null;
+    fileName: string;
+    originalFileName: string;
+    fileType: string;
+    mimeType: string;
+    fileSize: number;
+    fileScope: FileScope;
+    tags?: string[] | null;
+    blobUrl?: string | null;
+    processingStatus: ProcessingStatus;
+    errorMessage?: string | null;
+    totalChunks: number;
+    chunksEmbedded: number;
+    createdAt: string;
+    updatedAt: string;
+    deletedAt?: string | null;
+}
+interface FileUploadResponse {
+    fileId: UUID;
+    fileName: string;
+    status: ProcessingStatus;
+    message: string;
+}
+interface FileContentResponse {
+    fileId: UUID;
+    contentType: ContentType;
+    text: string;
+    metadata?: Record<string, any> | null;
+    startLine?: number | null;
+    endLine?: number | null;
+    totalLines?: number | null;
+}
+interface FileChunk {
+    id: UUID;
+    chunkIndex: number;
+    chunkText: string;
+    startLine?: number | null;
+    endLine?: number | null;
+    tokenCount?: number | null;
+    metadata?: Record<string, any> | null;
+    similarityScore?: number | null;
+}
+interface FileSearchResult {
+    file: FileMetadata;
+    chunks: FileChunk[];
+    overallScore: number;
+}
+interface FileSearchRequest {
+    query: string;
+    limit?: number;
+    minScore?: number;
+    fileTypes?: string[];
+    tags?: string[];
+    userId?: string;
+}
+interface FileSearchResponse {
+    results: FileSearchResult[];
+    totalCount: number;
+    query: string;
+    processingTimeMs?: number | null;
+}
+interface ProcessingStatusResponse {
+    status: ProcessingStatus;
+    progressPercentage: number;
+    chunksEmbedded: number;
+    totalChunks: number;
+    estimatedTimeRemainingSeconds?: number | null;
+    errorMessage?: string | null;
+    jobs?: Array<Record<string, any>> | null;
+}
+interface FileListResponse {
+    files: FileMetadata[];
+    totalCount: number;
+    page: number;
+    limit: number;
+    hasMore: boolean;
+}
+interface BulkDeleteRequest {
+    fileIds: UUID[];
+}
+interface BulkDeleteResponse {
+    deleted: UUID[];
+    failed: UUID[];
+    hardDelete: boolean;
+    totalRequested: number;
+}
+interface FileScopeUpdateRequest {
+    scope: FileScope;
+    userId?: UUID;
+}
+interface FileStatisticsResponse {
+    totalFiles: number;
+    totalSizeBytes: number;
+    filesByType: Record<string, number>;
+    filesByStatus: Record<ProcessingStatus, number>;
+    filesByScope: Record<FileScope, number>;
+    averageFileSizeBytes: number;
+    averageProcessingTimeSeconds?: number | null;
+    storageUsagePercentage?: number | null;
+}
+interface BulkUploadResponse {
+    uploaded: FileUploadResponse[];
+    failed: Array<{
+        filename: string;
+        error: string;
+    }>;
+    totalUploaded: number;
+    totalFailed: number;
+}
+
+declare class FilesResource {
+    private readonly http;
+    constructor(http: Http);
+    /**
+     * Upload a new file for processing
+     * @param file - The file to upload (File or Blob)
+     * @param options - Upload options
+     * @param options.scope - File access scope (user or tenant)
+     * @param options.userId - User ID or email (required for user-scoped files)
+     * @param options.tags - Comma-separated tags for categorization
+     * @param options.duplicateHandling - How to handle duplicate filenames
+     */
+    upload(file: File | Blob, options: {
+        scope: FileScope;
+        userId?: string;
+        tags?: string;
+        duplicateHandling?: 'error' | 'skip' | 'replace' | 'suffix';
+    }): Promise<FileUploadResponse>;
+    /**
+     * Upload multiple files at once
+     */
+    bulkUpload(files: Array<File | Blob>, options: {
+        scope: FileScope;
+        userId?: string;
+        tags?: string;
+    }): Promise<BulkUploadResponse>;
+    /**
+     * Get file metadata by ID
+     */
+    get(fileId: string, userId?: string): Promise<FileMetadata>;
+    /**
+     * List files with optional filters
+     */
+    list(params?: {
+        userId?: string;
+        scope?: FileScope;
+        fileType?: string;
+        status?: ProcessingStatus;
+        tags?: string;
+        page?: number;
+        limit?: number;
+    }): Promise<FileListResponse>;
+    /**
+     * Get file content
+     */
+    getContent(fileId: string, options?: {
+        contentType?: 'text' | 'transcript' | 'summary' | 'structured';
+        startLine?: number;
+        endLine?: number;
+        userId?: string;
+    }): Promise<FileContentResponse>;
+    /**
+     * Download original file
+     * Returns a redirect URL for blob storage or file content directly
+     */
+    download(fileId: string, userId?: string): Promise<any>;
+    /**
+     * Update file access scope
+     */
+    updateScope(fileId: string, data: FileScopeUpdateRequest): Promise<FileMetadata>;
+    /**
+     * Delete a file
+     */
+    delete(fileId: string, options?: {
+        hardDelete?: boolean;
+        userId?: string;
+    }): Promise<{
+        message: string;
+        fileId: string;
+        hardDelete: boolean;
+    }>;
+    /**
+     * Delete multiple files at once
+     */
+    bulkDelete(data: BulkDeleteRequest, options?: {
+        hardDelete?: boolean;
+        userId?: string;
+    }): Promise<BulkDeleteResponse>;
+    /**
+     * Get file processing status
+     */
+    getStatus(fileId: string, userId?: string): Promise<ProcessingStatusResponse>;
+    /**
+     * Semantic search across files
+     */
+    search(request: FileSearchRequest): Promise<FileSearchResponse>;
+    /**
+     * Get file statistics for the tenant
+     */
+    getStatistics(): Promise<FileStatisticsResponse>;
+}
+
+declare class IntegrationsResource {
+    private readonly http;
+    constructor(http: Http);
+    /**
+     * Start an OAuth connection flow for a user
+     */
+    initiateConnection(data: InitiateConnectionRequest): Promise<InitiateConnectionResponse>;
+    /**
+     * Check the status of a specific connection
+     */
+    getConnectionStatus(userId: string, appName: string): Promise<ConnectionStatusResponse>;
+    /**
+     * Get all connections for a user
+     */
+    getUserConnections(userId: string, appFilter?: string): Promise<UserConnectionsResponse>;
+    /**
+     * Get available tools for a user based on connections
+     */
+    getTools(data: GetToolsRequest): Promise<GetToolsResponse>;
+    /**
+     * Disconnect a user from an external app
+     */
+    disconnect(data: DisconnectRequest): Promise<DisconnectResponse>;
+    /**
+     * Handle OAuth callback (for custom implementations)
+     */
+    handleCallback(data: ConnectionCallbackRequest): Promise<ConnectionCallbackResponse>;
+    /**
+     * List apps enabled for the tenant
+     */
+    listApps(params?: {
+        includeAvailable?: boolean;
+    }): Promise<AppsListResponse>;
+    /**
+     * Check if a specific app is enabled
+     */
+    checkAppEnabled(appName: string): Promise<AppEnabledResponse>;
+    /**
+     * Enable or disable an app for the tenant
+     */
+    updateAppStatus(appName: string, enabled: boolean): Promise<UpdateAppStatusResponse>;
+    /**
+     * Get required fields for non-OAuth authentication (future)
+     */
+    getNonOAuthRequiredFields(appName: string, authScheme: string): Promise<any>;
+    isAppEnabled(appName: string): Promise<AppEnabledResponse>;
+    setAppEnabled(appName: string, data: {
+        enabled: boolean;
+    }): Promise<UpdateAppStatusResponse>;
+    listConnections(userId: string, params?: {
+        appFilter?: string;
+    }): Promise<UserConnectionsResponse>;
+}
+
+declare class MCPServersResource {
+    private readonly http;
+    constructor(http: Http);
+    /**
+     * Create a new MCP server configuration
+     */
+    create(data: MCPServerCreateRequest): Promise<MCPServerResponse>;
+    /**
+     * List MCP server configurations
+     */
+    list(params?: {
+        scope?: MCPScope | 'all';
+        userIdentifier?: string;
+        isActive?: boolean;
+        skip?: number;
+        limit?: number;
+    }): Promise<MCPServerListResponse>;
+    /**
+     * Get a specific MCP server configuration
+     */
+    get(serverId: string): Promise<MCPServerResponse>;
+    /**
+     * Update an MCP server configuration
+     */
+    update(serverId: string, data: MCPServerUpdateRequest): Promise<MCPServerResponse>;
+    /**
+     * Delete an MCP server configuration
+     */
+    delete(serverId: string): Promise<void>;
+    /**
+     * List tools provided by an MCP server
+     * Note: Currently returns empty list, tool indexing coming in Phase 1
+     */
+    listTools(serverId: string): Promise<MCPToolListResponse>;
+    /**
+     * Test connection to an MCP server
+     * Note: Currently returns placeholder, testing coming in Phase 1
+     */
+    testConnection(serverId: string): Promise<TestConnectionResponse>;
+    /**
+     * Test an MCP server configuration before saving
+     * Validates that the server can be connected to without creating a permanent configuration
+     */
+    testConfig(config: {
+        transport: 'stdio' | 'streamable_http' | 'sse';
+        command?: string;
+        args?: string[];
+        url?: string;
+        env?: Record<string, string>;
+        headers?: Record<string, string>;
+    }): Promise<TestConnectionResponse>;
+}
+
+declare class ModelPreferencesResource {
+    private readonly http;
+    constructor(http: Http);
+    /**
+     * Get all model preferences for the tenant
+     */
+    get(includeDefaults?: boolean): Promise<TenantModelPreferencesResponse>;
+    /**
+     * Update multiple model preferences in a single request
+     */
+    updateBulk(data: ModelPreferencesBulkUpdate): Promise<TenantModelPreferencesResponse>;
+    /**
+     * Update a specific model type preference
+     */
+    update(modelType: ModelType, data: ModelPreferenceCreate): Promise<TenantModelPreference>;
+    /**
+     * Delete a model preference to revert to system default
+     */
+    delete(modelType: ModelType): Promise<void>;
+    /**
+     * Check which models are available based on API key configuration
+     */
+    checkAvailability(models: ModelPreferenceCreate[]): Promise<ModelAvailability[]>;
+    /**
+     * List all model preferences (alias for get)
+     */
+    list(params?: {
+        includeDefaults?: boolean;
+    }): Promise<TenantModelPreferencesResponse>;
+}
+
+declare class ResponsesResource {
+    private readonly http;
+    constructor(http: Http);
+    private _validateFileReference;
+    /**
+     * Create a new response request for asynchronous processing
+     */
+    create(request: CreateResponseRequest): Promise<CreateResponseResponse>;
+    /**
+     * Get response status and content
+     * @param responseId - The response ID
+     * @param options - Optional parameters
+     * @param options.wait - Wait time in seconds for long-polling
+     */
+    get(responseId: string, options?: {
+        wait?: number;
+    }): Promise<ResponseObject>;
+    /**
+     * List responses with optional filtering
+     * @param params - Optional filter parameters
+     * @param params.userId - Filter by user ID
+     * @param params.status - Filter by response status
+     * @param params.startDate - Filter responses created after this date
+     * @param params.endDate - Filter responses created before this date
+     * @param params.limit - Maximum number of responses to return
+     * @param params.offset - Number of responses to skip for pagination
+     */
+    list(params?: {
+        userId?: string;
+        status?: 'queued' | 'in_progress' | 'succeeded' | 'failed' | 'cancelled';
+        startDate?: string;
+        endDate?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<ResponseListResponse>;
+    /**
+     * Cancel a queued or in-progress response
+     */
+    cancel(responseId: string): Promise<CancelResponseResponse>;
+    /**
+     * List artifacts generated by a response
+     */
+    listArtifacts(responseId: string, params?: PaginationParams): Promise<ArtifactsListResponse>;
+}
+
+declare class TenantInfoResource {
+    private readonly http;
+    constructor(http: Http);
+    /**
+     * Get detailed information about a tenant
+     * Users can only access information about their own tenant
+     */
+    get(tenantId: string): Promise<TenantDetailsResponse>;
+}
+
+declare class ThreadsResource {
+    private readonly http;
+    constructor(http: Http);
+    /**
+     * Create a new thread
+     */
+    create(params?: CreateThreadRequest): Promise<ThreadObject>;
+    /**
+     * List threads for the authenticated tenant
+     */
+    list(params?: {
+        userId?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<ThreadListResponse>;
+    /**
+     * Get detailed information about a specific thread
+     */
+    get(threadId: string): Promise<ThreadObject>;
+    /**
+     * Get all responses associated with a specific thread
+     */
+    getResponses(threadId: string, params?: ThreadResponsesParams): Promise<ResponseObject[]>;
+    /**
+     * Update thread metadata
+     */
+    update(threadId: string, data: UpdateThreadRequest): Promise<ThreadObject>;
+    /**
+     * Delete a thread and all its associated responses
+     */
+    delete(threadId: string): Promise<void>;
+}
+
+declare class UsersResource {
+    private readonly http;
+    constructor(http: Http);
+    /**
+     * Create a new user within the tenant
+     * Returns existing user with 200 OK if user with same email already exists
+     */
+    create(data: UserCreateRequest): Promise<UserResponse>;
+    /**
+     * List all users in the tenant with pagination
+     */
+    list(params?: {
+        page?: number;
+        pageSize?: number;
+    }): Promise<UserListResponse>;
+    /**
+     * Get user details by ID or email
+     */
+    get(userIdentifier: string): Promise<UserResponse>;
+    /**
+     * Update user information by ID or email
+     */
+    update(userIdentifier: string, data: UserUpdateRequest): Promise<UserResponse>;
+    /**
+     * Delete (deactivate) a user by ID or email
+     */
+    delete(userIdentifier: string): Promise<UserDeleteResponse>;
+    /**
+     * Get all AI responses generated for a specific user
+     */
+    getResponses(userIdentifier: string, params?: {
+        page?: number;
+        pageSize?: number;
+    }): Promise<ResponseObject[]>;
+    /**
+     * Get all conversation threads for a specific user
+     */
+    getThreads(userIdentifier: string, params?: {
+        page?: number;
+        pageSize?: number;
+    }): Promise<ThreadObject[]>;
+}
+
+interface LumnisClientOptions {
+    apiKey?: string;
+    tenantId?: string;
+    baseUrl?: string;
+    timeoutMs?: number;
+    maxRetries?: number;
+    scope?: Scope;
+    _scopedUserId?: string;
+}
+type InvokeMessages = string | Message | Message[];
+interface InvokeOptions extends Partial<Omit<CreateResponseRequest, 'messages'>> {
+    scope?: Scope;
+    showProgress?: boolean;
+    pollIntervalMs?: number;
+    maxWaitMs?: number;
+}
+declare class LumnisClient {
+    private readonly http;
+    readonly tenantId?: string;
+    readonly threads: ThreadsResource;
+    readonly responses: ResponsesResource;
+    readonly users: UsersResource;
+    readonly files: FilesResource;
+    readonly tenantInfo: TenantInfoResource;
+    readonly externalApiKeys: ExternalAPIKeysResource;
+    readonly integrations: IntegrationsResource;
+    readonly modelPreferences: ModelPreferencesResource;
+    readonly mcpServers: MCPServersResource;
+    private readonly _scopedUserId?;
+    private readonly _defaultScope;
+    constructor(options?: LumnisClientOptions);
+    forUser(userId: string): LumnisClient;
+    invoke(messages: InvokeMessages, options: InvokeOptions & {
+        stream?: false;
+    }): Promise<ResponseObject>;
+    invoke(messages: InvokeMessages, options: InvokeOptions & {
+        stream: true;
+    }): Promise<AsyncGenerator<ProgressEntry, void, unknown>>;
+    private _invokeStream;
+    private _invokeAndWait;
+    private _createResponse;
+    listThreads(params?: Parameters<ThreadsResource['list']>[0]): Promise<ThreadListResponse>;
+    createThread(params?: Parameters<ThreadsResource['create']>[0]): Promise<ThreadObject>;
+    getThread(threadId: string): Promise<ThreadObject>;
+    deleteThread(threadId: string): Promise<void>;
+    createUser(params: Parameters<UsersResource['create']>[0]): Promise<UserResponse>;
+    getUser(userId: string): Promise<UserResponse>;
+    updateUser(userId: string, params: Parameters<UsersResource['update']>[1]): Promise<UserResponse>;
+    deleteUser(userId: string): Promise<UserDeleteResponse>;
+    listUsers(params?: Parameters<UsersResource['list']>[0]): Promise<UserListResponse>;
+    addApiKey(params: Parameters<ExternalAPIKeysResource['create']>[0]): Promise<ExternalApiKeyResponse>;
+    listApiKeys(): Promise<ExternalApiKeyResponse[]>;
+    getApiKey(keyId: string): Promise<ExternalApiKeyResponse>;
+    deleteApiKey(provider: Parameters<ExternalAPIKeysResource['delete']>[0]): Promise<DeleteApiKeyResponse>;
+    getApiKeyMode(): Promise<ApiKeyModeResponse>;
+    setApiKeyMode(mode: Parameters<ExternalAPIKeysResource['setMode']>[0]): Promise<ApiKeyModeResponse>;
+    listApps(params?: Parameters<IntegrationsResource['listApps']>[0]): Promise<AppsListResponse>;
+    isAppEnabled(appName: string): Promise<AppEnabledResponse>;
+    setAppEnabled(appName: string, enabled: boolean): Promise<UpdateAppStatusResponse>;
+    initiateConnection(params: Parameters<IntegrationsResource['initiateConnection']>[0]): Promise<InitiateConnectionResponse>;
+    getConnectionStatus(userId: string, appName: string): Promise<ConnectionStatusResponse>;
+    listConnections(userId: string, params?: Parameters<IntegrationsResource['listConnections']>[1]): Promise<UserConnectionsResponse>;
+    getIntegrationTools(userId: string, params?: {
+        appFilter?: string[];
+    }): Promise<GetToolsResponse>;
+    getModelPreferences(params?: Parameters<ModelPreferencesResource['list']>[0]): Promise<TenantModelPreferencesResponse>;
+    updateModelPreferences(params: Parameters<ModelPreferencesResource['updateBulk']>[0]): Promise<TenantModelPreferencesResponse>;
+    createMcpServer(params: Parameters<MCPServersResource['create']>[0]): Promise<MCPServerResponse>;
+    getMcpServer(serverId: string): Promise<MCPServerResponse>;
+    listMcpServers(params?: Parameters<MCPServersResource['list']>[0]): Promise<MCPServerListResponse>;
+    updateMcpServer(serverId: string, params: Parameters<MCPServersResource['update']>[1]): Promise<MCPServerResponse>;
+    deleteMcpServer(serverId: string): Promise<void>;
+    listMcpServerTools(serverId: string): Promise<MCPToolListResponse>;
+    testMcpServer(serverId: string): Promise<TestConnectionResponse>;
+}
+
+interface LumnisErrorOptions {
+    code?: string;
+    statusCode?: number;
+    details?: any;
+    requestId?: string | null;
+}
+declare class LumnisError extends Error {
+    code: string;
+    statusCode?: number;
+    details?: any;
+    requestId?: string | null;
+    constructor(message: string, options?: LumnisErrorOptions);
+}
+interface RateLimitErrorOptions extends LumnisErrorOptions {
+    retryAfter?: string | number | null;
+}
+declare class AuthenticationError extends LumnisError {
+    constructor(message: string, options?: LumnisErrorOptions);
+}
+declare class ValidationError extends LumnisError {
+    constructor(message: string, options?: LumnisErrorOptions);
+}
+declare class NotFoundError extends LumnisError {
+    constructor(message: string, options?: LumnisErrorOptions);
+}
+declare class RateLimitError extends LumnisError {
+    retryAfter?: string | number | null;
+    constructor(options?: RateLimitErrorOptions);
+}
+declare class InternalServerError extends LumnisError {
+    constructor(message: string, options?: LumnisErrorOptions);
+}
+declare class LocalFileNotSupportedError extends ValidationError {
+    constructor(filePath: string);
+}
+
+export = LumnisClient;
+export { type AgentConfig, type AgentEffort, type ApiKeyMode, type ApiKeyModeRequest, type ApiKeyModeResponse, type ApiProvider, type AppEnabledResponse, type AppsListResponse, type ArtifactObject, type ArtifactsListResponse, AuthenticationError, type BaseResource, type BillingStatus, type BulkDeleteRequest, type BulkDeleteResponse, type BulkUploadResponse, type CancelResponseResponse, type ChunkingStrategy, type ConnectionCallbackRequest, type ConnectionCallbackResponse, type ConnectionInfo, type ConnectionStatus, type ConnectionStatusResponse, type ContentType, type CreateResponseRequest, type CreateResponseResponse, type CreateThreadRequest, type DatabaseStatus, type DeleteApiKeyResponse, type DisconnectRequest, type DisconnectResponse, type DuplicateHandling, type Email, type ErrorResponse, ExternalAPIKeysResource, type ExternalApiKeyResponse, type FileAttachment, type FileChunk, type FileContentResponse, type FileListResponse, type FileMetadata, type FileScope, type FileScopeUpdateRequest, type FileSearchRequest, type FileSearchResponse, type FileSearchResult, type FileStatisticsResponse, type FileUploadResponse, FilesResource, type GetToolsRequest, type GetToolsResponse, type InitiateConnectionRequest, type InitiateConnectionResponse, IntegrationsResource, InternalServerError, LocalFileNotSupportedError, LumnisClient, type LumnisClientOptions, LumnisError, type LumnisErrorOptions, type MCPScope, type MCPServerCreateRequest, type MCPServerListResponse, type MCPServerResponse, type MCPServerUpdateRequest, MCPServersResource, type MCPToolListResponse, type MCPToolResponse, type MCPTransport, type Message, type ModelAvailability, type ModelOverrides, type ModelPreferenceCreate, type ModelPreferencesBulkUpdate, ModelPreferencesResource, type ModelProvider, type ModelType, NotFoundError, type PaginationInfo, type PaginationParams, type Plan, type ProcessingStatus, type ProcessingStatusResponse, type ProgressEntry, RateLimitError, type RateLimitErrorOptions, type ResponseArtifact, type ResponseListResponse, type ResponseObject, type ResponseStatus, ResponsesResource, type Scope, type StoreApiKeyRequest, type TenantDetailsResponse, TenantInfoResource, type TenantModelPreference, type TenantModelPreferencesResponse, type TestConnectionResponse, type ThreadListResponse, type ThreadObject, type ThreadResponsesParams, ThreadsResource, type ToolInfo, type UUID, type UpdateAppStatusResponse, type UpdateThreadRequest, type UserConnectionsResponse, type UserCreateRequest, type UserDeleteResponse, type UserIdentifier, type UserListResponse, type UserResponse, type UserUpdateRequest, UsersResource, ValidationError };