import { BehaviorSubject } from 'rxjs';
/**
 * Observable that emits the current window size category ('small', 'medium', or 'large').
 * Automatically updates when the window is resized and crosses size thresholds.
 *
 * @example
 * ```typescript
 * import { windowSize } from 'rainbow-web-sdk';
 *
 * windowSize.subscribe(size => {
 *   console.log('Window size changed to:', size);
 * });
 * ```
 */
export declare const windowSize: BehaviorSubject<string>;
/**
 * Detects if the current browser is Internet Explorer.
 *
 * @returns `true` if the browser is Internet Explorer (any version), `false` otherwise
 *
 * @example
 * ```typescript
 * import { isIEBrowser } from 'rainbow-web-sdk';
 *
 * if (isIEBrowser()) {
 *   console.warn('IE is not fully supported');
 * }
 * ```
 */
export declare function isIEBrowser(): boolean;
/**
 * Detects if the current browser is Safari.
 *
 * @returns `true` if the browser is Safari, `false` otherwise
 *
 * @remarks
 * Uses the WebRTC adapter's browser detection for accurate Safari identification.
 *
 * @example
 * ```typescript
 * import { isSafari } from 'rainbow-web-sdk';
 *
 * if (isSafari()) {
 *   console.log('Applying Safari-specific workarounds');
 * }
 * ```
 */
export declare function isSafari(): boolean;
/**
 * Detects if the current browser is Firefox.
 *
 * @returns `true` if the browser is Firefox, `false` otherwise
 *
 * @remarks
 * Uses the WebRTC adapter's browser detection for accurate Firefox identification.
 *
 * @example
 * ```typescript
 * import { isFirefox } from 'rainbow-web-sdk';
 *
 * if (isFirefox()) {
 *   console.log('Running in Firefox');
 * }
 * ```
 */
export declare function isFirefox(): boolean;
/**
 * Detects if the application is running in a desktop environment (Electron or Qt WebEngine).
 *
 * @returns `true` if running in Electron or Qt WebEngine, `false` otherwise
 *
 * @example
 * ```typescript
 * import { isDesktop } from 'rainbow-web-sdk';
 *
 * if (isDesktop()) {
 *   console.log('Running as desktop application');
 * }
 * ```
 */
export declare function isDesktop(): boolean;
/**
 * Detects if the application is running on localhost.
 *
 * @returns `true` if the hostname is 'localhost', `false` otherwise
 *
 * @example
 * ```typescript
 * import { isLocalhost } from 'rainbow-web-sdk';
 *
 * if (isLocalhost()) {
 *   console.log('Running in development mode');
 * }
 * ```
 */
export declare function isLocalhost(): boolean;
/**
 * Detects the operating system platform from the user agent.
 *
 * @returns Platform identifier: 'mac', 'win', 'linux', or 'unknown'
 *
 * @example
 * ```typescript
 * import { platform } from 'rainbow-web-sdk';
 *
 * const os = platform();
 * console.log('Running on:', os);
 *
 * if (os === 'mac') {
 *   console.log('Use Cmd key for shortcuts');
 * }
 * ```
 */
export declare function platform(): string;
/**
 * Requests access to browser media devices (camera, microphone, screen sharing) with specified constraints.
 *
 * @param userMedia - Array of media constraints defining which devices to request
 * @returns Promise resolving to a MediaStream containing the requested media tracks
 *
 * @remarks
 * This function applies device constraints and settings before requesting media access.
 * Use {@link getBrowserMediaWithNoConstraints} if you need raw device access without constraints.
 *
 * @example
 * ```typescript
 * import { getBrowserMedia } from 'rainbow-web-sdk';
 *
 * // Request camera and microphone
 * const stream = await getBrowserMedia([
 *   { audio: true, video: { width: 1280, height: 720 } }
 * ]);
 * ```
 */
export declare const getBrowserMedia: (userMedia: any[]) => Promise<MediaStream>;
/**
 * Requests access to browser media devices without applying additional constraints.
 *
 * @param userMedia - Array of basic media requests (audio/video flags)
 * @returns Promise resolving to a MediaStream with raw device access
 *
 * @remarks
 * Unlike {@link getBrowserMedia}, this function does not apply device-specific constraints
 * or settings, providing raw access to media devices.
 *
 * @example
 * ```typescript
 * import { getBrowserMediaWithNoConstraints } from 'rainbow-web-sdk';
 *
 * // Request basic camera and microphone access
 * const stream = await getBrowserMediaWithNoConstraints([
 *   { audio: true, video: true }
 * ]);
 * ```
 */
export declare const getBrowserMediaWithNoConstraints: (userMedia: any[]) => Promise<MediaStream>;
/**
 * Copies text content to the system clipboard.
 *
 * @param data - The text string to copy to clipboard
 * @returns Promise that resolves when the text is copied
 *
 * @remarks
 * Automatically falls back to a legacy clipboard method if the Clipboard API is not available.
 * The fallback uses a temporary textarea element with document.execCommand('copy').
 *
 * @example
 * ```typescript
 * import { copyTextToClipboard } from 'rainbow-web-sdk';
 *
 * await copyTextToClipboard('Hello, World!');
 * console.log('Text copied to clipboard');
 * ```
 */
export declare const copyTextToClipboard: (data: string) => Promise<void>;
/**
 * Copies a ClipboardItem (which can contain multiple formats) to the system clipboard.
 *
 * @param data - ClipboardItem containing the data to copy (supports multiple MIME types)
 * @returns Promise that resolves when the data is copied
 *
 * @remarks
 * Supports rich clipboard content including images, HTML, and text. Falls back to text-only
 * copying if the Clipboard API is not available. The ClipboardItem can contain multiple
 * representations (e.g., both text and HTML) and the system will use the most appropriate one.
 *
 * @example
 * ```typescript
 * import { copyToClipboard } from 'rainbow-web-sdk';
 *
 * // Copy text and HTML to clipboard
 * const item = new ClipboardItem({
 *   'text/plain': new Blob(['Hello'], { type: 'text/plain' }),
 *   'text/html': new Blob(['<b>Hello</b>'], { type: 'text/html' })
 * });
 *
 * await copyToClipboard(item);
 * ```
 */
export declare const copyToClipboard: (data: ClipboardItem) => Promise<void>;
export declare const isDarkTheme: () => boolean;
//# sourceMappingURL=browser.d.ts.map