import type { CollectionBase, ICollection, RecordMeetingConfig } from '../interfaces/core';
import { IndexType, SearchType } from '../types/search';
import type { FileUploadConfig, URLUploadConfig } from '../types/collection';
import type { CreateCaptureSessionConfig, ListCaptureSessionsConfig } from '../types/capture';
import { HttpClient } from '../utils/httpClient';
import { SearchResult } from './search/searchResult';
import { Video } from './video';
import { Audio } from './audio';
import { Image } from './image';
import { Meeting } from './meeting';
import { CaptureSession } from './captureSession';
import { RTStream, RTStreamSearchResult } from './rtstream';
/**
 * The base VideoDB class
 * @remarks
 * The base class through which all videodb actions are possible
 */
export declare class Collection implements ICollection {
    #private;
    readonly id: string;
    readonly name?: string;
    readonly description?: string;
    readonly isPublic?: boolean;
    constructor(http: HttpClient, data: CollectionBase);
    /** * Get all videos from the collection
     * @returns A list of objects of the Video class
     * @throws an error if the request fails
     */
    getVideos: () => Promise<Video[]>;
    /**
     * Get all the information for a specific video
     * @param videoId - Unique ID of the video.
     * @returns An object of the Video class
     * @throws an error if the request fails
     */
    getVideo: (videoId: string) => Promise<Video>;
    /**
     *
     * @param videoId - Id of the video to be deleted
     * @returns A promise that resolves when delete is successful
     * @throws an error if the request fails
     */
    deleteVideo: (videoId: string) => Promise<import("../types/response").ResponseOf<Record<string, never>>>;
    /** * Get all audios from the collection
     * @returns A list of objects of the Audio class
     * @throws an error if the request fails
     */
    getAudios: () => Promise<Audio[]>;
    /**
     * Get all the information for a specific audio
     * @param audioId- Unique ID of the audio.
     * @returns An object of the Audio class
     * @throws an error if the request fails
     */
    getAudio: (audioId: string) => Promise<Audio>;
    /**
     *
     * @param audioId- Id of the audio to be deleted
     * @returns A promise that resolves when delete is successful
     * @throws an error if the request fails
     */
    deleteAudio: (audioId: string) => Promise<import("../types/response").ResponseOf<Record<string, never>>>;
    /** * Get all images from the collection
     * @returns A list of objects of the Image class
     * @throws an error if the request fails
     */
    getImages: () => Promise<Image[]>;
    /**
     * Get all the information for a specific image
     * @param imageId- Unique ID of the image.
     * @returns An object of the Image class
     * @throws an error if the request fails
     */
    getImage: (imageId: string) => Promise<Image>;
    /**
     *
     * @param imageId- Id of the image to be deleted
     * @returns A promise that resolves when delete is successful
     * @throws an error if the request fails
     */
    deleteImage: (imageId: string) => Promise<import("../types/response").ResponseOf<Record<string, never>>>;
    /**
     * Upload a file from the local filesystem.
     * @param data - Upload configuration containing:
     *   - filePath: absolute path to a file
     *   - callbackUrl: (optional) A url that will be called once upload is finished
     *   - name: (optional) Name of the file
     *   - description: (optional) Description of the file
     * @returns Video, Audio, or Image object. Returns undefined if callbackUrl is provided.
     */
    uploadFile: (data: FileUploadConfig) => Promise<Image | Video | Audio | undefined>;
    /**
     * Upload a file from a URL.
     * @param data - Upload configuration containing:
     *   - url: URL of the hosted file
     *   - callbackUrl: (optional) A url that will be called once upload is finished
     *   - name: (optional) Name of the file
     *   - description: (optional) Description of the file
     * @returns Video, Audio, or Image object. Returns undefined if callbackUrl is provided.
     */
    uploadURL: (data: URLUploadConfig) => Promise<Image | Video | Audio | undefined>;
    /**
     * Search for a query in the collection
     * @param query - Search query
     * @param searchType - [optional] Type of search to be performed
     * @param indexType - [optional] Index type
     * @param resultThreshold - [optional] Result Threshold
     * @param scoreThreshold - [optional] Score Threshold
     * @param dynamicScorePercentage - [optional] Percentage of dynamic score to consider
     * @param filter - [optional] Additional metadata filters
     * @param sortDocsOn - [optional] Sort docs within each video by "score" or "start"
     * @param namespace - [optional] Search namespace ("rtstream" to search RTStreams)
     * @param sceneIndexId - [optional] Filter by specific scene index
     * @returns SearchResult or RTStreamSearchResult object
     */
    search: (query: string, searchType?: SearchType, indexType?: IndexType, resultThreshold?: number, scoreThreshold?: number, dynamicScorePercentage?: number, filter?: Array<Record<string, unknown>>, sortDocsOn?: string, namespace?: string, sceneIndexId?: string) => Promise<SearchResult | RTStreamSearchResult>;
    /**
     * Delete the collection
     * @returns A promise that resolves when delete is successful
     */
    delete: () => Promise<import("../types/response").ResponseOf<Record<string, never>>>;
    /**
     * Connect to an RTStream
     * @param url - URL of the RTStream
     * @param name - Name of the RTStream
     * @param mediaTypes - List of media types to capture (default: ['video']). Valid values: 'video', 'audio'
     * @param sampleRate - Sample rate of the RTStream (optional, server default: 30)
     * @param store - Enable recording storage (optional, default: false). When true, the stream recording is stored and can be exported via RTStream.export()
     * @param enableTranscript - Enable real-time transcription (optional)
     * @param wsConnectionId - WebSocket connection ID for receiving events (optional)
     * @returns RTStream object
     */
    connectRTStream: (url: string, name: string, mediaTypes?: Array<'video' | 'audio'>, sampleRate?: number, store?: boolean, enableTranscript?: boolean, wsConnectionId?: string) => Promise<RTStream>;
    /**
     * Get an RTStream by its ID
     * @param id - ID of the RTStream
     * @returns RTStream object
     */
    getRTStream: (id: string) => Promise<RTStream>;
    /**
     * List all RTStreams in the collection
     * @param options - Query options: limit (default 10), offset (default 0), status, name, ordering
     * @returns List of RTStream objects
     */
    listRTStreams: (options?: {
        limit?: number;
        offset?: number;
        status?: string;
        name?: string;
        ordering?: string;
    }) => Promise<RTStream[]>;
    /**
     * Generate an image from a prompt
     * @param prompt - Prompt for the image generation
     * @param aspectRatio - Aspect ratio of the image (optional)
     * @param callbackUrl - URL to receive the callback (optional)
     * @returns Image object
     */
    generateImage: (prompt: string, aspectRatio?: '1:1' | '9:16' | '16:9' | '4:3' | '3:4', callbackUrl?: string) => Promise<Image | undefined>;
    /**
     * Generate music from a prompt
     * @param prompt - Prompt for the music generation
     * @param duration - Duration of the music in seconds
     * @param callbackUrl - URL to receive the callback (optional)
     * @returns Audio object
     */
    generateMusic: (prompt: string, duration?: number, callbackUrl?: string) => Promise<Audio | undefined>;
    /**
     * Generate sound effect from a prompt
     * @param prompt - Prompt for the sound effect generation
     * @param duration - Duration of the sound effect in seconds
     * @param config - Configuration for the sound effect generation
     * @param callbackUrl - URL to receive the callback (optional)
     * @returns Audio object
     */
    generateSoundEffect: (prompt: string, duration?: number, config?: Record<string, unknown>, callbackUrl?: string) => Promise<Audio | undefined>;
    /**
     * Generate voice from text
     * @param textContent - Text to convert to voice
     * @param voiceName - Name of the voice to use
     * @param config - Configuration for the voice generation
     * @param callbackUrl - URL to receive the callback (optional)
     * @returns Audio object
     */
    generateVoice: (textContent: string, voiceName?: string, config?: Record<string, unknown>, callbackUrl?: string) => Promise<Audio | undefined>;
    /**
     * Generate a video from the given text prompt
     * @param prompt - Text prompt used as input for video generation
     * @param duration - Duration of the generated video in seconds (5-8)
     * @param callbackUrl - URL to receive callback once video generation is complete
     * @returns Video object
     */
    generateVideo: (prompt: string, duration?: number, callbackUrl?: string) => Promise<Video | undefined>;
    /**
     * Generate text from a prompt using genai offering
     * @param prompt - Prompt for the text generation
     * @param modelName - Model name to use ("basic", "pro" or "ultra")
     * @param responseType - Desired response type ("text" or "json")
     * @returns Generated text response
     */
    generateText: (prompt: string, modelName?: 'basic' | 'pro' | 'ultra', responseType?: 'text' | 'json') => Promise<string | Record<string, unknown>>;
    /**
     * Dub a video to another language
     * @param videoId - ID of the video to dub
     * @param languageCode - Language code to dub the video to
     * @param callbackUrl - URL to receive the callback (optional)
     * @returns Video object
     */
    dubVideo: (videoId: string, languageCode: string, callbackUrl?: string) => Promise<Video | undefined>;
    /**
     * Search by video title
     * @param query - Search query
     * @returns List of video search results
     */
    searchTitle: (query: string) => Promise<Array<{
        video: Video;
    }>>;
    /**
     * Make the collection public
     */
    makePublic: () => Promise<void>;
    /**
     * Make the collection private
     */
    makePrivate: () => Promise<void>;
    /**
     * Record a meeting and upload it to this collection
     * @param config - Meeting recording configuration
     * @returns Meeting object representing the recording bot
     */
    recordMeeting: (config: RecordMeetingConfig) => Promise<Meeting>;
    /**
     * Get a meeting by its ID
     * @param meetingId - ID of the meeting
     * @returns Meeting object
     */
    getMeeting: (meetingId: string) => Promise<Meeting>;
    /**
     * Create a capture session for video recording
     * @param config - Capture session configuration
     * @returns CaptureSession object
     *
     * @example
     * ```typescript
     * const coll = await conn.getCollection('col-xxx');
     *
     * const session = await coll.createCaptureSession({
     *   endUserId: 'user_abc',
     *   callbackUrl: 'https://example.com/webhook',
     *   metadata: { clientName: 'desktop-app' },
     * });
     *
     * const token = await conn.generateClientToken(86400);
     * // Send token to desktop client
     * ```
     */
    createCaptureSession: (config: CreateCaptureSessionConfig) => Promise<CaptureSession>;
    /**
     * Get an existing capture session by ID
     * @param sessionId - ID of the capture session
     * @returns CaptureSession object
     *
     * @example
     * ```typescript
     * const session = await coll.getCaptureSession('cap-xxx');
     * await session.refresh();
     * console.log(session.status);
     * ```
     */
    getCaptureSession: (sessionId: string) => Promise<CaptureSession>;
    /**
     * List all capture sessions in this collection
     * @param config - Filter configuration
     * @returns List of CaptureSession objects
     *
     * @example
     * ```typescript
     * const sessions = await coll.listCaptureSessions({ status: 'active' });
     * ```
     */
    listCaptureSessions: (config?: ListCaptureSessionsConfig) => Promise<CaptureSession[]>;
}