@ceki/sdk 1.9.0

package/dist/index.d.cts

@@ -0,0 +1,420 @@
+interface ConnectOptions {
+    apiUrl?: string;
+    relayUrl?: string;
+    chatUrl?: string;
+    basicAuth?: [string, string];
+    reconnect?: boolean;
+}
+interface BrowserOption {
+    schedule_id: number;
+    user_id?: number | null;
+    geo?: string | null;
+    language?: string | null;
+    languages?: string[];
+    domain_allowed?: string[] | null;
+    skills?: string[];
+    price_per_min: number;
+    rating?: number | null;
+    online: boolean;
+    currency?: string | null;
+    kal_id?: number | null;
+    profile_mode?: 'main' | 'incognito' | null;
+    allowed_domains?: string[] | null;
+}
+interface Match {
+    session_id: string;
+    schedule_id: number;
+    event_id?: string | null;
+    chat_topic_id?: string | null;
+    provider_user_id?: number | null;
+    started_at?: number;
+    browser_info?: Record<string, unknown>;
+}
+interface ChatMessage {
+    id: string;
+    topic_id: string;
+    sender_id?: number | null;
+    text?: string | null;
+    media?: Record<string, unknown>[] | null;
+    type: string;
+    created_at: string;
+    edited_at?: string | null;
+    deleted_at?: string | null;
+    action?: {
+        kind: string;
+        event_id: number;
+        data?: Record<string, unknown>;
+    } | null;
+}
+interface ReadReceipt {
+    topic_id: string;
+    last_read_message_id: string;
+    read_at: number;
+}
+interface Snapshot {
+    screenshot: string;
+    chat: ChatMessage[];
+    ts: Date;
+}
+interface Profile {
+    schema_version: number;
+    fingerprint?: Record<string, unknown> | null;
+    origin?: string;
+    cookies?: Record<string, unknown>[];
+    localStorage?: Record<string, string>;
+    sessionStorage?: Record<string, string>;
+}
+interface RentOptions {
+    human?: 'natural' | 'careful' | null;
+    maskingMode?: boolean;
+    fingerprint?: boolean | Record<string, unknown>;
+    mode?: 'incognito' | 'main';
+}
+interface ScreenshotOptions {
+    format?: 'base64' | 'png';
+    fullPage?: boolean;
+}
+interface ScrollOptions {
+    x?: number;
+    y?: number;
+    deltaX?: number;
+    deltaY?: number;
+}
+interface ProfileExportOptions {
+    domains?: string[];
+    includeSessionStorage?: boolean;
+}
+interface ChatHistoryOptions {
+    limit?: number;
+    beforeId?: string;
+    since?: string;
+}
+interface SessionInfo {
+    id: number;
+    schedule_id: number;
+    started_at: string | null;
+    ended_at: string | null;
+    status: string;
+    duration: number;
+    earned: number;
+    price_per_min: number;
+    renter: Record<string, unknown>;
+    provider: Record<string, unknown>;
+    data: Record<string, unknown>;
+}
+interface CaptchaOptions {
+    acceptanceTimeout?: number;
+    completionTimeout?: number;
+    autoAccept?: boolean;
+}
+interface CaptchaResult {
+    solved: boolean;
+    proofMessageId: string | null;
+    cancelReason: string | null;
+    childEventId: number;
+    correctionId: number | null;
+    acceptWork: () => Promise<void>;
+    rejectWork: (reason?: string) => Promise<void>;
+}
+
+type MessageHandler = (msg: ChatMessage) => void | Promise<void>;
+type ReadHandler = (receipt: ReadReceipt) => void | Promise<void>;
+declare class BrowserChat {
+    private _browser;
+    private _topicId;
+    private _messageHandlers;
+    private _readHandlers;
+    private _pendingSends;
+    /** @internal */ _actionCallbacks: Map<number, (action: Record<string, unknown>) => void>;
+    constructor(browser: Browser);
+    get topicId(): string | null;
+    send(text: string): Promise<{
+        messageId: string;
+        sentAt: string;
+    }>;
+    sendImage(source: string | Buffer, text?: string): Promise<{
+        messageId: string;
+        sentAt: string;
+    }>;
+    onMessage(cb: MessageHandler): void;
+    onRead(cb: ReadHandler): void;
+    history(opts?: ChatHistoryOptions): Promise<ChatMessage[]>;
+    /** @internal */
+    _onMessage(payload: Record<string, unknown>): void;
+    /** @internal */
+    _onRead(payload: Record<string, unknown>): void;
+    /** @internal */
+    _onSendAck(msg: Record<string, unknown>): void;
+    /** @internal */
+    _onSendError(msg: Record<string, unknown>): void;
+}
+
+declare class BrowserProfile {
+    private _browser;
+    constructor(browser: Browser);
+    export(opts?: ProfileExportOptions): Promise<Profile>;
+    import(profile: Profile): Promise<void>;
+}
+
+interface HumanProfileRaw {
+    version?: number;
+    name?: string;
+    typing?: {
+        wpm?: number;
+        jitter?: number;
+        thinking_pause_prob?: number;
+        thinking_pause_ms?: [number, number];
+        typo_prob?: number;
+    };
+    pre_action_ms?: Record<string, [number, number]>;
+    post_action_ms?: Record<string, [number, number]>;
+    mouse?: {
+        move_before_click?: boolean;
+        trajectory?: string;
+    };
+    rng_seed?: number | null;
+}
+declare class HumanProfile {
+    readonly name: string;
+    readonly raw: HumanProfileRaw;
+    constructor(name: string, raw: HumanProfileRaw);
+    static fromDict(d: Record<string, unknown>): HumanProfile;
+    static load(filePath: string): HumanProfile;
+    static loadPreset(name: string): HumanProfile;
+    getRange(action: string, phase: 'pre' | 'post'): [number, number];
+    typingInterval(): number;
+    toDict(): HumanProfileRaw;
+    toJSON(indent?: number): string;
+}
+
+declare class Humanizer {
+    readonly profile: HumanProfile;
+    private _rng;
+    constructor(profile: HumanProfile);
+    before(action: string): Promise<void>;
+    after(action: string): Promise<void>;
+    typeDelay(): number;
+}
+
+interface PendingCdp {
+    resolve: (value: unknown) => void;
+    reject: (err: Error) => void;
+    timer: ReturnType<typeof setTimeout>;
+}
+type EventHandler = (method: string, params: Record<string, unknown>) => void;
+type TabHandler = (url: string) => void;
+type VoidHandler = () => void;
+type UserEventHandler = (events: Record<string, unknown>[]) => void;
+declare class Browser {
+    readonly sessionId: string;
+    readonly browserId: number;
+    readonly scheduleId: number;
+    readonly chatTopicId: string | null;
+    readonly browserInfo: Record<string, unknown>;
+    readonly providerUserId: number | null;
+    /** @internal */ _eventId: string | null;
+    readonly chat: BrowserChat;
+    readonly profile: BrowserProfile;
+    /** @internal */ _client: Client;
+    /** @internal */ _humanizer: Humanizer | null;
+    /** @internal */ _lastPointer: [number, number] | null;
+    /** @internal */ _lastSeenTs: string | null;
+    /** @internal */ _cdpCounter: number;
+    /** @internal */ _pendingCdp: Map<number, PendingCdp>;
+    /** @internal */ _ended: Promise<string>;
+    /** @internal */ _endedReason: string | null;
+    /** @internal */ _resolveEnded: (reason: string) => void;
+    private _eventHandlers;
+    private _tabHandlers;
+    private _disconnectHandlers;
+    private _reconnectHandlers;
+    private _userEventHandlers;
+    /** @internal */
+    get _apiKey(): string;
+    /** @internal */
+    get _chatUrl(): string;
+    /** @internal */
+    get _basicAuth(): [string, string] | undefined;
+    constructor(client: Client, match: Match, humanizer?: Humanizer | null);
+    /** @internal — send raw message via client WS */
+    _sendRaw(msg: Record<string, unknown>): void;
+    send(cdp: {
+        method: string;
+        params?: Record<string, unknown>;
+    }, timeout?: number): Promise<unknown>;
+    navigate(url: string, timeout?: number): Promise<{
+        url: string;
+        frameId?: string;
+    }>;
+    click(x: number, y: number): Promise<void>;
+    private _sendKeystroke;
+    type(text: string): Promise<void>;
+    scroll(opts?: ScrollOptions): Promise<void>;
+    screenshot(opts?: ScreenshotOptions): Promise<{
+        data: string;
+    } | Buffer>;
+    snapshot(): Promise<Snapshot>;
+    upload(selector: string, source: string | Buffer, filename?: string): Promise<{
+        ok: boolean;
+        filename: string;
+        size: number;
+    }>;
+    switchTab(): Promise<void>;
+    configure(opts: {
+        maskingMode?: boolean;
+        fingerprint?: boolean | Record<string, unknown>;
+    }): Promise<void>;
+    close(timeout?: number): Promise<void>;
+    release(timeout?: number): Promise<void>;
+    waitUntilEnded(): Promise<string>;
+    onEvent(cb: EventHandler): void;
+    onTabOpened(cb: TabHandler): void;
+    onProviderDisconnected(cb: VoidHandler): void;
+    onProviderReconnected(cb: VoidHandler): void;
+    onUserEvent(cb: UserEventHandler): void;
+    private _apiHeaders;
+    requestCaptcha(opts?: CaptchaOptions): Promise<CaptchaResult>;
+    private _createCaptchaEvent;
+    private _expireCaptchaEvent;
+    /** @internal */
+    _onCdpResponse(msg: Record<string, unknown>): void;
+    /** @internal */
+    _onCdpEvent(msg: Record<string, unknown>): void;
+    /** @internal */
+    _onTabOpened(msg: Record<string, unknown>): void;
+    /** @internal */
+    _onSessionEnded(msg: Record<string, unknown>): void;
+    /** @internal */
+    _onProviderDisconnected(): void;
+    /** @internal */
+    _onProviderReconnected(): void;
+    /** @internal */
+    _onError(msg: Record<string, unknown>): void;
+    /** @internal */
+    _onUserEvents(msg: Record<string, unknown>): void;
+    /** @internal */
+    _onChatMessage(payload: Record<string, unknown>): void;
+    /** @internal */
+    _onChatRead(payload: Record<string, unknown>): void;
+    /** @internal */
+    _onChatSendAck(msg: Record<string, unknown>): void;
+    /** @internal */
+    _onChatSendError(msg: Record<string, unknown>): void;
+    private _rejectAllPending;
+    private _cleanup;
+}
+
+declare class Client {
+    /** @internal */ _apiKey: string;
+    /** @internal */ _chatUrl: string;
+    /** @internal */ _basicAuth: [string, string] | undefined;
+    /** @internal */ _activeBrowsers: Map<string, Browser>;
+    private _ws;
+    /** @internal */ _apiUrl: string;
+    private _relayUrl;
+    private _reconnect;
+    private _reconnectAttempt;
+    private _reconnecting;
+    private _closed;
+    private _pingTimer;
+    private _pongTimer;
+    private _lastPongAt;
+    private _pendingRents;
+    private _pendingResumes;
+    private _connectResolve;
+    private _connectReject;
+    constructor(apiKey: string, opts?: Partial<ConnectOptions>);
+    /** Factory: create client and connect */
+    static create(apiKey: string, opts?: Partial<ConnectOptions>): Promise<Client>;
+    /** @internal */
+    _wsSend(msg: Record<string, unknown>): void;
+    search(filters?: Record<string, unknown>, limit?: number): Promise<BrowserOption[]>;
+    listSessions(opts?: {
+        active?: boolean;
+        limit?: number;
+    }): Promise<SessionInfo[]>;
+    myBrowsers(): Promise<BrowserOption[]>;
+    rent(scheduleId: number, opts?: RentOptions): Promise<Browser>;
+    resume(sessionId: string, opts?: RentOptions): Promise<Browser>;
+    close(): Promise<void>;
+    disconnect(): Promise<void>;
+    private _connect;
+    private _openWs;
+    private _closeWs;
+    private _scheduleReconnect;
+    private _startHeartbeat;
+    private _stopHeartbeat;
+    private _checkPongTimeout;
+    private _handleMessage;
+    private _onRentPending;
+    private _onMatch;
+    private _onRentError;
+    private _onResumeOk;
+    private _onResumeFailed;
+    private _onError;
+    private _rejectFirstPendingRent;
+    private _rejectAllPending;
+    private _resolveHumanizer;
+}
+/** Factory function: create a connected Client */
+declare function connect(apiKey: string, opts?: Partial<ConnectOptions>): Promise<Client>;
+
+declare class CekiBrowserError extends Error {
+    constructor(message: string);
+}
+declare class AuthError extends CekiBrowserError {
+    constructor(message?: string);
+}
+declare class SessionNotFound extends CekiBrowserError {
+    constructor(message?: string);
+}
+declare class SessionExpired extends SessionNotFound {
+    constructor(message?: string);
+}
+declare class NotOwner extends CekiBrowserError {
+    constructor(message?: string);
+}
+declare class TransportError extends CekiBrowserError {
+    constructor(message?: string);
+}
+declare class TimeoutError extends CekiBrowserError {
+    constructor(message?: string);
+}
+declare class SessionEnded extends CekiBrowserError {
+    reason: string;
+    constructor(reason: string);
+}
+declare class InsufficientFunds extends CekiBrowserError {
+    constructor(message?: string);
+}
+declare class RateLimitExceeded extends CekiBrowserError {
+    retryAfter: number;
+    constructor(retryAfter?: number, message?: string);
+}
+declare class ConnectionLost extends CekiBrowserError {
+    constructor(message?: string);
+}
+declare class ProviderOffline extends CekiBrowserError {
+    constructor(message?: string);
+}
+declare class ProviderDisconnected extends CekiBrowserError {
+    constructor(message?: string);
+}
+declare class CdpUnrecoverable extends CekiBrowserError {
+    lastError: string;
+    constructor(lastError: string);
+}
+declare class CaptchaError extends CekiBrowserError {
+    constructor(message?: string);
+}
+declare class CaptchaTimeoutError extends CaptchaError {
+    phase: 'acceptance' | 'completion';
+    constructor(phase: 'acceptance' | 'completion');
+}
+declare class ChatSendFailed extends CekiBrowserError {
+    status: number;
+    messageText: string;
+    constructor(status: number, messageText: string);
+}
+
+export { AuthError, Browser, BrowserChat, type BrowserOption, BrowserProfile, CaptchaError, type CaptchaOptions, type CaptchaResult, CaptchaTimeoutError, CdpUnrecoverable, CekiBrowserError, type ChatHistoryOptions, type ChatMessage, ChatSendFailed, Client, type ConnectOptions, ConnectionLost, HumanProfile, Humanizer, InsufficientFunds, type Match, NotOwner, type Profile, type ProfileExportOptions, ProviderDisconnected, ProviderOffline, RateLimitExceeded, type ReadReceipt, type RentOptions, type ScreenshotOptions, type ScrollOptions, SessionEnded, SessionExpired, type SessionInfo, SessionNotFound, type Snapshot, TimeoutError, TransportError, connect };