From e622f62126146a057f689063c09c1ef328b77eef Mon Sep 17 00:00:00 2001 From: Hiro Tamada Date: Wed, 8 Oct 2025 14:08:19 -0400 Subject: [PATCH] Add go openapi client generation --- server/Makefile | 32 + server/go.mod | 2 + server/go.sum | 9 + server/lib/oapi/client.go | 6559 +++++++++++++++++++++++++++++++ server/oapi-codegen.client.yaml | 8 + server/openapi.yaml | 4 +- 6 files changed, 6612 insertions(+), 2 deletions(-) create mode 100644 server/Makefile create mode 100644 server/lib/oapi/client.go create mode 100644 server/oapi-codegen.client.yaml diff --git a/server/Makefile b/server/Makefile new file mode 100644 index 000000000..7977d5a22 --- /dev/null +++ b/server/Makefile @@ -0,0 +1,32 @@ +SHELL := /bin/bash +.PHONY: generate-client install-tools clean-client help + +BIN_DIR ?= $(CURDIR)/bin +OAPI_CODEGEN ?= $(BIN_DIR)/oapi-codegen + +$(BIN_DIR): + mkdir -p $(BIN_DIR) + +$(OAPI_CODEGEN): | $(BIN_DIR) + GOBIN=$(BIN_DIR) go install github.com/oapi-codegen/oapi-codegen/v2/cmd/oapi-codegen@latest + +generate-client: $(OAPI_CODEGEN) + @echo "Generating Go client from OpenAPI spec..." + mkdir -p lib/oapi + $(OAPI_CODEGEN) -config oapi-codegen.client.yaml openapi.yaml + @echo "Formatting generated code..." + go fmt ./lib/oapi/... + @echo "Client generated at ./lib/oapi/" + +install-tools: $(OAPI_CODEGEN) + @echo "Tools installed to $(BIN_DIR)" + +clean-client: + rm -rf lib/oapi/client.go + +help: + @echo "Available targets:" + @echo " generate-client - Generate Go client from OpenAPI spec" + @echo " install-tools - Install required tools" + @echo " clean-client - Remove generated client code" + diff --git a/server/go.mod b/server/go.mod index 2875bd792..63e81660d 100644 --- a/server/go.mod +++ b/server/go.mod @@ -10,6 +10,7 @@ require ( github.com/gorilla/websocket v1.5.3 github.com/kataras/go-events v0.0.3 github.com/mitchellh/mapstructure v1.5.0 + github.com/oapi-codegen/runtime v1.1.2 github.com/onkernel/kernel-images/server v0.0.0-20250912023508-e0ca1d95b771 github.com/pion/ice/v2 v2.3.38 github.com/pion/interceptor v0.1.40 @@ -23,6 +24,7 @@ require ( ) require ( + github.com/apapsch/go-jsonmerge/v2 v2.0.0 // indirect github.com/beorn7/perks v1.0.1 // indirect github.com/cespare/xxhash/v2 v2.3.0 // indirect github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect diff --git a/server/go.sum b/server/go.sum index bf54b1f90..cf58312ff 100644 --- a/server/go.sum +++ b/server/go.sum @@ -2,8 +2,12 @@ github.com/PaesslerAG/gval v1.2.4 h1:rhX7MpjJlcxYwL2eTTYIOBUyEKZ+A96T9vQySWkVUiU github.com/PaesslerAG/gval v1.2.4/go.mod h1:XRFLwvmkTEdYziLdaCeCa5ImcGVrfQbeNUbVR+C6xac= github.com/PaesslerAG/jsonpath v0.1.0 h1:gADYeifvlqK3R3i2cR5B4DGgxLXIPb3TRTH1mGi0jPI= github.com/PaesslerAG/jsonpath v0.1.0/go.mod h1:4BzmtoM/PI8fPO4aQGIusjGxGir2BzcV0grWtFzq1Y8= +github.com/RaveNoX/go-jsoncommentstrip v1.0.0/go.mod h1:78ihd09MekBnJnxpICcwzCMzGrKSKYe4AqU6PDYYpjk= +github.com/apapsch/go-jsonmerge/v2 v2.0.0 h1:axGnT1gRIfimI7gJifB699GoE/oq+F2MU7Dml6nw9rQ= +github.com/apapsch/go-jsonmerge/v2 v2.0.0/go.mod h1:lvDnEdqiQrp0O42VQGgmlKpxL1AP2+08jFMw88y4klk= github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM= github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw= +github.com/bmatcuk/doublestar v1.1.1/go.mod h1:UD6OnuiIn0yFxxA2le/rnRU1G4RaI4UvFv1sNto9p6w= github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= github.com/coreos/go-systemd/v22 v22.5.0/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc= @@ -32,6 +36,7 @@ github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aN github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8= github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw= +github.com/juju/gnuflag v0.0.0-20171113085948-2ce1bb71843d/go.mod h1:2PavIy+JPciBPrBUjwbNvtwB6RQlve+hkpll6QSNmOE= github.com/kataras/go-events v0.0.3 h1:o5YK53uURXtrlg7qE/vovxd/yKOJcLuFtPQbf1rYMC4= github.com/kataras/go-events v0.0.3/go.mod h1:bFBgtzwwzrag7kQmGuU1ZaVxhK2qseYPQomXoVEMsj4= github.com/klauspost/compress v1.18.0 h1:c/Cqfb0r+Yi+JtIEq73FWXVkRonBlf0CRNYc8Zttxdo= @@ -56,6 +61,8 @@ github.com/mitchellh/mapstructure v1.5.0 h1:jeMsZIYE/09sWLaz43PL7Gy6RuMjD2eJVyua github.com/mitchellh/mapstructure v1.5.0/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo= github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA= github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ= +github.com/oapi-codegen/runtime v1.1.2 h1:P2+CubHq8fO4Q6fV1tqDBZHCwpVpvPg7oKiYzQgXIyI= +github.com/oapi-codegen/runtime v1.1.2/go.mod h1:SK9X900oXmPWilYR5/WKPzt3Kqxn/uS/+lbpREv+eCg= github.com/onkernel/kernel-images/server v0.0.0-20250912023508-e0ca1d95b771 h1:Z+Zu7ILww5/4q70h1oA+CYBCM0QCuNtAtGDUxjIyp1A= github.com/onkernel/kernel-images/server v0.0.0-20250912023508-e0ca1d95b771/go.mod h1:8BxVW6vmlK9as98BTOYIjsVPpXObs+b4aZyZ23JZf4Y= github.com/pelletier/go-toml/v2 v2.2.4 h1:mye9XuhQ6gvn5h28+VilKrrPoQVanw5PMw/TB0t5Ec4= @@ -139,9 +146,11 @@ github.com/spf13/pflag v1.0.7 h1:vN6T9TfwStFPFM5XzjsvmzZkLuaLX+HS+0SeFLRgU6M= github.com/spf13/pflag v1.0.7/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg= github.com/spf13/viper v1.20.1 h1:ZMi+z/lvLyPSCoNtFCpqjy0S4kPbirhpTMwl8BkW9X4= github.com/spf13/viper v1.20.1/go.mod h1:P9Mdzt1zoHIG8m2eZQinpiBjo6kCmZSKBClNNqjJvu4= +github.com/spkg/bom v0.0.0-20160624110644-59b7046e48ad/go.mod h1:qLr4V1qq6nMqFKkMo8ZTx3f+BZEkzsRUY10Xsm2mwU0= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= +github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= github.com/stretchr/testify v1.8.3/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= diff --git a/server/lib/oapi/client.go b/server/lib/oapi/client.go new file mode 100644 index 000000000..da3fc45df --- /dev/null +++ b/server/lib/oapi/client.go @@ -0,0 +1,6559 @@ +// Package oapi provides primitives to interact with the openapi HTTP API. +// +// Code generated by github.com/oapi-codegen/oapi-codegen/v2 version v2.5.0 DO NOT EDIT. +package oapi + +import ( + "bytes" + "context" + "encoding/json" + "fmt" + "io" + "net/http" + "net/url" + "strings" + "time" + + "github.com/oapi-codegen/runtime" + openapi_types "github.com/oapi-codegen/runtime/types" +) + +const ( + BearerAuthScopes = "BearerAuth.Scopes" + CookieAuthScopes = "CookieAuth.Scopes" + TokenAuthScopes = "TokenAuth.Scopes" +) + +// Defines values for BatchItemMethod. +const ( + BatchItemMethodDELETE BatchItemMethod = "DELETE" + BatchItemMethodGET BatchItemMethod = "GET" + BatchItemMethodPOST BatchItemMethod = "POST" +) + +// Defines values for BatchRequestMethod. +const ( + BatchRequestMethodDELETE BatchRequestMethod = "DELETE" + BatchRequestMethodGET BatchRequestMethod = "GET" + BatchRequestMethodPOST BatchRequestMethod = "POST" +) + +// BatchItem defines model for BatchItem. +type BatchItem struct { + // Body The response body from the API call. + Body interface{} `json:"body,omitempty"` + + // Method The HTTP method used. + Method *BatchItemMethod `json:"method,omitempty"` + + // Path The API endpoint path. + Path *string `json:"path,omitempty"` + + // Status The HTTP status code of the response. + Status *int `json:"status,omitempty"` +} + +// BatchItemMethod The HTTP method used. +type BatchItemMethod string + +// BatchRequest defines model for BatchRequest. +type BatchRequest struct { + // Body The request body for the API call. + Body interface{} `json:"body,omitempty"` + + // Method The HTTP method to be used. + Method *BatchRequestMethod `json:"method,omitempty"` + + // Path The API endpoint path. + Path *string `json:"path,omitempty"` +} + +// BatchRequestMethod The HTTP method to be used. +type BatchRequestMethod string + +// BroadcastStatus defines model for BroadcastStatus. +type BroadcastStatus struct { + // IsActive Indicates if the broadcast is active. + IsActive *bool `json:"is_active,omitempty"` + + // Url The URL of the broadcast. + Url *string `json:"url,omitempty"` +} + +// ClipboardText defines model for ClipboardText. +type ClipboardText struct { + // Html The HTML content of the clipboard. + Html *string `json:"html,omitempty"` + + // Text The plain text content of the clipboard. + Text *string `json:"text,omitempty"` +} + +// ControlStatus defines model for ControlStatus. +type ControlStatus struct { + // HasHost Indicates if there is a host currently. + HasHost *bool `json:"has_host,omitempty"` + + // HostId The ID of the current host, if any. + HostId *string `json:"host_id,omitempty"` +} + +// ErrorMessage defines model for ErrorMessage. +type ErrorMessage struct { + // Message Detailed error message. + Message *string `json:"message,omitempty"` +} + +// KeyboardMap defines model for KeyboardMap. +type KeyboardMap struct { + // Layout The keyboard layout. + Layout *string `json:"layout,omitempty"` + + // Variant The keyboard variant. + Variant *string `json:"variant,omitempty"` +} + +// KeyboardModifiers defines model for KeyboardModifiers. +type KeyboardModifiers struct { + // Alt Indicates if the alt key is pressed. + Alt *bool `json:"alt,omitempty"` + + // Altgr Indicates if the altgr key is pressed. + Altgr *bool `json:"altgr,omitempty"` + + // Capslock Indicates if the caps lock key is active. + Capslock *bool `json:"capslock,omitempty"` + + // Control Indicates if the control key is pressed. + Control *bool `json:"control,omitempty"` + + // Meta Indicates if the meta key is pressed. + Meta *bool `json:"meta,omitempty"` + + // Numlock Indicates if the num lock key is active. + Numlock *bool `json:"numlock,omitempty"` + + // Shift Indicates if the shift key is pressed. + Shift *bool `json:"shift,omitempty"` + + // Super Indicates if the super key is pressed. + Super *bool `json:"super,omitempty"` +} + +// MemberBulkDelete defines model for MemberBulkDelete. +type MemberBulkDelete struct { + // Ids The list of member IDs to be deleted. + Ids *[]string `json:"ids,omitempty"` +} + +// MemberBulkUpdate defines model for MemberBulkUpdate. +type MemberBulkUpdate struct { + // Ids The list of member IDs to be updated. + Ids *[]string `json:"ids,omitempty"` + Profile *MemberProfile `json:"profile,omitempty"` +} + +// MemberCreate defines model for MemberCreate. +type MemberCreate struct { + // Password The password of the new member. + Password *string `json:"password,omitempty"` + Profile *MemberProfile `json:"profile,omitempty"` + + // Username The username of the new member. + Username *string `json:"username,omitempty"` +} + +// MemberData defines model for MemberData. +type MemberData struct { + // Id The unique identifier of the member. + Id *string `json:"id,omitempty"` + Profile *MemberProfile `json:"profile,omitempty"` +} + +// MemberPassword defines model for MemberPassword. +type MemberPassword struct { + // Password The new password for the member. + Password *string `json:"password,omitempty"` +} + +// MemberProfile defines model for MemberProfile. +type MemberProfile struct { + // CanAccessClipboard Indicates if the member can access the clipboard. + CanAccessClipboard *bool `json:"can_access_clipboard,omitempty"` + + // CanConnect Indicates if the member can connect. + CanConnect *bool `json:"can_connect,omitempty"` + + // CanHost Indicates if the member can host. + CanHost *bool `json:"can_host,omitempty"` + + // CanLogin Indicates if the member can log in. + CanLogin *bool `json:"can_login,omitempty"` + + // CanSeeInactiveCursors Indicates if the member can see inactive cursors. + CanSeeInactiveCursors *bool `json:"can_see_inactive_cursors,omitempty"` + + // CanShareMedia Indicates if the member can share media. + CanShareMedia *bool `json:"can_share_media,omitempty"` + + // CanWatch Indicates if the member can watch. + CanWatch *bool `json:"can_watch,omitempty"` + + // IsAdmin Indicates if the member is an admin. + IsAdmin *bool `json:"is_admin,omitempty"` + + // Name The name of the member. + Name *string `json:"name,omitempty"` + + // Plugins Additional plugin settings. + Plugins *map[string]interface{} `json:"plugins,omitempty"` + + // SendsInactiveCursor Indicates if the member sends inactive cursor. + SendsInactiveCursor *bool `json:"sends_inactive_cursor,omitempty"` +} + +// ScreenConfiguration defines model for ScreenConfiguration. +type ScreenConfiguration struct { + // Height The height of the screen. + Height *int `json:"height,omitempty"` + + // Rate The refresh rate of the screen. + Rate *int `json:"rate,omitempty"` + + // Width The width of the screen. + Width *int `json:"width,omitempty"` +} + +// SessionData defines model for SessionData. +type SessionData struct { + // Id The unique identifier of the session. + Id *string `json:"id,omitempty"` + Profile *MemberProfile `json:"profile,omitempty"` + State *SessionState `json:"state,omitempty"` +} + +// SessionLoginRequest defines model for SessionLoginRequest. +type SessionLoginRequest struct { + // Password The password of the user. + Password *string `json:"password,omitempty"` + + // Username The username of the user. + Username *string `json:"username,omitempty"` +} + +// SessionLoginResponse defines model for SessionLoginResponse. +type SessionLoginResponse struct { + // Id The unique identifier of the session. + Id *string `json:"id,omitempty"` + Profile *MemberProfile `json:"profile,omitempty"` + State *SessionState `json:"state,omitempty"` + + // Token The session token, only if cookie authentication is disabled. + Token *string `json:"token,omitempty"` +} + +// SessionState defines model for SessionState. +type SessionState struct { + // IsConnected Indicates if the user is connected. + IsConnected *bool `json:"is_connected,omitempty"` + + // IsWatching Indicates if the user is watching. + IsWatching *bool `json:"is_watching,omitempty"` +} + +// Settings defines model for Settings. +type Settings struct { + // ImplicitHosting Indicates if implicit hosting is enabled. + ImplicitHosting *bool `json:"implicit_hosting,omitempty"` + + // InactiveCursors Indicates if inactive cursors are shown. + InactiveCursors *bool `json:"inactive_cursors,omitempty"` + + // LockedControls Indicates if the room controls are locked. + LockedControls *bool `json:"locked_controls,omitempty"` + + // MercifulReconnect Indicates if merciful reconnect is enabled. + MercifulReconnect *bool `json:"merciful_reconnect,omitempty"` + + // Plugins Additional plugin settings. + Plugins *map[string]interface{} `json:"plugins,omitempty"` + + // PrivateMode Indicates if the room is in private mode. + PrivateMode *bool `json:"private_mode,omitempty"` +} + +// Stats defines model for Stats. +type Stats struct { + // HasHost Indicates if there is a host currently. + HasHost *bool `json:"has_host,omitempty"` + + // HostId The ID of the current host, if any. + HostId *string `json:"host_id,omitempty"` + + // LastAdminLeftAt The timestamp when the last admin left, if any. + LastAdminLeftAt *time.Time `json:"last_admin_left_at,omitempty"` + + // LastUserLeftAt The timestamp when the last user left, if any. + LastUserLeftAt *time.Time `json:"last_user_left_at,omitempty"` + + // ServerStartedAt The timestamp when the server started. + ServerStartedAt *time.Time `json:"server_started_at,omitempty"` + + // TotalAdmins The total number of admins connected. + TotalAdmins *int `json:"total_admins,omitempty"` + + // TotalUsers The total number of users connected. + TotalUsers *int `json:"total_users,omitempty"` +} + +// Forbidden defines model for Forbidden. +type Forbidden = ErrorMessage + +// NotFound defines model for NotFound. +type NotFound = ErrorMessage + +// Unauthorized defines model for Unauthorized. +type Unauthorized = ErrorMessage + +// BatchJSONBody defines parameters for Batch. +type BatchJSONBody = []BatchRequest + +// MembersListParams defines parameters for MembersList. +type MembersListParams struct { + Limit *float32 `form:"limit,omitempty" json:"limit,omitempty"` + Offset *float32 `form:"offset,omitempty" json:"offset,omitempty"` +} + +// ScreenShotImageParams defines parameters for ScreenShotImage. +type ScreenShotImageParams struct { + // Quality Image quality (0-100). + Quality *int `form:"quality,omitempty" json:"quality,omitempty"` +} + +// UploadDialogMultipartBody defines parameters for UploadDialog. +type UploadDialogMultipartBody struct { + // Files Files to be uploaded. + Files *[]openapi_types.File `json:"files,omitempty"` +} + +// UploadDropMultipartBody defines parameters for UploadDrop. +type UploadDropMultipartBody struct { + // Files Files to be uploaded. + Files *[]openapi_types.File `json:"files,omitempty"` + + // X X coordinate of drop. + X *float32 `json:"x,omitempty"` + + // Y Y coordinate of drop. + Y *float32 `json:"y,omitempty"` +} + +// BatchJSONRequestBody defines body for Batch for application/json ContentType. +type BatchJSONRequestBody = BatchJSONBody + +// LoginJSONRequestBody defines body for Login for application/json ContentType. +type LoginJSONRequestBody = SessionLoginRequest + +// MembersCreateJSONRequestBody defines body for MembersCreate for application/json ContentType. +type MembersCreateJSONRequestBody = MemberCreate + +// MembersUpdateProfileJSONRequestBody defines body for MembersUpdateProfile for application/json ContentType. +type MembersUpdateProfileJSONRequestBody = MemberProfile + +// MembersUpdatePasswordJSONRequestBody defines body for MembersUpdatePassword for application/json ContentType. +type MembersUpdatePasswordJSONRequestBody = MemberPassword + +// MembersBulkDeleteJSONRequestBody defines body for MembersBulkDelete for application/json ContentType. +type MembersBulkDeleteJSONRequestBody = MemberBulkDelete + +// MembersBulkUpdateJSONRequestBody defines body for MembersBulkUpdate for application/json ContentType. +type MembersBulkUpdateJSONRequestBody = MemberBulkUpdate + +// ProfileJSONRequestBody defines body for Profile for application/json ContentType. +type ProfileJSONRequestBody = MemberProfile + +// BroadcastStartJSONRequestBody defines body for BroadcastStart for application/json ContentType. +type BroadcastStartJSONRequestBody = BroadcastStatus + +// ClipboardSetTextJSONRequestBody defines body for ClipboardSetText for application/json ContentType. +type ClipboardSetTextJSONRequestBody = ClipboardText + +// KeyboardMapSetJSONRequestBody defines body for KeyboardMapSet for application/json ContentType. +type KeyboardMapSetJSONRequestBody = KeyboardMap + +// KeyboardModifiersSetJSONRequestBody defines body for KeyboardModifiersSet for application/json ContentType. +type KeyboardModifiersSetJSONRequestBody = KeyboardModifiers + +// ScreenConfigurationChangeJSONRequestBody defines body for ScreenConfigurationChange for application/json ContentType. +type ScreenConfigurationChangeJSONRequestBody = ScreenConfiguration + +// SettingsSetJSONRequestBody defines body for SettingsSet for application/json ContentType. +type SettingsSetJSONRequestBody = Settings + +// UploadDialogMultipartRequestBody defines body for UploadDialog for multipart/form-data ContentType. +type UploadDialogMultipartRequestBody UploadDialogMultipartBody + +// UploadDropMultipartRequestBody defines body for UploadDrop for multipart/form-data ContentType. +type UploadDropMultipartRequestBody UploadDropMultipartBody + +// RequestEditorFn is the function signature for the RequestEditor callback function +type RequestEditorFn func(ctx context.Context, req *http.Request) error + +// Doer performs HTTP requests. +// +// The standard http.Client implements this interface. +type HttpRequestDoer interface { + Do(req *http.Request) (*http.Response, error) +} + +// Client which conforms to the OpenAPI3 specification for this service. +type Client struct { + // The endpoint of the server conforming to this interface, with scheme, + // https://api.deepmap.com for example. This can contain a path relative + // to the server, such as https://api.deepmap.com/dev-test, and all the + // paths in the swagger spec will be appended to the server. + Server string + + // Doer for performing requests, typically a *http.Client with any + // customized settings, such as certificate chains. + Client HttpRequestDoer + + // A list of callbacks for modifying requests which are generated before sending over + // the network. + RequestEditors []RequestEditorFn +} + +// ClientOption allows setting custom parameters during construction +type ClientOption func(*Client) error + +// Creates a new Client, with reasonable defaults +func NewClient(server string, opts ...ClientOption) (*Client, error) { + // create a client with sane default values + client := Client{ + Server: server, + } + // mutate client and add all optional params + for _, o := range opts { + if err := o(&client); err != nil { + return nil, err + } + } + // ensure the server URL always has a trailing slash + if !strings.HasSuffix(client.Server, "/") { + client.Server += "/" + } + // create httpClient, if not already present + if client.Client == nil { + client.Client = &http.Client{} + } + return &client, nil +} + +// WithHTTPClient allows overriding the default Doer, which is +// automatically created using http.Client. This is useful for tests. +func WithHTTPClient(doer HttpRequestDoer) ClientOption { + return func(c *Client) error { + c.Client = doer + return nil + } +} + +// WithRequestEditorFn allows setting up a callback function, which will be +// called right before sending the request. This can be used to mutate the request. +func WithRequestEditorFn(fn RequestEditorFn) ClientOption { + return func(c *Client) error { + c.RequestEditors = append(c.RequestEditors, fn) + return nil + } +} + +// The interface specification for the client above. +type ClientInterface interface { + // BatchWithBody request with any body + BatchWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) + + Batch(ctx context.Context, body BatchJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) + + // LoginWithBody request with any body + LoginWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) + + Login(ctx context.Context, body LoginJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) + + // Logout request + Logout(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) + + // MembersList request + MembersList(ctx context.Context, params *MembersListParams, reqEditors ...RequestEditorFn) (*http.Response, error) + + // MembersCreateWithBody request with any body + MembersCreateWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) + + MembersCreate(ctx context.Context, body MembersCreateJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) + + // MembersRemove request + MembersRemove(ctx context.Context, memberId string, reqEditors ...RequestEditorFn) (*http.Response, error) + + // MembersGetProfile request + MembersGetProfile(ctx context.Context, memberId string, reqEditors ...RequestEditorFn) (*http.Response, error) + + // MembersUpdateProfileWithBody request with any body + MembersUpdateProfileWithBody(ctx context.Context, memberId string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) + + MembersUpdateProfile(ctx context.Context, memberId string, body MembersUpdateProfileJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) + + // MembersUpdatePasswordWithBody request with any body + MembersUpdatePasswordWithBody(ctx context.Context, memberId string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) + + MembersUpdatePassword(ctx context.Context, memberId string, body MembersUpdatePasswordJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) + + // MembersBulkDeleteWithBody request with any body + MembersBulkDeleteWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) + + MembersBulkDelete(ctx context.Context, body MembersBulkDeleteJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) + + // MembersBulkUpdateWithBody request with any body + MembersBulkUpdateWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) + + MembersBulkUpdate(ctx context.Context, body MembersBulkUpdateJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) + + // ProfileWithBody request with any body + ProfileWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) + + Profile(ctx context.Context, body ProfileJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) + + // BroadcastStatus request + BroadcastStatus(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) + + // BroadcastStartWithBody request with any body + BroadcastStartWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) + + BroadcastStart(ctx context.Context, body BroadcastStartJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) + + // BroadcastStop request + BroadcastStop(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) + + // ClipboardGetText request + ClipboardGetText(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) + + // ClipboardSetTextWithBody request with any body + ClipboardSetTextWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) + + ClipboardSetText(ctx context.Context, body ClipboardSetTextJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) + + // ClipboardGetImage request + ClipboardGetImage(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) + + // ControlStatus request + ControlStatus(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) + + // ControlGive request + ControlGive(ctx context.Context, sessionId string, reqEditors ...RequestEditorFn) (*http.Response, error) + + // ControlRelease request + ControlRelease(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) + + // ControlRequest request + ControlRequest(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) + + // ControlReset request + ControlReset(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) + + // ControlTake request + ControlTake(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) + + // KeyboardMapGet request + KeyboardMapGet(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) + + // KeyboardMapSetWithBody request with any body + KeyboardMapSetWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) + + KeyboardMapSet(ctx context.Context, body KeyboardMapSetJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) + + // KeyboardModifiersGet request + KeyboardModifiersGet(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) + + // KeyboardModifiersSetWithBody request with any body + KeyboardModifiersSetWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) + + KeyboardModifiersSet(ctx context.Context, body KeyboardModifiersSetJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) + + // ScreenConfiguration request + ScreenConfiguration(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) + + // ScreenConfigurationChangeWithBody request with any body + ScreenConfigurationChangeWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) + + ScreenConfigurationChange(ctx context.Context, body ScreenConfigurationChangeJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) + + // ScreenCastImage request + ScreenCastImage(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) + + // ScreenConfigurationsList request + ScreenConfigurationsList(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) + + // ScreenShotImage request + ScreenShotImage(ctx context.Context, params *ScreenShotImageParams, reqEditors ...RequestEditorFn) (*http.Response, error) + + // SettingsGet request + SettingsGet(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) + + // SettingsSetWithBody request with any body + SettingsSetWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) + + SettingsSet(ctx context.Context, body SettingsSetJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) + + // UploadDialogClose request + UploadDialogClose(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) + + // UploadDialogWithBody request with any body + UploadDialogWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) + + // UploadDropWithBody request with any body + UploadDropWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) + + // SessionsGet request + SessionsGet(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) + + // SessionRemove request + SessionRemove(ctx context.Context, sessionId string, reqEditors ...RequestEditorFn) (*http.Response, error) + + // SessionGet request + SessionGet(ctx context.Context, sessionId string, reqEditors ...RequestEditorFn) (*http.Response, error) + + // SessionDisconnect request + SessionDisconnect(ctx context.Context, sessionId string, reqEditors ...RequestEditorFn) (*http.Response, error) + + // Stats request + Stats(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) + + // Whoami request + Whoami(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) + + // Healthcheck request + Healthcheck(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) + + // Metrics request + Metrics(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) +} + +func (c *Client) BatchWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewBatchRequestWithBody(c.Server, contentType, body) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) Batch(ctx context.Context, body BatchJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewBatchRequest(c.Server, body) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) LoginWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewLoginRequestWithBody(c.Server, contentType, body) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) Login(ctx context.Context, body LoginJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewLoginRequest(c.Server, body) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) Logout(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewLogoutRequest(c.Server) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) MembersList(ctx context.Context, params *MembersListParams, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewMembersListRequest(c.Server, params) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) MembersCreateWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewMembersCreateRequestWithBody(c.Server, contentType, body) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) MembersCreate(ctx context.Context, body MembersCreateJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewMembersCreateRequest(c.Server, body) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) MembersRemove(ctx context.Context, memberId string, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewMembersRemoveRequest(c.Server, memberId) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) MembersGetProfile(ctx context.Context, memberId string, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewMembersGetProfileRequest(c.Server, memberId) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) MembersUpdateProfileWithBody(ctx context.Context, memberId string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewMembersUpdateProfileRequestWithBody(c.Server, memberId, contentType, body) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) MembersUpdateProfile(ctx context.Context, memberId string, body MembersUpdateProfileJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewMembersUpdateProfileRequest(c.Server, memberId, body) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) MembersUpdatePasswordWithBody(ctx context.Context, memberId string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewMembersUpdatePasswordRequestWithBody(c.Server, memberId, contentType, body) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) MembersUpdatePassword(ctx context.Context, memberId string, body MembersUpdatePasswordJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewMembersUpdatePasswordRequest(c.Server, memberId, body) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) MembersBulkDeleteWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewMembersBulkDeleteRequestWithBody(c.Server, contentType, body) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) MembersBulkDelete(ctx context.Context, body MembersBulkDeleteJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewMembersBulkDeleteRequest(c.Server, body) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) MembersBulkUpdateWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewMembersBulkUpdateRequestWithBody(c.Server, contentType, body) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) MembersBulkUpdate(ctx context.Context, body MembersBulkUpdateJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewMembersBulkUpdateRequest(c.Server, body) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) ProfileWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewProfileRequestWithBody(c.Server, contentType, body) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) Profile(ctx context.Context, body ProfileJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewProfileRequest(c.Server, body) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) BroadcastStatus(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewBroadcastStatusRequest(c.Server) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) BroadcastStartWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewBroadcastStartRequestWithBody(c.Server, contentType, body) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) BroadcastStart(ctx context.Context, body BroadcastStartJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewBroadcastStartRequest(c.Server, body) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) BroadcastStop(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewBroadcastStopRequest(c.Server) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) ClipboardGetText(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewClipboardGetTextRequest(c.Server) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) ClipboardSetTextWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewClipboardSetTextRequestWithBody(c.Server, contentType, body) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) ClipboardSetText(ctx context.Context, body ClipboardSetTextJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewClipboardSetTextRequest(c.Server, body) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) ClipboardGetImage(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewClipboardGetImageRequest(c.Server) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) ControlStatus(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewControlStatusRequest(c.Server) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) ControlGive(ctx context.Context, sessionId string, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewControlGiveRequest(c.Server, sessionId) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) ControlRelease(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewControlReleaseRequest(c.Server) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) ControlRequest(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewControlRequestRequest(c.Server) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) ControlReset(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewControlResetRequest(c.Server) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) ControlTake(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewControlTakeRequest(c.Server) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) KeyboardMapGet(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewKeyboardMapGetRequest(c.Server) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) KeyboardMapSetWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewKeyboardMapSetRequestWithBody(c.Server, contentType, body) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) KeyboardMapSet(ctx context.Context, body KeyboardMapSetJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewKeyboardMapSetRequest(c.Server, body) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) KeyboardModifiersGet(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewKeyboardModifiersGetRequest(c.Server) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) KeyboardModifiersSetWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewKeyboardModifiersSetRequestWithBody(c.Server, contentType, body) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) KeyboardModifiersSet(ctx context.Context, body KeyboardModifiersSetJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewKeyboardModifiersSetRequest(c.Server, body) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) ScreenConfiguration(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewScreenConfigurationRequest(c.Server) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) ScreenConfigurationChangeWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewScreenConfigurationChangeRequestWithBody(c.Server, contentType, body) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) ScreenConfigurationChange(ctx context.Context, body ScreenConfigurationChangeJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewScreenConfigurationChangeRequest(c.Server, body) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) ScreenCastImage(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewScreenCastImageRequest(c.Server) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) ScreenConfigurationsList(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewScreenConfigurationsListRequest(c.Server) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) ScreenShotImage(ctx context.Context, params *ScreenShotImageParams, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewScreenShotImageRequest(c.Server, params) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) SettingsGet(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewSettingsGetRequest(c.Server) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) SettingsSetWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewSettingsSetRequestWithBody(c.Server, contentType, body) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) SettingsSet(ctx context.Context, body SettingsSetJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewSettingsSetRequest(c.Server, body) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) UploadDialogClose(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewUploadDialogCloseRequest(c.Server) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) UploadDialogWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewUploadDialogRequestWithBody(c.Server, contentType, body) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) UploadDropWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewUploadDropRequestWithBody(c.Server, contentType, body) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) SessionsGet(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewSessionsGetRequest(c.Server) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) SessionRemove(ctx context.Context, sessionId string, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewSessionRemoveRequest(c.Server, sessionId) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) SessionGet(ctx context.Context, sessionId string, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewSessionGetRequest(c.Server, sessionId) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) SessionDisconnect(ctx context.Context, sessionId string, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewSessionDisconnectRequest(c.Server, sessionId) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) Stats(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewStatsRequest(c.Server) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) Whoami(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewWhoamiRequest(c.Server) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) Healthcheck(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewHealthcheckRequest(c.Server) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) Metrics(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewMetricsRequest(c.Server) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +// NewBatchRequest calls the generic Batch builder with application/json body +func NewBatchRequest(server string, body BatchJSONRequestBody) (*http.Request, error) { + var bodyReader io.Reader + buf, err := json.Marshal(body) + if err != nil { + return nil, err + } + bodyReader = bytes.NewReader(buf) + return NewBatchRequestWithBody(server, "application/json", bodyReader) +} + +// NewBatchRequestWithBody generates requests for Batch with any type of body +func NewBatchRequestWithBody(server string, contentType string, body io.Reader) (*http.Request, error) { + var err error + + serverURL, err := url.Parse(server) + if err != nil { + return nil, err + } + + operationPath := fmt.Sprintf("/api/batch") + if operationPath[0] == '/' { + operationPath = "." + operationPath + } + + queryURL, err := serverURL.Parse(operationPath) + if err != nil { + return nil, err + } + + req, err := http.NewRequest("POST", queryURL.String(), body) + if err != nil { + return nil, err + } + + req.Header.Add("Content-Type", contentType) + + return req, nil +} + +// NewLoginRequest calls the generic Login builder with application/json body +func NewLoginRequest(server string, body LoginJSONRequestBody) (*http.Request, error) { + var bodyReader io.Reader + buf, err := json.Marshal(body) + if err != nil { + return nil, err + } + bodyReader = bytes.NewReader(buf) + return NewLoginRequestWithBody(server, "application/json", bodyReader) +} + +// NewLoginRequestWithBody generates requests for Login with any type of body +func NewLoginRequestWithBody(server string, contentType string, body io.Reader) (*http.Request, error) { + var err error + + serverURL, err := url.Parse(server) + if err != nil { + return nil, err + } + + operationPath := fmt.Sprintf("/api/login") + if operationPath[0] == '/' { + operationPath = "." + operationPath + } + + queryURL, err := serverURL.Parse(operationPath) + if err != nil { + return nil, err + } + + req, err := http.NewRequest("POST", queryURL.String(), body) + if err != nil { + return nil, err + } + + req.Header.Add("Content-Type", contentType) + + return req, nil +} + +// NewLogoutRequest generates requests for Logout +func NewLogoutRequest(server string) (*http.Request, error) { + var err error + + serverURL, err := url.Parse(server) + if err != nil { + return nil, err + } + + operationPath := fmt.Sprintf("/api/logout") + if operationPath[0] == '/' { + operationPath = "." + operationPath + } + + queryURL, err := serverURL.Parse(operationPath) + if err != nil { + return nil, err + } + + req, err := http.NewRequest("POST", queryURL.String(), nil) + if err != nil { + return nil, err + } + + return req, nil +} + +// NewMembersListRequest generates requests for MembersList +func NewMembersListRequest(server string, params *MembersListParams) (*http.Request, error) { + var err error + + serverURL, err := url.Parse(server) + if err != nil { + return nil, err + } + + operationPath := fmt.Sprintf("/api/members") + if operationPath[0] == '/' { + operationPath = "." + operationPath + } + + queryURL, err := serverURL.Parse(operationPath) + if err != nil { + return nil, err + } + + if params != nil { + queryValues := queryURL.Query() + + if params.Limit != nil { + + if queryFrag, err := runtime.StyleParamWithLocation("form", true, "limit", runtime.ParamLocationQuery, *params.Limit); err != nil { + return nil, err + } else if parsed, err := url.ParseQuery(queryFrag); err != nil { + return nil, err + } else { + for k, v := range parsed { + for _, v2 := range v { + queryValues.Add(k, v2) + } + } + } + + } + + if params.Offset != nil { + + if queryFrag, err := runtime.StyleParamWithLocation("form", true, "offset", runtime.ParamLocationQuery, *params.Offset); err != nil { + return nil, err + } else if parsed, err := url.ParseQuery(queryFrag); err != nil { + return nil, err + } else { + for k, v := range parsed { + for _, v2 := range v { + queryValues.Add(k, v2) + } + } + } + + } + + queryURL.RawQuery = queryValues.Encode() + } + + req, err := http.NewRequest("GET", queryURL.String(), nil) + if err != nil { + return nil, err + } + + return req, nil +} + +// NewMembersCreateRequest calls the generic MembersCreate builder with application/json body +func NewMembersCreateRequest(server string, body MembersCreateJSONRequestBody) (*http.Request, error) { + var bodyReader io.Reader + buf, err := json.Marshal(body) + if err != nil { + return nil, err + } + bodyReader = bytes.NewReader(buf) + return NewMembersCreateRequestWithBody(server, "application/json", bodyReader) +} + +// NewMembersCreateRequestWithBody generates requests for MembersCreate with any type of body +func NewMembersCreateRequestWithBody(server string, contentType string, body io.Reader) (*http.Request, error) { + var err error + + serverURL, err := url.Parse(server) + if err != nil { + return nil, err + } + + operationPath := fmt.Sprintf("/api/members") + if operationPath[0] == '/' { + operationPath = "." + operationPath + } + + queryURL, err := serverURL.Parse(operationPath) + if err != nil { + return nil, err + } + + req, err := http.NewRequest("POST", queryURL.String(), body) + if err != nil { + return nil, err + } + + req.Header.Add("Content-Type", contentType) + + return req, nil +} + +// NewMembersRemoveRequest generates requests for MembersRemove +func NewMembersRemoveRequest(server string, memberId string) (*http.Request, error) { + var err error + + var pathParam0 string + + pathParam0, err = runtime.StyleParamWithLocation("simple", false, "memberId", runtime.ParamLocationPath, memberId) + if err != nil { + return nil, err + } + + serverURL, err := url.Parse(server) + if err != nil { + return nil, err + } + + operationPath := fmt.Sprintf("/api/members/%s", pathParam0) + if operationPath[0] == '/' { + operationPath = "." + operationPath + } + + queryURL, err := serverURL.Parse(operationPath) + if err != nil { + return nil, err + } + + req, err := http.NewRequest("DELETE", queryURL.String(), nil) + if err != nil { + return nil, err + } + + return req, nil +} + +// NewMembersGetProfileRequest generates requests for MembersGetProfile +func NewMembersGetProfileRequest(server string, memberId string) (*http.Request, error) { + var err error + + var pathParam0 string + + pathParam0, err = runtime.StyleParamWithLocation("simple", false, "memberId", runtime.ParamLocationPath, memberId) + if err != nil { + return nil, err + } + + serverURL, err := url.Parse(server) + if err != nil { + return nil, err + } + + operationPath := fmt.Sprintf("/api/members/%s", pathParam0) + if operationPath[0] == '/' { + operationPath = "." + operationPath + } + + queryURL, err := serverURL.Parse(operationPath) + if err != nil { + return nil, err + } + + req, err := http.NewRequest("GET", queryURL.String(), nil) + if err != nil { + return nil, err + } + + return req, nil +} + +// NewMembersUpdateProfileRequest calls the generic MembersUpdateProfile builder with application/json body +func NewMembersUpdateProfileRequest(server string, memberId string, body MembersUpdateProfileJSONRequestBody) (*http.Request, error) { + var bodyReader io.Reader + buf, err := json.Marshal(body) + if err != nil { + return nil, err + } + bodyReader = bytes.NewReader(buf) + return NewMembersUpdateProfileRequestWithBody(server, memberId, "application/json", bodyReader) +} + +// NewMembersUpdateProfileRequestWithBody generates requests for MembersUpdateProfile with any type of body +func NewMembersUpdateProfileRequestWithBody(server string, memberId string, contentType string, body io.Reader) (*http.Request, error) { + var err error + + var pathParam0 string + + pathParam0, err = runtime.StyleParamWithLocation("simple", false, "memberId", runtime.ParamLocationPath, memberId) + if err != nil { + return nil, err + } + + serverURL, err := url.Parse(server) + if err != nil { + return nil, err + } + + operationPath := fmt.Sprintf("/api/members/%s", pathParam0) + if operationPath[0] == '/' { + operationPath = "." + operationPath + } + + queryURL, err := serverURL.Parse(operationPath) + if err != nil { + return nil, err + } + + req, err := http.NewRequest("POST", queryURL.String(), body) + if err != nil { + return nil, err + } + + req.Header.Add("Content-Type", contentType) + + return req, nil +} + +// NewMembersUpdatePasswordRequest calls the generic MembersUpdatePassword builder with application/json body +func NewMembersUpdatePasswordRequest(server string, memberId string, body MembersUpdatePasswordJSONRequestBody) (*http.Request, error) { + var bodyReader io.Reader + buf, err := json.Marshal(body) + if err != nil { + return nil, err + } + bodyReader = bytes.NewReader(buf) + return NewMembersUpdatePasswordRequestWithBody(server, memberId, "application/json", bodyReader) +} + +// NewMembersUpdatePasswordRequestWithBody generates requests for MembersUpdatePassword with any type of body +func NewMembersUpdatePasswordRequestWithBody(server string, memberId string, contentType string, body io.Reader) (*http.Request, error) { + var err error + + var pathParam0 string + + pathParam0, err = runtime.StyleParamWithLocation("simple", false, "memberId", runtime.ParamLocationPath, memberId) + if err != nil { + return nil, err + } + + serverURL, err := url.Parse(server) + if err != nil { + return nil, err + } + + operationPath := fmt.Sprintf("/api/members/%s/password", pathParam0) + if operationPath[0] == '/' { + operationPath = "." + operationPath + } + + queryURL, err := serverURL.Parse(operationPath) + if err != nil { + return nil, err + } + + req, err := http.NewRequest("POST", queryURL.String(), body) + if err != nil { + return nil, err + } + + req.Header.Add("Content-Type", contentType) + + return req, nil +} + +// NewMembersBulkDeleteRequest calls the generic MembersBulkDelete builder with application/json body +func NewMembersBulkDeleteRequest(server string, body MembersBulkDeleteJSONRequestBody) (*http.Request, error) { + var bodyReader io.Reader + buf, err := json.Marshal(body) + if err != nil { + return nil, err + } + bodyReader = bytes.NewReader(buf) + return NewMembersBulkDeleteRequestWithBody(server, "application/json", bodyReader) +} + +// NewMembersBulkDeleteRequestWithBody generates requests for MembersBulkDelete with any type of body +func NewMembersBulkDeleteRequestWithBody(server string, contentType string, body io.Reader) (*http.Request, error) { + var err error + + serverURL, err := url.Parse(server) + if err != nil { + return nil, err + } + + operationPath := fmt.Sprintf("/api/members_bulk/delete") + if operationPath[0] == '/' { + operationPath = "." + operationPath + } + + queryURL, err := serverURL.Parse(operationPath) + if err != nil { + return nil, err + } + + req, err := http.NewRequest("POST", queryURL.String(), body) + if err != nil { + return nil, err + } + + req.Header.Add("Content-Type", contentType) + + return req, nil +} + +// NewMembersBulkUpdateRequest calls the generic MembersBulkUpdate builder with application/json body +func NewMembersBulkUpdateRequest(server string, body MembersBulkUpdateJSONRequestBody) (*http.Request, error) { + var bodyReader io.Reader + buf, err := json.Marshal(body) + if err != nil { + return nil, err + } + bodyReader = bytes.NewReader(buf) + return NewMembersBulkUpdateRequestWithBody(server, "application/json", bodyReader) +} + +// NewMembersBulkUpdateRequestWithBody generates requests for MembersBulkUpdate with any type of body +func NewMembersBulkUpdateRequestWithBody(server string, contentType string, body io.Reader) (*http.Request, error) { + var err error + + serverURL, err := url.Parse(server) + if err != nil { + return nil, err + } + + operationPath := fmt.Sprintf("/api/members_bulk/update") + if operationPath[0] == '/' { + operationPath = "." + operationPath + } + + queryURL, err := serverURL.Parse(operationPath) + if err != nil { + return nil, err + } + + req, err := http.NewRequest("POST", queryURL.String(), body) + if err != nil { + return nil, err + } + + req.Header.Add("Content-Type", contentType) + + return req, nil +} + +// NewProfileRequest calls the generic Profile builder with application/json body +func NewProfileRequest(server string, body ProfileJSONRequestBody) (*http.Request, error) { + var bodyReader io.Reader + buf, err := json.Marshal(body) + if err != nil { + return nil, err + } + bodyReader = bytes.NewReader(buf) + return NewProfileRequestWithBody(server, "application/json", bodyReader) +} + +// NewProfileRequestWithBody generates requests for Profile with any type of body +func NewProfileRequestWithBody(server string, contentType string, body io.Reader) (*http.Request, error) { + var err error + + serverURL, err := url.Parse(server) + if err != nil { + return nil, err + } + + operationPath := fmt.Sprintf("/api/profile") + if operationPath[0] == '/' { + operationPath = "." + operationPath + } + + queryURL, err := serverURL.Parse(operationPath) + if err != nil { + return nil, err + } + + req, err := http.NewRequest("POST", queryURL.String(), body) + if err != nil { + return nil, err + } + + req.Header.Add("Content-Type", contentType) + + return req, nil +} + +// NewBroadcastStatusRequest generates requests for BroadcastStatus +func NewBroadcastStatusRequest(server string) (*http.Request, error) { + var err error + + serverURL, err := url.Parse(server) + if err != nil { + return nil, err + } + + operationPath := fmt.Sprintf("/api/room/broadcast") + if operationPath[0] == '/' { + operationPath = "." + operationPath + } + + queryURL, err := serverURL.Parse(operationPath) + if err != nil { + return nil, err + } + + req, err := http.NewRequest("GET", queryURL.String(), nil) + if err != nil { + return nil, err + } + + return req, nil +} + +// NewBroadcastStartRequest calls the generic BroadcastStart builder with application/json body +func NewBroadcastStartRequest(server string, body BroadcastStartJSONRequestBody) (*http.Request, error) { + var bodyReader io.Reader + buf, err := json.Marshal(body) + if err != nil { + return nil, err + } + bodyReader = bytes.NewReader(buf) + return NewBroadcastStartRequestWithBody(server, "application/json", bodyReader) +} + +// NewBroadcastStartRequestWithBody generates requests for BroadcastStart with any type of body +func NewBroadcastStartRequestWithBody(server string, contentType string, body io.Reader) (*http.Request, error) { + var err error + + serverURL, err := url.Parse(server) + if err != nil { + return nil, err + } + + operationPath := fmt.Sprintf("/api/room/broadcast/start") + if operationPath[0] == '/' { + operationPath = "." + operationPath + } + + queryURL, err := serverURL.Parse(operationPath) + if err != nil { + return nil, err + } + + req, err := http.NewRequest("POST", queryURL.String(), body) + if err != nil { + return nil, err + } + + req.Header.Add("Content-Type", contentType) + + return req, nil +} + +// NewBroadcastStopRequest generates requests for BroadcastStop +func NewBroadcastStopRequest(server string) (*http.Request, error) { + var err error + + serverURL, err := url.Parse(server) + if err != nil { + return nil, err + } + + operationPath := fmt.Sprintf("/api/room/broadcast/stop") + if operationPath[0] == '/' { + operationPath = "." + operationPath + } + + queryURL, err := serverURL.Parse(operationPath) + if err != nil { + return nil, err + } + + req, err := http.NewRequest("POST", queryURL.String(), nil) + if err != nil { + return nil, err + } + + return req, nil +} + +// NewClipboardGetTextRequest generates requests for ClipboardGetText +func NewClipboardGetTextRequest(server string) (*http.Request, error) { + var err error + + serverURL, err := url.Parse(server) + if err != nil { + return nil, err + } + + operationPath := fmt.Sprintf("/api/room/clipboard") + if operationPath[0] == '/' { + operationPath = "." + operationPath + } + + queryURL, err := serverURL.Parse(operationPath) + if err != nil { + return nil, err + } + + req, err := http.NewRequest("GET", queryURL.String(), nil) + if err != nil { + return nil, err + } + + return req, nil +} + +// NewClipboardSetTextRequest calls the generic ClipboardSetText builder with application/json body +func NewClipboardSetTextRequest(server string, body ClipboardSetTextJSONRequestBody) (*http.Request, error) { + var bodyReader io.Reader + buf, err := json.Marshal(body) + if err != nil { + return nil, err + } + bodyReader = bytes.NewReader(buf) + return NewClipboardSetTextRequestWithBody(server, "application/json", bodyReader) +} + +// NewClipboardSetTextRequestWithBody generates requests for ClipboardSetText with any type of body +func NewClipboardSetTextRequestWithBody(server string, contentType string, body io.Reader) (*http.Request, error) { + var err error + + serverURL, err := url.Parse(server) + if err != nil { + return nil, err + } + + operationPath := fmt.Sprintf("/api/room/clipboard") + if operationPath[0] == '/' { + operationPath = "." + operationPath + } + + queryURL, err := serverURL.Parse(operationPath) + if err != nil { + return nil, err + } + + req, err := http.NewRequest("POST", queryURL.String(), body) + if err != nil { + return nil, err + } + + req.Header.Add("Content-Type", contentType) + + return req, nil +} + +// NewClipboardGetImageRequest generates requests for ClipboardGetImage +func NewClipboardGetImageRequest(server string) (*http.Request, error) { + var err error + + serverURL, err := url.Parse(server) + if err != nil { + return nil, err + } + + operationPath := fmt.Sprintf("/api/room/clipboard/image.png") + if operationPath[0] == '/' { + operationPath = "." + operationPath + } + + queryURL, err := serverURL.Parse(operationPath) + if err != nil { + return nil, err + } + + req, err := http.NewRequest("GET", queryURL.String(), nil) + if err != nil { + return nil, err + } + + return req, nil +} + +// NewControlStatusRequest generates requests for ControlStatus +func NewControlStatusRequest(server string) (*http.Request, error) { + var err error + + serverURL, err := url.Parse(server) + if err != nil { + return nil, err + } + + operationPath := fmt.Sprintf("/api/room/control") + if operationPath[0] == '/' { + operationPath = "." + operationPath + } + + queryURL, err := serverURL.Parse(operationPath) + if err != nil { + return nil, err + } + + req, err := http.NewRequest("GET", queryURL.String(), nil) + if err != nil { + return nil, err + } + + return req, nil +} + +// NewControlGiveRequest generates requests for ControlGive +func NewControlGiveRequest(server string, sessionId string) (*http.Request, error) { + var err error + + var pathParam0 string + + pathParam0, err = runtime.StyleParamWithLocation("simple", false, "sessionId", runtime.ParamLocationPath, sessionId) + if err != nil { + return nil, err + } + + serverURL, err := url.Parse(server) + if err != nil { + return nil, err + } + + operationPath := fmt.Sprintf("/api/room/control/give/%s", pathParam0) + if operationPath[0] == '/' { + operationPath = "." + operationPath + } + + queryURL, err := serverURL.Parse(operationPath) + if err != nil { + return nil, err + } + + req, err := http.NewRequest("POST", queryURL.String(), nil) + if err != nil { + return nil, err + } + + return req, nil +} + +// NewControlReleaseRequest generates requests for ControlRelease +func NewControlReleaseRequest(server string) (*http.Request, error) { + var err error + + serverURL, err := url.Parse(server) + if err != nil { + return nil, err + } + + operationPath := fmt.Sprintf("/api/room/control/release") + if operationPath[0] == '/' { + operationPath = "." + operationPath + } + + queryURL, err := serverURL.Parse(operationPath) + if err != nil { + return nil, err + } + + req, err := http.NewRequest("POST", queryURL.String(), nil) + if err != nil { + return nil, err + } + + return req, nil +} + +// NewControlRequestRequest generates requests for ControlRequest +func NewControlRequestRequest(server string) (*http.Request, error) { + var err error + + serverURL, err := url.Parse(server) + if err != nil { + return nil, err + } + + operationPath := fmt.Sprintf("/api/room/control/request") + if operationPath[0] == '/' { + operationPath = "." + operationPath + } + + queryURL, err := serverURL.Parse(operationPath) + if err != nil { + return nil, err + } + + req, err := http.NewRequest("POST", queryURL.String(), nil) + if err != nil { + return nil, err + } + + return req, nil +} + +// NewControlResetRequest generates requests for ControlReset +func NewControlResetRequest(server string) (*http.Request, error) { + var err error + + serverURL, err := url.Parse(server) + if err != nil { + return nil, err + } + + operationPath := fmt.Sprintf("/api/room/control/reset") + if operationPath[0] == '/' { + operationPath = "." + operationPath + } + + queryURL, err := serverURL.Parse(operationPath) + if err != nil { + return nil, err + } + + req, err := http.NewRequest("POST", queryURL.String(), nil) + if err != nil { + return nil, err + } + + return req, nil +} + +// NewControlTakeRequest generates requests for ControlTake +func NewControlTakeRequest(server string) (*http.Request, error) { + var err error + + serverURL, err := url.Parse(server) + if err != nil { + return nil, err + } + + operationPath := fmt.Sprintf("/api/room/control/take") + if operationPath[0] == '/' { + operationPath = "." + operationPath + } + + queryURL, err := serverURL.Parse(operationPath) + if err != nil { + return nil, err + } + + req, err := http.NewRequest("POST", queryURL.String(), nil) + if err != nil { + return nil, err + } + + return req, nil +} + +// NewKeyboardMapGetRequest generates requests for KeyboardMapGet +func NewKeyboardMapGetRequest(server string) (*http.Request, error) { + var err error + + serverURL, err := url.Parse(server) + if err != nil { + return nil, err + } + + operationPath := fmt.Sprintf("/api/room/keyboard/map") + if operationPath[0] == '/' { + operationPath = "." + operationPath + } + + queryURL, err := serverURL.Parse(operationPath) + if err != nil { + return nil, err + } + + req, err := http.NewRequest("GET", queryURL.String(), nil) + if err != nil { + return nil, err + } + + return req, nil +} + +// NewKeyboardMapSetRequest calls the generic KeyboardMapSet builder with application/json body +func NewKeyboardMapSetRequest(server string, body KeyboardMapSetJSONRequestBody) (*http.Request, error) { + var bodyReader io.Reader + buf, err := json.Marshal(body) + if err != nil { + return nil, err + } + bodyReader = bytes.NewReader(buf) + return NewKeyboardMapSetRequestWithBody(server, "application/json", bodyReader) +} + +// NewKeyboardMapSetRequestWithBody generates requests for KeyboardMapSet with any type of body +func NewKeyboardMapSetRequestWithBody(server string, contentType string, body io.Reader) (*http.Request, error) { + var err error + + serverURL, err := url.Parse(server) + if err != nil { + return nil, err + } + + operationPath := fmt.Sprintf("/api/room/keyboard/map") + if operationPath[0] == '/' { + operationPath = "." + operationPath + } + + queryURL, err := serverURL.Parse(operationPath) + if err != nil { + return nil, err + } + + req, err := http.NewRequest("POST", queryURL.String(), body) + if err != nil { + return nil, err + } + + req.Header.Add("Content-Type", contentType) + + return req, nil +} + +// NewKeyboardModifiersGetRequest generates requests for KeyboardModifiersGet +func NewKeyboardModifiersGetRequest(server string) (*http.Request, error) { + var err error + + serverURL, err := url.Parse(server) + if err != nil { + return nil, err + } + + operationPath := fmt.Sprintf("/api/room/keyboard/modifiers") + if operationPath[0] == '/' { + operationPath = "." + operationPath + } + + queryURL, err := serverURL.Parse(operationPath) + if err != nil { + return nil, err + } + + req, err := http.NewRequest("GET", queryURL.String(), nil) + if err != nil { + return nil, err + } + + return req, nil +} + +// NewKeyboardModifiersSetRequest calls the generic KeyboardModifiersSet builder with application/json body +func NewKeyboardModifiersSetRequest(server string, body KeyboardModifiersSetJSONRequestBody) (*http.Request, error) { + var bodyReader io.Reader + buf, err := json.Marshal(body) + if err != nil { + return nil, err + } + bodyReader = bytes.NewReader(buf) + return NewKeyboardModifiersSetRequestWithBody(server, "application/json", bodyReader) +} + +// NewKeyboardModifiersSetRequestWithBody generates requests for KeyboardModifiersSet with any type of body +func NewKeyboardModifiersSetRequestWithBody(server string, contentType string, body io.Reader) (*http.Request, error) { + var err error + + serverURL, err := url.Parse(server) + if err != nil { + return nil, err + } + + operationPath := fmt.Sprintf("/api/room/keyboard/modifiers") + if operationPath[0] == '/' { + operationPath = "." + operationPath + } + + queryURL, err := serverURL.Parse(operationPath) + if err != nil { + return nil, err + } + + req, err := http.NewRequest("POST", queryURL.String(), body) + if err != nil { + return nil, err + } + + req.Header.Add("Content-Type", contentType) + + return req, nil +} + +// NewScreenConfigurationRequest generates requests for ScreenConfiguration +func NewScreenConfigurationRequest(server string) (*http.Request, error) { + var err error + + serverURL, err := url.Parse(server) + if err != nil { + return nil, err + } + + operationPath := fmt.Sprintf("/api/room/screen") + if operationPath[0] == '/' { + operationPath = "." + operationPath + } + + queryURL, err := serverURL.Parse(operationPath) + if err != nil { + return nil, err + } + + req, err := http.NewRequest("GET", queryURL.String(), nil) + if err != nil { + return nil, err + } + + return req, nil +} + +// NewScreenConfigurationChangeRequest calls the generic ScreenConfigurationChange builder with application/json body +func NewScreenConfigurationChangeRequest(server string, body ScreenConfigurationChangeJSONRequestBody) (*http.Request, error) { + var bodyReader io.Reader + buf, err := json.Marshal(body) + if err != nil { + return nil, err + } + bodyReader = bytes.NewReader(buf) + return NewScreenConfigurationChangeRequestWithBody(server, "application/json", bodyReader) +} + +// NewScreenConfigurationChangeRequestWithBody generates requests for ScreenConfigurationChange with any type of body +func NewScreenConfigurationChangeRequestWithBody(server string, contentType string, body io.Reader) (*http.Request, error) { + var err error + + serverURL, err := url.Parse(server) + if err != nil { + return nil, err + } + + operationPath := fmt.Sprintf("/api/room/screen") + if operationPath[0] == '/' { + operationPath = "." + operationPath + } + + queryURL, err := serverURL.Parse(operationPath) + if err != nil { + return nil, err + } + + req, err := http.NewRequest("POST", queryURL.String(), body) + if err != nil { + return nil, err + } + + req.Header.Add("Content-Type", contentType) + + return req, nil +} + +// NewScreenCastImageRequest generates requests for ScreenCastImage +func NewScreenCastImageRequest(server string) (*http.Request, error) { + var err error + + serverURL, err := url.Parse(server) + if err != nil { + return nil, err + } + + operationPath := fmt.Sprintf("/api/room/screen/cast.jpg") + if operationPath[0] == '/' { + operationPath = "." + operationPath + } + + queryURL, err := serverURL.Parse(operationPath) + if err != nil { + return nil, err + } + + req, err := http.NewRequest("GET", queryURL.String(), nil) + if err != nil { + return nil, err + } + + return req, nil +} + +// NewScreenConfigurationsListRequest generates requests for ScreenConfigurationsList +func NewScreenConfigurationsListRequest(server string) (*http.Request, error) { + var err error + + serverURL, err := url.Parse(server) + if err != nil { + return nil, err + } + + operationPath := fmt.Sprintf("/api/room/screen/configurations") + if operationPath[0] == '/' { + operationPath = "." + operationPath + } + + queryURL, err := serverURL.Parse(operationPath) + if err != nil { + return nil, err + } + + req, err := http.NewRequest("GET", queryURL.String(), nil) + if err != nil { + return nil, err + } + + return req, nil +} + +// NewScreenShotImageRequest generates requests for ScreenShotImage +func NewScreenShotImageRequest(server string, params *ScreenShotImageParams) (*http.Request, error) { + var err error + + serverURL, err := url.Parse(server) + if err != nil { + return nil, err + } + + operationPath := fmt.Sprintf("/api/room/screen/shot.jpg") + if operationPath[0] == '/' { + operationPath = "." + operationPath + } + + queryURL, err := serverURL.Parse(operationPath) + if err != nil { + return nil, err + } + + if params != nil { + queryValues := queryURL.Query() + + if params.Quality != nil { + + if queryFrag, err := runtime.StyleParamWithLocation("form", true, "quality", runtime.ParamLocationQuery, *params.Quality); err != nil { + return nil, err + } else if parsed, err := url.ParseQuery(queryFrag); err != nil { + return nil, err + } else { + for k, v := range parsed { + for _, v2 := range v { + queryValues.Add(k, v2) + } + } + } + + } + + queryURL.RawQuery = queryValues.Encode() + } + + req, err := http.NewRequest("GET", queryURL.String(), nil) + if err != nil { + return nil, err + } + + return req, nil +} + +// NewSettingsGetRequest generates requests for SettingsGet +func NewSettingsGetRequest(server string) (*http.Request, error) { + var err error + + serverURL, err := url.Parse(server) + if err != nil { + return nil, err + } + + operationPath := fmt.Sprintf("/api/room/settings") + if operationPath[0] == '/' { + operationPath = "." + operationPath + } + + queryURL, err := serverURL.Parse(operationPath) + if err != nil { + return nil, err + } + + req, err := http.NewRequest("GET", queryURL.String(), nil) + if err != nil { + return nil, err + } + + return req, nil +} + +// NewSettingsSetRequest calls the generic SettingsSet builder with application/json body +func NewSettingsSetRequest(server string, body SettingsSetJSONRequestBody) (*http.Request, error) { + var bodyReader io.Reader + buf, err := json.Marshal(body) + if err != nil { + return nil, err + } + bodyReader = bytes.NewReader(buf) + return NewSettingsSetRequestWithBody(server, "application/json", bodyReader) +} + +// NewSettingsSetRequestWithBody generates requests for SettingsSet with any type of body +func NewSettingsSetRequestWithBody(server string, contentType string, body io.Reader) (*http.Request, error) { + var err error + + serverURL, err := url.Parse(server) + if err != nil { + return nil, err + } + + operationPath := fmt.Sprintf("/api/room/settings") + if operationPath[0] == '/' { + operationPath = "." + operationPath + } + + queryURL, err := serverURL.Parse(operationPath) + if err != nil { + return nil, err + } + + req, err := http.NewRequest("POST", queryURL.String(), body) + if err != nil { + return nil, err + } + + req.Header.Add("Content-Type", contentType) + + return req, nil +} + +// NewUploadDialogCloseRequest generates requests for UploadDialogClose +func NewUploadDialogCloseRequest(server string) (*http.Request, error) { + var err error + + serverURL, err := url.Parse(server) + if err != nil { + return nil, err + } + + operationPath := fmt.Sprintf("/api/room/upload/dialog") + if operationPath[0] == '/' { + operationPath = "." + operationPath + } + + queryURL, err := serverURL.Parse(operationPath) + if err != nil { + return nil, err + } + + req, err := http.NewRequest("DELETE", queryURL.String(), nil) + if err != nil { + return nil, err + } + + return req, nil +} + +// NewUploadDialogRequestWithBody generates requests for UploadDialog with any type of body +func NewUploadDialogRequestWithBody(server string, contentType string, body io.Reader) (*http.Request, error) { + var err error + + serverURL, err := url.Parse(server) + if err != nil { + return nil, err + } + + operationPath := fmt.Sprintf("/api/room/upload/dialog") + if operationPath[0] == '/' { + operationPath = "." + operationPath + } + + queryURL, err := serverURL.Parse(operationPath) + if err != nil { + return nil, err + } + + req, err := http.NewRequest("POST", queryURL.String(), body) + if err != nil { + return nil, err + } + + req.Header.Add("Content-Type", contentType) + + return req, nil +} + +// NewUploadDropRequestWithBody generates requests for UploadDrop with any type of body +func NewUploadDropRequestWithBody(server string, contentType string, body io.Reader) (*http.Request, error) { + var err error + + serverURL, err := url.Parse(server) + if err != nil { + return nil, err + } + + operationPath := fmt.Sprintf("/api/room/upload/drop") + if operationPath[0] == '/' { + operationPath = "." + operationPath + } + + queryURL, err := serverURL.Parse(operationPath) + if err != nil { + return nil, err + } + + req, err := http.NewRequest("POST", queryURL.String(), body) + if err != nil { + return nil, err + } + + req.Header.Add("Content-Type", contentType) + + return req, nil +} + +// NewSessionsGetRequest generates requests for SessionsGet +func NewSessionsGetRequest(server string) (*http.Request, error) { + var err error + + serverURL, err := url.Parse(server) + if err != nil { + return nil, err + } + + operationPath := fmt.Sprintf("/api/sessions") + if operationPath[0] == '/' { + operationPath = "." + operationPath + } + + queryURL, err := serverURL.Parse(operationPath) + if err != nil { + return nil, err + } + + req, err := http.NewRequest("GET", queryURL.String(), nil) + if err != nil { + return nil, err + } + + return req, nil +} + +// NewSessionRemoveRequest generates requests for SessionRemove +func NewSessionRemoveRequest(server string, sessionId string) (*http.Request, error) { + var err error + + var pathParam0 string + + pathParam0, err = runtime.StyleParamWithLocation("simple", false, "sessionId", runtime.ParamLocationPath, sessionId) + if err != nil { + return nil, err + } + + serverURL, err := url.Parse(server) + if err != nil { + return nil, err + } + + operationPath := fmt.Sprintf("/api/sessions/%s", pathParam0) + if operationPath[0] == '/' { + operationPath = "." + operationPath + } + + queryURL, err := serverURL.Parse(operationPath) + if err != nil { + return nil, err + } + + req, err := http.NewRequest("DELETE", queryURL.String(), nil) + if err != nil { + return nil, err + } + + return req, nil +} + +// NewSessionGetRequest generates requests for SessionGet +func NewSessionGetRequest(server string, sessionId string) (*http.Request, error) { + var err error + + var pathParam0 string + + pathParam0, err = runtime.StyleParamWithLocation("simple", false, "sessionId", runtime.ParamLocationPath, sessionId) + if err != nil { + return nil, err + } + + serverURL, err := url.Parse(server) + if err != nil { + return nil, err + } + + operationPath := fmt.Sprintf("/api/sessions/%s", pathParam0) + if operationPath[0] == '/' { + operationPath = "." + operationPath + } + + queryURL, err := serverURL.Parse(operationPath) + if err != nil { + return nil, err + } + + req, err := http.NewRequest("GET", queryURL.String(), nil) + if err != nil { + return nil, err + } + + return req, nil +} + +// NewSessionDisconnectRequest generates requests for SessionDisconnect +func NewSessionDisconnectRequest(server string, sessionId string) (*http.Request, error) { + var err error + + var pathParam0 string + + pathParam0, err = runtime.StyleParamWithLocation("simple", false, "sessionId", runtime.ParamLocationPath, sessionId) + if err != nil { + return nil, err + } + + serverURL, err := url.Parse(server) + if err != nil { + return nil, err + } + + operationPath := fmt.Sprintf("/api/sessions/%s/disconnect", pathParam0) + if operationPath[0] == '/' { + operationPath = "." + operationPath + } + + queryURL, err := serverURL.Parse(operationPath) + if err != nil { + return nil, err + } + + req, err := http.NewRequest("POST", queryURL.String(), nil) + if err != nil { + return nil, err + } + + return req, nil +} + +// NewStatsRequest generates requests for Stats +func NewStatsRequest(server string) (*http.Request, error) { + var err error + + serverURL, err := url.Parse(server) + if err != nil { + return nil, err + } + + operationPath := fmt.Sprintf("/api/stats") + if operationPath[0] == '/' { + operationPath = "." + operationPath + } + + queryURL, err := serverURL.Parse(operationPath) + if err != nil { + return nil, err + } + + req, err := http.NewRequest("GET", queryURL.String(), nil) + if err != nil { + return nil, err + } + + return req, nil +} + +// NewWhoamiRequest generates requests for Whoami +func NewWhoamiRequest(server string) (*http.Request, error) { + var err error + + serverURL, err := url.Parse(server) + if err != nil { + return nil, err + } + + operationPath := fmt.Sprintf("/api/whoami") + if operationPath[0] == '/' { + operationPath = "." + operationPath + } + + queryURL, err := serverURL.Parse(operationPath) + if err != nil { + return nil, err + } + + req, err := http.NewRequest("GET", queryURL.String(), nil) + if err != nil { + return nil, err + } + + return req, nil +} + +// NewHealthcheckRequest generates requests for Healthcheck +func NewHealthcheckRequest(server string) (*http.Request, error) { + var err error + + serverURL, err := url.Parse(server) + if err != nil { + return nil, err + } + + operationPath := fmt.Sprintf("/health") + if operationPath[0] == '/' { + operationPath = "." + operationPath + } + + queryURL, err := serverURL.Parse(operationPath) + if err != nil { + return nil, err + } + + req, err := http.NewRequest("GET", queryURL.String(), nil) + if err != nil { + return nil, err + } + + return req, nil +} + +// NewMetricsRequest generates requests for Metrics +func NewMetricsRequest(server string) (*http.Request, error) { + var err error + + serverURL, err := url.Parse(server) + if err != nil { + return nil, err + } + + operationPath := fmt.Sprintf("/metrics") + if operationPath[0] == '/' { + operationPath = "." + operationPath + } + + queryURL, err := serverURL.Parse(operationPath) + if err != nil { + return nil, err + } + + req, err := http.NewRequest("GET", queryURL.String(), nil) + if err != nil { + return nil, err + } + + return req, nil +} + +func (c *Client) applyEditors(ctx context.Context, req *http.Request, additionalEditors []RequestEditorFn) error { + for _, r := range c.RequestEditors { + if err := r(ctx, req); err != nil { + return err + } + } + for _, r := range additionalEditors { + if err := r(ctx, req); err != nil { + return err + } + } + return nil +} + +// ClientWithResponses builds on ClientInterface to offer response payloads +type ClientWithResponses struct { + ClientInterface +} + +// NewClientWithResponses creates a new ClientWithResponses, which wraps +// Client with return type handling +func NewClientWithResponses(server string, opts ...ClientOption) (*ClientWithResponses, error) { + client, err := NewClient(server, opts...) + if err != nil { + return nil, err + } + return &ClientWithResponses{client}, nil +} + +// WithBaseURL overrides the baseURL. +func WithBaseURL(baseURL string) ClientOption { + return func(c *Client) error { + newBaseURL, err := url.Parse(baseURL) + if err != nil { + return err + } + c.Server = newBaseURL.String() + return nil + } +} + +// ClientWithResponsesInterface is the interface specification for the client with responses above. +type ClientWithResponsesInterface interface { + // BatchWithBodyWithResponse request with any body + BatchWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*BatchResponse, error) + + BatchWithResponse(ctx context.Context, body BatchJSONRequestBody, reqEditors ...RequestEditorFn) (*BatchResponse, error) + + // LoginWithBodyWithResponse request with any body + LoginWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*LoginResponse, error) + + LoginWithResponse(ctx context.Context, body LoginJSONRequestBody, reqEditors ...RequestEditorFn) (*LoginResponse, error) + + // LogoutWithResponse request + LogoutWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*LogoutResponse, error) + + // MembersListWithResponse request + MembersListWithResponse(ctx context.Context, params *MembersListParams, reqEditors ...RequestEditorFn) (*MembersListResponse, error) + + // MembersCreateWithBodyWithResponse request with any body + MembersCreateWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*MembersCreateResponse, error) + + MembersCreateWithResponse(ctx context.Context, body MembersCreateJSONRequestBody, reqEditors ...RequestEditorFn) (*MembersCreateResponse, error) + + // MembersRemoveWithResponse request + MembersRemoveWithResponse(ctx context.Context, memberId string, reqEditors ...RequestEditorFn) (*MembersRemoveResponse, error) + + // MembersGetProfileWithResponse request + MembersGetProfileWithResponse(ctx context.Context, memberId string, reqEditors ...RequestEditorFn) (*MembersGetProfileResponse, error) + + // MembersUpdateProfileWithBodyWithResponse request with any body + MembersUpdateProfileWithBodyWithResponse(ctx context.Context, memberId string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*MembersUpdateProfileResponse, error) + + MembersUpdateProfileWithResponse(ctx context.Context, memberId string, body MembersUpdateProfileJSONRequestBody, reqEditors ...RequestEditorFn) (*MembersUpdateProfileResponse, error) + + // MembersUpdatePasswordWithBodyWithResponse request with any body + MembersUpdatePasswordWithBodyWithResponse(ctx context.Context, memberId string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*MembersUpdatePasswordResponse, error) + + MembersUpdatePasswordWithResponse(ctx context.Context, memberId string, body MembersUpdatePasswordJSONRequestBody, reqEditors ...RequestEditorFn) (*MembersUpdatePasswordResponse, error) + + // MembersBulkDeleteWithBodyWithResponse request with any body + MembersBulkDeleteWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*MembersBulkDeleteResponse, error) + + MembersBulkDeleteWithResponse(ctx context.Context, body MembersBulkDeleteJSONRequestBody, reqEditors ...RequestEditorFn) (*MembersBulkDeleteResponse, error) + + // MembersBulkUpdateWithBodyWithResponse request with any body + MembersBulkUpdateWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*MembersBulkUpdateResponse, error) + + MembersBulkUpdateWithResponse(ctx context.Context, body MembersBulkUpdateJSONRequestBody, reqEditors ...RequestEditorFn) (*MembersBulkUpdateResponse, error) + + // ProfileWithBodyWithResponse request with any body + ProfileWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*ProfileResponse, error) + + ProfileWithResponse(ctx context.Context, body ProfileJSONRequestBody, reqEditors ...RequestEditorFn) (*ProfileResponse, error) + + // BroadcastStatusWithResponse request + BroadcastStatusWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*BroadcastStatusResponse, error) + + // BroadcastStartWithBodyWithResponse request with any body + BroadcastStartWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*BroadcastStartResponse, error) + + BroadcastStartWithResponse(ctx context.Context, body BroadcastStartJSONRequestBody, reqEditors ...RequestEditorFn) (*BroadcastStartResponse, error) + + // BroadcastStopWithResponse request + BroadcastStopWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*BroadcastStopResponse, error) + + // ClipboardGetTextWithResponse request + ClipboardGetTextWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*ClipboardGetTextResponse, error) + + // ClipboardSetTextWithBodyWithResponse request with any body + ClipboardSetTextWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*ClipboardSetTextResponse, error) + + ClipboardSetTextWithResponse(ctx context.Context, body ClipboardSetTextJSONRequestBody, reqEditors ...RequestEditorFn) (*ClipboardSetTextResponse, error) + + // ClipboardGetImageWithResponse request + ClipboardGetImageWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*ClipboardGetImageResponse, error) + + // ControlStatusWithResponse request + ControlStatusWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*ControlStatusResponse, error) + + // ControlGiveWithResponse request + ControlGiveWithResponse(ctx context.Context, sessionId string, reqEditors ...RequestEditorFn) (*ControlGiveResponse, error) + + // ControlReleaseWithResponse request + ControlReleaseWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*ControlReleaseResponse, error) + + // ControlRequestWithResponse request + ControlRequestWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*ControlRequestResponse, error) + + // ControlResetWithResponse request + ControlResetWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*ControlResetResponse, error) + + // ControlTakeWithResponse request + ControlTakeWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*ControlTakeResponse, error) + + // KeyboardMapGetWithResponse request + KeyboardMapGetWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*KeyboardMapGetResponse, error) + + // KeyboardMapSetWithBodyWithResponse request with any body + KeyboardMapSetWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*KeyboardMapSetResponse, error) + + KeyboardMapSetWithResponse(ctx context.Context, body KeyboardMapSetJSONRequestBody, reqEditors ...RequestEditorFn) (*KeyboardMapSetResponse, error) + + // KeyboardModifiersGetWithResponse request + KeyboardModifiersGetWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*KeyboardModifiersGetResponse, error) + + // KeyboardModifiersSetWithBodyWithResponse request with any body + KeyboardModifiersSetWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*KeyboardModifiersSetResponse, error) + + KeyboardModifiersSetWithResponse(ctx context.Context, body KeyboardModifiersSetJSONRequestBody, reqEditors ...RequestEditorFn) (*KeyboardModifiersSetResponse, error) + + // ScreenConfigurationWithResponse request + ScreenConfigurationWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*ScreenConfigurationResponse, error) + + // ScreenConfigurationChangeWithBodyWithResponse request with any body + ScreenConfigurationChangeWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*ScreenConfigurationChangeResponse, error) + + ScreenConfigurationChangeWithResponse(ctx context.Context, body ScreenConfigurationChangeJSONRequestBody, reqEditors ...RequestEditorFn) (*ScreenConfigurationChangeResponse, error) + + // ScreenCastImageWithResponse request + ScreenCastImageWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*ScreenCastImageResponse, error) + + // ScreenConfigurationsListWithResponse request + ScreenConfigurationsListWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*ScreenConfigurationsListResponse, error) + + // ScreenShotImageWithResponse request + ScreenShotImageWithResponse(ctx context.Context, params *ScreenShotImageParams, reqEditors ...RequestEditorFn) (*ScreenShotImageResponse, error) + + // SettingsGetWithResponse request + SettingsGetWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*SettingsGetResponse, error) + + // SettingsSetWithBodyWithResponse request with any body + SettingsSetWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*SettingsSetResponse, error) + + SettingsSetWithResponse(ctx context.Context, body SettingsSetJSONRequestBody, reqEditors ...RequestEditorFn) (*SettingsSetResponse, error) + + // UploadDialogCloseWithResponse request + UploadDialogCloseWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*UploadDialogCloseResponse, error) + + // UploadDialogWithBodyWithResponse request with any body + UploadDialogWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*UploadDialogResponse, error) + + // UploadDropWithBodyWithResponse request with any body + UploadDropWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*UploadDropResponse, error) + + // SessionsGetWithResponse request + SessionsGetWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*SessionsGetResponse, error) + + // SessionRemoveWithResponse request + SessionRemoveWithResponse(ctx context.Context, sessionId string, reqEditors ...RequestEditorFn) (*SessionRemoveResponse, error) + + // SessionGetWithResponse request + SessionGetWithResponse(ctx context.Context, sessionId string, reqEditors ...RequestEditorFn) (*SessionGetResponse, error) + + // SessionDisconnectWithResponse request + SessionDisconnectWithResponse(ctx context.Context, sessionId string, reqEditors ...RequestEditorFn) (*SessionDisconnectResponse, error) + + // StatsWithResponse request + StatsWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*StatsResponse, error) + + // WhoamiWithResponse request + WhoamiWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*WhoamiResponse, error) + + // HealthcheckWithResponse request + HealthcheckWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*HealthcheckResponse, error) + + // MetricsWithResponse request + MetricsWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*MetricsResponse, error) +} + +type BatchResponse struct { + Body []byte + HTTPResponse *http.Response + JSON200 *[]BatchItem +} + +// Status returns HTTPResponse.Status +func (r BatchResponse) Status() string { + if r.HTTPResponse != nil { + return r.HTTPResponse.Status + } + return http.StatusText(0) +} + +// StatusCode returns HTTPResponse.StatusCode +func (r BatchResponse) StatusCode() int { + if r.HTTPResponse != nil { + return r.HTTPResponse.StatusCode + } + return 0 +} + +type LoginResponse struct { + Body []byte + HTTPResponse *http.Response + JSON200 *SessionLoginResponse + JSON401 *Unauthorized + JSON403 *Forbidden +} + +// Status returns HTTPResponse.Status +func (r LoginResponse) Status() string { + if r.HTTPResponse != nil { + return r.HTTPResponse.Status + } + return http.StatusText(0) +} + +// StatusCode returns HTTPResponse.StatusCode +func (r LoginResponse) StatusCode() int { + if r.HTTPResponse != nil { + return r.HTTPResponse.StatusCode + } + return 0 +} + +type LogoutResponse struct { + Body []byte + HTTPResponse *http.Response + JSON401 *Unauthorized +} + +// Status returns HTTPResponse.Status +func (r LogoutResponse) Status() string { + if r.HTTPResponse != nil { + return r.HTTPResponse.Status + } + return http.StatusText(0) +} + +// StatusCode returns HTTPResponse.StatusCode +func (r LogoutResponse) StatusCode() int { + if r.HTTPResponse != nil { + return r.HTTPResponse.StatusCode + } + return 0 +} + +type MembersListResponse struct { + Body []byte + HTTPResponse *http.Response + JSON200 *[]MemberData + JSON401 *Unauthorized + JSON403 *Forbidden +} + +// Status returns HTTPResponse.Status +func (r MembersListResponse) Status() string { + if r.HTTPResponse != nil { + return r.HTTPResponse.Status + } + return http.StatusText(0) +} + +// StatusCode returns HTTPResponse.StatusCode +func (r MembersListResponse) StatusCode() int { + if r.HTTPResponse != nil { + return r.HTTPResponse.StatusCode + } + return 0 +} + +type MembersCreateResponse struct { + Body []byte + HTTPResponse *http.Response + JSON200 *MemberData + JSON401 *Unauthorized + JSON403 *Forbidden + JSON422 *ErrorMessage +} + +// Status returns HTTPResponse.Status +func (r MembersCreateResponse) Status() string { + if r.HTTPResponse != nil { + return r.HTTPResponse.Status + } + return http.StatusText(0) +} + +// StatusCode returns HTTPResponse.StatusCode +func (r MembersCreateResponse) StatusCode() int { + if r.HTTPResponse != nil { + return r.HTTPResponse.StatusCode + } + return 0 +} + +type MembersRemoveResponse struct { + Body []byte + HTTPResponse *http.Response + JSON401 *Unauthorized + JSON403 *Forbidden + JSON404 *NotFound +} + +// Status returns HTTPResponse.Status +func (r MembersRemoveResponse) Status() string { + if r.HTTPResponse != nil { + return r.HTTPResponse.Status + } + return http.StatusText(0) +} + +// StatusCode returns HTTPResponse.StatusCode +func (r MembersRemoveResponse) StatusCode() int { + if r.HTTPResponse != nil { + return r.HTTPResponse.StatusCode + } + return 0 +} + +type MembersGetProfileResponse struct { + Body []byte + HTTPResponse *http.Response + JSON200 *MemberProfile + JSON401 *Unauthorized + JSON403 *Forbidden + JSON404 *NotFound +} + +// Status returns HTTPResponse.Status +func (r MembersGetProfileResponse) Status() string { + if r.HTTPResponse != nil { + return r.HTTPResponse.Status + } + return http.StatusText(0) +} + +// StatusCode returns HTTPResponse.StatusCode +func (r MembersGetProfileResponse) StatusCode() int { + if r.HTTPResponse != nil { + return r.HTTPResponse.StatusCode + } + return 0 +} + +type MembersUpdateProfileResponse struct { + Body []byte + HTTPResponse *http.Response + JSON401 *Unauthorized + JSON403 *Forbidden + JSON404 *NotFound +} + +// Status returns HTTPResponse.Status +func (r MembersUpdateProfileResponse) Status() string { + if r.HTTPResponse != nil { + return r.HTTPResponse.Status + } + return http.StatusText(0) +} + +// StatusCode returns HTTPResponse.StatusCode +func (r MembersUpdateProfileResponse) StatusCode() int { + if r.HTTPResponse != nil { + return r.HTTPResponse.StatusCode + } + return 0 +} + +type MembersUpdatePasswordResponse struct { + Body []byte + HTTPResponse *http.Response + JSON401 *Unauthorized + JSON403 *Forbidden + JSON404 *NotFound +} + +// Status returns HTTPResponse.Status +func (r MembersUpdatePasswordResponse) Status() string { + if r.HTTPResponse != nil { + return r.HTTPResponse.Status + } + return http.StatusText(0) +} + +// StatusCode returns HTTPResponse.StatusCode +func (r MembersUpdatePasswordResponse) StatusCode() int { + if r.HTTPResponse != nil { + return r.HTTPResponse.StatusCode + } + return 0 +} + +type MembersBulkDeleteResponse struct { + Body []byte + HTTPResponse *http.Response + JSON401 *Unauthorized + JSON403 *Forbidden + JSON404 *NotFound +} + +// Status returns HTTPResponse.Status +func (r MembersBulkDeleteResponse) Status() string { + if r.HTTPResponse != nil { + return r.HTTPResponse.Status + } + return http.StatusText(0) +} + +// StatusCode returns HTTPResponse.StatusCode +func (r MembersBulkDeleteResponse) StatusCode() int { + if r.HTTPResponse != nil { + return r.HTTPResponse.StatusCode + } + return 0 +} + +type MembersBulkUpdateResponse struct { + Body []byte + HTTPResponse *http.Response + JSON401 *Unauthorized + JSON403 *Forbidden + JSON404 *NotFound +} + +// Status returns HTTPResponse.Status +func (r MembersBulkUpdateResponse) Status() string { + if r.HTTPResponse != nil { + return r.HTTPResponse.Status + } + return http.StatusText(0) +} + +// StatusCode returns HTTPResponse.StatusCode +func (r MembersBulkUpdateResponse) StatusCode() int { + if r.HTTPResponse != nil { + return r.HTTPResponse.StatusCode + } + return 0 +} + +type ProfileResponse struct { + Body []byte + HTTPResponse *http.Response + JSON401 *Unauthorized +} + +// Status returns HTTPResponse.Status +func (r ProfileResponse) Status() string { + if r.HTTPResponse != nil { + return r.HTTPResponse.Status + } + return http.StatusText(0) +} + +// StatusCode returns HTTPResponse.StatusCode +func (r ProfileResponse) StatusCode() int { + if r.HTTPResponse != nil { + return r.HTTPResponse.StatusCode + } + return 0 +} + +type BroadcastStatusResponse struct { + Body []byte + HTTPResponse *http.Response + JSON200 *BroadcastStatus + JSON401 *Unauthorized + JSON403 *Forbidden +} + +// Status returns HTTPResponse.Status +func (r BroadcastStatusResponse) Status() string { + if r.HTTPResponse != nil { + return r.HTTPResponse.Status + } + return http.StatusText(0) +} + +// StatusCode returns HTTPResponse.StatusCode +func (r BroadcastStatusResponse) StatusCode() int { + if r.HTTPResponse != nil { + return r.HTTPResponse.StatusCode + } + return 0 +} + +type BroadcastStartResponse struct { + Body []byte + HTTPResponse *http.Response + JSON400 *ErrorMessage + JSON401 *Unauthorized + JSON403 *Forbidden + JSON422 *ErrorMessage + JSON500 *ErrorMessage +} + +// Status returns HTTPResponse.Status +func (r BroadcastStartResponse) Status() string { + if r.HTTPResponse != nil { + return r.HTTPResponse.Status + } + return http.StatusText(0) +} + +// StatusCode returns HTTPResponse.StatusCode +func (r BroadcastStartResponse) StatusCode() int { + if r.HTTPResponse != nil { + return r.HTTPResponse.StatusCode + } + return 0 +} + +type BroadcastStopResponse struct { + Body []byte + HTTPResponse *http.Response + JSON401 *Unauthorized + JSON403 *Forbidden + JSON422 *ErrorMessage +} + +// Status returns HTTPResponse.Status +func (r BroadcastStopResponse) Status() string { + if r.HTTPResponse != nil { + return r.HTTPResponse.Status + } + return http.StatusText(0) +} + +// StatusCode returns HTTPResponse.StatusCode +func (r BroadcastStopResponse) StatusCode() int { + if r.HTTPResponse != nil { + return r.HTTPResponse.StatusCode + } + return 0 +} + +type ClipboardGetTextResponse struct { + Body []byte + HTTPResponse *http.Response + JSON200 *ClipboardText + JSON401 *Unauthorized + JSON403 *Forbidden + JSON500 *ErrorMessage +} + +// Status returns HTTPResponse.Status +func (r ClipboardGetTextResponse) Status() string { + if r.HTTPResponse != nil { + return r.HTTPResponse.Status + } + return http.StatusText(0) +} + +// StatusCode returns HTTPResponse.StatusCode +func (r ClipboardGetTextResponse) StatusCode() int { + if r.HTTPResponse != nil { + return r.HTTPResponse.StatusCode + } + return 0 +} + +type ClipboardSetTextResponse struct { + Body []byte + HTTPResponse *http.Response + JSON401 *Unauthorized + JSON403 *Forbidden + JSON500 *ErrorMessage +} + +// Status returns HTTPResponse.Status +func (r ClipboardSetTextResponse) Status() string { + if r.HTTPResponse != nil { + return r.HTTPResponse.Status + } + return http.StatusText(0) +} + +// StatusCode returns HTTPResponse.StatusCode +func (r ClipboardSetTextResponse) StatusCode() int { + if r.HTTPResponse != nil { + return r.HTTPResponse.StatusCode + } + return 0 +} + +type ClipboardGetImageResponse struct { + Body []byte + HTTPResponse *http.Response + JSON401 *Unauthorized + JSON403 *Forbidden + JSON500 *ErrorMessage +} + +// Status returns HTTPResponse.Status +func (r ClipboardGetImageResponse) Status() string { + if r.HTTPResponse != nil { + return r.HTTPResponse.Status + } + return http.StatusText(0) +} + +// StatusCode returns HTTPResponse.StatusCode +func (r ClipboardGetImageResponse) StatusCode() int { + if r.HTTPResponse != nil { + return r.HTTPResponse.StatusCode + } + return 0 +} + +type ControlStatusResponse struct { + Body []byte + HTTPResponse *http.Response + JSON200 *ControlStatus + JSON401 *Unauthorized + JSON403 *Forbidden +} + +// Status returns HTTPResponse.Status +func (r ControlStatusResponse) Status() string { + if r.HTTPResponse != nil { + return r.HTTPResponse.Status + } + return http.StatusText(0) +} + +// StatusCode returns HTTPResponse.StatusCode +func (r ControlStatusResponse) StatusCode() int { + if r.HTTPResponse != nil { + return r.HTTPResponse.StatusCode + } + return 0 +} + +type ControlGiveResponse struct { + Body []byte + HTTPResponse *http.Response + JSON400 *ErrorMessage + JSON401 *Unauthorized + JSON403 *Forbidden + JSON404 *NotFound +} + +// Status returns HTTPResponse.Status +func (r ControlGiveResponse) Status() string { + if r.HTTPResponse != nil { + return r.HTTPResponse.Status + } + return http.StatusText(0) +} + +// StatusCode returns HTTPResponse.StatusCode +func (r ControlGiveResponse) StatusCode() int { + if r.HTTPResponse != nil { + return r.HTTPResponse.StatusCode + } + return 0 +} + +type ControlReleaseResponse struct { + Body []byte + HTTPResponse *http.Response + JSON401 *Unauthorized + JSON403 *Forbidden + JSON422 *ErrorMessage +} + +// Status returns HTTPResponse.Status +func (r ControlReleaseResponse) Status() string { + if r.HTTPResponse != nil { + return r.HTTPResponse.Status + } + return http.StatusText(0) +} + +// StatusCode returns HTTPResponse.StatusCode +func (r ControlReleaseResponse) StatusCode() int { + if r.HTTPResponse != nil { + return r.HTTPResponse.StatusCode + } + return 0 +} + +type ControlRequestResponse struct { + Body []byte + HTTPResponse *http.Response + JSON401 *Unauthorized + JSON403 *Forbidden + JSON422 *ErrorMessage +} + +// Status returns HTTPResponse.Status +func (r ControlRequestResponse) Status() string { + if r.HTTPResponse != nil { + return r.HTTPResponse.Status + } + return http.StatusText(0) +} + +// StatusCode returns HTTPResponse.StatusCode +func (r ControlRequestResponse) StatusCode() int { + if r.HTTPResponse != nil { + return r.HTTPResponse.StatusCode + } + return 0 +} + +type ControlResetResponse struct { + Body []byte + HTTPResponse *http.Response + JSON401 *Unauthorized + JSON403 *Forbidden +} + +// Status returns HTTPResponse.Status +func (r ControlResetResponse) Status() string { + if r.HTTPResponse != nil { + return r.HTTPResponse.Status + } + return http.StatusText(0) +} + +// StatusCode returns HTTPResponse.StatusCode +func (r ControlResetResponse) StatusCode() int { + if r.HTTPResponse != nil { + return r.HTTPResponse.StatusCode + } + return 0 +} + +type ControlTakeResponse struct { + Body []byte + HTTPResponse *http.Response + JSON401 *Unauthorized + JSON403 *Forbidden +} + +// Status returns HTTPResponse.Status +func (r ControlTakeResponse) Status() string { + if r.HTTPResponse != nil { + return r.HTTPResponse.Status + } + return http.StatusText(0) +} + +// StatusCode returns HTTPResponse.StatusCode +func (r ControlTakeResponse) StatusCode() int { + if r.HTTPResponse != nil { + return r.HTTPResponse.StatusCode + } + return 0 +} + +type KeyboardMapGetResponse struct { + Body []byte + HTTPResponse *http.Response + JSON200 *KeyboardMap + JSON401 *Unauthorized + JSON403 *Forbidden + JSON500 *ErrorMessage +} + +// Status returns HTTPResponse.Status +func (r KeyboardMapGetResponse) Status() string { + if r.HTTPResponse != nil { + return r.HTTPResponse.Status + } + return http.StatusText(0) +} + +// StatusCode returns HTTPResponse.StatusCode +func (r KeyboardMapGetResponse) StatusCode() int { + if r.HTTPResponse != nil { + return r.HTTPResponse.StatusCode + } + return 0 +} + +type KeyboardMapSetResponse struct { + Body []byte + HTTPResponse *http.Response + JSON401 *Unauthorized + JSON403 *Forbidden + JSON500 *ErrorMessage +} + +// Status returns HTTPResponse.Status +func (r KeyboardMapSetResponse) Status() string { + if r.HTTPResponse != nil { + return r.HTTPResponse.Status + } + return http.StatusText(0) +} + +// StatusCode returns HTTPResponse.StatusCode +func (r KeyboardMapSetResponse) StatusCode() int { + if r.HTTPResponse != nil { + return r.HTTPResponse.StatusCode + } + return 0 +} + +type KeyboardModifiersGetResponse struct { + Body []byte + HTTPResponse *http.Response + JSON200 *KeyboardModifiers + JSON401 *Unauthorized + JSON403 *Forbidden +} + +// Status returns HTTPResponse.Status +func (r KeyboardModifiersGetResponse) Status() string { + if r.HTTPResponse != nil { + return r.HTTPResponse.Status + } + return http.StatusText(0) +} + +// StatusCode returns HTTPResponse.StatusCode +func (r KeyboardModifiersGetResponse) StatusCode() int { + if r.HTTPResponse != nil { + return r.HTTPResponse.StatusCode + } + return 0 +} + +type KeyboardModifiersSetResponse struct { + Body []byte + HTTPResponse *http.Response + JSON401 *Unauthorized + JSON403 *Forbidden +} + +// Status returns HTTPResponse.Status +func (r KeyboardModifiersSetResponse) Status() string { + if r.HTTPResponse != nil { + return r.HTTPResponse.Status + } + return http.StatusText(0) +} + +// StatusCode returns HTTPResponse.StatusCode +func (r KeyboardModifiersSetResponse) StatusCode() int { + if r.HTTPResponse != nil { + return r.HTTPResponse.StatusCode + } + return 0 +} + +type ScreenConfigurationResponse struct { + Body []byte + HTTPResponse *http.Response + JSON200 *ScreenConfiguration + JSON401 *Unauthorized + JSON403 *Forbidden + JSON500 *ErrorMessage +} + +// Status returns HTTPResponse.Status +func (r ScreenConfigurationResponse) Status() string { + if r.HTTPResponse != nil { + return r.HTTPResponse.Status + } + return http.StatusText(0) +} + +// StatusCode returns HTTPResponse.StatusCode +func (r ScreenConfigurationResponse) StatusCode() int { + if r.HTTPResponse != nil { + return r.HTTPResponse.StatusCode + } + return 0 +} + +type ScreenConfigurationChangeResponse struct { + Body []byte + HTTPResponse *http.Response + JSON200 *ScreenConfiguration + JSON401 *Unauthorized + JSON403 *Forbidden + JSON422 *ErrorMessage +} + +// Status returns HTTPResponse.Status +func (r ScreenConfigurationChangeResponse) Status() string { + if r.HTTPResponse != nil { + return r.HTTPResponse.Status + } + return http.StatusText(0) +} + +// StatusCode returns HTTPResponse.StatusCode +func (r ScreenConfigurationChangeResponse) StatusCode() int { + if r.HTTPResponse != nil { + return r.HTTPResponse.StatusCode + } + return 0 +} + +type ScreenCastImageResponse struct { + Body []byte + HTTPResponse *http.Response + JSON400 *ErrorMessage + JSON401 *Unauthorized + JSON403 *Forbidden + JSON500 *ErrorMessage +} + +// Status returns HTTPResponse.Status +func (r ScreenCastImageResponse) Status() string { + if r.HTTPResponse != nil { + return r.HTTPResponse.Status + } + return http.StatusText(0) +} + +// StatusCode returns HTTPResponse.StatusCode +func (r ScreenCastImageResponse) StatusCode() int { + if r.HTTPResponse != nil { + return r.HTTPResponse.StatusCode + } + return 0 +} + +type ScreenConfigurationsListResponse struct { + Body []byte + HTTPResponse *http.Response + JSON200 *[]ScreenConfiguration + JSON401 *Unauthorized + JSON403 *Forbidden +} + +// Status returns HTTPResponse.Status +func (r ScreenConfigurationsListResponse) Status() string { + if r.HTTPResponse != nil { + return r.HTTPResponse.Status + } + return http.StatusText(0) +} + +// StatusCode returns HTTPResponse.StatusCode +func (r ScreenConfigurationsListResponse) StatusCode() int { + if r.HTTPResponse != nil { + return r.HTTPResponse.StatusCode + } + return 0 +} + +type ScreenShotImageResponse struct { + Body []byte + HTTPResponse *http.Response + JSON401 *Unauthorized + JSON403 *Forbidden + JSON500 *ErrorMessage +} + +// Status returns HTTPResponse.Status +func (r ScreenShotImageResponse) Status() string { + if r.HTTPResponse != nil { + return r.HTTPResponse.Status + } + return http.StatusText(0) +} + +// StatusCode returns HTTPResponse.StatusCode +func (r ScreenShotImageResponse) StatusCode() int { + if r.HTTPResponse != nil { + return r.HTTPResponse.StatusCode + } + return 0 +} + +type SettingsGetResponse struct { + Body []byte + HTTPResponse *http.Response + JSON200 *Settings + JSON401 *Unauthorized + JSON403 *Forbidden +} + +// Status returns HTTPResponse.Status +func (r SettingsGetResponse) Status() string { + if r.HTTPResponse != nil { + return r.HTTPResponse.Status + } + return http.StatusText(0) +} + +// StatusCode returns HTTPResponse.StatusCode +func (r SettingsGetResponse) StatusCode() int { + if r.HTTPResponse != nil { + return r.HTTPResponse.StatusCode + } + return 0 +} + +type SettingsSetResponse struct { + Body []byte + HTTPResponse *http.Response + JSON401 *Unauthorized + JSON403 *Forbidden +} + +// Status returns HTTPResponse.Status +func (r SettingsSetResponse) Status() string { + if r.HTTPResponse != nil { + return r.HTTPResponse.Status + } + return http.StatusText(0) +} + +// StatusCode returns HTTPResponse.StatusCode +func (r SettingsSetResponse) StatusCode() int { + if r.HTTPResponse != nil { + return r.HTTPResponse.StatusCode + } + return 0 +} + +type UploadDialogCloseResponse struct { + Body []byte + HTTPResponse *http.Response + JSON401 *Unauthorized + JSON403 *Forbidden + JSON422 *ErrorMessage +} + +// Status returns HTTPResponse.Status +func (r UploadDialogCloseResponse) Status() string { + if r.HTTPResponse != nil { + return r.HTTPResponse.Status + } + return http.StatusText(0) +} + +// StatusCode returns HTTPResponse.StatusCode +func (r UploadDialogCloseResponse) StatusCode() int { + if r.HTTPResponse != nil { + return r.HTTPResponse.StatusCode + } + return 0 +} + +type UploadDialogResponse struct { + Body []byte + HTTPResponse *http.Response + JSON400 *ErrorMessage + JSON401 *Unauthorized + JSON403 *Forbidden + JSON422 *ErrorMessage + JSON500 *ErrorMessage +} + +// Status returns HTTPResponse.Status +func (r UploadDialogResponse) Status() string { + if r.HTTPResponse != nil { + return r.HTTPResponse.Status + } + return http.StatusText(0) +} + +// StatusCode returns HTTPResponse.StatusCode +func (r UploadDialogResponse) StatusCode() int { + if r.HTTPResponse != nil { + return r.HTTPResponse.StatusCode + } + return 0 +} + +type UploadDropResponse struct { + Body []byte + HTTPResponse *http.Response + JSON400 *ErrorMessage + JSON401 *Unauthorized + JSON403 *Forbidden + JSON500 *ErrorMessage +} + +// Status returns HTTPResponse.Status +func (r UploadDropResponse) Status() string { + if r.HTTPResponse != nil { + return r.HTTPResponse.Status + } + return http.StatusText(0) +} + +// StatusCode returns HTTPResponse.StatusCode +func (r UploadDropResponse) StatusCode() int { + if r.HTTPResponse != nil { + return r.HTTPResponse.StatusCode + } + return 0 +} + +type SessionsGetResponse struct { + Body []byte + HTTPResponse *http.Response + JSON200 *[]SessionData + JSON401 *Unauthorized + JSON403 *Forbidden +} + +// Status returns HTTPResponse.Status +func (r SessionsGetResponse) Status() string { + if r.HTTPResponse != nil { + return r.HTTPResponse.Status + } + return http.StatusText(0) +} + +// StatusCode returns HTTPResponse.StatusCode +func (r SessionsGetResponse) StatusCode() int { + if r.HTTPResponse != nil { + return r.HTTPResponse.StatusCode + } + return 0 +} + +type SessionRemoveResponse struct { + Body []byte + HTTPResponse *http.Response + JSON401 *Unauthorized + JSON403 *Forbidden + JSON404 *NotFound +} + +// Status returns HTTPResponse.Status +func (r SessionRemoveResponse) Status() string { + if r.HTTPResponse != nil { + return r.HTTPResponse.Status + } + return http.StatusText(0) +} + +// StatusCode returns HTTPResponse.StatusCode +func (r SessionRemoveResponse) StatusCode() int { + if r.HTTPResponse != nil { + return r.HTTPResponse.StatusCode + } + return 0 +} + +type SessionGetResponse struct { + Body []byte + HTTPResponse *http.Response + JSON200 *SessionData + JSON401 *Unauthorized + JSON403 *Forbidden + JSON404 *NotFound +} + +// Status returns HTTPResponse.Status +func (r SessionGetResponse) Status() string { + if r.HTTPResponse != nil { + return r.HTTPResponse.Status + } + return http.StatusText(0) +} + +// StatusCode returns HTTPResponse.StatusCode +func (r SessionGetResponse) StatusCode() int { + if r.HTTPResponse != nil { + return r.HTTPResponse.StatusCode + } + return 0 +} + +type SessionDisconnectResponse struct { + Body []byte + HTTPResponse *http.Response + JSON401 *Unauthorized + JSON403 *Forbidden + JSON404 *NotFound +} + +// Status returns HTTPResponse.Status +func (r SessionDisconnectResponse) Status() string { + if r.HTTPResponse != nil { + return r.HTTPResponse.Status + } + return http.StatusText(0) +} + +// StatusCode returns HTTPResponse.StatusCode +func (r SessionDisconnectResponse) StatusCode() int { + if r.HTTPResponse != nil { + return r.HTTPResponse.StatusCode + } + return 0 +} + +type StatsResponse struct { + Body []byte + HTTPResponse *http.Response + JSON200 *Stats + JSON401 *Unauthorized + JSON403 *Forbidden +} + +// Status returns HTTPResponse.Status +func (r StatsResponse) Status() string { + if r.HTTPResponse != nil { + return r.HTTPResponse.Status + } + return http.StatusText(0) +} + +// StatusCode returns HTTPResponse.StatusCode +func (r StatsResponse) StatusCode() int { + if r.HTTPResponse != nil { + return r.HTTPResponse.StatusCode + } + return 0 +} + +type WhoamiResponse struct { + Body []byte + HTTPResponse *http.Response + JSON200 *SessionData + JSON401 *Unauthorized + JSON403 *Forbidden +} + +// Status returns HTTPResponse.Status +func (r WhoamiResponse) Status() string { + if r.HTTPResponse != nil { + return r.HTTPResponse.Status + } + return http.StatusText(0) +} + +// StatusCode returns HTTPResponse.StatusCode +func (r WhoamiResponse) StatusCode() int { + if r.HTTPResponse != nil { + return r.HTTPResponse.StatusCode + } + return 0 +} + +type HealthcheckResponse struct { + Body []byte + HTTPResponse *http.Response +} + +// Status returns HTTPResponse.Status +func (r HealthcheckResponse) Status() string { + if r.HTTPResponse != nil { + return r.HTTPResponse.Status + } + return http.StatusText(0) +} + +// StatusCode returns HTTPResponse.StatusCode +func (r HealthcheckResponse) StatusCode() int { + if r.HTTPResponse != nil { + return r.HTTPResponse.StatusCode + } + return 0 +} + +type MetricsResponse struct { + Body []byte + HTTPResponse *http.Response +} + +// Status returns HTTPResponse.Status +func (r MetricsResponse) Status() string { + if r.HTTPResponse != nil { + return r.HTTPResponse.Status + } + return http.StatusText(0) +} + +// StatusCode returns HTTPResponse.StatusCode +func (r MetricsResponse) StatusCode() int { + if r.HTTPResponse != nil { + return r.HTTPResponse.StatusCode + } + return 0 +} + +// BatchWithBodyWithResponse request with arbitrary body returning *BatchResponse +func (c *ClientWithResponses) BatchWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*BatchResponse, error) { + rsp, err := c.BatchWithBody(ctx, contentType, body, reqEditors...) + if err != nil { + return nil, err + } + return ParseBatchResponse(rsp) +} + +func (c *ClientWithResponses) BatchWithResponse(ctx context.Context, body BatchJSONRequestBody, reqEditors ...RequestEditorFn) (*BatchResponse, error) { + rsp, err := c.Batch(ctx, body, reqEditors...) + if err != nil { + return nil, err + } + return ParseBatchResponse(rsp) +} + +// LoginWithBodyWithResponse request with arbitrary body returning *LoginResponse +func (c *ClientWithResponses) LoginWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*LoginResponse, error) { + rsp, err := c.LoginWithBody(ctx, contentType, body, reqEditors...) + if err != nil { + return nil, err + } + return ParseLoginResponse(rsp) +} + +func (c *ClientWithResponses) LoginWithResponse(ctx context.Context, body LoginJSONRequestBody, reqEditors ...RequestEditorFn) (*LoginResponse, error) { + rsp, err := c.Login(ctx, body, reqEditors...) + if err != nil { + return nil, err + } + return ParseLoginResponse(rsp) +} + +// LogoutWithResponse request returning *LogoutResponse +func (c *ClientWithResponses) LogoutWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*LogoutResponse, error) { + rsp, err := c.Logout(ctx, reqEditors...) + if err != nil { + return nil, err + } + return ParseLogoutResponse(rsp) +} + +// MembersListWithResponse request returning *MembersListResponse +func (c *ClientWithResponses) MembersListWithResponse(ctx context.Context, params *MembersListParams, reqEditors ...RequestEditorFn) (*MembersListResponse, error) { + rsp, err := c.MembersList(ctx, params, reqEditors...) + if err != nil { + return nil, err + } + return ParseMembersListResponse(rsp) +} + +// MembersCreateWithBodyWithResponse request with arbitrary body returning *MembersCreateResponse +func (c *ClientWithResponses) MembersCreateWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*MembersCreateResponse, error) { + rsp, err := c.MembersCreateWithBody(ctx, contentType, body, reqEditors...) + if err != nil { + return nil, err + } + return ParseMembersCreateResponse(rsp) +} + +func (c *ClientWithResponses) MembersCreateWithResponse(ctx context.Context, body MembersCreateJSONRequestBody, reqEditors ...RequestEditorFn) (*MembersCreateResponse, error) { + rsp, err := c.MembersCreate(ctx, body, reqEditors...) + if err != nil { + return nil, err + } + return ParseMembersCreateResponse(rsp) +} + +// MembersRemoveWithResponse request returning *MembersRemoveResponse +func (c *ClientWithResponses) MembersRemoveWithResponse(ctx context.Context, memberId string, reqEditors ...RequestEditorFn) (*MembersRemoveResponse, error) { + rsp, err := c.MembersRemove(ctx, memberId, reqEditors...) + if err != nil { + return nil, err + } + return ParseMembersRemoveResponse(rsp) +} + +// MembersGetProfileWithResponse request returning *MembersGetProfileResponse +func (c *ClientWithResponses) MembersGetProfileWithResponse(ctx context.Context, memberId string, reqEditors ...RequestEditorFn) (*MembersGetProfileResponse, error) { + rsp, err := c.MembersGetProfile(ctx, memberId, reqEditors...) + if err != nil { + return nil, err + } + return ParseMembersGetProfileResponse(rsp) +} + +// MembersUpdateProfileWithBodyWithResponse request with arbitrary body returning *MembersUpdateProfileResponse +func (c *ClientWithResponses) MembersUpdateProfileWithBodyWithResponse(ctx context.Context, memberId string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*MembersUpdateProfileResponse, error) { + rsp, err := c.MembersUpdateProfileWithBody(ctx, memberId, contentType, body, reqEditors...) + if err != nil { + return nil, err + } + return ParseMembersUpdateProfileResponse(rsp) +} + +func (c *ClientWithResponses) MembersUpdateProfileWithResponse(ctx context.Context, memberId string, body MembersUpdateProfileJSONRequestBody, reqEditors ...RequestEditorFn) (*MembersUpdateProfileResponse, error) { + rsp, err := c.MembersUpdateProfile(ctx, memberId, body, reqEditors...) + if err != nil { + return nil, err + } + return ParseMembersUpdateProfileResponse(rsp) +} + +// MembersUpdatePasswordWithBodyWithResponse request with arbitrary body returning *MembersUpdatePasswordResponse +func (c *ClientWithResponses) MembersUpdatePasswordWithBodyWithResponse(ctx context.Context, memberId string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*MembersUpdatePasswordResponse, error) { + rsp, err := c.MembersUpdatePasswordWithBody(ctx, memberId, contentType, body, reqEditors...) + if err != nil { + return nil, err + } + return ParseMembersUpdatePasswordResponse(rsp) +} + +func (c *ClientWithResponses) MembersUpdatePasswordWithResponse(ctx context.Context, memberId string, body MembersUpdatePasswordJSONRequestBody, reqEditors ...RequestEditorFn) (*MembersUpdatePasswordResponse, error) { + rsp, err := c.MembersUpdatePassword(ctx, memberId, body, reqEditors...) + if err != nil { + return nil, err + } + return ParseMembersUpdatePasswordResponse(rsp) +} + +// MembersBulkDeleteWithBodyWithResponse request with arbitrary body returning *MembersBulkDeleteResponse +func (c *ClientWithResponses) MembersBulkDeleteWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*MembersBulkDeleteResponse, error) { + rsp, err := c.MembersBulkDeleteWithBody(ctx, contentType, body, reqEditors...) + if err != nil { + return nil, err + } + return ParseMembersBulkDeleteResponse(rsp) +} + +func (c *ClientWithResponses) MembersBulkDeleteWithResponse(ctx context.Context, body MembersBulkDeleteJSONRequestBody, reqEditors ...RequestEditorFn) (*MembersBulkDeleteResponse, error) { + rsp, err := c.MembersBulkDelete(ctx, body, reqEditors...) + if err != nil { + return nil, err + } + return ParseMembersBulkDeleteResponse(rsp) +} + +// MembersBulkUpdateWithBodyWithResponse request with arbitrary body returning *MembersBulkUpdateResponse +func (c *ClientWithResponses) MembersBulkUpdateWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*MembersBulkUpdateResponse, error) { + rsp, err := c.MembersBulkUpdateWithBody(ctx, contentType, body, reqEditors...) + if err != nil { + return nil, err + } + return ParseMembersBulkUpdateResponse(rsp) +} + +func (c *ClientWithResponses) MembersBulkUpdateWithResponse(ctx context.Context, body MembersBulkUpdateJSONRequestBody, reqEditors ...RequestEditorFn) (*MembersBulkUpdateResponse, error) { + rsp, err := c.MembersBulkUpdate(ctx, body, reqEditors...) + if err != nil { + return nil, err + } + return ParseMembersBulkUpdateResponse(rsp) +} + +// ProfileWithBodyWithResponse request with arbitrary body returning *ProfileResponse +func (c *ClientWithResponses) ProfileWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*ProfileResponse, error) { + rsp, err := c.ProfileWithBody(ctx, contentType, body, reqEditors...) + if err != nil { + return nil, err + } + return ParseProfileResponse(rsp) +} + +func (c *ClientWithResponses) ProfileWithResponse(ctx context.Context, body ProfileJSONRequestBody, reqEditors ...RequestEditorFn) (*ProfileResponse, error) { + rsp, err := c.Profile(ctx, body, reqEditors...) + if err != nil { + return nil, err + } + return ParseProfileResponse(rsp) +} + +// BroadcastStatusWithResponse request returning *BroadcastStatusResponse +func (c *ClientWithResponses) BroadcastStatusWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*BroadcastStatusResponse, error) { + rsp, err := c.BroadcastStatus(ctx, reqEditors...) + if err != nil { + return nil, err + } + return ParseBroadcastStatusResponse(rsp) +} + +// BroadcastStartWithBodyWithResponse request with arbitrary body returning *BroadcastStartResponse +func (c *ClientWithResponses) BroadcastStartWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*BroadcastStartResponse, error) { + rsp, err := c.BroadcastStartWithBody(ctx, contentType, body, reqEditors...) + if err != nil { + return nil, err + } + return ParseBroadcastStartResponse(rsp) +} + +func (c *ClientWithResponses) BroadcastStartWithResponse(ctx context.Context, body BroadcastStartJSONRequestBody, reqEditors ...RequestEditorFn) (*BroadcastStartResponse, error) { + rsp, err := c.BroadcastStart(ctx, body, reqEditors...) + if err != nil { + return nil, err + } + return ParseBroadcastStartResponse(rsp) +} + +// BroadcastStopWithResponse request returning *BroadcastStopResponse +func (c *ClientWithResponses) BroadcastStopWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*BroadcastStopResponse, error) { + rsp, err := c.BroadcastStop(ctx, reqEditors...) + if err != nil { + return nil, err + } + return ParseBroadcastStopResponse(rsp) +} + +// ClipboardGetTextWithResponse request returning *ClipboardGetTextResponse +func (c *ClientWithResponses) ClipboardGetTextWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*ClipboardGetTextResponse, error) { + rsp, err := c.ClipboardGetText(ctx, reqEditors...) + if err != nil { + return nil, err + } + return ParseClipboardGetTextResponse(rsp) +} + +// ClipboardSetTextWithBodyWithResponse request with arbitrary body returning *ClipboardSetTextResponse +func (c *ClientWithResponses) ClipboardSetTextWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*ClipboardSetTextResponse, error) { + rsp, err := c.ClipboardSetTextWithBody(ctx, contentType, body, reqEditors...) + if err != nil { + return nil, err + } + return ParseClipboardSetTextResponse(rsp) +} + +func (c *ClientWithResponses) ClipboardSetTextWithResponse(ctx context.Context, body ClipboardSetTextJSONRequestBody, reqEditors ...RequestEditorFn) (*ClipboardSetTextResponse, error) { + rsp, err := c.ClipboardSetText(ctx, body, reqEditors...) + if err != nil { + return nil, err + } + return ParseClipboardSetTextResponse(rsp) +} + +// ClipboardGetImageWithResponse request returning *ClipboardGetImageResponse +func (c *ClientWithResponses) ClipboardGetImageWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*ClipboardGetImageResponse, error) { + rsp, err := c.ClipboardGetImage(ctx, reqEditors...) + if err != nil { + return nil, err + } + return ParseClipboardGetImageResponse(rsp) +} + +// ControlStatusWithResponse request returning *ControlStatusResponse +func (c *ClientWithResponses) ControlStatusWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*ControlStatusResponse, error) { + rsp, err := c.ControlStatus(ctx, reqEditors...) + if err != nil { + return nil, err + } + return ParseControlStatusResponse(rsp) +} + +// ControlGiveWithResponse request returning *ControlGiveResponse +func (c *ClientWithResponses) ControlGiveWithResponse(ctx context.Context, sessionId string, reqEditors ...RequestEditorFn) (*ControlGiveResponse, error) { + rsp, err := c.ControlGive(ctx, sessionId, reqEditors...) + if err != nil { + return nil, err + } + return ParseControlGiveResponse(rsp) +} + +// ControlReleaseWithResponse request returning *ControlReleaseResponse +func (c *ClientWithResponses) ControlReleaseWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*ControlReleaseResponse, error) { + rsp, err := c.ControlRelease(ctx, reqEditors...) + if err != nil { + return nil, err + } + return ParseControlReleaseResponse(rsp) +} + +// ControlRequestWithResponse request returning *ControlRequestResponse +func (c *ClientWithResponses) ControlRequestWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*ControlRequestResponse, error) { + rsp, err := c.ControlRequest(ctx, reqEditors...) + if err != nil { + return nil, err + } + return ParseControlRequestResponse(rsp) +} + +// ControlResetWithResponse request returning *ControlResetResponse +func (c *ClientWithResponses) ControlResetWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*ControlResetResponse, error) { + rsp, err := c.ControlReset(ctx, reqEditors...) + if err != nil { + return nil, err + } + return ParseControlResetResponse(rsp) +} + +// ControlTakeWithResponse request returning *ControlTakeResponse +func (c *ClientWithResponses) ControlTakeWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*ControlTakeResponse, error) { + rsp, err := c.ControlTake(ctx, reqEditors...) + if err != nil { + return nil, err + } + return ParseControlTakeResponse(rsp) +} + +// KeyboardMapGetWithResponse request returning *KeyboardMapGetResponse +func (c *ClientWithResponses) KeyboardMapGetWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*KeyboardMapGetResponse, error) { + rsp, err := c.KeyboardMapGet(ctx, reqEditors...) + if err != nil { + return nil, err + } + return ParseKeyboardMapGetResponse(rsp) +} + +// KeyboardMapSetWithBodyWithResponse request with arbitrary body returning *KeyboardMapSetResponse +func (c *ClientWithResponses) KeyboardMapSetWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*KeyboardMapSetResponse, error) { + rsp, err := c.KeyboardMapSetWithBody(ctx, contentType, body, reqEditors...) + if err != nil { + return nil, err + } + return ParseKeyboardMapSetResponse(rsp) +} + +func (c *ClientWithResponses) KeyboardMapSetWithResponse(ctx context.Context, body KeyboardMapSetJSONRequestBody, reqEditors ...RequestEditorFn) (*KeyboardMapSetResponse, error) { + rsp, err := c.KeyboardMapSet(ctx, body, reqEditors...) + if err != nil { + return nil, err + } + return ParseKeyboardMapSetResponse(rsp) +} + +// KeyboardModifiersGetWithResponse request returning *KeyboardModifiersGetResponse +func (c *ClientWithResponses) KeyboardModifiersGetWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*KeyboardModifiersGetResponse, error) { + rsp, err := c.KeyboardModifiersGet(ctx, reqEditors...) + if err != nil { + return nil, err + } + return ParseKeyboardModifiersGetResponse(rsp) +} + +// KeyboardModifiersSetWithBodyWithResponse request with arbitrary body returning *KeyboardModifiersSetResponse +func (c *ClientWithResponses) KeyboardModifiersSetWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*KeyboardModifiersSetResponse, error) { + rsp, err := c.KeyboardModifiersSetWithBody(ctx, contentType, body, reqEditors...) + if err != nil { + return nil, err + } + return ParseKeyboardModifiersSetResponse(rsp) +} + +func (c *ClientWithResponses) KeyboardModifiersSetWithResponse(ctx context.Context, body KeyboardModifiersSetJSONRequestBody, reqEditors ...RequestEditorFn) (*KeyboardModifiersSetResponse, error) { + rsp, err := c.KeyboardModifiersSet(ctx, body, reqEditors...) + if err != nil { + return nil, err + } + return ParseKeyboardModifiersSetResponse(rsp) +} + +// ScreenConfigurationWithResponse request returning *ScreenConfigurationResponse +func (c *ClientWithResponses) ScreenConfigurationWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*ScreenConfigurationResponse, error) { + rsp, err := c.ScreenConfiguration(ctx, reqEditors...) + if err != nil { + return nil, err + } + return ParseScreenConfigurationResponse(rsp) +} + +// ScreenConfigurationChangeWithBodyWithResponse request with arbitrary body returning *ScreenConfigurationChangeResponse +func (c *ClientWithResponses) ScreenConfigurationChangeWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*ScreenConfigurationChangeResponse, error) { + rsp, err := c.ScreenConfigurationChangeWithBody(ctx, contentType, body, reqEditors...) + if err != nil { + return nil, err + } + return ParseScreenConfigurationChangeResponse(rsp) +} + +func (c *ClientWithResponses) ScreenConfigurationChangeWithResponse(ctx context.Context, body ScreenConfigurationChangeJSONRequestBody, reqEditors ...RequestEditorFn) (*ScreenConfigurationChangeResponse, error) { + rsp, err := c.ScreenConfigurationChange(ctx, body, reqEditors...) + if err != nil { + return nil, err + } + return ParseScreenConfigurationChangeResponse(rsp) +} + +// ScreenCastImageWithResponse request returning *ScreenCastImageResponse +func (c *ClientWithResponses) ScreenCastImageWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*ScreenCastImageResponse, error) { + rsp, err := c.ScreenCastImage(ctx, reqEditors...) + if err != nil { + return nil, err + } + return ParseScreenCastImageResponse(rsp) +} + +// ScreenConfigurationsListWithResponse request returning *ScreenConfigurationsListResponse +func (c *ClientWithResponses) ScreenConfigurationsListWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*ScreenConfigurationsListResponse, error) { + rsp, err := c.ScreenConfigurationsList(ctx, reqEditors...) + if err != nil { + return nil, err + } + return ParseScreenConfigurationsListResponse(rsp) +} + +// ScreenShotImageWithResponse request returning *ScreenShotImageResponse +func (c *ClientWithResponses) ScreenShotImageWithResponse(ctx context.Context, params *ScreenShotImageParams, reqEditors ...RequestEditorFn) (*ScreenShotImageResponse, error) { + rsp, err := c.ScreenShotImage(ctx, params, reqEditors...) + if err != nil { + return nil, err + } + return ParseScreenShotImageResponse(rsp) +} + +// SettingsGetWithResponse request returning *SettingsGetResponse +func (c *ClientWithResponses) SettingsGetWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*SettingsGetResponse, error) { + rsp, err := c.SettingsGet(ctx, reqEditors...) + if err != nil { + return nil, err + } + return ParseSettingsGetResponse(rsp) +} + +// SettingsSetWithBodyWithResponse request with arbitrary body returning *SettingsSetResponse +func (c *ClientWithResponses) SettingsSetWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*SettingsSetResponse, error) { + rsp, err := c.SettingsSetWithBody(ctx, contentType, body, reqEditors...) + if err != nil { + return nil, err + } + return ParseSettingsSetResponse(rsp) +} + +func (c *ClientWithResponses) SettingsSetWithResponse(ctx context.Context, body SettingsSetJSONRequestBody, reqEditors ...RequestEditorFn) (*SettingsSetResponse, error) { + rsp, err := c.SettingsSet(ctx, body, reqEditors...) + if err != nil { + return nil, err + } + return ParseSettingsSetResponse(rsp) +} + +// UploadDialogCloseWithResponse request returning *UploadDialogCloseResponse +func (c *ClientWithResponses) UploadDialogCloseWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*UploadDialogCloseResponse, error) { + rsp, err := c.UploadDialogClose(ctx, reqEditors...) + if err != nil { + return nil, err + } + return ParseUploadDialogCloseResponse(rsp) +} + +// UploadDialogWithBodyWithResponse request with arbitrary body returning *UploadDialogResponse +func (c *ClientWithResponses) UploadDialogWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*UploadDialogResponse, error) { + rsp, err := c.UploadDialogWithBody(ctx, contentType, body, reqEditors...) + if err != nil { + return nil, err + } + return ParseUploadDialogResponse(rsp) +} + +// UploadDropWithBodyWithResponse request with arbitrary body returning *UploadDropResponse +func (c *ClientWithResponses) UploadDropWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*UploadDropResponse, error) { + rsp, err := c.UploadDropWithBody(ctx, contentType, body, reqEditors...) + if err != nil { + return nil, err + } + return ParseUploadDropResponse(rsp) +} + +// SessionsGetWithResponse request returning *SessionsGetResponse +func (c *ClientWithResponses) SessionsGetWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*SessionsGetResponse, error) { + rsp, err := c.SessionsGet(ctx, reqEditors...) + if err != nil { + return nil, err + } + return ParseSessionsGetResponse(rsp) +} + +// SessionRemoveWithResponse request returning *SessionRemoveResponse +func (c *ClientWithResponses) SessionRemoveWithResponse(ctx context.Context, sessionId string, reqEditors ...RequestEditorFn) (*SessionRemoveResponse, error) { + rsp, err := c.SessionRemove(ctx, sessionId, reqEditors...) + if err != nil { + return nil, err + } + return ParseSessionRemoveResponse(rsp) +} + +// SessionGetWithResponse request returning *SessionGetResponse +func (c *ClientWithResponses) SessionGetWithResponse(ctx context.Context, sessionId string, reqEditors ...RequestEditorFn) (*SessionGetResponse, error) { + rsp, err := c.SessionGet(ctx, sessionId, reqEditors...) + if err != nil { + return nil, err + } + return ParseSessionGetResponse(rsp) +} + +// SessionDisconnectWithResponse request returning *SessionDisconnectResponse +func (c *ClientWithResponses) SessionDisconnectWithResponse(ctx context.Context, sessionId string, reqEditors ...RequestEditorFn) (*SessionDisconnectResponse, error) { + rsp, err := c.SessionDisconnect(ctx, sessionId, reqEditors...) + if err != nil { + return nil, err + } + return ParseSessionDisconnectResponse(rsp) +} + +// StatsWithResponse request returning *StatsResponse +func (c *ClientWithResponses) StatsWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*StatsResponse, error) { + rsp, err := c.Stats(ctx, reqEditors...) + if err != nil { + return nil, err + } + return ParseStatsResponse(rsp) +} + +// WhoamiWithResponse request returning *WhoamiResponse +func (c *ClientWithResponses) WhoamiWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*WhoamiResponse, error) { + rsp, err := c.Whoami(ctx, reqEditors...) + if err != nil { + return nil, err + } + return ParseWhoamiResponse(rsp) +} + +// HealthcheckWithResponse request returning *HealthcheckResponse +func (c *ClientWithResponses) HealthcheckWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*HealthcheckResponse, error) { + rsp, err := c.Healthcheck(ctx, reqEditors...) + if err != nil { + return nil, err + } + return ParseHealthcheckResponse(rsp) +} + +// MetricsWithResponse request returning *MetricsResponse +func (c *ClientWithResponses) MetricsWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*MetricsResponse, error) { + rsp, err := c.Metrics(ctx, reqEditors...) + if err != nil { + return nil, err + } + return ParseMetricsResponse(rsp) +} + +// ParseBatchResponse parses an HTTP response from a BatchWithResponse call +func ParseBatchResponse(rsp *http.Response) (*BatchResponse, error) { + bodyBytes, err := io.ReadAll(rsp.Body) + defer func() { _ = rsp.Body.Close() }() + if err != nil { + return nil, err + } + + response := &BatchResponse{ + Body: bodyBytes, + HTTPResponse: rsp, + } + + switch { + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200: + var dest []BatchItem + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON200 = &dest + + } + + return response, nil +} + +// ParseLoginResponse parses an HTTP response from a LoginWithResponse call +func ParseLoginResponse(rsp *http.Response) (*LoginResponse, error) { + bodyBytes, err := io.ReadAll(rsp.Body) + defer func() { _ = rsp.Body.Close() }() + if err != nil { + return nil, err + } + + response := &LoginResponse{ + Body: bodyBytes, + HTTPResponse: rsp, + } + + switch { + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200: + var dest SessionLoginResponse + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON200 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401: + var dest Unauthorized + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON401 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403: + var dest Forbidden + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON403 = &dest + + } + + return response, nil +} + +// ParseLogoutResponse parses an HTTP response from a LogoutWithResponse call +func ParseLogoutResponse(rsp *http.Response) (*LogoutResponse, error) { + bodyBytes, err := io.ReadAll(rsp.Body) + defer func() { _ = rsp.Body.Close() }() + if err != nil { + return nil, err + } + + response := &LogoutResponse{ + Body: bodyBytes, + HTTPResponse: rsp, + } + + switch { + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401: + var dest Unauthorized + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON401 = &dest + + } + + return response, nil +} + +// ParseMembersListResponse parses an HTTP response from a MembersListWithResponse call +func ParseMembersListResponse(rsp *http.Response) (*MembersListResponse, error) { + bodyBytes, err := io.ReadAll(rsp.Body) + defer func() { _ = rsp.Body.Close() }() + if err != nil { + return nil, err + } + + response := &MembersListResponse{ + Body: bodyBytes, + HTTPResponse: rsp, + } + + switch { + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200: + var dest []MemberData + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON200 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401: + var dest Unauthorized + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON401 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403: + var dest Forbidden + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON403 = &dest + + } + + return response, nil +} + +// ParseMembersCreateResponse parses an HTTP response from a MembersCreateWithResponse call +func ParseMembersCreateResponse(rsp *http.Response) (*MembersCreateResponse, error) { + bodyBytes, err := io.ReadAll(rsp.Body) + defer func() { _ = rsp.Body.Close() }() + if err != nil { + return nil, err + } + + response := &MembersCreateResponse{ + Body: bodyBytes, + HTTPResponse: rsp, + } + + switch { + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200: + var dest MemberData + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON200 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401: + var dest Unauthorized + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON401 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403: + var dest Forbidden + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON403 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 422: + var dest ErrorMessage + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON422 = &dest + + } + + return response, nil +} + +// ParseMembersRemoveResponse parses an HTTP response from a MembersRemoveWithResponse call +func ParseMembersRemoveResponse(rsp *http.Response) (*MembersRemoveResponse, error) { + bodyBytes, err := io.ReadAll(rsp.Body) + defer func() { _ = rsp.Body.Close() }() + if err != nil { + return nil, err + } + + response := &MembersRemoveResponse{ + Body: bodyBytes, + HTTPResponse: rsp, + } + + switch { + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401: + var dest Unauthorized + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON401 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403: + var dest Forbidden + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON403 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404: + var dest NotFound + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON404 = &dest + + } + + return response, nil +} + +// ParseMembersGetProfileResponse parses an HTTP response from a MembersGetProfileWithResponse call +func ParseMembersGetProfileResponse(rsp *http.Response) (*MembersGetProfileResponse, error) { + bodyBytes, err := io.ReadAll(rsp.Body) + defer func() { _ = rsp.Body.Close() }() + if err != nil { + return nil, err + } + + response := &MembersGetProfileResponse{ + Body: bodyBytes, + HTTPResponse: rsp, + } + + switch { + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200: + var dest MemberProfile + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON200 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401: + var dest Unauthorized + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON401 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403: + var dest Forbidden + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON403 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404: + var dest NotFound + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON404 = &dest + + } + + return response, nil +} + +// ParseMembersUpdateProfileResponse parses an HTTP response from a MembersUpdateProfileWithResponse call +func ParseMembersUpdateProfileResponse(rsp *http.Response) (*MembersUpdateProfileResponse, error) { + bodyBytes, err := io.ReadAll(rsp.Body) + defer func() { _ = rsp.Body.Close() }() + if err != nil { + return nil, err + } + + response := &MembersUpdateProfileResponse{ + Body: bodyBytes, + HTTPResponse: rsp, + } + + switch { + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401: + var dest Unauthorized + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON401 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403: + var dest Forbidden + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON403 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404: + var dest NotFound + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON404 = &dest + + } + + return response, nil +} + +// ParseMembersUpdatePasswordResponse parses an HTTP response from a MembersUpdatePasswordWithResponse call +func ParseMembersUpdatePasswordResponse(rsp *http.Response) (*MembersUpdatePasswordResponse, error) { + bodyBytes, err := io.ReadAll(rsp.Body) + defer func() { _ = rsp.Body.Close() }() + if err != nil { + return nil, err + } + + response := &MembersUpdatePasswordResponse{ + Body: bodyBytes, + HTTPResponse: rsp, + } + + switch { + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401: + var dest Unauthorized + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON401 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403: + var dest Forbidden + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON403 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404: + var dest NotFound + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON404 = &dest + + } + + return response, nil +} + +// ParseMembersBulkDeleteResponse parses an HTTP response from a MembersBulkDeleteWithResponse call +func ParseMembersBulkDeleteResponse(rsp *http.Response) (*MembersBulkDeleteResponse, error) { + bodyBytes, err := io.ReadAll(rsp.Body) + defer func() { _ = rsp.Body.Close() }() + if err != nil { + return nil, err + } + + response := &MembersBulkDeleteResponse{ + Body: bodyBytes, + HTTPResponse: rsp, + } + + switch { + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401: + var dest Unauthorized + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON401 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403: + var dest Forbidden + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON403 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404: + var dest NotFound + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON404 = &dest + + } + + return response, nil +} + +// ParseMembersBulkUpdateResponse parses an HTTP response from a MembersBulkUpdateWithResponse call +func ParseMembersBulkUpdateResponse(rsp *http.Response) (*MembersBulkUpdateResponse, error) { + bodyBytes, err := io.ReadAll(rsp.Body) + defer func() { _ = rsp.Body.Close() }() + if err != nil { + return nil, err + } + + response := &MembersBulkUpdateResponse{ + Body: bodyBytes, + HTTPResponse: rsp, + } + + switch { + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401: + var dest Unauthorized + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON401 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403: + var dest Forbidden + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON403 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404: + var dest NotFound + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON404 = &dest + + } + + return response, nil +} + +// ParseProfileResponse parses an HTTP response from a ProfileWithResponse call +func ParseProfileResponse(rsp *http.Response) (*ProfileResponse, error) { + bodyBytes, err := io.ReadAll(rsp.Body) + defer func() { _ = rsp.Body.Close() }() + if err != nil { + return nil, err + } + + response := &ProfileResponse{ + Body: bodyBytes, + HTTPResponse: rsp, + } + + switch { + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401: + var dest Unauthorized + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON401 = &dest + + } + + return response, nil +} + +// ParseBroadcastStatusResponse parses an HTTP response from a BroadcastStatusWithResponse call +func ParseBroadcastStatusResponse(rsp *http.Response) (*BroadcastStatusResponse, error) { + bodyBytes, err := io.ReadAll(rsp.Body) + defer func() { _ = rsp.Body.Close() }() + if err != nil { + return nil, err + } + + response := &BroadcastStatusResponse{ + Body: bodyBytes, + HTTPResponse: rsp, + } + + switch { + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200: + var dest BroadcastStatus + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON200 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401: + var dest Unauthorized + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON401 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403: + var dest Forbidden + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON403 = &dest + + } + + return response, nil +} + +// ParseBroadcastStartResponse parses an HTTP response from a BroadcastStartWithResponse call +func ParseBroadcastStartResponse(rsp *http.Response) (*BroadcastStartResponse, error) { + bodyBytes, err := io.ReadAll(rsp.Body) + defer func() { _ = rsp.Body.Close() }() + if err != nil { + return nil, err + } + + response := &BroadcastStartResponse{ + Body: bodyBytes, + HTTPResponse: rsp, + } + + switch { + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400: + var dest ErrorMessage + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON400 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401: + var dest Unauthorized + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON401 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403: + var dest Forbidden + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON403 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 422: + var dest ErrorMessage + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON422 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500: + var dest ErrorMessage + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON500 = &dest + + } + + return response, nil +} + +// ParseBroadcastStopResponse parses an HTTP response from a BroadcastStopWithResponse call +func ParseBroadcastStopResponse(rsp *http.Response) (*BroadcastStopResponse, error) { + bodyBytes, err := io.ReadAll(rsp.Body) + defer func() { _ = rsp.Body.Close() }() + if err != nil { + return nil, err + } + + response := &BroadcastStopResponse{ + Body: bodyBytes, + HTTPResponse: rsp, + } + + switch { + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401: + var dest Unauthorized + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON401 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403: + var dest Forbidden + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON403 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 422: + var dest ErrorMessage + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON422 = &dest + + } + + return response, nil +} + +// ParseClipboardGetTextResponse parses an HTTP response from a ClipboardGetTextWithResponse call +func ParseClipboardGetTextResponse(rsp *http.Response) (*ClipboardGetTextResponse, error) { + bodyBytes, err := io.ReadAll(rsp.Body) + defer func() { _ = rsp.Body.Close() }() + if err != nil { + return nil, err + } + + response := &ClipboardGetTextResponse{ + Body: bodyBytes, + HTTPResponse: rsp, + } + + switch { + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200: + var dest ClipboardText + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON200 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401: + var dest Unauthorized + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON401 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403: + var dest Forbidden + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON403 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500: + var dest ErrorMessage + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON500 = &dest + + } + + return response, nil +} + +// ParseClipboardSetTextResponse parses an HTTP response from a ClipboardSetTextWithResponse call +func ParseClipboardSetTextResponse(rsp *http.Response) (*ClipboardSetTextResponse, error) { + bodyBytes, err := io.ReadAll(rsp.Body) + defer func() { _ = rsp.Body.Close() }() + if err != nil { + return nil, err + } + + response := &ClipboardSetTextResponse{ + Body: bodyBytes, + HTTPResponse: rsp, + } + + switch { + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401: + var dest Unauthorized + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON401 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403: + var dest Forbidden + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON403 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500: + var dest ErrorMessage + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON500 = &dest + + } + + return response, nil +} + +// ParseClipboardGetImageResponse parses an HTTP response from a ClipboardGetImageWithResponse call +func ParseClipboardGetImageResponse(rsp *http.Response) (*ClipboardGetImageResponse, error) { + bodyBytes, err := io.ReadAll(rsp.Body) + defer func() { _ = rsp.Body.Close() }() + if err != nil { + return nil, err + } + + response := &ClipboardGetImageResponse{ + Body: bodyBytes, + HTTPResponse: rsp, + } + + switch { + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401: + var dest Unauthorized + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON401 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403: + var dest Forbidden + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON403 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500: + var dest ErrorMessage + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON500 = &dest + + } + + return response, nil +} + +// ParseControlStatusResponse parses an HTTP response from a ControlStatusWithResponse call +func ParseControlStatusResponse(rsp *http.Response) (*ControlStatusResponse, error) { + bodyBytes, err := io.ReadAll(rsp.Body) + defer func() { _ = rsp.Body.Close() }() + if err != nil { + return nil, err + } + + response := &ControlStatusResponse{ + Body: bodyBytes, + HTTPResponse: rsp, + } + + switch { + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200: + var dest ControlStatus + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON200 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401: + var dest Unauthorized + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON401 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403: + var dest Forbidden + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON403 = &dest + + } + + return response, nil +} + +// ParseControlGiveResponse parses an HTTP response from a ControlGiveWithResponse call +func ParseControlGiveResponse(rsp *http.Response) (*ControlGiveResponse, error) { + bodyBytes, err := io.ReadAll(rsp.Body) + defer func() { _ = rsp.Body.Close() }() + if err != nil { + return nil, err + } + + response := &ControlGiveResponse{ + Body: bodyBytes, + HTTPResponse: rsp, + } + + switch { + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400: + var dest ErrorMessage + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON400 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401: + var dest Unauthorized + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON401 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403: + var dest Forbidden + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON403 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404: + var dest NotFound + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON404 = &dest + + } + + return response, nil +} + +// ParseControlReleaseResponse parses an HTTP response from a ControlReleaseWithResponse call +func ParseControlReleaseResponse(rsp *http.Response) (*ControlReleaseResponse, error) { + bodyBytes, err := io.ReadAll(rsp.Body) + defer func() { _ = rsp.Body.Close() }() + if err != nil { + return nil, err + } + + response := &ControlReleaseResponse{ + Body: bodyBytes, + HTTPResponse: rsp, + } + + switch { + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401: + var dest Unauthorized + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON401 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403: + var dest Forbidden + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON403 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 422: + var dest ErrorMessage + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON422 = &dest + + } + + return response, nil +} + +// ParseControlRequestResponse parses an HTTP response from a ControlRequestWithResponse call +func ParseControlRequestResponse(rsp *http.Response) (*ControlRequestResponse, error) { + bodyBytes, err := io.ReadAll(rsp.Body) + defer func() { _ = rsp.Body.Close() }() + if err != nil { + return nil, err + } + + response := &ControlRequestResponse{ + Body: bodyBytes, + HTTPResponse: rsp, + } + + switch { + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401: + var dest Unauthorized + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON401 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403: + var dest Forbidden + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON403 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 422: + var dest ErrorMessage + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON422 = &dest + + } + + return response, nil +} + +// ParseControlResetResponse parses an HTTP response from a ControlResetWithResponse call +func ParseControlResetResponse(rsp *http.Response) (*ControlResetResponse, error) { + bodyBytes, err := io.ReadAll(rsp.Body) + defer func() { _ = rsp.Body.Close() }() + if err != nil { + return nil, err + } + + response := &ControlResetResponse{ + Body: bodyBytes, + HTTPResponse: rsp, + } + + switch { + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401: + var dest Unauthorized + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON401 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403: + var dest Forbidden + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON403 = &dest + + } + + return response, nil +} + +// ParseControlTakeResponse parses an HTTP response from a ControlTakeWithResponse call +func ParseControlTakeResponse(rsp *http.Response) (*ControlTakeResponse, error) { + bodyBytes, err := io.ReadAll(rsp.Body) + defer func() { _ = rsp.Body.Close() }() + if err != nil { + return nil, err + } + + response := &ControlTakeResponse{ + Body: bodyBytes, + HTTPResponse: rsp, + } + + switch { + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401: + var dest Unauthorized + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON401 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403: + var dest Forbidden + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON403 = &dest + + } + + return response, nil +} + +// ParseKeyboardMapGetResponse parses an HTTP response from a KeyboardMapGetWithResponse call +func ParseKeyboardMapGetResponse(rsp *http.Response) (*KeyboardMapGetResponse, error) { + bodyBytes, err := io.ReadAll(rsp.Body) + defer func() { _ = rsp.Body.Close() }() + if err != nil { + return nil, err + } + + response := &KeyboardMapGetResponse{ + Body: bodyBytes, + HTTPResponse: rsp, + } + + switch { + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200: + var dest KeyboardMap + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON200 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401: + var dest Unauthorized + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON401 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403: + var dest Forbidden + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON403 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500: + var dest ErrorMessage + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON500 = &dest + + } + + return response, nil +} + +// ParseKeyboardMapSetResponse parses an HTTP response from a KeyboardMapSetWithResponse call +func ParseKeyboardMapSetResponse(rsp *http.Response) (*KeyboardMapSetResponse, error) { + bodyBytes, err := io.ReadAll(rsp.Body) + defer func() { _ = rsp.Body.Close() }() + if err != nil { + return nil, err + } + + response := &KeyboardMapSetResponse{ + Body: bodyBytes, + HTTPResponse: rsp, + } + + switch { + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401: + var dest Unauthorized + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON401 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403: + var dest Forbidden + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON403 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500: + var dest ErrorMessage + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON500 = &dest + + } + + return response, nil +} + +// ParseKeyboardModifiersGetResponse parses an HTTP response from a KeyboardModifiersGetWithResponse call +func ParseKeyboardModifiersGetResponse(rsp *http.Response) (*KeyboardModifiersGetResponse, error) { + bodyBytes, err := io.ReadAll(rsp.Body) + defer func() { _ = rsp.Body.Close() }() + if err != nil { + return nil, err + } + + response := &KeyboardModifiersGetResponse{ + Body: bodyBytes, + HTTPResponse: rsp, + } + + switch { + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200: + var dest KeyboardModifiers + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON200 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401: + var dest Unauthorized + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON401 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403: + var dest Forbidden + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON403 = &dest + + } + + return response, nil +} + +// ParseKeyboardModifiersSetResponse parses an HTTP response from a KeyboardModifiersSetWithResponse call +func ParseKeyboardModifiersSetResponse(rsp *http.Response) (*KeyboardModifiersSetResponse, error) { + bodyBytes, err := io.ReadAll(rsp.Body) + defer func() { _ = rsp.Body.Close() }() + if err != nil { + return nil, err + } + + response := &KeyboardModifiersSetResponse{ + Body: bodyBytes, + HTTPResponse: rsp, + } + + switch { + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401: + var dest Unauthorized + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON401 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403: + var dest Forbidden + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON403 = &dest + + } + + return response, nil +} + +// ParseScreenConfigurationResponse parses an HTTP response from a ScreenConfigurationWithResponse call +func ParseScreenConfigurationResponse(rsp *http.Response) (*ScreenConfigurationResponse, error) { + bodyBytes, err := io.ReadAll(rsp.Body) + defer func() { _ = rsp.Body.Close() }() + if err != nil { + return nil, err + } + + response := &ScreenConfigurationResponse{ + Body: bodyBytes, + HTTPResponse: rsp, + } + + switch { + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200: + var dest ScreenConfiguration + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON200 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401: + var dest Unauthorized + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON401 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403: + var dest Forbidden + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON403 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500: + var dest ErrorMessage + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON500 = &dest + + } + + return response, nil +} + +// ParseScreenConfigurationChangeResponse parses an HTTP response from a ScreenConfigurationChangeWithResponse call +func ParseScreenConfigurationChangeResponse(rsp *http.Response) (*ScreenConfigurationChangeResponse, error) { + bodyBytes, err := io.ReadAll(rsp.Body) + defer func() { _ = rsp.Body.Close() }() + if err != nil { + return nil, err + } + + response := &ScreenConfigurationChangeResponse{ + Body: bodyBytes, + HTTPResponse: rsp, + } + + switch { + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200: + var dest ScreenConfiguration + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON200 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401: + var dest Unauthorized + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON401 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403: + var dest Forbidden + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON403 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 422: + var dest ErrorMessage + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON422 = &dest + + } + + return response, nil +} + +// ParseScreenCastImageResponse parses an HTTP response from a ScreenCastImageWithResponse call +func ParseScreenCastImageResponse(rsp *http.Response) (*ScreenCastImageResponse, error) { + bodyBytes, err := io.ReadAll(rsp.Body) + defer func() { _ = rsp.Body.Close() }() + if err != nil { + return nil, err + } + + response := &ScreenCastImageResponse{ + Body: bodyBytes, + HTTPResponse: rsp, + } + + switch { + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400: + var dest ErrorMessage + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON400 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401: + var dest Unauthorized + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON401 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403: + var dest Forbidden + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON403 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500: + var dest ErrorMessage + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON500 = &dest + + } + + return response, nil +} + +// ParseScreenConfigurationsListResponse parses an HTTP response from a ScreenConfigurationsListWithResponse call +func ParseScreenConfigurationsListResponse(rsp *http.Response) (*ScreenConfigurationsListResponse, error) { + bodyBytes, err := io.ReadAll(rsp.Body) + defer func() { _ = rsp.Body.Close() }() + if err != nil { + return nil, err + } + + response := &ScreenConfigurationsListResponse{ + Body: bodyBytes, + HTTPResponse: rsp, + } + + switch { + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200: + var dest []ScreenConfiguration + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON200 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401: + var dest Unauthorized + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON401 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403: + var dest Forbidden + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON403 = &dest + + } + + return response, nil +} + +// ParseScreenShotImageResponse parses an HTTP response from a ScreenShotImageWithResponse call +func ParseScreenShotImageResponse(rsp *http.Response) (*ScreenShotImageResponse, error) { + bodyBytes, err := io.ReadAll(rsp.Body) + defer func() { _ = rsp.Body.Close() }() + if err != nil { + return nil, err + } + + response := &ScreenShotImageResponse{ + Body: bodyBytes, + HTTPResponse: rsp, + } + + switch { + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401: + var dest Unauthorized + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON401 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403: + var dest Forbidden + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON403 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500: + var dest ErrorMessage + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON500 = &dest + + } + + return response, nil +} + +// ParseSettingsGetResponse parses an HTTP response from a SettingsGetWithResponse call +func ParseSettingsGetResponse(rsp *http.Response) (*SettingsGetResponse, error) { + bodyBytes, err := io.ReadAll(rsp.Body) + defer func() { _ = rsp.Body.Close() }() + if err != nil { + return nil, err + } + + response := &SettingsGetResponse{ + Body: bodyBytes, + HTTPResponse: rsp, + } + + switch { + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200: + var dest Settings + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON200 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401: + var dest Unauthorized + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON401 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403: + var dest Forbidden + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON403 = &dest + + } + + return response, nil +} + +// ParseSettingsSetResponse parses an HTTP response from a SettingsSetWithResponse call +func ParseSettingsSetResponse(rsp *http.Response) (*SettingsSetResponse, error) { + bodyBytes, err := io.ReadAll(rsp.Body) + defer func() { _ = rsp.Body.Close() }() + if err != nil { + return nil, err + } + + response := &SettingsSetResponse{ + Body: bodyBytes, + HTTPResponse: rsp, + } + + switch { + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401: + var dest Unauthorized + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON401 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403: + var dest Forbidden + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON403 = &dest + + } + + return response, nil +} + +// ParseUploadDialogCloseResponse parses an HTTP response from a UploadDialogCloseWithResponse call +func ParseUploadDialogCloseResponse(rsp *http.Response) (*UploadDialogCloseResponse, error) { + bodyBytes, err := io.ReadAll(rsp.Body) + defer func() { _ = rsp.Body.Close() }() + if err != nil { + return nil, err + } + + response := &UploadDialogCloseResponse{ + Body: bodyBytes, + HTTPResponse: rsp, + } + + switch { + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401: + var dest Unauthorized + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON401 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403: + var dest Forbidden + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON403 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 422: + var dest ErrorMessage + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON422 = &dest + + } + + return response, nil +} + +// ParseUploadDialogResponse parses an HTTP response from a UploadDialogWithResponse call +func ParseUploadDialogResponse(rsp *http.Response) (*UploadDialogResponse, error) { + bodyBytes, err := io.ReadAll(rsp.Body) + defer func() { _ = rsp.Body.Close() }() + if err != nil { + return nil, err + } + + response := &UploadDialogResponse{ + Body: bodyBytes, + HTTPResponse: rsp, + } + + switch { + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400: + var dest ErrorMessage + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON400 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401: + var dest Unauthorized + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON401 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403: + var dest Forbidden + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON403 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 422: + var dest ErrorMessage + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON422 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500: + var dest ErrorMessage + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON500 = &dest + + } + + return response, nil +} + +// ParseUploadDropResponse parses an HTTP response from a UploadDropWithResponse call +func ParseUploadDropResponse(rsp *http.Response) (*UploadDropResponse, error) { + bodyBytes, err := io.ReadAll(rsp.Body) + defer func() { _ = rsp.Body.Close() }() + if err != nil { + return nil, err + } + + response := &UploadDropResponse{ + Body: bodyBytes, + HTTPResponse: rsp, + } + + switch { + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400: + var dest ErrorMessage + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON400 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401: + var dest Unauthorized + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON401 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403: + var dest Forbidden + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON403 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500: + var dest ErrorMessage + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON500 = &dest + + } + + return response, nil +} + +// ParseSessionsGetResponse parses an HTTP response from a SessionsGetWithResponse call +func ParseSessionsGetResponse(rsp *http.Response) (*SessionsGetResponse, error) { + bodyBytes, err := io.ReadAll(rsp.Body) + defer func() { _ = rsp.Body.Close() }() + if err != nil { + return nil, err + } + + response := &SessionsGetResponse{ + Body: bodyBytes, + HTTPResponse: rsp, + } + + switch { + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200: + var dest []SessionData + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON200 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401: + var dest Unauthorized + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON401 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403: + var dest Forbidden + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON403 = &dest + + } + + return response, nil +} + +// ParseSessionRemoveResponse parses an HTTP response from a SessionRemoveWithResponse call +func ParseSessionRemoveResponse(rsp *http.Response) (*SessionRemoveResponse, error) { + bodyBytes, err := io.ReadAll(rsp.Body) + defer func() { _ = rsp.Body.Close() }() + if err != nil { + return nil, err + } + + response := &SessionRemoveResponse{ + Body: bodyBytes, + HTTPResponse: rsp, + } + + switch { + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401: + var dest Unauthorized + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON401 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403: + var dest Forbidden + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON403 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404: + var dest NotFound + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON404 = &dest + + } + + return response, nil +} + +// ParseSessionGetResponse parses an HTTP response from a SessionGetWithResponse call +func ParseSessionGetResponse(rsp *http.Response) (*SessionGetResponse, error) { + bodyBytes, err := io.ReadAll(rsp.Body) + defer func() { _ = rsp.Body.Close() }() + if err != nil { + return nil, err + } + + response := &SessionGetResponse{ + Body: bodyBytes, + HTTPResponse: rsp, + } + + switch { + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200: + var dest SessionData + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON200 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401: + var dest Unauthorized + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON401 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403: + var dest Forbidden + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON403 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404: + var dest NotFound + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON404 = &dest + + } + + return response, nil +} + +// ParseSessionDisconnectResponse parses an HTTP response from a SessionDisconnectWithResponse call +func ParseSessionDisconnectResponse(rsp *http.Response) (*SessionDisconnectResponse, error) { + bodyBytes, err := io.ReadAll(rsp.Body) + defer func() { _ = rsp.Body.Close() }() + if err != nil { + return nil, err + } + + response := &SessionDisconnectResponse{ + Body: bodyBytes, + HTTPResponse: rsp, + } + + switch { + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401: + var dest Unauthorized + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON401 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403: + var dest Forbidden + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON403 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404: + var dest NotFound + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON404 = &dest + + } + + return response, nil +} + +// ParseStatsResponse parses an HTTP response from a StatsWithResponse call +func ParseStatsResponse(rsp *http.Response) (*StatsResponse, error) { + bodyBytes, err := io.ReadAll(rsp.Body) + defer func() { _ = rsp.Body.Close() }() + if err != nil { + return nil, err + } + + response := &StatsResponse{ + Body: bodyBytes, + HTTPResponse: rsp, + } + + switch { + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200: + var dest Stats + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON200 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401: + var dest Unauthorized + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON401 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403: + var dest Forbidden + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON403 = &dest + + } + + return response, nil +} + +// ParseWhoamiResponse parses an HTTP response from a WhoamiWithResponse call +func ParseWhoamiResponse(rsp *http.Response) (*WhoamiResponse, error) { + bodyBytes, err := io.ReadAll(rsp.Body) + defer func() { _ = rsp.Body.Close() }() + if err != nil { + return nil, err + } + + response := &WhoamiResponse{ + Body: bodyBytes, + HTTPResponse: rsp, + } + + switch { + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200: + var dest SessionData + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON200 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401: + var dest Unauthorized + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON401 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403: + var dest Forbidden + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON403 = &dest + + } + + return response, nil +} + +// ParseHealthcheckResponse parses an HTTP response from a HealthcheckWithResponse call +func ParseHealthcheckResponse(rsp *http.Response) (*HealthcheckResponse, error) { + bodyBytes, err := io.ReadAll(rsp.Body) + defer func() { _ = rsp.Body.Close() }() + if err != nil { + return nil, err + } + + response := &HealthcheckResponse{ + Body: bodyBytes, + HTTPResponse: rsp, + } + + return response, nil +} + +// ParseMetricsResponse parses an HTTP response from a MetricsWithResponse call +func ParseMetricsResponse(rsp *http.Response) (*MetricsResponse, error) { + bodyBytes, err := io.ReadAll(rsp.Body) + defer func() { _ = rsp.Body.Close() }() + if err != nil { + return nil, err + } + + response := &MetricsResponse{ + Body: bodyBytes, + HTTPResponse: rsp, + } + + return response, nil +} diff --git a/server/oapi-codegen.client.yaml b/server/oapi-codegen.client.yaml new file mode 100644 index 000000000..29bca5abd --- /dev/null +++ b/server/oapi-codegen.client.yaml @@ -0,0 +1,8 @@ +package: oapi +output: lib/oapi/client.go +generate: + client: true + models: true + embedded-spec: false +output-options: + skip-prune: true diff --git a/server/openapi.yaml b/server/openapi.yaml index ce8e44dc5..c77a88a4f 100644 --- a/server/openapi.yaml +++ b/server/openapi.yaml @@ -111,7 +111,7 @@ paths: schema: type: array items: - $ref: '#/components/schemas/BatchResponse' + $ref: '#/components/schemas/BatchItem' requestBody: content: application/json: @@ -1232,7 +1232,7 @@ components: body: description: The request body for the API call. - BatchResponse: + BatchItem: type: object properties: path: