browser-commander 0.19.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 `HTTPRequest` (puppeteer-core 25.12.0), a remote object
    /// served by `browser-commander serve --stdio`.
    HTTPRequest
);

impl HTTPRequest {
    /// `HTTPRequest.client`
    ///
    /// ```text
    /// get client(): CDPSession
    /// ```
    pub async fn client(&self) -> Result<CDPSession, BridgeError> {
        self.remote.get("client").await
    }

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

    /// `HTTPRequest.continueRequestOverrides`
    ///
    /// ```text
    /// continueRequestOverrides(): ContinueRequestOverrides
    /// ```
    pub async fn continue_request_overrides(&self) -> Result<Value, BridgeError> {
        self.remote.call("continueRequestOverrides", vec![]).await
    }

    /// `HTTPRequest.responseForRequest`
    ///
    /// ```text
    /// responseForRequest(): Partial<ResponseForRequest> | null
    /// ```
    pub async fn response_for_request(&self) -> Result<Option<Value>, BridgeError> {
        self.remote.call("responseForRequest", vec![]).await
    }

    /// `HTTPRequest.abortErrorReason`
    ///
    /// ```text
    /// abortErrorReason(): Protocol.Network.ErrorReason | null
    /// ```
    pub async fn abort_error_reason(&self) -> Result<Option<Value>, BridgeError> {
        self.remote.call("abortErrorReason", vec![]).await
    }

    /// `HTTPRequest.interceptResolutionState`
    ///
    /// ```text
    /// interceptResolutionState(): InterceptResolutionState
    /// ```
    pub async fn intercept_resolution_state(&self) -> Result<Value, BridgeError> {
        self.remote.call("interceptResolutionState", vec![]).await
    }

    /// `HTTPRequest.isInterceptResolutionHandled`
    ///
    /// ```text
    /// isInterceptResolutionHandled(): boolean
    /// ```
    pub async fn is_intercept_resolution_handled(&self) -> Result<bool, BridgeError> {
        self.remote.call("isInterceptResolutionHandled", vec![]).await
    }

    /// `HTTPRequest.enqueueInterceptAction`
    ///
    /// ```text
    /// enqueueInterceptAction(pendingHandler: () => void | PromiseLike<unknown>): void
    /// ```
    pub async fn enqueue_intercept_action(&self, pending_handler: impl Into<JsFunction>) -> Result<(), BridgeError> {
        self.remote.call("enqueueInterceptAction", vec![Some(pending_handler.into().to_wire())]).await
    }

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

    /// `HTTPRequest.resourceType`
    ///
    /// ```text
    /// resourceType(): ResourceType
    /// ```
    pub async fn resource_type(&self) -> Result<Value, BridgeError> {
        self.remote.call("resourceType", vec![]).await
    }

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

    /// `HTTPRequest.postData`
    ///
    /// ```text
    /// postData(): string | undefined
    /// ```
    pub async fn post_data(&self) -> Result<Option<String>, BridgeError> {
        self.remote.call("postData", vec![]).await
    }

    /// `HTTPRequest.hasPostData`
    ///
    /// ```text
    /// hasPostData(): boolean
    /// ```
    pub async fn has_post_data(&self) -> Result<bool, BridgeError> {
        self.remote.call("hasPostData", vec![]).await
    }

    /// `HTTPRequest.fetchPostData`
    ///
    /// ```text
    /// fetchPostData(): Promise<string | undefined>
    /// ```
    pub async fn fetch_post_data(&self) -> Result<Option<String>, BridgeError> {
        self.remote.call("fetchPostData", vec![]).await
    }

    /// `HTTPRequest.headers`
    ///
    /// ```text
    /// headers(): Record<string, string>
    /// ```
    pub async fn headers(&self) -> Result<Value, BridgeError> {
        self.remote.call("headers", vec![]).await
    }

    /// `HTTPRequest.response`
    ///
    /// ```text
    /// response(): HTTPResponse | null
    /// ```
    pub async fn response(&self) -> Result<Option<HTTPResponse>, BridgeError> {
        self.remote.call("response", vec![]).await
    }

    /// `HTTPRequest.frame`
    ///
    /// ```text
    /// frame(): Frame | null
    /// ```
    pub async fn frame(&self) -> Result<Option<Frame>, BridgeError> {
        self.remote.call("frame", vec![]).await
    }

    /// `HTTPRequest.isNavigationRequest`
    ///
    /// ```text
    /// isNavigationRequest(): boolean
    /// ```
    pub async fn is_navigation_request(&self) -> Result<bool, BridgeError> {
        self.remote.call("isNavigationRequest", vec![]).await
    }

    /// `HTTPRequest.initiator`
    ///
    /// ```text
    /// initiator(): Protocol.Network.Initiator | undefined
    /// ```
    pub async fn initiator(&self) -> Result<Option<Value>, BridgeError> {
        self.remote.call("initiator", vec![]).await
    }

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

    /// `HTTPRequest.failure`
    ///
    /// ```text
    /// failure(): { errorText: string; } | null
    /// ```
    pub async fn failure(&self) -> Result<Option<Value>, BridgeError> {
        self.remote.call("failure", vec![]).await
    }

    /// `HTTPRequest.continue`
    ///
    /// ```text
    /// continue(overrides?: ContinueRequestOverrides, priority?: number): Promise<void>
    /// ```
    pub async fn r#continue(&self, overrides: Option<Value>, priority: Option<f64>) -> Result<(), BridgeError> {
        self.remote.call("continue", vec![overrides, priority.map(|x| Value::from(x))]).await
    }

    /// `HTTPRequest.respond`
    ///
    /// ```text
    /// respond(response: Partial<ResponseForRequest>, priority?: number): Promise<void>
    /// ```
    pub async fn respond(&self, response: Value, priority: Option<f64>) -> Result<(), BridgeError> {
        self.remote.call("respond", vec![Some(response), priority.map(|x| Value::from(x))]).await
    }

    /// `HTTPRequest.abort`
    ///
    /// ```text
    /// abort(errorCode?: ErrorCode, priority?: number): Promise<void>
    /// ```
    pub async fn abort(&self, error_code: Option<&str>, priority: Option<f64>) -> Result<(), BridgeError> {
        self.remote.call("abort", vec![error_code.map(|x| Value::from(x)), priority.map(|x| Value::from(x))]).await
    }
}