w3cproto

type Alert interface {

	// Dismiss dismisses a simple dialog if present.
	// A request to dismiss an alert user prompt, which may not necessarily have a dismiss button,
	// has the same effect as accepting it.
	Dismiss(ctx context.Context) error

	// Accept accepts the currently displayed alert dialog.
	Accept(ctx context.Context) error

	// Text gets the text of the currently displayed JavaScript alert(), confirm(), or prompt() dialog.
	Text(ctx context.Context) (string, error)

	// SetText sets the text field of a window.prompt user prompt to the given value.
	SetText(ctx context.Context, text string) error
}

type BrowserOptions interface {
	FirstMatch() []Capabilities
	AlwaysMatch() Capabilities
}

type Capabilities map[string]interface{}

type Context interface {

	// GetWindowHandle returns the current window handle.
	GetWindowHandle(context.Context) (WindowHandle, error)

	// GetWindowHandles returns the list of all window handles available to the session.
	GetWindowHandles(context.Context) ([]WindowHandle, error)

	// CloseWindow close the current window.
	CloseWindow(context.Context) ([]WindowHandle, error)

	// NewWindow create a new top-level browsing context.
	NewWindow(context.Context, WindowType) (Window, error)

	// SwitchToWindow switching window will select the current top-level browsing context used as the target
	// for all subsequent commands. In a tabbed browser, this will typically make the tab containing
	// the browsing context the selected tab.
	SwitchToWindow(context.Context, WindowHandle) error

	// SwitchToFrame change focus to another frame on the page.
	SwitchToFrame(context.Context, FrameHandle) error

	// SwitchToParentFrame change focus back to parent frame.
	SwitchToParentFrame(context.Context) error

	// SetRect alters the size and the position of the operating system window
	// corresponding to the current top-level browsing context.
	SetRect(context.Context, Rect) (Rect, error)

	// returns the size and position on the screen of the operating system
	// window corresponding to the current top-level browsing context.
	GetRect(context.Context) (Rect, error)

	// Maximize invokes the window manager-specific “maximize” operation,
	// if any, on the window containing the current top-level browsing context.
	// This typically increases the window to the maximum available size without going full-screen.
	Maximize(context.Context) (Rect, error)

	// Minimize invokes the window manager-specific “minimize” operation,
	// if any, on the window containing the current top-level browsing context.
	// This typically hides the window in the system tray.
	Minimize(context.Context) (Rect, error)

	// Fullscreen fullscreen mode.
	Fullscreen(context.Context) (Rect, error)
}

type Cookie map[string]interface{}

type Cookies interface {

	// All returns an all cookies visible to the current page.
	All(context.Context) ([]Cookie, error)

	// Get returns a cookie by name visible to the current page.
	Get(context.Context, string) (Cookie, error)

	// Add adds a cookie.
	Add(context.Context, Cookie) error

	// Delete deletes cookies by name visible to the current page.
	Delete(context.Context, string) error

	// DeleteAll deletes all cookies visible to the current page.
	DeleteAll(context.Context) error
}

type Document interface {

	// GetPageSource returns a string serialization of the DOM of the current browsing context active document.
	GetPageSource(ctx context.Context) (source string, err error)

	// ExecuteScript inject a snippet of JavaScript into the page for execution in the context of the currently
	// selected frame. The executed script is assumed to be synchronous and the result of evaluating the script
	// is returned to the client. The script argument defines the script to execute in the form of a function body.
	// The value returned by that function will be returned to the client. The function will be invoked with
	// the provided args array and the values may be accessed via the arguments object in the order specified.
	// Arguments may be any JSON-primitive, array, or JSON object. JSON objects that define a WebElement
	// reference will be converted to the corresponding DOM element. Likewise, any WebElements in the script result
	// will be returned to the client as WebElement JSON objects.
	ExecuteScript(ctx context.Context, script string, args []interface{}) ([]byte, error)

	// ExecuteAsyncScript  inject a snippet of JavaScript into the page for execution in the context of the
	// currently selected frame. The executed script is assumed to be asynchronous and must signal that
	// is done by invoking the provided callback, which is always provided as the final argument to the function.
	// The value to this callback will be returned to the client. Asynchronous script commands may not span page loads.
	// If an unload event is fired while waiting for a script result, an error should be returned to the client.
	// The script argument defines the script to execute in teh form of a function body. The function will be invoked
	// with the provided args array and the values may be accessed via the arguments object in the order specified.
	// The final argument will always be a callback function that must be invoked to signal that the script has finished.
	// Arguments may be any JSON-primitive, array, or JSON object. JSON objects that define a WebElement reference
	// will be converted to the corresponding DOM element. Likewise, any WebElements in the script result
	// will be returned to the client as WebElement JSON objects.
	ExecuteAsyncScript(ctx context.Context, script string, args []interface{}) ([]byte, error)
}

type Doer interface {
	Do(ctx context.Context, method string, path string, p Params) (resp *Response, err error)
}

type Elements interface {

	// FindOne finds an element on the page, starting from the document root.
	FindOne(ctx context.Context, by FindElementStrategy, value string) (WebElement, error)

	// Find finds multiple elements on the page, starting from the document root.
	Find(ctx context.Context, by FindElementStrategy, value string) ([]WebElement, error)

	// Active returns the currently active element on the page.
	Active(ctx context.Context) (WebElement, error)
}

type Error struct {
	Code          string                 `json:"error"`
	Message       string                 `json:"message"`
	RawStacktrace string                 `json:"stacktrace"`
	Data          map[string]interface{} `json:"data"`

	Stacktrace []string
}

type FindElementStrategy string

type Frame struct {
	Handle FrameHandle `json:"handle"`
}

type FrameHandle string

type Key string

type MockBrowserOptions struct {
	// contains filtered or unexported fields
}

type MockBrowserOptionsMockRecorder struct {
	// contains filtered or unexported fields
}

type MockDoer struct {
	// contains filtered or unexported fields
}

type MockDoerMockRecorder struct {
	// contains filtered or unexported fields
}

type MockSession struct {
	// contains filtered or unexported fields
}

type MockSessionMockRecorder struct {
	// contains filtered or unexported fields
}

type Navigation interface {

	// NavigateTo navigates to a new URL.
	NavigateTo(ctx context.Context, url string) (err error)

	// GetCurrentURL returns the URL of the current page.
	GetCurrentURL(ctx context.Context) (url string, err error)

	// Back navigate backwards in the browser history, if possible.
	Back(ctx context.Context) error

	// Forward navigate forwards in the browser history, if possible.
	Forward(ctx context.Context) error

	// Refresh refresh the current page.
	Refresh(ctx context.Context) error

	// GetTitle returns the current page title.
	GetTitle(ctx context.Context) (title string, err error)
}

type Params map[string]interface{}

type Platform string

type Point struct {
	X, Y int
}

type Proxy struct {

	// Type is the type of proxy to use. This is required to be populated.
	Type ProxyType `json:"proxyType"`

	// AutoconfigURL is the URL to be used for proxy auto configuration. This is
	// required if Type is set to PAC.
	AutoconfigURL string `json:"proxyAutoconfigUrl,omitempty"`

	// The following are used when Type is set to Manual.
	//
	// Note that in Firefox, connections to localhost are not proxied by default,
	// even if a proxy is set. This can be overridden via a preference setting.
	FTP           string   `json:"ftpProxy,omitempty"`
	HTTP          string   `json:"httpProxy,omitempty"`
	SSL           string   `json:"sslProxy,omitempty"`
	SOCKS         string   `json:"socksProxy,omitempty"`
	SOCKSUsername string   `json:"socksUsername,omitempty"`
	SOCKSPassword string   `json:"socksPassword,omitempty"`
	NoProxy       []string `json:"noProxy,omitempty"`

	// The W3C draft spec includes port fields as well. According to the
	// specification, ports can also be included in the above addresses. However,
	// in the Geckodriver implementation, the ports must be specified by these
	// additional fields.
	HTTPPort  int `json:"httpProxyPort,omitempty"`
	SSLPort   int `json:"sslProxyPort,omitempty"`
	SocksPort int `json:"socksProxyPort,omitempty"`
}

type ProxyType string

type Rect struct {
	Width  int `json:"width"`
	Height int `json:"height"`
	Y      int `json:"y"`
	X      int `json:"x"`
}

type Response struct {
	SessionID string          `json:"sessionId"`
	Status    int             `json:"status"`
	Value     json.RawMessage `json:"value"`
}

type ScreenCapture interface {

	// Take takes a screenshot of the current page.
	Take(ctx context.Context) (io.Reader, error)

	// TakeElement takes a screenshot of the element on the current page.
	TakeElement(ctx context.Context, elementID string) (io.Reader, error)
}

type Session interface {
	// ID returns the unique session id.
	ID() string

	// Capabilities returns the capabilities of the specified session.
	Capabilities() Capabilities

	// Status returns information about whether a remote end is in a state
	// in which it can create new sessions, but may additionally include arbitrary
	// meta information that is specific to the implementation.
	Status(context.Context) (Status, error)

	// Delete delete the session.
	Delete(context.Context) error
}

type Status struct {
	// protocol specification
	Ready   bool   `json:"ready"`
	Message string `json:"message"`

	// extension
	Build struct {
		Version  string `json:"version"`
		Revision string `json:"revision"`
		Time     string `json:"time"`
	} `json:"build"`
	OS struct {
		Arch    string `json:"arch"`
		Name    string `json:"name"`
		Version string `json:"version"`
	} `json:"os"`
}

type Timeout struct {
	Implicit uint `json:"implicit"`
	PageLoad uint `json:"pageLoad"`
	Script   uint `json:"script"`
}

type Timeouts interface {

	// Get returns the timeouts implicit, pageLoad, script.
	Get(context.Context) (Timeout, error)

	// SetImplicit sets the amount of time the driver should wait when
	// searching for elements. The timeout will be rounded to nearest millisecond.
	SetImplicit(context.Context, time.Duration) error

	// SetPageLoad sets the amount of time the driver should wait when
	// loading a page. The timeout will be rounded to nearest millisecond.
	SetPageLoad(context.Context, time.Duration) error

	// SetScript sets the amount of time that asynchronous scripts
	// are permitted to run before they are aborted. The timeout will be rounded
	// to nearest millisecond.
	SetScript(context.Context, time.Duration) error
}

type WebElement interface {

	// ID returns the identifier of the element.
	ID() string

	// Click clicks on the element.
	Click(ctx context.Context) error

	// SendKeys types into the element.
	SendKeys(ctx context.Context, keys ...Key) error

	// Clear clears the element.
	Clear(ctx context.Context) error

	// FindOne finds a child element.
	FindOne(ctx context.Context, by FindElementStrategy, value string) (WebElement, error)

	// Find finds multiple children elements.
	Find(ctx context.Context, by FindElementStrategy, value string) ([]WebElement, error)

	// TagName returns the element's name.
	TagName(ctx context.Context) (string, error)

	// Text returns the text of the element.
	Text(ctx context.Context) (string, error)

	// IsSelected returns true if element is selected.
	IsSelected(ctx context.Context) (bool, error)

	// IsEnabled returns true if the element is enabled.
	IsEnabled(ctx context.Context) (bool, error)

	// GetAttribute returns the named attribute of the element.
	GetAttribute(ctx context.Context, name string) (string, error)

	// Rect returns the element's size.
	Rect(ctx context.Context) (Rect, error)

	// GetProperty returns the value of the specified property of the element.
	GetProperty(ctx context.Context, name string) (string, error)

	// GetCSSValue returns the value of the specified CSS property of the element.
	GetCSSValue(ctx context.Context, name string) (string, error)
}

type Window struct {
	Handle WindowHandle `json:"handle"`
	Type   WindowType   `json:"type"`
}

type WindowHandle string

type WindowType string