goselenium

type AcceptAlertResponse struct {
	State string
}

type AddCookieResponse struct {
	State string
}

type AlertTextResponse struct {
	State string
	Text  string
}

type AllCookiesResponse struct {
	State   string   `json:"state"`
	Cookies []Cookie `json:"value"`
}

type BackResponse struct {
	State string
}

type Browser interface {
	BrowserName() string
}

type By interface {
	// Type is the type of by (i.e. id, xpath, class, name, index).
	Type() string

	// Value is the actual value to retrieve something by (i.e. #test, 1).
	Value() interface{}
}

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

type CloseWindowResponse struct {
	State   string   `json:state"`
	Handles []string `json:"value"`
}

type CommunicationError struct {
	Response *ErrorResponse
	// contains filtered or unexported fields
}

type Cookie struct {
	Name       string `json:"name"`
	Value      string `json:"value"`
	Path       string `json:"path"`
	Domain     string `json:"domain"`
	SecureOnly bool   `json:"secure"`
	HTTPOnly   bool   `json:"httpOnly"`
}

type CookieResponse struct {
	State  string `json:"state"`
	Cookie Cookie `json:"value"`
}

type CreateSessionCapabilities struct {
	AcceptInsecureCerts bool   `json:"acceptSslCerts"`
	BrowserName         string `json:"browserName"`
	BrowserVersion      string `json:"browserVersion"`
	PlatformName        string `json:"platformVersion"`
}

type CreateSessionResponse struct {
	Capabilities CreateSessionCapabilities `json:"value"`
	SessionID    string                    `json:"sessionId"`
}

type CurrentURLResponse struct {
	State string
	URL   string
}

type DeleteCookieResponse struct {
	State string
}

type DeleteSessionResponse struct {
	State     string `json:"state"`
	SessionID string `json:"sessionId"`
}

type Dimensions struct {
	Width  uint `json:"width"`
	Height uint `json:"height"`
}

type DismissAlertResponse struct {
	State string
}

type Element interface {
	// ID is the assigned ID for the element returned from the Selenium driver.
	ID() string

	// Selected gets whether or not the current element is selected. This only
	// makes sense for inputs such as radio buttons and checkboxes.
	Selected() (*ElementSelectedResponse, error)

	// Attribute retrieves an attribute (i.e. href, class) of the current
	// active element.
	Attribute(att string) (*ElementAttributeResponse, error)

	// CSSValue retrieves a CSS property associated with the current element.
	// As an example, this could be the 'background' or 'font-family' properties.
	CSSValue(prop string) (*ElementCSSValueResponse, error)

	// Text gets the value of element.innerText for the current element.
	Text() (*ElementTextResponse, error)

	// TagName gets the HTML element name (i.e. p, div) of the currently selected
	// element.
	TagName() (*ElementTagNameResponse, error)

	// Rectangle gets the dimensions and co-ordinates of the currently selected
	// element.
	Rectangle() (*ElementRectangleResponse, error)

	// Enabled gets whether or not the current selected elemented is enabled.
	Enabled() (*ElementEnabledResponse, error)

	// Click clicks the currently selected element. Please note, you may have to
	// implement your own wait to ensure the page actually navigates. This is due to
	// Selenium having no idea whether or not your click will be interrupted by JS.
	// Alternatively, you can use the WaitUntil(TitleEquals("title"), 20) to
	// automatically wait until the page title has changed.
	Click() (*ElementClickResponse, error)

	// Clear clears the currently selected element according to the specification.
	Clear() (*ElementClearResponse, error)

	// SendKeys sends a set of keystrokes to the currently selected element.
	SendKeys(keys string) (*ElementSendKeysResponse, error)
}

type ElementAttributeResponse struct {
	State string
	Value string
}

type ElementCSSValueResponse struct {
	State string
	Value string
}

type ElementClearResponse struct {
	State string
}

type ElementClickResponse struct {
	State string
}

type ElementEnabledResponse struct {
	State   string `json:"state"`
	Enabled bool   `json:"value"`
}

type ElementRectangleResponse struct {
	State     string
	Rectangle Rectangle `json:"value"`
}

type ElementSelectedResponse struct {
	State    string `json:"state"`
	Selected bool   `json:"value"`
}

type ElementSendKeysResponse struct {
	State string
}

type ElementTagNameResponse struct {
	State string
	Tag   string
}

type ElementTextResponse struct {
	State string
	Text  string
}

type ErrorResponse struct {
	Message string
	State   string
}

type ExecuteScriptResponse struct {
	State    string
	Response string
}

type ForwardResponse struct {
	State string
}

type GoResponse struct {
	State string
}

type InvalidURLError string

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

type MaximizeWindowResponse struct {
	State string
}

type PageSourceResponse struct {
	State  string
	Source string
}

type Rectangle struct {
	Dimensions

	X int `json:"x"`
	Y int `json:"y"`
}

type RefreshResponse struct {
	State string
}

type ScreenshotResponse struct {
	State        string
	EncodedImage string
}

type SendAlertTextResponse struct {
	State string
}

type SessionIDError string

type SessionStatusResponse struct {
	State string
}

type SetSessionTimeoutResponse struct {
	State string
}

type SetWindowSizeResponse struct {
	State string
}

type SwitchToFrameResponse struct {
	State string
}

type SwitchToParentFrameResponse struct {
	State string
}

type SwitchToWindowResponse struct {
}

type Timeout interface {
	// Type is the type of the timeout that is being used.
	Type() string

	// Timeout is the timeout in milliseconds.
	Timeout() int
}

type TitleResponse struct {
	State string
	Title string
}

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

type Until func(w WebDriver) bool

type WebDriver interface {

	// DriverURL returns the URL where the W3C compliant web driver is hosted.
	DriverURL() string

	// CreateSession creates a session in the remote driver with the
	// desired capabilities.
	CreateSession() (*CreateSessionResponse, error)

	// DeleteSession deletes the current session associated with the web driver.
	DeleteSession() (*DeleteSessionResponse, error)

	// SessionStatus gets the status about whether a remove end is in a state
	// which it can create new sessions.
	SessionStatus() (*SessionStatusResponse, error)

	// SetSessionTimeout sets a timeout for one of the 3 options.
	// Call SessionScriptTimeout() to generate a script timeout.
	// Call SessionPageLoadTimeout() to generate a page load timeout.
	// Call SessionImplicitWaitTimeout() to generate an implicit wait timeout.
	SetSessionTimeout(to Timeout) (*SetSessionTimeoutResponse, error)

	// Go forces the browser to perform a GET request on a URL.
	Go(url string) (*GoResponse, error)

	// CurrentURL returns the current URL of the top level browsing context.
	CurrentURL() (*CurrentURLResponse, error)

	// Back instructs the web driver to go one step back in the page history.
	Back() (*BackResponse, error)

	// Forward instructs the web driver to go one step forward in the page history.
	Forward() (*ForwardResponse, error)

	// Refresh instructs the web driver to refresh the page that it is currently on.
	Refresh() (*RefreshResponse, error)

	// Title gets the title of the current page of the web driver.
	Title() (*TitleResponse, error)

	// WindowHandle retrieves the current active browsing string for the current session.
	WindowHandle() (*WindowHandleResponse, error)

	// CloseWindow closes the current active window (see WindowHandle() for what
	// window that will be).
	CloseWindow() (*CloseWindowResponse, error)

	// SwitchToWindow switches the current browsing context to a specified window
	// handle.
	SwitchToWindow(handle string) (*SwitchToWindowResponse, error)

	// WindowHandles gets all of the window handles for the current session.
	// To retrieve the currently active window handle, see WindowHandle().
	WindowHandles() (*WindowHandlesResponse, error)

	// SwitchToFrame switches to a frame determined by the "by" parameter.
	// You can use ByIndex to find the frame to switch to. Any other
	// By implementation will yield an InvalidByParameter error.
	SwitchToFrame(by By) (*SwitchToFrameResponse, error)

	// SwitchToParentFrame switches to the parent of the current top level
	// browsing context.
	SwitchToParentFrame() (*SwitchToParentFrameResponse, error)

	// WindowSize retrieves the current browser window size for the
	// active session.
	WindowSize() (*WindowSizeResponse, error)

	// SetWindowSize sets the current browser window size for the active
	// session.
	SetWindowSize(dimensions *Dimensions) (*SetWindowSizeResponse, error)

	// Maximize increases the current browser window to its maximum size.
	MaximizeWindow() (*MaximizeWindowResponse, error)

	// FindElement finds an element via a By implementation (i.e. CSS selector,
	// x-path). Attempting to find via index will result in an argument error
	// being thrown.
	FindElement(by By) (Element, error)

	// FindElements works the same way as FindElement but can return more than
	// one result.
	FindElements(by By) ([]Element, error)

	// PageSource retrieves the outerHTML value of the current URL.
	PageSource() (*PageSourceResponse, error)

	// ExecuteScript executes a Javascript script on the currently active
	// page.
	ExecuteScript(script string) (*ExecuteScriptResponse, error)

	// ExecuteScriptAsync executes a Javascript script asynchronously on the
	// currently active page. If you do not have experience with this call,
	// there is an example below.
	//
	// The async handler runs on the concept of a callback; meaning it will run
	// your code asynchronously and if it completes, will call the callback.
	//
	// Selenium helpfully provides a callback function which is passed in
	// to the 'arguments' array that you can access within your script. The
	// callback function is always the LAST element of the array. You can
	// access it like the below:
	//		var callback = arguments[arguments.length - 1];
	// The callback function also accepts one argument as a parameter, this
	// can be anything and will be assigned to the Response property of
	// ExecuteScriptResponse.
	//
	// An example:
	//		var callback = arguments[arguments.length - 1];
	//		doLongWindedTask();
	//		callback();
	ExecuteScriptAsync(script string) (*ExecuteScriptResponse, error)

	// AllCookies returns all cookies associated with the active URL of the
	// current browsing context.
	AllCookies() (*AllCookiesResponse, error)

	// Cookie gets a single named cookie associated with the active URL of the
	// current browsing context.
	Cookie(name string) (*CookieResponse, error)

	// AddCookie adds a cookie to the current browsing context.
	AddCookie(c *Cookie) (*AddCookieResponse, error)

	// DeleteCookie deletes a cookie from the current browsing session. If name
	// is passed as an empty string, all cookies for the current address will
	// be deleted.
	DeleteCookie(name string) (*DeleteCookieResponse, error)

	// DismissAlert dismisses an alert if there is one present. If not, it will
	// throw an error.
	DismissAlert() (*DismissAlertResponse, error)

	// AcceptAlertResponse accepts an alert if there is one present. If not,
	// it will throw an error.
	AcceptAlert() (*AcceptAlertResponse, error)

	// AlertText gets the text associated with the current alert. If there is
	// not an alert, it will throw an error.
	AlertText() (*AlertTextResponse, error)

	// SendAlertText enters the text specified into the value box.
	//
	// If the prompt is of type 'alert' or 'confirm', a communication error
	// with code 'element not interactable' will be returned.
	//
	// If the prompt is anything other than 'prompt', a communication error with
	// code 'unsupported operation' will be returned.
	SendAlertText(text string) (*SendAlertTextResponse, error)

	// Screenshot takes a screenshot of the window of the current top level
	// browsing context.
	Screenshot() (*ScreenshotResponse, error)

	// Wait repeats an action until the action yields a valid result or
	// until the timeout is reached. If the timeout is reached without
	// the until function returning a satisfactory result, this method
	// will return false.
	//
	// time.Sleep will be called with the sleep parameter after every
	// u iteration.
	Wait(u Until, timeout time.Duration, sleep time.Duration) bool
}

type WindowHandleResponse struct {
	State  string
	Handle string
}

type WindowHandlesResponse struct {
	State   string   `json:"state"`
	Handles []string `json:"value"`
}

type WindowSizeResponse struct {
	State      string     `json:"state"`
	Dimensions Dimensions `json:"value"`
}