browser-commander 0.14.0

// @generated by scripts/generate-puppeteer-bindings.mjs from
// rust/protocol/puppeteer/api.json. Do not edit by hand.

#![allow(clippy::all, missing_docs, unused_imports, non_snake_case)]

use serde_json::Value;

use super::*;
use crate::puppeteer::bridge::{binary, remote_type, BridgeError, JsFunction, Remote};

remote_type!(
    /// Puppeteer's `BrowserContext` (puppeteer-core 25.10.0), a remote object
    /// served by `browser-commander serve --stdio`.
    ///
    /// Extends [`EventEmitter`]; the inherited methods are repeated here.
    BrowserContext
);

impl BrowserContext {
    /// `EventEmitter.on`
    ///
    /// ```text
    /// on<Key extends keyof EventsWithWildcard<Events>>(type: Key, handler: Handler<EventsWithWildcard<Events>[Key]>): this
    /// ```
    pub async fn on(&self, type_: Value, handler: impl Into<JsFunction>) -> Result<BrowserContext, BridgeError> {
        self.remote.call("on", vec![Some(type_), Some(handler.into().to_wire())]).await
    }

    /// `EventEmitter.off`
    ///
    /// ```text
    /// off<Key extends keyof EventsWithWildcard<Events>>(type: Key, handler?: Handler<EventsWithWildcard<Events>[Key]>): this
    /// ```
    pub async fn off(&self, type_: Value, handler: Option<JsFunction>) -> Result<BrowserContext, BridgeError> {
        self.remote.call("off", vec![Some(type_), handler.map(|x| x.to_wire())]).await
    }

    /// `EventEmitter.emit`
    ///
    /// ```text
    /// emit<Key extends keyof EventsWithWildcard<Events>>(type: Key, event: EventsWithWildcard<Events>[Key]): boolean
    /// ```
    pub async fn emit(&self, type_: Value, event: Value) -> Result<bool, BridgeError> {
        self.remote.call("emit", vec![Some(type_), Some(event)]).await
    }

    /// `EventEmitter.once`
    ///
    /// ```text
    /// once<Key extends keyof EventsWithWildcard<Events>>(type: Key, handler: Handler<EventsWithWildcard<Events>[Key]>): this
    /// ```
    pub async fn once(&self, type_: Value, handler: impl Into<JsFunction>) -> Result<BrowserContext, BridgeError> {
        self.remote.call("once", vec![Some(type_), Some(handler.into().to_wire())]).await
    }

    /// `EventEmitter.listenerCount`
    ///
    /// ```text
    /// listenerCount(type: keyof EventsWithWildcard<Events>): number
    /// ```
    pub async fn listener_count(&self, type_: Value) -> Result<f64, BridgeError> {
        self.remote.call("listenerCount", vec![Some(type_)]).await
    }

    /// `EventEmitter.removeAllListeners`
    ///
    /// ```text
    /// removeAllListeners(type?: keyof EventsWithWildcard<Events>): this
    /// ```
    pub async fn remove_all_listeners(&self, type_: Option<Value>) -> Result<BrowserContext, BridgeError> {
        self.remote.call("removeAllListeners", vec![type_]).await
    }

    /// `BrowserContext.targets`
    ///
    /// ```text
    /// targets(): Target[]
    /// ```
    pub async fn targets(&self) -> Result<Vec<Target>, BridgeError> {
        self.remote.call("targets", vec![]).await
    }

    /// `BrowserContext.waitForTarget`
    ///
    /// ```text
    /// waitForTarget(predicate: (x: Target) => boolean | Promise<boolean>, options?: WaitForTargetOptions): Promise<Target>
    /// ```
    pub async fn wait_for_target(&self, predicate: impl Into<JsFunction>, options: Option<Value>) -> Result<Target, BridgeError> {
        self.remote.call("waitForTarget", vec![Some(predicate.into().to_wire()), options]).await
    }

    /// `BrowserContext.pages`
    ///
    /// ```text
    /// pages(includeAll?: boolean): Promise<Page[]>
    /// ```
    pub async fn pages(&self, include_all: Option<bool>) -> Result<Vec<Page>, BridgeError> {
        self.remote.call("pages", vec![include_all.map(|x| Value::from(x))]).await
    }

    /// `BrowserContext.overridePermissions`
    ///
    /// ```text
    /// overridePermissions(origin: string, permissions: Permission[]): Promise<void>
    /// ```
    pub async fn override_permissions(&self, origin: &str, permissions: &[&str]) -> Result<(), BridgeError> {
        self.remote.call("overridePermissions", vec![Some(Value::from(origin)), Some(Value::Array(permissions.iter().map(|v| Value::from(*v)).collect()))]).await
    }

    /// `BrowserContext.setPermission`
    ///
    /// ```text
    /// setPermission(origin: string | '*', ...permissions: Array<{ permission: PermissionDescriptor_2; state: PermissionState_2; }> ): Promise<void>
    /// ```
    pub async fn set_permission(&self, origin: &str, permissions: &[Value]) -> Result<(), BridgeError> {
        let mut call_args: Vec<Option<Value>> = vec![Some(Value::from(origin))];
        call_args.extend(permissions.iter().map(|v| Some(v.clone())));
        self.remote.call("setPermission", call_args).await
    }

    /// `BrowserContext.clearPermissionOverrides`
    ///
    /// ```text
    /// clearPermissionOverrides(): Promise<void>
    /// ```
    pub async fn clear_permission_overrides(&self) -> Result<(), BridgeError> {
        self.remote.call("clearPermissionOverrides", vec![]).await
    }

    /// `BrowserContext.newPage`
    ///
    /// ```text
    /// newPage(options?: CreatePageOptions): Promise<Page>
    /// ```
    pub async fn new_page(&self, options: Option<Value>) -> Result<Page, BridgeError> {
        self.remote.call("newPage", vec![options]).await
    }

    /// `BrowserContext.browser`
    ///
    /// ```text
    /// browser(): Browser
    /// ```
    pub async fn browser(&self) -> Result<Browser, BridgeError> {
        self.remote.call("browser", vec![]).await
    }

    /// `BrowserContext.close`
    ///
    /// ```text
    /// close(): Promise<void>
    /// ```
    pub async fn close(&self) -> Result<(), BridgeError> {
        self.remote.call("close", vec![]).await
    }

    /// `BrowserContext.cookies`
    ///
    /// ```text
    /// cookies(): Promise<Cookie[]>
    /// ```
    pub async fn cookies(&self) -> Result<Vec<Value>, BridgeError> {
        self.remote.call("cookies", vec![]).await
    }

    /// `BrowserContext.setCookie`
    ///
    /// ```text
    /// setCookie(...cookies: CookieData[]): Promise<void>
    /// ```
    pub async fn set_cookie(&self, cookies: &[Value]) -> Result<(), BridgeError> {
        let mut call_args: Vec<Option<Value>> = vec![];
        call_args.extend(cookies.iter().map(|v| Some(v.clone())));
        self.remote.call("setCookie", call_args).await
    }

    /// `BrowserContext.deleteCookie`
    ///
    /// ```text
    /// deleteCookie(...cookies: Cookie[]): Promise<void>
    /// ```
    pub async fn delete_cookie(&self, cookies: &[Value]) -> Result<(), BridgeError> {
        let mut call_args: Vec<Option<Value>> = vec![];
        call_args.extend(cookies.iter().map(|v| Some(v.clone())));
        self.remote.call("deleteCookie", call_args).await
    }

    /// `BrowserContext.deleteMatchingCookies`
    ///
    /// ```text
    /// deleteMatchingCookies(...filters: DeleteCookiesRequest[]): Promise<void>
    /// ```
    pub async fn delete_matching_cookies(&self, filters: &[Value]) -> Result<(), BridgeError> {
        let mut call_args: Vec<Option<Value>> = vec![];
        call_args.extend(filters.iter().map(|v| Some(v.clone())));
        self.remote.call("deleteMatchingCookies", call_args).await
    }

    /// `BrowserContext.closed`
    ///
    /// ```text
    /// get closed(): boolean
    /// ```
    pub async fn closed(&self) -> Result<bool, BridgeError> {
        self.remote.get("closed").await
    }

    /// `BrowserContext.id`
    ///
    /// ```text
    /// get id(): string | undefined
    /// ```
    pub async fn id(&self) -> Result<Option<String>, BridgeError> {
        self.remote.get("id").await
    }
}