🥮 mooncakes.io
    Sign in

    mizchi/webdriver/bidi does not have a README file

    AccessibilityLocator

    source
    pub struct AccessibilityLocator {
      role : String
      name : String?
      exact : Bool?
    }

    Accessibility locator value

    AccessibilityLocator::output

    source
    fn AccessibilityLocator::output(self : AccessibilityLocator, logger : &Logger) -> Unit

    AccessibilityLocator::to_string

    source
    fn AccessibilityLocator::to_string(self : AccessibilityLocator) -> String

    ActionOrigin

    source
    pub enum ActionOrigin {
      Viewport
      Pointer
      ElementHandle(handle~ : String)
      ElementSharedId(shared_id~ : String)
    }

    Action origin for pointer actions

    ActionOrigin::element_handle

    source
    fn ActionOrigin::element_handle(handle : String) -> ActionOrigin

    ActionOrigin::element_shared_id

    source
    fn ActionOrigin::element_shared_id(shared_id : String) -> ActionOrigin

    ActionOrigin::output

    source
    fn ActionOrigin::output(self : ActionOrigin, logger : &Logger) -> Unit

    ActionOrigin::pointer

    source
    fn ActionOrigin::pointer() -> ActionOrigin

    ActionOrigin::to_json

    source
    fn ActionOrigin::to_json(self : ActionOrigin) -> Json

    ActionOrigin::to_string

    source
    fn ActionOrigin::to_string(self : ActionOrigin) -> String

    ActionOrigin::viewport

    source
    fn ActionOrigin::viewport() -> ActionOrigin

    ActionSequence

    source
    pub struct ActionSequence {
      id : String
      source_type : InputSourceType
      actions : Array[InputAction]
      parameters : PointerParameters?
    }

    Action sequence for input.performActions

    ActionSequence::key

    source
    fn ActionSequence::key(id : String, actions : Array[InputAction]) -> ActionSequence

    ActionSequence::none

    source
    fn ActionSequence::none(id : String, actions : Array[InputAction]) -> ActionSequence

    ActionSequence::output

    source
    fn ActionSequence::output(self : ActionSequence, logger : &Logger) -> Unit

    ActionSequence::pointer

    source
    fn ActionSequence::pointer(id : String, pointer_type : PointerType, actions : Array[InputAction]) -> ActionSequence

    ActionSequence::to_json

    source
    fn ActionSequence::to_json(self : ActionSequence) -> Json

    ActionSequence::to_string

    source
    fn ActionSequence::to_string(self : ActionSequence) -> String

    Backend

    source
    pub struct Backend {
      navigate : (String, String, String) -> Result[NavigationResult, BackendError]
      evaluate : (String, String, Bool) -> Result[Json, BackendError]
      locate_nodes : (String, Json, Int?) -> Result[Array[NodeReference], BackendError]
      perform_actions : (String?, Array[Json]) -> Result[Unit, BackendError]
      release_actions : (String?) -> Result[Unit, BackendError]
      capture_screenshot : (String, String?) -> Result[String, BackendError]
      capabilities : () -> BackendCapabilities
    }

    Backend contract for protocol behavior

    Backend::new

    source
    fn Backend::new(navigate : (String, String, String) -> Result[NavigationResult, BackendError], evaluate : (String, String, Bool) -> Result[Json, BackendError], locate_nodes : (String, Json, Int?) -> Result[Array[NodeReference], BackendError], perform_actions : (String?, Array[Json]) -> Result[Unit, BackendError], release_actions : (String?) -> Result[Unit, BackendError], capture_screenshot : (String, String?) -> Result[String, BackendError], capabilities : () -> BackendCapabilities) -> Backend

    Create backend contract object

    BackendCapabilities

    source
    pub struct BackendCapabilities {
      navigation : Bool
      evaluate : Bool
      element_lookup : Bool
      input_actions : Bool
      screenshot : Bool
    } derive(Eq)

    Backend capability flags

    BackendCapabilities::equal

    source

    BackendCapabilities::not_equal

    source

    BackendCapabilities::output

    source
    fn BackendCapabilities::output(self : BackendCapabilities, logger : &Logger) -> Unit

    BackendCapabilities::to_string

    source
    fn BackendCapabilities::to_string(self : BackendCapabilities) -> String

    BackendError

    source
    pub enum BackendError {
      InvalidArgument(message~ : String)
      NotFound(message~ : String)
    } derive(Eq)

    Backend contract error

    BackendError::equal

    source

    BackendError::not_equal

    source
    fn BackendError::not_equal(x : BackendError, y : BackendError) -> Bool

    BackendError::output

    source
    fn BackendError::output(self : BackendError, logger : &Logger) -> Unit

    BackendError::to_string

    source
    fn BackendError::to_string(self : BackendError) -> String

    BidiClient

    source
    pub struct BidiClient {
      transport : Transport
      next_id : Int
      connected : Bool
      has_subscription_filter : Bool
      pending : Map[Int, BidiResponse]
      event_handlers : Array[(BidiEvent) -> Unit]
      global_subscriptions : Map[String, Bool]
      context_subscriptions : Map[String, Map[String, Bool]]
    }

    BiDi client state

    BidiClient::browser_close

    source
    async fn BidiClient::browser_close(self : BidiClient) -> Result[Unit, ClientError]

    browser.close

    BidiClient::browser_create_user_context

    source
    async fn BidiClient::browser_create_user_context(self : BidiClient) -> Result[String, ClientError]

    browser.createUserContext

    BidiClient::browser_get_user_contexts

    source
    async fn BidiClient::browser_get_user_contexts(self : BidiClient) -> Result[Array[String], ClientError]

    browser.getUserContexts

    BidiClient::browser_remove_user_context

    source
    async fn BidiClient::browser_remove_user_context(self : BidiClient, user_context : String) -> Result[Unit, ClientError]

    browser.removeUserContext

    BidiClient::browsing_context_capture_screenshot

    source
    async fn BidiClient::browsing_context_capture_screenshot(self : BidiClient, context_id : String, origin? : String, format? : String, quality? : Int, clip? : Json) -> Result[String, ClientError]

    browsingContext.captureScreenshot

    BidiClient::browsing_context_close

    source
    async fn BidiClient::browsing_context_close(self : BidiClient, context_id : String) -> Result[Unit, ClientError]

    browsingContext.close

    BidiClient::browsing_context_create

    source
    async fn BidiClient::browsing_context_create(self : BidiClient, context_type : String, user_context? : String) -> Result[String, ClientError]

    browsingContext.create

    BidiClient::browsing_context_get_tree

    source
    async fn BidiClient::browsing_context_get_tree(self : BidiClient, root? : String, max_depth? : Int) -> Result[Json, ClientError]

    browsingContext.getTree

    BidiClient::browsing_context_locate_nodes

    source
    async fn BidiClient::browsing_context_locate_nodes(self : BidiClient, context_id : String, locator : Json, max_node_count? : Int, serialization_options? : SerializationOptions) -> Result[Json, ClientError]

    browsingContext.locateNodes

    BidiClient::browsing_context_locate_nodes_typed

    source
    async fn BidiClient::browsing_context_locate_nodes_typed(self : BidiClient, context_id : String, locator : Locator, max_node_count? : Int, serialization_options? : SerializationOptions) -> Result[Json, ClientError]

    browsingContext.locateNodes (typed)

    BidiClient::browsing_context_locate_nodes_typed_refs

    source
    async fn BidiClient::browsing_context_locate_nodes_typed_refs(self : BidiClient, context_id : String, locator : Locator, max_node_count? : Int, serialization_options? : SerializationOptions) -> Result[Array[NodeReference], ClientError]

    browsingContext.locateNodes (typed refs)

    BidiClient::browsing_context_navigate

    source
    async fn BidiClient::browsing_context_navigate(self : BidiClient, context_id : String, url : String, wait? : String) -> Result[NavigationResult, ClientError]

    browsingContext.navigate

    BidiClient::browsing_context_reload

    source
    async fn BidiClient::browsing_context_reload(self : BidiClient, context_id : String) -> Result[Unit, ClientError]

    browsingContext.reload

    BidiClient::close

    source
    fn BidiClient::close(self : BidiClient) -> Result[Unit, ClientError]

    Close transport

    BidiClient::connect

    source
    async fn BidiClient::connect(self : BidiClient) -> Result[Unit, ClientError]

    Connect transport

    BidiClient::dispatch

    source
    async fn BidiClient::dispatch(self : BidiClient, domain : String, command : String, params? : Json?) -> Result[Json, ClientError]

    Dispatch request through the domain router

    BidiClient::input_perform_actions

    source
    async fn BidiClient::input_perform_actions(self : BidiClient, actions : Array[Json], context_id? : String) -> Result[Unit, ClientError]

    input.performActions

    BidiClient::input_perform_actions_typed

    source
    async fn BidiClient::input_perform_actions_typed(self : BidiClient, actions : Array[ActionSequence], context_id? : String) -> Result[Unit, ClientError]

    input.performActions (typed)

    BidiClient::input_release_actions

    source
    async fn BidiClient::input_release_actions(self : BidiClient, context_id? : String) -> Result[Unit, ClientError]

    input.releaseActions

    BidiClient::network_add_data_collector

    source
    async fn BidiClient::network_add_data_collector(self : BidiClient) -> Result[Unit, ClientError]

    network.addDataCollector

    BidiClient::network_add_data_collector_typed

    source
    async fn BidiClient::network_add_data_collector_typed(self : BidiClient, collector : NetworkDataCollector) -> Result[Unit, ClientError]

    network.addDataCollector (typed)

    BidiClient::network_set_cache_behavior

    source
    async fn BidiClient::network_set_cache_behavior(self : BidiClient, cache_behavior : String, contexts? : Array[String]) -> Result[Unit, ClientError]

    network.setCacheBehavior

    BidiClient::network_set_cache_behavior_typed

    source
    async fn BidiClient::network_set_cache_behavior_typed(self : BidiClient, cache_behavior : CacheBehavior, contexts? : Array[String]) -> Result[Unit, ClientError]

    network.setCacheBehavior (typed)

    BidiClient::new

    source
    fn BidiClient::new(transport : Transport) -> BidiClient

    Create a new client

    BidiClient::on_browser_event

    source
    fn BidiClient::on_browser_event(self : BidiClient, handler : (BidiEvent) -> Unit) -> Unit

    Register handler for browser.* events

    BidiClient::on_browsing_context_event

    source
    fn BidiClient::on_browsing_context_event(self : BidiClient, handler : (BidiEvent) -> Unit) -> Unit

    Register handler for browsingContext.* events

    BidiClient::on_event

    source
    fn BidiClient::on_event(self : BidiClient, handler : (BidiEvent) -> Unit) -> Unit

    Register event handler

    BidiClient::on_event_method

    source
    fn BidiClient::on_event_method(self : BidiClient, event_method : String, handler : (BidiEvent) -> Unit) -> Unit

    Register handler for a specific event method

    BidiClient::on_input_event

    source
    fn BidiClient::on_input_event(self : BidiClient, handler : (BidiEvent) -> Unit) -> Unit

    Register handler for input.* events

    BidiClient::on_log_entry_added

    source
    fn BidiClient::on_log_entry_added(self : BidiClient, level? : String, handler : (BidiEvent) -> Unit) -> Unit

    Register handler for log.entryAdded (optional level filter)

    BidiClient::on_log_event

    source
    fn BidiClient::on_log_event(self : BidiClient, handler : (BidiEvent) -> Unit) -> Unit

    Register handler for log.* events

    BidiClient::on_network_event

    source
    fn BidiClient::on_network_event(self : BidiClient, handler : (BidiEvent) -> Unit) -> Unit

    Register handler for network.* events

    BidiClient::on_script_event

    source
    fn BidiClient::on_script_event(self : BidiClient, handler : (BidiEvent) -> Unit) -> Unit

    Register handler for script.* events

    BidiClient::on_session_event

    source
    fn BidiClient::on_session_event(self : BidiClient, handler : (BidiEvent) -> Unit) -> Unit

    Register handler for session.* events

    BidiClient::script_add_preload_script

    source
    async fn BidiClient::script_add_preload_script(self : BidiClient, function_declaration : String, arguments? : Array[RemoteValue], contexts? : Array[String], user_contexts? : Array[String], sandbox? : String) -> Result[String, ClientError]

    script.addPreloadScript

    BidiClient::script_call_function

    source
    async fn BidiClient::script_call_function(self : BidiClient, function_declaration : String, context_id : String, arguments? : Array[Json], await_promise? : Bool, result_ownership? : ResultOwnership, serialization_options? : SerializationOptions, user_activation? : Bool, this_value? : Json) -> Result[Json, ClientError]

    script.callFunction

    BidiClient::script_call_function_typed

    source
    async fn BidiClient::script_call_function_typed(self : BidiClient, function_declaration : String, context_id : String, arguments? : Array[RemoteValue], await_promise? : Bool, result_ownership? : ResultOwnership, serialization_options? : SerializationOptions, user_activation? : Bool, this_value? : RemoteValue) -> Result[Json, ClientError]

    script.callFunction (typed arguments)

    BidiClient::script_disown

    source
    async fn BidiClient::script_disown(self : BidiClient, handles : Array[String], context_id? : String, sandbox? : String) -> Result[Unit, ClientError]

    script.disown

    BidiClient::script_evaluate

    source
    async fn BidiClient::script_evaluate(self : BidiClient, expression : String, context_id : String, await_promise? : Bool, result_ownership? : ResultOwnership, serialization_options? : SerializationOptions, user_activation? : Bool) -> Result[Json, ClientError]

    script.evaluate

    BidiClient::script_remove_preload_script

    source
    async fn BidiClient::script_remove_preload_script(self : BidiClient, script_id : String) -> Result[Unit, ClientError]

    script.removePreloadScript

    BidiClient::send

    source
    async fn BidiClient::send(self : BidiClient, method_name : String, params? : Json?) -> Result[Json, ClientError]

    Send raw request and await response

    BidiClient::session_end

    source
    async fn BidiClient::session_end(self : BidiClient) -> Result[Unit, ClientError]

    Session: end

    BidiClient::session_new

    source
    async fn BidiClient::session_new(self : BidiClient, capabilities? : Json?) -> Result[SessionInfo, ClientError]

    Session: new

    BidiClient::session_status

    source
    async fn BidiClient::session_status(self : BidiClient) -> Result[SessionStatus, ClientError]

    Session: status

    BidiClient::session_subscribe

    source
    async fn BidiClient::session_subscribe(self : BidiClient, events : Array[String], contexts? : Array[String]) -> Result[Unit, ClientError]

    Session: subscribe

    BidiClient::session_unsubscribe

    source
    async fn BidiClient::session_unsubscribe(self : BidiClient, events : Array[String], contexts? : Array[String]) -> Result[Unit, ClientError]

    Session: unsubscribe

    BidiError

    source
    pub struct BidiError {
      error : String
      message : String
      stacktrace : String
    }

    BiDi error payload
    impl Show for BidiError

    BidiError::output

    source
    fn BidiError::output(self : BidiError, logger : &Logger) -> Unit

    BidiError::to_string

    source
    fn BidiError::to_string(self : BidiError) -> String

    BidiEvent

    source
    pub struct BidiEvent {
      event_method : String
      params : Json
    }

    BiDi event message
    impl Show for BidiEvent

    BidiEvent::output

    source
    fn BidiEvent::output(self : BidiEvent, logger : &Logger) -> Unit

    BidiEvent::to_string

    source
    fn BidiEvent::to_string(self : BidiEvent) -> String

    BidiIncoming

    source
    pub enum BidiIncoming {
      Response(BidiResponse)
      Event(BidiEvent)
    }

    Incoming BiDi message

    BidiIncoming::output

    source
    fn BidiIncoming::output(self : BidiIncoming, logger : &Logger) -> Unit

    BidiIncoming::to_string

    source
    fn BidiIncoming::to_string(self : BidiIncoming) -> String

    BidiRequest

    source
    pub struct BidiRequest {
      id : Int
      method_name : String
      params : Json?
    }

    BiDi request message
    impl Show for BidiRequest

    BidiRequest::output

    source
    fn BidiRequest::output(self : BidiRequest, logger : &Logger) -> Unit

    BidiRequest::to_json

    source
    fn BidiRequest::to_json(self : BidiRequest) -> String

    Serialize request to JSON string

    BidiRequest::to_string

    source
    fn BidiRequest::to_string(self : BidiRequest) -> String

    BidiResponse

    source
    pub struct BidiResponse {
      id : Int
      result : Json?
      error : BidiError?
    }

    BiDi response message

    BidiResponse::output

    source
    fn BidiResponse::output(self : BidiResponse, logger : &Logger) -> Unit

    BidiResponse::to_string

    source
    fn BidiResponse::to_string(self : BidiResponse) -> String

    CacheBehavior

    source
    pub struct CacheBehavior {
      value : String
    }

    Network cache behavior wrapper

    CacheBehavior::bypass

    source

    CacheBehavior::default

    source
    fn CacheBehavior::default() -> CacheBehavior

    CacheBehavior::new

    source
    fn CacheBehavior::new(value : String) -> CacheBehavior

    CacheBehavior::output

    source
    fn CacheBehavior::output(self : CacheBehavior, logger : &Logger) -> Unit

    CacheBehavior::to_string

    source
    fn CacheBehavior::to_string(self : CacheBehavior) -> String

    ChromePipeState

    source
    pub struct ChromePipeState {
      headless : Bool
      proc_id : 
    Ref    [Int?]
      closed : 
    Ref    [Bool]
    }

    Chrome BiDi pipe transport state

    ClientError

    source
    pub enum ClientError {
      Transport(TransportError)
      ParseError(message~ : String)
      InvalidArgument(message~ : String)
      ResponseError(error~ : BidiError)
    }

    Client error
    impl Show for ClientError

    ClientError::output

    source
    fn ClientError::output(self : ClientError, logger : &Logger) -> Unit

    ClientError::to_string

    source
    fn ClientError::to_string(self : ClientError) -> String

    CustomTransport

    source
    pub struct CustomTransport {
      connect : () -> Result[Unit, TransportError]
      send : (String) -> Result[Unit, TransportError]
      recv : () -> Result[String, TransportError]
      close : () -> Result[Unit, TransportError]
    }

    Custom transport hooks (sync)

    CustomTransport::new

    source
    fn CustomTransport::new(connect : () -> Result[Unit, TransportError], send : (String) -> Result[Unit, TransportError], recv : () -> Result[String, TransportError], close : () -> Result[Unit, TransportError]) -> CustomTransport

    Create custom transport

    InMemoryBackend

    source
    pub struct InMemoryBackend {
      state : 
    Ref    [InMemoryBackendState]
    }

    Minimal in-memory backend

    InMemoryBackend::action_log_length

    source
    fn InMemoryBackend::action_log_length(self : InMemoryBackend) -> Int

    Snapshot helper for in-memory action history size

    InMemoryBackend::get_context_url

    source
    fn InMemoryBackend::get_context_url(self : InMemoryBackend, context_id : String) -> String?

    Snapshot helper for in-memory contexts

    InMemoryBackend::new

    source
    fn InMemoryBackend::new(initial_contexts? : Array[String]) -> InMemoryBackend

    Create in-memory backend

    InMemoryBackend::to_backend

    source
    fn InMemoryBackend::to_backend(self : InMemoryBackend) -> Backend

    Export in-memory backend as contract

    InMemoryBackendState

    source
    pub struct InMemoryBackendState {
      next_navigation_id : Int
      contexts : Map[String, String]
      action_log : Array[String]
    }

    In-memory backend state

    InnerTextLocator

    source
    pub struct InnerTextLocator {
      text : String
      match_type : InnerTextMatchType
      ignore_case : Bool
    }

    InnerText locator value

    InnerTextLocator::output

    source
    fn InnerTextLocator::output(self : InnerTextLocator, logger : &Logger) -> Unit

    InnerTextLocator::to_string

    source
    fn InnerTextLocator::to_string(self : InnerTextLocator) -> String

    InnerTextMatchType

    source
    pub enum InnerTextMatchType {
      Full
      Partial
    } derive(Eq)

    Match type for innerText locator

    InnerTextMatchType::equal

    source

    InnerTextMatchType::full

    source

    InnerTextMatchType::not_equal

    source

    InnerTextMatchType::output

    source
    fn InnerTextMatchType::output(self : InnerTextMatchType, logger : &Logger) -> Unit

    InnerTextMatchType::partial

    source

    InnerTextMatchType::to_string

    source
    fn InnerTextMatchType::to_string(self : InnerTextMatchType) -> String

    InputAction

    source
    pub enum InputAction {
      Pause(duration~ : Int?)
      PointerMove(x~ : Double, y~ : Double, origin~ : ActionOrigin, duration~ : Int?)
      PointerDown(button~ : Int)
      PointerUp(button~ : Int)
      PointerCancel
      KeyDown(value~ : String)
      KeyUp(value~ : String)
    }

    Input action item
    impl Show for InputAction

    InputAction::key_down

    source
    fn InputAction::key_down(value : String) -> InputAction

    InputAction::key_up

    source
    fn InputAction::key_up(value : String) -> InputAction

    InputAction::output

    source
    fn InputAction::output(self : InputAction, logger : &Logger) -> Unit

    InputAction::pause

    source
    fn InputAction::pause(duration? : Int) -> InputAction

    InputAction::pointer_cancel

    source
    fn InputAction::pointer_cancel() -> InputAction

    InputAction::pointer_down

    source
    fn InputAction::pointer_down(button : Int) -> InputAction

    InputAction::pointer_move

    source
    fn InputAction::pointer_move(x : Double, y : Double, origin? : ActionOrigin, duration? : Int?) -> InputAction

    InputAction::pointer_up

    source
    fn InputAction::pointer_up(button : Int) -> InputAction

    InputAction::to_json

    source
    fn InputAction::to_json(self : InputAction) -> Json

    InputAction::to_string

    source
    fn InputAction::to_string(self : InputAction) -> String

    InputSourceType

    source
    pub enum InputSourceType {
      Pointer
      Key
      NoneSource
    } derive(Eq)

    Input source type

    InputSourceType::equal

    source

    InputSourceType::not_equal

    source
    fn InputSourceType::not_equal(x : InputSourceType, y : InputSourceType) -> Bool

    InputSourceType::output

    source
    fn InputSourceType::output(self : InputSourceType, logger : &Logger) -> Unit

    InputSourceType::to_string

    source
    fn InputSourceType::to_string(self : InputSourceType) -> String

    JsWebSocketState

    source
    pub struct JsWebSocketState {
      url : String
      conn : 
    Ref    [
    Conn    ?]
      closed : 
    Ref    [Bool]
    }

    JS WebSocket state (native)

    Locator

    source
    pub enum Locator {
      Css(String)
      Xpath(String)
      InnerText(InnerTextLocator)
      Accessibility(AccessibilityLocator)
      Custom(type_name~ : String, value~ : Json)
    }

    Locator for browsingContext.locateNodes
    impl Show for Locator

    Locator::accessibility

    source
    fn Locator::accessibility(role : String, name? : String, exact? : Bool) -> Locator

    Locator::css

    source
    fn Locator::css(selector : String) -> Locator

    Locator::custom

    source
    fn Locator::custom(type_name : String, value : Json) -> Locator

    Locator::inner_text

    source
    fn Locator::inner_text(text : String, match_type? : InnerTextMatchType, ignore_case? : Bool) -> Locator

    Locator::output

    source
    fn Locator::output(self : Locator, logger : &Logger) -> Unit

    Locator::to_json

    source
    fn Locator::to_json(self : Locator) -> Json

    Locator::to_string

    source
    fn Locator::to_string(self : Locator) -> String

    Locator::xpath

    source
    fn Locator::xpath(expr : String) -> Locator

    pub struct NavigationResult {
      navigation : String
      url : String
    }

    browsingContext.navigate result
    fn NavigationResult::output(self : NavigationResult, logger : &Logger) -> Unit

    fn NavigationResult::to_string(self : NavigationResult) -> String

    NetworkDataCollector

    source
    pub struct NetworkDataCollector {
      data_types : Array[String]
      contexts : Array[String]?
    }

    network.addDataCollector params

    NetworkDataCollector::new

    source
    fn NetworkDataCollector::new(data_types : Array[String], contexts? : Array[String]) -> NetworkDataCollector

    NetworkDataCollector::output

    source
    fn NetworkDataCollector::output(self : NetworkDataCollector, logger : &Logger) -> Unit

    NetworkDataCollector::to_json

    source

    NetworkDataCollector::to_string

    source
    fn NetworkDataCollector::to_string(self : NetworkDataCollector) -> String

    NodeReference

    source
    pub struct NodeReference {
      handle : String?
      shared_id : String?
    }

    browsingContext.locateNodes node reference

    NodeReference::output

    source
    fn NodeReference::output(self : NodeReference, logger : &Logger) -> Unit

    NodeReference::to_string

    source
    fn NodeReference::to_string(self : NodeReference) -> String

    PointerParameters

    source
    pub struct PointerParameters {
      pointer_type : PointerType
    }

    Pointer parameters

    PointerParameters::output

    source
    fn PointerParameters::output(self : PointerParameters, logger : &Logger) -> Unit

    PointerParameters::to_json

    source

    PointerParameters::to_string

    source
    fn PointerParameters::to_string(self : PointerParameters) -> String

    PointerType

    source
    pub enum PointerType {
      Mouse
      Pen
      Touch
    } derive(Eq)

    Pointer device type
    impl Show for PointerType

    PointerType::equal

    source
    fn PointerType::equal(PointerType, PointerType) -> Bool

    PointerType::mouse

    source
    fn PointerType::mouse() -> PointerType

    PointerType::not_equal

    source
    fn PointerType::not_equal(x : PointerType, y : PointerType) -> Bool

    PointerType::output

    source
    fn PointerType::output(self : PointerType, logger : &Logger) -> Unit

    PointerType::pen

    source

    PointerType::to_string

    source
    fn PointerType::to_string(self : PointerType) -> String

    PointerType::touch

    source
    fn PointerType::touch() -> PointerType

    RemoteValue

    source
    pub struct RemoteValue {
      json : Json
    }

    Remote value for script arguments
    impl Show for RemoteValue

    RemoteValue::boolean

    source
    fn RemoteValue::boolean(value : Bool) -> RemoteValue

    RemoteValue::handle

    source
    fn RemoteValue::handle(handle : String) -> RemoteValue

    RemoteValue::null

    source
    fn RemoteValue::null() -> RemoteValue

    RemoteValue::number

    source
    fn RemoteValue::number(value : Double) -> RemoteValue

    RemoteValue::output

    source
    fn RemoteValue::output(self : RemoteValue, logger : &Logger) -> Unit

    RemoteValue::shared_id

    source
    fn RemoteValue::shared_id(shared_id : String) -> RemoteValue

    RemoteValue::string

    source
    fn RemoteValue::string(value : String) -> RemoteValue

    RemoteValue::to_json

    source
    fn RemoteValue::to_json(self : RemoteValue) -> Json

    RemoteValue::to_string

    source
    fn RemoteValue::to_string(self : RemoteValue) -> String

    RemoteValue::undefined

    source
    fn RemoteValue::undefined() -> RemoteValue

    ResultOwnership

    source
    pub enum ResultOwnership {
      NoneOwnership
      Root
    } derive(Eq)

    Result ownership for script.evaluate / callFunction

    ResultOwnership::equal

    source

    ResultOwnership::none

    source

    ResultOwnership::not_equal

    source
    fn ResultOwnership::not_equal(x : ResultOwnership, y : ResultOwnership) -> Bool

    ResultOwnership::output

    source
    fn ResultOwnership::output(self : ResultOwnership, logger : &Logger) -> Unit

    ResultOwnership::root

    source

    ResultOwnership::to_string

    source
    fn ResultOwnership::to_string(self : ResultOwnership) -> String

    SerializationOptions

    source
    pub struct SerializationOptions {
      max_depth : Int?
      max_object_depth : Int?
      include_shadow_tree : String?
    }

    Serialization options for script results

    SerializationOptions::new

    source
    fn SerializationOptions::new(max_depth? : Int, max_object_depth? : Int, include_shadow_tree? : String) -> SerializationOptions

    SerializationOptions::output

    source
    fn SerializationOptions::output(self : SerializationOptions, logger : &Logger) -> Unit

    SerializationOptions::to_json

    source

    SerializationOptions::to_string

    source
    fn SerializationOptions::to_string(self : SerializationOptions) -> String

    SessionInfo

    source
    pub struct SessionInfo {
      session_id : String
      capabilities : Json?
    }

    session.new result
    impl Show for SessionInfo

    SessionInfo::output

    source
    fn SessionInfo::output(self : SessionInfo, logger : &Logger) -> Unit

    SessionInfo::to_string

    source
    fn SessionInfo::to_string(self : SessionInfo) -> String

    SessionStatus

    source
    pub struct SessionStatus {
      ready : Bool
      message : String?
    }

    session.status result

    SessionStatus::output

    source
    fn SessionStatus::output(self : SessionStatus, logger : &Logger) -> Unit

    SessionStatus::to_string

    source
    fn SessionStatus::to_string(self : SessionStatus) -> String

    Transport

    source
    pub enum Transport {
      JsWebSocket(JsWebSocketState)
      ChromePipe(ChromePipeState)
      Custom(CustomTransport)
      Unsupported(TransportError)
    }

    Transport::close

    source
    fn Transport::close(self : Transport) -> Result[Unit, TransportError]

    Close transport

    Transport::connect

    source
    async fn Transport::connect(self : Transport) -> Result[Unit, TransportError]

    Connect transport

    Transport::custom

    source
    fn Transport::custom(custom : CustomTransport) -> Transport

    Create custom transport wrapper

    Transport::recv

    source
    async fn Transport::recv(self : Transport) -> Result[String, TransportError]

    Receive message

    Transport::send

    source
    async fn Transport::send(self : Transport, message : String) -> Result[Unit, TransportError]

    Send message

    Transport::unsupported

    source
    fn Transport::unsupported(message : String) -> Transport

    Create unsupported transport

    Transport::websocket

    source
    fn Transport::websocket(url : String) -> Transport

    Create WebSocket transport

    TransportError

    source
    pub enum TransportError {
      NotSupported(message~ : String)
      NetworkError(message~ : String)
      Closed
    }

    Transport error

    TransportError::output

    source
    fn TransportError::output(self : TransportError, logger : &Logger) -> Unit

    TransportError::to_string

    source
    fn TransportError::to_string(self : TransportError) -> String

    error_response_to_json

    source
    fn error_response_to_json(id : Int, code : String, message : String) -> String

    Serialize a WebDriver BiDi error response envelope.

    error_response_to_json_with_stacktrace

    source
    fn error_response_to_json_with_stacktrace(id : Int, code : String, message : String, stacktrace : String) -> String

    Serialize a WebDriver BiDi error response envelope with stacktrace.

    event_to_json

    source
    fn event_to_json(event_method : String, params : Json) -> String

    Serialize a WebDriver BiDi event envelope.

    parse_incoming

    source
    fn parse_incoming(json_str : String) -> Result[BidiIncoming, String]

    Parse incoming message (response/event)

    parse_request

    source
    fn parse_request(json_str : String) -> Result[BidiRequest, String]

    Parse incoming command request JSON for BiDi server implementations.

    success_response_to_json

    source
    fn success_response_to_json(id : Int, result : Json?) -> String

    Serialize a WebDriver BiDi success response envelope.

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io