methods.go

/*

MIT License

Copyright (c) 2023 Looker Data Sciences, Inc.

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

*/

/*

464 API methods
*/

// NOTE: Do not edit this file generated by Looker SDK Codegen for API v4

package v4

import (
	"fmt"
	"github.com/looker-open-source/sdk-codegen/go/rtl"
	"net/url"
	"time"
)

type LookerSDK struct {
	session *rtl.AuthSession
}

func NewLookerSDK(session *rtl.AuthSession) *LookerSDK {
	return &LookerSDK{
		session: session,
	}
}

// region Alert: Alert

// Follow an alert.
//
// POST /alerts/{alert_id}/follow -> Void
func (l *LookerSDK) FollowAlert(
	alertId string,
	options *rtl.ApiSettings) error {
	alertId = url.PathEscape(alertId)
	err := l.session.Do(nil, "POST", "/4.0", fmt.Sprintf("/alerts/%v/follow", alertId), nil, nil, options)
	return err

}

// Unfollow an alert.
//
// DELETE /alerts/{alert_id}/follow -> Void
func (l *LookerSDK) UnfollowAlert(
	alertId string,
	options *rtl.ApiSettings) error {
	alertId = url.PathEscape(alertId)
	err := l.session.Do(nil, "DELETE", "/4.0", fmt.Sprintf("/alerts/%v/follow", alertId), nil, nil, options)
	return err

}

// ### Search Alerts
//
// GET /alerts/search -> []Alert
func (l *LookerSDK) SearchAlerts(request RequestSearchAlerts,
	options *rtl.ApiSettings) ([]Alert, error) {
	var result []Alert
	err := l.session.Do(&result, "GET", "/4.0", "/alerts/search", map[string]interface{}{"limit": request.Limit, "offset": request.Offset, "group_by": request.GroupBy, "fields": request.Fields, "disabled": request.Disabled, "frequency": request.Frequency, "condition_met": request.ConditionMet, "last_run_start": request.LastRunStart, "last_run_end": request.LastRunEnd, "all_owners": request.AllOwners}, nil, options)
	return result, err

}

// ### Get an alert by a given alert ID
//
// GET /alerts/{alert_id} -> Alert
func (l *LookerSDK) GetAlert(
	alertId string,
	options *rtl.ApiSettings) (Alert, error) {
	alertId = url.PathEscape(alertId)
	var result Alert
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/alerts/%v", alertId), nil, nil, options)
	return result, err

}

// ### Update an alert
// # Required fields: `owner_id`, `field`, `destinations`, `comparison_type`, `threshold`, `cron`
// #
//
// PUT /alerts/{alert_id} -> Alert
func (l *LookerSDK) UpdateAlert(
	alertId string,
	body WriteAlert,
	options *rtl.ApiSettings) (Alert, error) {
	alertId = url.PathEscape(alertId)
	var result Alert
	err := l.session.Do(&result, "PUT", "/4.0", fmt.Sprintf("/alerts/%v", alertId), nil, body, options)
	return result, err

}

// ### Update select alert fields
// # Available fields: `owner_id`, `is_disabled`, `disabled_reason`, `is_public`, `threshold`
// #
//
// PATCH /alerts/{alert_id} -> Alert
func (l *LookerSDK) UpdateAlertField(
	alertId string,
	body AlertPatch,
	options *rtl.ApiSettings) (Alert, error) {
	alertId = url.PathEscape(alertId)
	var result Alert
	err := l.session.Do(&result, "PATCH", "/4.0", fmt.Sprintf("/alerts/%v", alertId), nil, body, options)
	return result, err

}

// ### Delete an alert by a given alert ID
//
// DELETE /alerts/{alert_id} -> Void
func (l *LookerSDK) DeleteAlert(
	alertId string,
	options *rtl.ApiSettings) error {
	alertId = url.PathEscape(alertId)
	err := l.session.Do(nil, "DELETE", "/4.0", fmt.Sprintf("/alerts/%v", alertId), nil, nil, options)
	return err

}

// ### Create a new alert and return details of the newly created object
//
// Required fields: `field`, `destinations`, `comparison_type`, `threshold`, `cron`
//
// Example Request:
// Run alert on dashboard element '103' at 5am every day. Send an email to 'test@test.com' if inventory for Los Angeles (using dashboard filter `Warehouse Name`) is lower than 1,000
// ```
//
//	{
//	  "cron": "0 5 * * *",
//	  "custom_title": "Alert when LA inventory is low",
//	  "dashboard_element_id": 103,
//	  "applied_dashboard_filters": [
//	    {
//	      "filter_title": "Warehouse Name",
//	      "field_name": "distribution_centers.name",
//	      "filter_value": "Los Angeles CA",
//	      "filter_description": "is Los Angeles CA"
//	    }
//	  ],
//	  "comparison_type": "LESS_THAN",
//	  "destinations": [
//	    {
//	      "destination_type": "EMAIL",
//	      "email_address": "test@test.com"
//	    }
//	  ],
//	  "field": {
//	    "title": "Number on Hand",
//	    "name": "inventory_items.number_on_hand"
//	  },
//	  "is_disabled": false,
//	  "is_public": true,
//	  "threshold": 1000
//	}
//
// ```
//
// POST /alerts -> Alert
func (l *LookerSDK) CreateAlert(
	body WriteAlert,
	options *rtl.ApiSettings) (Alert, error) {
	var result Alert
	err := l.session.Do(&result, "POST", "/4.0", "/alerts", nil, body, options)
	return result, err

}

// ### Enqueue an Alert by ID
//
// POST /alerts/{alert_id}/enqueue -> Void
func (l *LookerSDK) EnqueueAlert(
	alertId string,
	force bool,
	options *rtl.ApiSettings) error {
	alertId = url.PathEscape(alertId)
	err := l.session.Do(nil, "POST", "/4.0", fmt.Sprintf("/alerts/%v/enqueue", alertId), map[string]interface{}{"force": force}, nil, options)
	return err

}

// # Alert Notifications.
//
//	The endpoint returns all the alert notifications received by the user on email in the past 7 days. It also returns whether the notifications have been read by the user.
//
// GET /alert_notifications -> []AlertNotifications
func (l *LookerSDK) AlertNotifications(request RequestAlertNotifications,
	options *rtl.ApiSettings) ([]AlertNotifications, error) {
	var result []AlertNotifications
	err := l.session.Do(&result, "GET", "/4.0", "/alert_notifications", map[string]interface{}{"limit": request.Limit, "offset": request.Offset}, nil, options)
	return result, err

}

// # Reads a Notification
//
//	The endpoint marks a given alert notification as read by the user, in case it wasn't already read. The AlertNotification model is updated for this purpose. It returns the notification as a response.
//
// PATCH /alert_notifications/{alert_notification_id} -> AlertNotifications
func (l *LookerSDK) ReadAlertNotification(
	alertNotificationId string,
	options *rtl.ApiSettings) (AlertNotifications, error) {
	alertNotificationId = url.PathEscape(alertNotificationId)
	var result AlertNotifications
	err := l.session.Do(&result, "PATCH", "/4.0", fmt.Sprintf("/alert_notifications/%v", alertNotificationId), nil, nil, options)
	return result, err

}

// endregion Alert: Alert

// region ApiAuth: API Authentication

// ### Present client credentials to obtain an authorization token
//
// Looker API implements the OAuth2 [Resource Owner Password Credentials Grant](https://cloud.google.com/looker/docs/r/api/outh2_resource_owner_pc) pattern.
// The client credentials required for this login must be obtained by creating an API key on a user account
// in the Looker Admin console. The API key consists of a public `client_id` and a private `client_secret`.
//
// The access token returned by `login` must be used in the HTTP Authorization header of subsequent
// API requests, like this:
// ```
// Authorization: token 4QDkCyCtZzYgj4C2p2cj3csJH7zqS5RzKs2kTnG4
// ```
// Replace "4QDkCy..." with the `access_token` value returned by `login`.
// The word `token` is a string literal and must be included exactly as shown.
//
// This function can accept `client_id` and `client_secret` parameters as URL query params or as www-form-urlencoded params in the body of the HTTP request. Since there is a small risk that URL parameters may be visible to intermediate nodes on the network route (proxies, routers, etc), passing credentials in the body of the request is considered more secure than URL params.
//
// Example of passing credentials in the HTTP request body:
// ````
// POST HTTP /login
// Content-Type: application/x-www-form-urlencoded
//
// client_id=CGc9B7v7J48dQSJvxxx&client_secret=nNVS9cSS3xNpSC9JdsBvvvvv
// ````
//
// ### Best Practice:
// Always pass credentials in body params. Pass credentials in URL query params **only** when you cannot pass body params due to application, tool, or other limitations.
//
// For more information and detailed examples of Looker API authorization, see [How to Authenticate to Looker API](https://github.com/looker/looker-sdk-ruby/blob/master/authentication.md).
//
// POST /login -> AccessToken
func (l *LookerSDK) Login(request RequestLogin,
	options *rtl.ApiSettings) (AccessToken, error) {
	var result AccessToken
	err := l.session.Do(&result, "POST", "/4.0", "/login", map[string]interface{}{"client_id": request.ClientId, "client_secret": request.ClientSecret}, nil, options)
	return result, err

}

// ### Create an access token that runs as a given user.
//
// This can only be called by an authenticated admin user. It allows that admin to generate a new
// authentication token for the user with the given user id. That token can then be used for subsequent
// API calls - which are then performed *as* that target user.
//
// The target user does *not* need to have a pre-existing API client_id/client_secret pair. And, no such
// credentials are created by this call.
//
// This allows for building systems where api user authentication for an arbitrary number of users is done
// outside of Looker and funneled through a single 'service account' with admin permissions. Note that a
// new access token is generated on each call. If target users are going to be making numerous API
// calls in a short period then it is wise to cache this authentication token rather than call this before
// each of those API calls.
//
// See 'login' for more detail on the access token and how to use it.
//
// Calls to this endpoint may be denied by [Looker (Google Cloud core)](https://cloud.google.com/looker/docs/r/looker-core/overview).
//
// POST /login/{user_id} -> AccessToken
func (l *LookerSDK) LoginUser(
	userId string,
	associative bool,
	options *rtl.ApiSettings) (AccessToken, error) {
	userId = url.PathEscape(userId)
	var result AccessToken
	err := l.session.Do(&result, "POST", "/4.0", fmt.Sprintf("/login/%v", userId), map[string]interface{}{"associative": associative}, nil, options)
	return result, err

}

// ### Logout of the API and invalidate the current access token.
//
// DELETE /logout -> string
func (l *LookerSDK) Logout(
	options *rtl.ApiSettings) (string, error) {
	var result string
	err := l.session.Do(&result, "DELETE", "/4.0", "/logout", nil, nil, options)
	return result, err

}

// endregion ApiAuth: API Authentication

// region Artifact: Artifact Storage

// Get the maximum configured size of the entire artifact store, and the currently used storage in bytes.
//
// **Note**: The artifact storage API can only be used by Looker-built extensions.
//
// GET /artifact/usage -> ArtifactUsage
func (l *LookerSDK) ArtifactUsage(
	fields string,
	options *rtl.ApiSettings) (ArtifactUsage, error) {
	var result ArtifactUsage
	err := l.session.Do(&result, "GET", "/4.0", "/artifact/usage", map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// Get all artifact namespaces and the count of artifacts in each namespace
//
// **Note**: The artifact storage API can only be used by Looker-built extensions.
//
// GET /artifact/namespaces -> []ArtifactNamespace
func (l *LookerSDK) ArtifactNamespaces(request RequestArtifactNamespaces,
	options *rtl.ApiSettings) ([]ArtifactNamespace, error) {
	var result []ArtifactNamespace
	err := l.session.Do(&result, "GET", "/4.0", "/artifact/namespaces", map[string]interface{}{"fields": request.Fields, "limit": request.Limit, "offset": request.Offset}, nil, options)
	return result, err

}

// ### Return the value of an artifact
//
// The MIME type for the API response is set to the `content_type` of the value
//
// **Note**: The artifact storage API can only be used by Looker-built extensions.
//
// GET /artifact/{namespace}/value -> string
func (l *LookerSDK) ArtifactValue(
	namespace string,
	key string,
	options *rtl.ApiSettings) (string, error) {
	namespace = url.PathEscape(namespace)
	var result string
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/artifact/%v/value", namespace), map[string]interface{}{"key": key}, nil, options)
	return result, err

}

// Remove *all* artifacts from a namespace. Purged artifacts are permanently deleted
//
// **Note**: The artifact storage API can only be used by Looker-built extensions.
//
// DELETE /artifact/{namespace}/purge -> Void
func (l *LookerSDK) PurgeArtifacts(
	namespace string,
	options *rtl.ApiSettings) error {
	namespace = url.PathEscape(namespace)
	err := l.session.Do(nil, "DELETE", "/4.0", fmt.Sprintf("/artifact/%v/purge", namespace), nil, nil, options)
	return err

}

// ### Search all key/value pairs in a namespace for matching criteria.
//
// Returns an array of artifacts matching the specified search criteria.
//
// Key search patterns use case-insensitive matching and can contain `%` and `_` as SQL LIKE pattern match wildcard expressions.
//
// The parameters `min_size` and `max_size` can be used individually or together.
//
// - `min_size` finds artifacts with sizes greater than or equal to its value
// - `max_size` finds artifacts with sizes less than or equal to its value
// - using both parameters restricts the minimum and maximum size range for artifacts
//
// **NOTE**: Artifacts are always returned in alphanumeric order by key.
//
// Get a **single artifact** by namespace and key with [`artifact`](#!/Artifact/artifact)
//
// **Note**: The artifact storage API can only be used by Looker-built extensions.
//
// GET /artifact/{namespace}/search -> []Artifact
func (l *LookerSDK) SearchArtifacts(request RequestSearchArtifacts,
	options *rtl.ApiSettings) ([]Artifact, error) {
	request.Namespace = url.PathEscape(request.Namespace)
	var result []Artifact
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/artifact/%v/search", request.Namespace), map[string]interface{}{"fields": request.Fields, "key": request.Key, "user_ids": request.UserIds, "min_size": request.MinSize, "max_size": request.MaxSize, "limit": request.Limit, "offset": request.Offset}, nil, options)
	return result, err

}

// ### Get one or more artifacts
//
// Returns an array of artifacts matching the specified key value(s).
//
// **Note**: The artifact storage API can only be used by Looker-built extensions.
//
// GET /artifact/{namespace} -> []Artifact
func (l *LookerSDK) Artifact(request RequestArtifact,
	options *rtl.ApiSettings) ([]Artifact, error) {
	request.Namespace = url.PathEscape(request.Namespace)
	var result []Artifact
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/artifact/%v", request.Namespace), map[string]interface{}{"key": request.Key, "fields": request.Fields, "limit": request.Limit, "offset": request.Offset}, nil, options)
	return result, err

}

// ### Delete one or more artifacts
//
// To avoid rate limiting on deletion requests, multiple artifacts can be deleted at the same time by using a comma-delimited list of artifact keys.
//
// **Note**: The artifact storage API can only be used by Looker-built extensions.
//
// DELETE /artifact/{namespace} -> Void
func (l *LookerSDK) DeleteArtifact(
	namespace string,
	key string,
	options *rtl.ApiSettings) error {
	namespace = url.PathEscape(namespace)
	err := l.session.Do(nil, "DELETE", "/4.0", fmt.Sprintf("/artifact/%v", namespace), map[string]interface{}{"key": key}, nil, options)
	return err

}

// ### Create or update one or more artifacts
//
// Only `key` and `value` are required to _create_ an artifact.
// To _update_ an artifact, its current `version` value must be provided.
//
// In the following example `body` payload, `one` and `two` are existing artifacts, and `three` is new:
//
// ```json
// [
//
//	{ "key": "one", "value": "[ \"updating\", \"existing\", \"one\" ]", "version": 10, "content_type": "application/json" },
//	{ "key": "two", "value": "updating existing two", "version": 20 },
//	{ "key": "three", "value": "creating new three" },
//
// ]
// ```
//
// Notes for this body:
//
// - The `value` for `key` **one** is a JSON payload, so a `content_type` override is needed. This override must be done **every** time a JSON value is set.
// - The `version` values for **one** and **two** mean they have been saved 10 and 20 times, respectively.
// - If `version` is **not** provided for an existing artifact, the entire request will be refused and a `Bad Request` response will be sent.
// - If `version` is provided for an artifact, it is only used for helping to prevent inadvertent data overwrites. It cannot be used to **set** the version of an artifact. The Looker server controls `version`.
// - We suggest encoding binary values as base64. Because the MIME content type for base64 is detected as plain text, also provide `content_type` to correctly indicate the value's type for retrieval and client-side processing.
//
// Because artifacts are stored encrypted, the same value can be written multiple times (provided the correct `version` number is used). Looker does not examine any values stored in the artifact store, and only decrypts when sending artifacts back in an API response.
//
// **Note**: The artifact storage API can only be used by Looker-built extensions.
//
// PUT /artifacts/{namespace} -> []Artifact
func (l *LookerSDK) UpdateArtifacts(
	namespace string,
	body []UpdateArtifact,
	fields string,
	options *rtl.ApiSettings) ([]Artifact, error) {
	namespace = url.PathEscape(namespace)
	var result []Artifact
	err := l.session.Do(&result, "PUT", "/4.0", fmt.Sprintf("/artifacts/%v", namespace), map[string]interface{}{"fields": fields}, body, options)
	return result, err

}

// endregion Artifact: Artifact Storage

// region Auth: Manage User Authentication Configuration

// ### Create an embed secret using the specified information.
//
// The value of the `secret` field will be set by Looker and returned.
//
// Calls to this endpoint require [Embedding](https://cloud.google.com/looker/docs/r/looker-core-feature-embed) to be enabled
//
// POST /embed_config/secrets -> EmbedSecret
func (l *LookerSDK) CreateEmbedSecret(
	body WriteEmbedSecret,
	options *rtl.ApiSettings) (EmbedSecret, error) {
	var result EmbedSecret
	err := l.session.Do(&result, "POST", "/4.0", "/embed_config/secrets", nil, body, options)
	return result, err

}

// ### Delete an embed secret.
//
// Calls to this endpoint require [Embedding](https://cloud.google.com/looker/docs/r/looker-core-feature-embed) to be enabled
//
// DELETE /embed_config/secrets/{embed_secret_id} -> string
func (l *LookerSDK) DeleteEmbedSecret(
	embedSecretId string,
	options *rtl.ApiSettings) (string, error) {
	embedSecretId = url.PathEscape(embedSecretId)
	var result string
	err := l.session.Do(&result, "DELETE", "/4.0", fmt.Sprintf("/embed_config/secrets/%v", embedSecretId), nil, nil, options)
	return result, err

}

// ### Create Signed Embed URL
//
// Creates a signed embed URL and cryptographically signs it with an embed secret.
// This signed URL can then be used to instantiate a Looker embed session in a PBL web application.
// Do not make any modifications to the returned URL - any change may invalidate the signature and
// cause the URL to fail to load a Looker embed session.
//
// A signed embed URL can only be **used once**. After the URL has been used to request a page from the
// Looker server, it is invalid. Future requests using the same URL will fail. This is to prevent
// 'replay attacks'.
//
// The `target_url` property must be a complete URL of a Looker UI page - scheme, hostname, path and query params.
// To load a dashboard with id 56 and with a filter of `Date=1 years`, the looker URL would look like `https:/myname.looker.com/dashboards/56?Date=1%20years`.
// The best way to obtain this `target_url` is to navigate to the desired Looker page in your web browser and use the "Get embed URL" menu option
// to copy it to your clipboard and paste it into the `target_url` property as a quoted string value in this API request.
//
// Permissions for the embed user are defined by the groups in which the embed user is a member (`group_ids` property)
// and the lists of models and permissions assigned to the embed user.
// At a minimum, you must provide values for either the `group_ids` property, or **both** the models and permissions properties.
// These properties are additive; an embed user can be a member of certain groups AND be granted access to models and permissions.
//
// The embed user's access is the union of permissions granted by the `group_ids`, `models`, and `permissions` properties.
//
// This function does not strictly require all group_ids, user attribute names, or model names to exist at the moment the
// embed url is created. Unknown group_id, user attribute names or model names will be passed through to the output URL.
//
// To diagnose potential problems with an SSO embed URL, you can copy the signed URL into the Embed URI Validator text box in `<your looker instance>/admin/embed`.
//
// The `secret_id` parameter is optional. If specified, its value must be the id of an active secret defined in the Looker instance.
// if not specified, the URL will be signed using the most recent active signing secret. If there is no active secret for signing embed urls,
// a default secret will be created. This default secret is encrypted using HMAC/SHA-256.
//
// The `embed_domain` parameter is optional. If specified and valid, the domain will be added to the embed domain allowlist if it is missing.
//
// #### Security Note
// Protect this signed URL as you would an access token or password credentials - do not write
// it to disk, do not pass it to a third party, and only pass it through a secure HTTPS
// encrypted transport.
//
// Calls to this endpoint require [Embedding](https://cloud.google.com/looker/docs/r/looker-core-feature-embed) to be enabled
//
// POST /embed/sso_url -> EmbedUrlResponse
func (l *LookerSDK) CreateSsoEmbedUrl(
	body EmbedSsoParams,
	options *rtl.ApiSettings) (EmbedUrlResponse, error) {
	var result EmbedUrlResponse
	err := l.session.Do(&result, "POST", "/4.0", "/embed/sso_url", nil, body, options)
	return result, err

}

// ### Create an Embed URL
//
// Creates an embed URL that runs as the Looker user making this API call. ("Embed as me")
// This embed URL can then be used to instantiate a Looker embed session in a
// "Powered by Looker" (PBL) web application.
//
// This is similar to Private Embedding (https://cloud.google.com/looker/docs/r/admin/embed/private-embed). Instead of
// logging into the Web UI to authenticate, the user has already authenticated against the API to be able to
// make this call. However, unlike Private Embed where the user has access to any other part of the Looker UI,
// the embed web session created by requesting the EmbedUrlResponse.url in a browser only has access to
// content visible under the `/embed` context.
//
// An embed URL can only be used once, and must be used within 5 minutes of being created. After it
// has been used to request a page from the Looker server, the URL is invalid. Future requests using
// the same URL will fail. This is to prevent 'replay attacks'.
//
// The `target_url` property must be a complete URL of a Looker Embedded UI page - scheme, hostname, path starting with "/embed" and query params.
// To load a dashboard with id 56 and with a filter of `Date=1 years`, the looker Embed URL would look like `https://myname.looker.com/embed/dashboards/56?Date=1%20years`.
// The best way to obtain this target_url is to navigate to the desired Looker page in your web browser,
// copy the URL shown in the browser address bar, insert "/embed" after the host/port, and paste it into the `target_url` property as a quoted string value in this API request.
//
// #### Security Note
// Protect this signed URL as you would an access token or password credentials - do not write
// it to disk, do not pass it to a third party, and only pass it through a secure HTTPS
// encrypted transport.
//
// Calls to this endpoint require [Embedding](https://cloud.google.com/looker/docs/r/looker-core-feature-embed) to be enabled
//
// POST /embed/token_url/me -> EmbedUrlResponse
func (l *LookerSDK) CreateEmbedUrlAsMe(
	body EmbedParams,
	options *rtl.ApiSettings) (EmbedUrlResponse, error) {
	var result EmbedUrlResponse
	err := l.session.Do(&result, "POST", "/4.0", "/embed/token_url/me", nil, body, options)
	return result, err

}

// ### Validate a Signed Embed URL
//
// GET /embed/sso/validate -> EmbedUrlResponse
func (l *LookerSDK) ValidateEmbedUrl(
	url string,
	options *rtl.ApiSettings) (EmbedUrlResponse, error) {
	var result EmbedUrlResponse
	err := l.session.Do(&result, "GET", "/4.0", "/embed/sso/validate", map[string]interface{}{"url": url}, nil, options)
	return result, err

}

// ### Acquire a cookieless embed session.
//
// The acquire session endpoint negates the need for signing the embed url and passing it as a parameter
// to the embed login. This endpoint accepts an embed user definition and creates or updates it. This is
// similar behavior to the embed SSO login as they both can create and update embed user data.
//
// The endpoint also accepts an optional `session_reference_token`. If present and the session has not expired
// and the credentials match the credentials for the embed session, a new authentication token will be
// generated. This allows the embed session to attach a new embedded IFRAME to the embed session. Note that
// the session is NOT extended in this scenario. In other words the session_length parameter is ignored.
//
// **IMPORTANT:** If the `session_reference_token` is provided and the session has NOT expired, the embed user
// is NOT updated. This is done for performance reasons and to support the embed SSO usecase where the
// first IFRAME created on a page uses a signed url and subsequently created IFRAMEs do not.
//
// If the `session_reference_token` is provided but the session has expired, the token will be ignored and a
// new embed session will be created. Note that the embed user definition will be updated in this scenario.
//
// If the credentials do not match the credentials associated with an existing session_reference_token, a
// 404 will be returned.
//
// The endpoint returns the following:
//   - Authentication token - a token that is passed to `/embed/login` endpoint that creates or attaches to the
//     embed session. This token can be used once and has a lifetime of 30 seconds.
//   - Session reference token - a token that lives for the length of the session. This token is used to
//     generate new api and navigation tokens OR create new embed IFRAMEs.
//   - Api token - lives for 10 minutes. The Looker client will ask for this token once it is loaded into the
//     iframe.
//   - Navigation token - lives for 10 minutes. The Looker client will ask for this token once it is loaded into
//     the iframe.
//
// Calls to this endpoint require [Embedding](https://cloud.google.com/looker/docs/r/looker-core-feature-embed) to be enabled
//
// POST /embed/cookieless_session/acquire -> EmbedCookielessSessionAcquireResponse
func (l *LookerSDK) AcquireEmbedCookielessSession(
	body EmbedCookielessSessionAcquire,
	options *rtl.ApiSettings) (EmbedCookielessSessionAcquireResponse, error) {
	var result EmbedCookielessSessionAcquireResponse
	err := l.session.Do(&result, "POST", "/4.0", "/embed/cookieless_session/acquire", nil, body, options)
	return result, err

}

// ### Delete cookieless embed session
//
// This will delete the session associated with the given session reference token. Calling this endpoint will result
// in the session and session reference data being cleared from the system. This endpoint can be used to log an embed
// user out of the Looker instance.
//
// Calls to this endpoint require [Embedding](https://cloud.google.com/looker/docs/r/looker-core-feature-embed) to be enabled
//
// DELETE /embed/cookieless_session/{session_reference_token} -> string
func (l *LookerSDK) DeleteEmbedCookielessSession(
	sessionReferenceToken string,
	options *rtl.ApiSettings) (string, error) {
	sessionReferenceToken = url.PathEscape(sessionReferenceToken)
	var result string
	err := l.session.Do(&result, "DELETE", "/4.0", fmt.Sprintf("/embed/cookieless_session/%v", sessionReferenceToken), nil, nil, options)
	return result, err

}

// ### Generate api and navigation tokens for a cookieless embed session
//
// The generate tokens endpoint is used to create new tokens of type:
// - Api token.
// - Navigation token.
// The generate tokens endpoint should be called every time the Looker client asks for a token (except for the
// first time when the tokens returned by the acquire_session endpoint should be used).
//
// #### Embed session expiration handling
//
// This endpoint does NOT return an error when the embed session expires. This is to simplify processing
// in the caller as errors can happen for non session expiration reasons. Instead the endpoint returns
// the session time to live in the `session_reference_token_ttl` response property. If this property
// contains a zero, the embed session has expired.
//
// Calls to this endpoint require [Embedding](https://cloud.google.com/looker/docs/r/looker-core-feature-embed) to be enabled
//
// PUT /embed/cookieless_session/generate_tokens -> EmbedCookielessSessionGenerateTokensResponse
func (l *LookerSDK) GenerateTokensForCookielessSession(
	body EmbedCookielessSessionGenerateTokens,
	options *rtl.ApiSettings) (EmbedCookielessSessionGenerateTokensResponse, error) {
	var result EmbedCookielessSessionGenerateTokensResponse
	err := l.session.Do(&result, "PUT", "/4.0", "/embed/cookieless_session/generate_tokens", nil, body, options)
	return result, err

}

// ### Get the LDAP configuration.
//
// Looker can be optionally configured to authenticate users against an Active Directory or other LDAP directory server.
// LDAP setup requires coordination with an administrator of that directory server.
//
// Only Looker administrators can read and update the LDAP configuration.
//
// Configuring LDAP impacts authentication for all users. This configuration should be done carefully.
//
// Looker maintains a single LDAP configuration. It can be read and updated. Updates only succeed if the new state will be valid (in the sense that all required fields are populated); it is up to you to ensure that the configuration is appropriate and correct).
//
// LDAP is enabled or disabled for Looker using the **enabled** field.
//
// Looker will never return an **auth_password** field. That value can be set, but never retrieved.
//
// See the [Looker LDAP docs](https://cloud.google.com/looker/docs/r/api/ldap_setup) for additional information.
//
// Calls to this endpoint may be denied by [Looker (Google Cloud core)](https://cloud.google.com/looker/docs/r/looker-core/overview).
//
// GET /ldap_config -> LDAPConfig
func (l *LookerSDK) LdapConfig(
	options *rtl.ApiSettings) (LDAPConfig, error) {
	var result LDAPConfig
	err := l.session.Do(&result, "GET", "/4.0", "/ldap_config", nil, nil, options)
	return result, err

}

// ### Update the LDAP configuration.
//
// Configuring LDAP impacts authentication for all users. This configuration should be done carefully.
//
// Only Looker administrators can read and update the LDAP configuration.
//
// LDAP is enabled or disabled for Looker using the **enabled** field.
//
// It is **highly** recommended that any LDAP setting changes be tested using the APIs below before being set globally.
//
// See the [Looker LDAP docs](https://cloud.google.com/looker/docs/r/api/ldap_setup) for additional information.
//
// Calls to this endpoint may be denied by [Looker (Google Cloud core)](https://cloud.google.com/looker/docs/r/looker-core/overview).
//
// PATCH /ldap_config -> LDAPConfig
func (l *LookerSDK) UpdateLdapConfig(
	body WriteLDAPConfig,
	options *rtl.ApiSettings) (LDAPConfig, error) {
	var result LDAPConfig
	err := l.session.Do(&result, "PATCH", "/4.0", "/ldap_config", nil, body, options)
	return result, err

}

// ### Test the connection settings for an LDAP configuration.
//
// This tests that the connection is possible given a connection_host and connection_port.
//
// **connection_host** and **connection_port** are required. **connection_tls** is optional.
//
// Example:
// ```json
//
//	{
//	  "connection_host": "ldap.example.com",
//	  "connection_port": "636",
//	  "connection_tls": true
//	}
//
// ```
//
// No authentication to the LDAP server is attempted.
//
// The active LDAP settings are not modified.
//
// Calls to this endpoint may be denied by [Looker (Google Cloud core)](https://cloud.google.com/looker/docs/r/looker-core/overview).
//
// PUT /ldap_config/test_connection -> LDAPConfigTestResult
func (l *LookerSDK) TestLdapConfigConnection(
	body WriteLDAPConfig,
	options *rtl.ApiSettings) (LDAPConfigTestResult, error) {
	var result LDAPConfigTestResult
	err := l.session.Do(&result, "PUT", "/4.0", "/ldap_config/test_connection", nil, body, options)
	return result, err

}

// ### Test the connection authentication settings for an LDAP configuration.
//
// This tests that the connection is possible and that a 'server' account to be used by Looker can authenticate to the LDAP server given connection and authentication information.
//
// **connection_host**, **connection_port**, and **auth_username**, are required. **connection_tls** and **auth_password** are optional.
//
// Example:
// ```json
//
//	{
//	  "connection_host": "ldap.example.com",
//	  "connection_port": "636",
//	  "connection_tls": true,
//	  "auth_username": "cn=looker,dc=example,dc=com",
//	  "auth_password": "secret"
//	}
//
// ```
//
// Looker will never return an **auth_password**. If this request omits the **auth_password** field, then the **auth_password** value from the active config (if present) will be used for the test.
//
// The active LDAP settings are not modified.
//
// Calls to this endpoint may be denied by [Looker (Google Cloud core)](https://cloud.google.com/looker/docs/r/looker-core/overview).
//
// PUT /ldap_config/test_auth -> LDAPConfigTestResult
func (l *LookerSDK) TestLdapConfigAuth(
	body WriteLDAPConfig,
	options *rtl.ApiSettings) (LDAPConfigTestResult, error) {
	var result LDAPConfigTestResult
	err := l.session.Do(&result, "PUT", "/4.0", "/ldap_config/test_auth", nil, body, options)
	return result, err

}

// ### Test the user authentication settings for an LDAP configuration without authenticating the user.
//
// This test will let you easily test the mapping for user properties and roles for any user withoutneeding to authenticate as that user.
//
// This test accepts a full LDAP configuration along with a username and attempts to find the full infofor the user from the LDAP server without actually authenticating the user. So, user password is notrequired.The configuration is validated before attempting to contact the server.
//
// **test_ldap_user** is required.
//
// The active LDAP settings are not modified.
//
// Calls to this endpoint may be denied by [Looker (Google Cloud core)](https://cloud.google.com/looker/docs/r/looker-core/overview).
//
// PUT /ldap_config/test_user_info -> LDAPConfigTestResult
func (l *LookerSDK) TestLdapConfigUserInfo(
	body WriteLDAPConfig,
	options *rtl.ApiSettings) (LDAPConfigTestResult, error) {
	var result LDAPConfigTestResult
	err := l.session.Do(&result, "PUT", "/4.0", "/ldap_config/test_user_info", nil, body, options)
	return result, err

}

// ### Test the user authentication settings for an LDAP configuration.
//
// This test accepts a full LDAP configuration along with a username/password pair and attempts to authenticate the user with the LDAP server. The configuration is validated before attempting the authentication.
//
// Looker will never return an **auth_password**. If this request omits the **auth_password** field, then the **auth_password** value from the active config (if present) will be used for the test.
//
// **test_ldap_user** and **test_ldap_password** are required.
//
// The active LDAP settings are not modified.
//
// Calls to this endpoint may be denied by [Looker (Google Cloud core)](https://cloud.google.com/looker/docs/r/looker-core/overview).
//
// PUT /ldap_config/test_user_auth -> LDAPConfigTestResult
func (l *LookerSDK) TestLdapConfigUserAuth(
	body WriteLDAPConfig,
	options *rtl.ApiSettings) (LDAPConfigTestResult, error) {
	var result LDAPConfigTestResult
	err := l.session.Do(&result, "PUT", "/4.0", "/ldap_config/test_user_auth", nil, body, options)
	return result, err

}

// ### Registers a mobile device.
// # Required fields: [:device_token, :device_type]
//
// POST /mobile/device -> MobileToken
func (l *LookerSDK) RegisterMobileDevice(
	body WriteMobileToken,
	options *rtl.ApiSettings) (MobileToken, error) {
	var result MobileToken
	err := l.session.Do(&result, "POST", "/4.0", "/mobile/device", nil, body, options)
	return result, err

}

// ### Updates the mobile device registration
//
// PATCH /mobile/device/{device_id} -> MobileToken
func (l *LookerSDK) UpdateMobileDeviceRegistration(
	deviceId string,
	options *rtl.ApiSettings) (MobileToken, error) {
	deviceId = url.PathEscape(deviceId)
	var result MobileToken
	err := l.session.Do(&result, "PATCH", "/4.0", fmt.Sprintf("/mobile/device/%v", deviceId), nil, nil, options)
	return result, err

}

// ### Deregister a mobile device.
//
// DELETE /mobile/device/{device_id} -> Void
func (l *LookerSDK) DeregisterMobileDevice(
	deviceId string,
	options *rtl.ApiSettings) error {
	deviceId = url.PathEscape(deviceId)
	err := l.session.Do(nil, "DELETE", "/4.0", fmt.Sprintf("/mobile/device/%v", deviceId), nil, nil, options)
	return err

}

// ### List All OAuth Client Apps
//
// Lists all applications registered to use OAuth2 login with this Looker instance, including
// enabled and disabled apps.
//
// Results are filtered to include only the apps that the caller (current user)
// has permission to see.
//
// GET /oauth_client_apps -> []OauthClientApp
func (l *LookerSDK) AllOauthClientApps(
	fields string,
	options *rtl.ApiSettings) ([]OauthClientApp, error) {
	var result []OauthClientApp
	err := l.session.Do(&result, "GET", "/4.0", "/oauth_client_apps", map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Get Oauth Client App
//
// Returns the registered app client with matching client_guid.
//
// GET /oauth_client_apps/{client_guid} -> OauthClientApp
func (l *LookerSDK) OauthClientApp(
	clientGuid string,
	fields string,
	options *rtl.ApiSettings) (OauthClientApp, error) {
	clientGuid = url.PathEscape(clientGuid)
	var result OauthClientApp
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/oauth_client_apps/%v", clientGuid), map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Register an OAuth2 Client App
//
// Registers details identifying an external web app or native app as an OAuth2 login client of the Looker instance.
// The app registration must provide a unique client_guid and redirect_uri that the app will present
// in OAuth login requests. If the client_guid and redirect_uri parameters in the login request do not match
// the app details registered with the Looker instance, the request is assumed to be a forgery and is rejected.
//
// POST /oauth_client_apps/{client_guid} -> OauthClientApp
func (l *LookerSDK) RegisterOauthClientApp(
	clientGuid string,
	body WriteOauthClientApp,
	fields string,
	options *rtl.ApiSettings) (OauthClientApp, error) {
	clientGuid = url.PathEscape(clientGuid)
	var result OauthClientApp
	err := l.session.Do(&result, "POST", "/4.0", fmt.Sprintf("/oauth_client_apps/%v", clientGuid), map[string]interface{}{"fields": fields}, body, options)
	return result, err

}

// ### Update OAuth2 Client App Details
//
// Modifies the details a previously registered OAuth2 login client app.
//
// PATCH /oauth_client_apps/{client_guid} -> OauthClientApp
func (l *LookerSDK) UpdateOauthClientApp(
	clientGuid string,
	body WriteOauthClientApp,
	fields string,
	options *rtl.ApiSettings) (OauthClientApp, error) {
	clientGuid = url.PathEscape(clientGuid)
	var result OauthClientApp
	err := l.session.Do(&result, "PATCH", "/4.0", fmt.Sprintf("/oauth_client_apps/%v", clientGuid), map[string]interface{}{"fields": fields}, body, options)
	return result, err

}

// ### Delete OAuth Client App
//
// Deletes the registration info of the app with the matching client_guid.
// All active sessions and tokens issued for this app will immediately become invalid.
//
// As with most REST DELETE operations, this endpoint does not return an error if the
// indicated resource does not exist.
//
// ### Note: this deletion cannot be undone.
//
// DELETE /oauth_client_apps/{client_guid} -> string
func (l *LookerSDK) DeleteOauthClientApp(
	clientGuid string,
	options *rtl.ApiSettings) (string, error) {
	clientGuid = url.PathEscape(clientGuid)
	var result string
	err := l.session.Do(&result, "DELETE", "/4.0", fmt.Sprintf("/oauth_client_apps/%v", clientGuid), nil, nil, options)
	return result, err

}

// ### Invalidate All Issued Tokens
//
// Immediately invalidates all auth codes, sessions, access tokens and refresh tokens issued for
// this app for ALL USERS of this app.
//
// DELETE /oauth_client_apps/{client_guid}/tokens -> string
func (l *LookerSDK) InvalidateTokens(
	clientGuid string,
	options *rtl.ApiSettings) (string, error) {
	clientGuid = url.PathEscape(clientGuid)
	var result string
	err := l.session.Do(&result, "DELETE", "/4.0", fmt.Sprintf("/oauth_client_apps/%v/tokens", clientGuid), nil, nil, options)
	return result, err

}

// ### Activate an app for a user
//
// Activates a user for a given oauth client app. This indicates the user has been informed that
// the app will have access to the user's looker data, and that the user has accepted and allowed
// the app to use their Looker account.
//
// Activating a user for an app that the user is already activated with returns a success response.
//
// POST /oauth_client_apps/{client_guid}/users/{user_id} -> string
func (l *LookerSDK) ActivateAppUser(
	clientGuid string,
	userId string,
	fields string,
	options *rtl.ApiSettings) (string, error) {
	clientGuid = url.PathEscape(clientGuid)
	userId = url.PathEscape(userId)
	var result string
	err := l.session.Do(&result, "POST", "/4.0", fmt.Sprintf("/oauth_client_apps/%v/users/%v", clientGuid, userId), map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Deactivate an app for a user
//
// Deactivate a user for a given oauth client app. All tokens issued to the app for
// this user will be invalid immediately. Before the user can use the app with their
// Looker account, the user will have to read and accept an account use disclosure statement for the app.
//
// Admin users can deactivate other users, but non-admin users can only deactivate themselves.
//
// As with most REST DELETE operations, this endpoint does not return an error if the indicated
// resource (app or user) does not exist or has already been deactivated.
//
// DELETE /oauth_client_apps/{client_guid}/users/{user_id} -> string
func (l *LookerSDK) DeactivateAppUser(
	clientGuid string,
	userId string,
	fields string,
	options *rtl.ApiSettings) (string, error) {
	clientGuid = url.PathEscape(clientGuid)
	userId = url.PathEscape(userId)
	var result string
	err := l.session.Do(&result, "DELETE", "/4.0", fmt.Sprintf("/oauth_client_apps/%v/users/%v", clientGuid, userId), map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Get the OIDC configuration.
//
// Looker can be optionally configured to authenticate users against an OpenID Connect (OIDC)
// authentication server. OIDC setup requires coordination with an administrator of that server.
//
// Only Looker administrators can read and update the OIDC configuration.
//
// Configuring OIDC impacts authentication for all users. This configuration should be done carefully.
//
// Looker maintains a single OIDC configuration. It can be read and updated. Updates only succeed if the new state will be valid (in the sense that all required fields are populated); it is up to you to ensure that the configuration is appropriate and correct).
//
// OIDC is enabled or disabled for Looker using the **enabled** field.
//
// Calls to this endpoint may be denied by [Looker (Google Cloud core)](https://cloud.google.com/looker/docs/r/looker-core/overview).
//
// GET /oidc_config -> OIDCConfig
func (l *LookerSDK) OidcConfig(
	options *rtl.ApiSettings) (OIDCConfig, error) {
	var result OIDCConfig
	err := l.session.Do(&result, "GET", "/4.0", "/oidc_config", nil, nil, options)
	return result, err

}

// ### Update the OIDC configuration.
//
// Configuring OIDC impacts authentication for all users. This configuration should be done carefully.
//
// Only Looker administrators can read and update the OIDC configuration.
//
// OIDC is enabled or disabled for Looker using the **enabled** field.
//
// It is **highly** recommended that any OIDC setting changes be tested using the APIs below before being set globally.
//
// Calls to this endpoint may be denied by [Looker (Google Cloud core)](https://cloud.google.com/looker/docs/r/looker-core/overview).
//
// PATCH /oidc_config -> OIDCConfig
func (l *LookerSDK) UpdateOidcConfig(
	body WriteOIDCConfig,
	options *rtl.ApiSettings) (OIDCConfig, error) {
	var result OIDCConfig
	err := l.session.Do(&result, "PATCH", "/4.0", "/oidc_config", nil, body, options)
	return result, err

}

// ### Get a OIDC test configuration by test_slug.
//
// Calls to this endpoint may be denied by [Looker (Google Cloud core)](https://cloud.google.com/looker/docs/r/looker-core/overview).
//
// GET /oidc_test_configs/{test_slug} -> OIDCConfig
func (l *LookerSDK) OidcTestConfig(
	testSlug string,
	options *rtl.ApiSettings) (OIDCConfig, error) {
	testSlug = url.PathEscape(testSlug)
	var result OIDCConfig
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/oidc_test_configs/%v", testSlug), nil, nil, options)
	return result, err

}

// ### Delete a OIDC test configuration.
//
// Calls to this endpoint may be denied by [Looker (Google Cloud core)](https://cloud.google.com/looker/docs/r/looker-core/overview).
//
// DELETE /oidc_test_configs/{test_slug} -> string
func (l *LookerSDK) DeleteOidcTestConfig(
	testSlug string,
	options *rtl.ApiSettings) (string, error) {
	testSlug = url.PathEscape(testSlug)
	var result string
	err := l.session.Do(&result, "DELETE", "/4.0", fmt.Sprintf("/oidc_test_configs/%v", testSlug), nil, nil, options)
	return result, err

}

// ### Create a OIDC test configuration.
//
// Calls to this endpoint may be denied by [Looker (Google Cloud core)](https://cloud.google.com/looker/docs/r/looker-core/overview).
//
// POST /oidc_test_configs -> OIDCConfig
func (l *LookerSDK) CreateOidcTestConfig(
	body WriteOIDCConfig,
	options *rtl.ApiSettings) (OIDCConfig, error) {
	var result OIDCConfig
	err := l.session.Do(&result, "POST", "/4.0", "/oidc_test_configs", nil, body, options)
	return result, err

}

// ### Get password config.
//
// Calls to this endpoint may be denied by [Looker (Google Cloud core)](https://cloud.google.com/looker/docs/r/looker-core/overview).
//
// GET /password_config -> PasswordConfig
func (l *LookerSDK) PasswordConfig(
	options *rtl.ApiSettings) (PasswordConfig, error) {
	var result PasswordConfig
	err := l.session.Do(&result, "GET", "/4.0", "/password_config", nil, nil, options)
	return result, err

}

// ### Update password config.
//
// Calls to this endpoint may be denied by [Looker (Google Cloud core)](https://cloud.google.com/looker/docs/r/looker-core/overview).
//
// PATCH /password_config -> PasswordConfig
func (l *LookerSDK) UpdatePasswordConfig(
	body WritePasswordConfig,
	options *rtl.ApiSettings) (PasswordConfig, error) {
	var result PasswordConfig
	err := l.session.Do(&result, "PATCH", "/4.0", "/password_config", nil, body, options)
	return result, err

}

// ### Force all credentials_email users to reset their login passwords upon their next login.
//
// Calls to this endpoint may be denied by [Looker (Google Cloud core)](https://cloud.google.com/looker/docs/r/looker-core/overview).
//
// PUT /password_config/force_password_reset_at_next_login_for_all_users -> string
func (l *LookerSDK) ForcePasswordResetAtNextLoginForAllUsers(
	options *rtl.ApiSettings) (string, error) {
	var result string
	err := l.session.Do(&result, "PUT", "/4.0", "/password_config/force_password_reset_at_next_login_for_all_users", nil, nil, options)
	return result, err

}

// ### Get the SAML configuration.
//
// Looker can be optionally configured to authenticate users against a SAML authentication server.
// SAML setup requires coordination with an administrator of that server.
//
// Only Looker administrators can read and update the SAML configuration.
//
// Configuring SAML impacts authentication for all users. This configuration should be done carefully.
//
// Looker maintains a single SAML configuration. It can be read and updated. Updates only succeed if the new state will be valid (in the sense that all required fields are populated); it is up to you to ensure that the configuration is appropriate and correct).
//
// SAML is enabled or disabled for Looker using the **enabled** field.
//
// Calls to this endpoint may be denied by [Looker (Google Cloud core)](https://cloud.google.com/looker/docs/r/looker-core/overview).
//
// GET /saml_config -> SamlConfig
func (l *LookerSDK) SamlConfig(
	options *rtl.ApiSettings) (SamlConfig, error) {
	var result SamlConfig
	err := l.session.Do(&result, "GET", "/4.0", "/saml_config", nil, nil, options)
	return result, err

}

// ### Update the SAML configuration.
//
// Configuring SAML impacts authentication for all users. This configuration should be done carefully.
//
// Only Looker administrators can read and update the SAML configuration.
//
// SAML is enabled or disabled for Looker using the **enabled** field.
//
// It is **highly** recommended that any SAML setting changes be tested using the APIs below before being set globally.
//
// Calls to this endpoint may be denied by [Looker (Google Cloud core)](https://cloud.google.com/looker/docs/r/looker-core/overview).
//
// PATCH /saml_config -> SamlConfig
func (l *LookerSDK) UpdateSamlConfig(
	body WriteSamlConfig,
	options *rtl.ApiSettings) (SamlConfig, error) {
	var result SamlConfig
	err := l.session.Do(&result, "PATCH", "/4.0", "/saml_config", nil, body, options)
	return result, err

}

// ### Get a SAML test configuration by test_slug.
//
// Calls to this endpoint may be denied by [Looker (Google Cloud core)](https://cloud.google.com/looker/docs/r/looker-core/overview).
//
// GET /saml_test_configs/{test_slug} -> SamlConfig
func (l *LookerSDK) SamlTestConfig(
	testSlug string,
	options *rtl.ApiSettings) (SamlConfig, error) {
	testSlug = url.PathEscape(testSlug)
	var result SamlConfig
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/saml_test_configs/%v", testSlug), nil, nil, options)
	return result, err

}

// ### Delete a SAML test configuration.
//
// Calls to this endpoint may be denied by [Looker (Google Cloud core)](https://cloud.google.com/looker/docs/r/looker-core/overview).
//
// DELETE /saml_test_configs/{test_slug} -> string
func (l *LookerSDK) DeleteSamlTestConfig(
	testSlug string,
	options *rtl.ApiSettings) (string, error) {
	testSlug = url.PathEscape(testSlug)
	var result string
	err := l.session.Do(&result, "DELETE", "/4.0", fmt.Sprintf("/saml_test_configs/%v", testSlug), nil, nil, options)
	return result, err

}

// ### Create a SAML test configuration.
//
// Calls to this endpoint may be denied by [Looker (Google Cloud core)](https://cloud.google.com/looker/docs/r/looker-core/overview).
//
// POST /saml_test_configs -> SamlConfig
func (l *LookerSDK) CreateSamlTestConfig(
	body WriteSamlConfig,
	options *rtl.ApiSettings) (SamlConfig, error) {
	var result SamlConfig
	err := l.session.Do(&result, "POST", "/4.0", "/saml_test_configs", nil, body, options)
	return result, err

}

// ### Parse the given xml as a SAML IdP metadata document and return the result.
//
// Calls to this endpoint may be denied by [Looker (Google Cloud core)](https://cloud.google.com/looker/docs/r/looker-core/overview).
//
// POST /parse_saml_idp_metadata -> SamlMetadataParseResult
func (l *LookerSDK) ParseSamlIdpMetadata(
	body string,
	options *rtl.ApiSettings) (SamlMetadataParseResult, error) {
	var result SamlMetadataParseResult
	err := l.session.Do(&result, "POST", "/4.0", "/parse_saml_idp_metadata", nil, body, options)
	return result, err

}

// ### Fetch the given url and parse it as a SAML IdP metadata document and return the result.
// Note that this requires that the url be public or at least at a location where the Looker instance
// can fetch it without requiring any special authentication.
//
// Calls to this endpoint may be denied by [Looker (Google Cloud core)](https://cloud.google.com/looker/docs/r/looker-core/overview).
//
// POST /fetch_and_parse_saml_idp_metadata -> SamlMetadataParseResult
func (l *LookerSDK) FetchAndParseSamlIdpMetadata(
	body string,
	options *rtl.ApiSettings) (SamlMetadataParseResult, error) {
	var result SamlMetadataParseResult
	err := l.session.Do(&result, "POST", "/4.0", "/fetch_and_parse_saml_idp_metadata", nil, body, options)
	return result, err

}

// ### Get session config.
//
// GET /session_config -> SessionConfig
func (l *LookerSDK) SessionConfig(
	options *rtl.ApiSettings) (SessionConfig, error) {
	var result SessionConfig
	err := l.session.Do(&result, "GET", "/4.0", "/session_config", nil, nil, options)
	return result, err

}

// ### Update session config.
//
// PATCH /session_config -> SessionConfig
func (l *LookerSDK) UpdateSessionConfig(
	body WriteSessionConfig,
	options *rtl.ApiSettings) (SessionConfig, error) {
	var result SessionConfig
	err := l.session.Do(&result, "PATCH", "/4.0", "/session_config", nil, body, options)
	return result, err

}

// ### Get Support Access Allowlist Users
//
// # Returns the users that have been added to the Support Access Allowlist
//
// Calls to this endpoint may be denied by [Looker (Google Cloud core)](https://cloud.google.com/looker/docs/r/looker-core/overview).
//
// GET /support_access/allowlist -> []SupportAccessAllowlistEntry
func (l *LookerSDK) GetSupportAccessAllowlistEntries(
	fields string,
	options *rtl.ApiSettings) ([]SupportAccessAllowlistEntry, error) {
	var result []SupportAccessAllowlistEntry
	err := l.session.Do(&result, "GET", "/4.0", "/support_access/allowlist", map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Add Support Access Allowlist Users
//
// # Adds a list of emails to the Allowlist, using the provided reason
//
// Calls to this endpoint may be denied by [Looker (Google Cloud core)](https://cloud.google.com/looker/docs/r/looker-core/overview).
//
// POST /support_access/allowlist -> []SupportAccessAllowlistEntry
func (l *LookerSDK) AddSupportAccessAllowlistEntries(
	body SupportAccessAddEntries,
	options *rtl.ApiSettings) ([]SupportAccessAllowlistEntry, error) {
	var result []SupportAccessAllowlistEntry
	err := l.session.Do(&result, "POST", "/4.0", "/support_access/allowlist", nil, body, options)
	return result, err

}

// ### Delete Support Access Allowlist User
//
// # Deletes the specified Allowlist Entry Id
//
// Calls to this endpoint may be denied by [Looker (Google Cloud core)](https://cloud.google.com/looker/docs/r/looker-core/overview).
//
// DELETE /support_access/allowlist/{entry_id} -> string
func (l *LookerSDK) DeleteSupportAccessAllowlistEntry(
	entryId string,
	options *rtl.ApiSettings) (string, error) {
	entryId = url.PathEscape(entryId)
	var result string
	err := l.session.Do(&result, "DELETE", "/4.0", fmt.Sprintf("/support_access/allowlist/%v", entryId), nil, nil, options)
	return result, err

}

// ### Enable Support Access
//
// # Enables Support Access for the provided duration
//
// Calls to this endpoint may be denied by [Looker (Google Cloud core)](https://cloud.google.com/looker/docs/r/looker-core/overview).
//
// PUT /support_access/enable -> SupportAccessStatus
func (l *LookerSDK) EnableSupportAccess(
	body SupportAccessEnable,
	options *rtl.ApiSettings) (SupportAccessStatus, error) {
	var result SupportAccessStatus
	err := l.session.Do(&result, "PUT", "/4.0", "/support_access/enable", nil, body, options)
	return result, err

}

// ### Disable Support Access
//
// # Disables Support Access immediately
//
// Calls to this endpoint may be denied by [Looker (Google Cloud core)](https://cloud.google.com/looker/docs/r/looker-core/overview).
//
// PUT /support_access/disable -> SupportAccessStatus
func (l *LookerSDK) DisableSupportAccess(
	options *rtl.ApiSettings) (SupportAccessStatus, error) {
	var result SupportAccessStatus
	err := l.session.Do(&result, "PUT", "/4.0", "/support_access/disable", nil, nil, options)
	return result, err

}

// ### Support Access Status
//
// # Returns the current Support Access Status
//
// Calls to this endpoint may be denied by [Looker (Google Cloud core)](https://cloud.google.com/looker/docs/r/looker-core/overview).
//
// GET /support_access/status -> SupportAccessStatus
func (l *LookerSDK) SupportAccessStatus(
	options *rtl.ApiSettings) (SupportAccessStatus, error) {
	var result SupportAccessStatus
	err := l.session.Do(&result, "GET", "/4.0", "/support_access/status", nil, nil, options)
	return result, err

}

// ### Get currently locked-out users.
//
// GET /user_login_lockouts -> []UserLoginLockout
func (l *LookerSDK) AllUserLoginLockouts(
	fields string,
	options *rtl.ApiSettings) ([]UserLoginLockout, error) {
	var result []UserLoginLockout
	err := l.session.Do(&result, "GET", "/4.0", "/user_login_lockouts", map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Search currently locked-out users.
//
// GET /user_login_lockouts/search -> []UserLoginLockout
func (l *LookerSDK) SearchUserLoginLockouts(request RequestSearchUserLoginLockouts,
	options *rtl.ApiSettings) ([]UserLoginLockout, error) {
	var result []UserLoginLockout
	err := l.session.Do(&result, "GET", "/4.0", "/user_login_lockouts/search", map[string]interface{}{"fields": request.Fields, "page": request.Page, "per_page": request.PerPage, "limit": request.Limit, "offset": request.Offset, "sorts": request.Sorts, "auth_type": request.AuthType, "full_name": request.FullName, "email": request.Email, "remote_id": request.RemoteId, "filter_or": request.FilterOr}, nil, options)
	return result, err

}

// ### Removes login lockout for the associated user.
//
// DELETE /user_login_lockout/{key} -> string
func (l *LookerSDK) DeleteUserLoginLockout(
	key string,
	options *rtl.ApiSettings) (string, error) {
	key = url.PathEscape(key)
	var result string
	err := l.session.Do(&result, "DELETE", "/4.0", fmt.Sprintf("/user_login_lockout/%v", key), nil, nil, options)
	return result, err

}

// endregion Auth: Manage User Authentication Configuration

// region Board: Manage Boards

// ### Get information about all boards.
//
// GET /boards -> []Board
func (l *LookerSDK) AllBoards(
	fields string,
	options *rtl.ApiSettings) ([]Board, error) {
	var result []Board
	err := l.session.Do(&result, "GET", "/4.0", "/boards", map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Create a new board.
//
// POST /boards -> Board
func (l *LookerSDK) CreateBoard(
	body WriteBoard,
	fields string,
	options *rtl.ApiSettings) (Board, error) {
	var result Board
	err := l.session.Do(&result, "POST", "/4.0", "/boards", map[string]interface{}{"fields": fields}, body, options)
	return result, err

}

// ### Search Boards
//
// If multiple search params are given and `filter_or` is FALSE or not specified,
// search params are combined in a logical AND operation.
// Only rows that match *all* search param criteria will be returned.
//
// If `filter_or` is TRUE, multiple search params are combined in a logical OR operation.
// Results will include rows that match **any** of the search criteria.
//
// String search params use case-insensitive matching.
// String search params can contain `%` and '_' as SQL LIKE pattern match wildcard expressions.
// example="dan%" will match "danger" and "Danzig" but not "David"
// example="D_m%" will match "Damage" and "dump"
//
// Integer search params can accept a single value or a comma separated list of values. The multiple
// values will be combined under a logical OR operation - results will match at least one of
// the given values.
//
// Most search params can accept "IS NULL" and "NOT NULL" as special expressions to match
// or exclude (respectively) rows where the column is null.
//
// Boolean search params accept only "true" and "false" as values.
//
// GET /boards/search -> []Board
func (l *LookerSDK) SearchBoards(request RequestSearchBoards,
	options *rtl.ApiSettings) ([]Board, error) {
	var result []Board
	err := l.session.Do(&result, "GET", "/4.0", "/boards/search", map[string]interface{}{"title": request.Title, "created_at": request.CreatedAt, "first_name": request.FirstName, "last_name": request.LastName, "fields": request.Fields, "favorited": request.Favorited, "creator_id": request.CreatorId, "sorts": request.Sorts, "page": request.Page, "per_page": request.PerPage, "offset": request.Offset, "limit": request.Limit, "filter_or": request.FilterOr, "permission": request.Permission}, nil, options)
	return result, err

}

// ### Get information about a board.
//
// GET /boards/{board_id} -> Board
func (l *LookerSDK) Board(
	boardId string,
	fields string,
	options *rtl.ApiSettings) (Board, error) {
	boardId = url.PathEscape(boardId)
	var result Board
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/boards/%v", boardId), map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Update a board definition.
//
// PATCH /boards/{board_id} -> Board
func (l *LookerSDK) UpdateBoard(
	boardId string,
	body WriteBoard,
	fields string,
	options *rtl.ApiSettings) (Board, error) {
	boardId = url.PathEscape(boardId)
	var result Board
	err := l.session.Do(&result, "PATCH", "/4.0", fmt.Sprintf("/boards/%v", boardId), map[string]interface{}{"fields": fields}, body, options)
	return result, err

}

// ### Delete a board.
//
// DELETE /boards/{board_id} -> string
func (l *LookerSDK) DeleteBoard(
	boardId string,
	options *rtl.ApiSettings) (string, error) {
	boardId = url.PathEscape(boardId)
	var result string
	err := l.session.Do(&result, "DELETE", "/4.0", fmt.Sprintf("/boards/%v", boardId), nil, nil, options)
	return result, err

}

// ### Get information about all board items.
//
// GET /board_items -> []BoardItem
func (l *LookerSDK) AllBoardItems(request RequestAllBoardItems,
	options *rtl.ApiSettings) ([]BoardItem, error) {
	var result []BoardItem
	err := l.session.Do(&result, "GET", "/4.0", "/board_items", map[string]interface{}{"fields": request.Fields, "sorts": request.Sorts, "board_section_id": request.BoardSectionId}, nil, options)
	return result, err

}

// ### Create a new board item.
//
// POST /board_items -> BoardItem
func (l *LookerSDK) CreateBoardItem(
	body WriteBoardItem,
	fields string,
	options *rtl.ApiSettings) (BoardItem, error) {
	var result BoardItem
	err := l.session.Do(&result, "POST", "/4.0", "/board_items", map[string]interface{}{"fields": fields}, body, options)
	return result, err

}

// ### Get information about a board item.
//
// GET /board_items/{board_item_id} -> BoardItem
func (l *LookerSDK) BoardItem(
	boardItemId string,
	fields string,
	options *rtl.ApiSettings) (BoardItem, error) {
	boardItemId = url.PathEscape(boardItemId)
	var result BoardItem
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/board_items/%v", boardItemId), map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Update a board item definition.
//
// PATCH /board_items/{board_item_id} -> BoardItem
func (l *LookerSDK) UpdateBoardItem(
	boardItemId string,
	body WriteBoardItem,
	fields string,
	options *rtl.ApiSettings) (BoardItem, error) {
	boardItemId = url.PathEscape(boardItemId)
	var result BoardItem
	err := l.session.Do(&result, "PATCH", "/4.0", fmt.Sprintf("/board_items/%v", boardItemId), map[string]interface{}{"fields": fields}, body, options)
	return result, err

}

// ### Delete a board item.
//
// DELETE /board_items/{board_item_id} -> string
func (l *LookerSDK) DeleteBoardItem(
	boardItemId string,
	options *rtl.ApiSettings) (string, error) {
	boardItemId = url.PathEscape(boardItemId)
	var result string
	err := l.session.Do(&result, "DELETE", "/4.0", fmt.Sprintf("/board_items/%v", boardItemId), nil, nil, options)
	return result, err

}

// ### Get information about all board sections.
//
// GET /board_sections -> []BoardSection
func (l *LookerSDK) AllBoardSections(request RequestAllBoardSections,
	options *rtl.ApiSettings) ([]BoardSection, error) {
	var result []BoardSection
	err := l.session.Do(&result, "GET", "/4.0", "/board_sections", map[string]interface{}{"fields": request.Fields, "sorts": request.Sorts}, nil, options)
	return result, err

}

// ### Create a new board section.
//
// POST /board_sections -> BoardSection
func (l *LookerSDK) CreateBoardSection(
	body WriteBoardSection,
	fields string,
	options *rtl.ApiSettings) (BoardSection, error) {
	var result BoardSection
	err := l.session.Do(&result, "POST", "/4.0", "/board_sections", map[string]interface{}{"fields": fields}, body, options)
	return result, err

}

// ### Get information about a board section.
//
// GET /board_sections/{board_section_id} -> BoardSection
func (l *LookerSDK) BoardSection(
	boardSectionId string,
	fields string,
	options *rtl.ApiSettings) (BoardSection, error) {
	boardSectionId = url.PathEscape(boardSectionId)
	var result BoardSection
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/board_sections/%v", boardSectionId), map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Update a board section definition.
//
// PATCH /board_sections/{board_section_id} -> BoardSection
func (l *LookerSDK) UpdateBoardSection(
	boardSectionId string,
	body WriteBoardSection,
	fields string,
	options *rtl.ApiSettings) (BoardSection, error) {
	boardSectionId = url.PathEscape(boardSectionId)
	var result BoardSection
	err := l.session.Do(&result, "PATCH", "/4.0", fmt.Sprintf("/board_sections/%v", boardSectionId), map[string]interface{}{"fields": fields}, body, options)
	return result, err

}

// ### Delete a board section.
//
// DELETE /board_sections/{board_section_id} -> string
func (l *LookerSDK) DeleteBoardSection(
	boardSectionId string,
	options *rtl.ApiSettings) (string, error) {
	boardSectionId = url.PathEscape(boardSectionId)
	var result string
	err := l.session.Do(&result, "DELETE", "/4.0", fmt.Sprintf("/board_sections/%v", boardSectionId), nil, nil, options)
	return result, err

}

// endregion Board: Manage Boards

// region ColorCollection: Manage Color Collections

// ### Get an array of all existing Color Collections
// Get a **single** color collection by id with [ColorCollection](#!/ColorCollection/color_collection)
//
// Get all **standard** color collections with [ColorCollection](#!/ColorCollection/color_collections_standard)
//
// Get all **custom** color collections with [ColorCollection](#!/ColorCollection/color_collections_custom)
//
// **Note**: Only an API user with the Admin role can call this endpoint. Unauthorized requests will return `Not Found` (404) errors.
//
// GET /color_collections -> []ColorCollection
func (l *LookerSDK) AllColorCollections(
	fields string,
	options *rtl.ApiSettings) ([]ColorCollection, error) {
	var result []ColorCollection
	err := l.session.Do(&result, "GET", "/4.0", "/color_collections", map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Create a custom color collection with the specified information
//
// Creates a new custom color collection object, returning the details, including the created id.
//
// **Update** an existing color collection with [Update Color Collection](#!/ColorCollection/update_color_collection)
//
// **Permanently delete** an existing custom color collection with [Delete Color Collection](#!/ColorCollection/delete_color_collection)
//
// **Note**: Only an API user with the Admin role can call this endpoint. Unauthorized requests will return `Not Found` (404) errors.
//
// POST /color_collections -> ColorCollection
func (l *LookerSDK) CreateColorCollection(
	body WriteColorCollection,
	options *rtl.ApiSettings) (ColorCollection, error) {
	var result ColorCollection
	err := l.session.Do(&result, "POST", "/4.0", "/color_collections", nil, body, options)
	return result, err

}

// ### Get an array of all existing **Custom** Color Collections
// Get a **single** color collection by id with [ColorCollection](#!/ColorCollection/color_collection)
//
// Get all **standard** color collections with [ColorCollection](#!/ColorCollection/color_collections_standard)
//
// **Note**: Only an API user with the Admin role can call this endpoint. Unauthorized requests will return `Not Found` (404) errors.
//
// GET /color_collections/custom -> []ColorCollection
func (l *LookerSDK) ColorCollectionsCustom(
	fields string,
	options *rtl.ApiSettings) ([]ColorCollection, error) {
	var result []ColorCollection
	err := l.session.Do(&result, "GET", "/4.0", "/color_collections/custom", map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Get an array of all existing **Standard** Color Collections
// Get a **single** color collection by id with [ColorCollection](#!/ColorCollection/color_collection)
//
// Get all **custom** color collections with [ColorCollection](#!/ColorCollection/color_collections_custom)
//
// **Note**: Only an API user with the Admin role can call this endpoint. Unauthorized requests will return `Not Found` (404) errors.
//
// GET /color_collections/standard -> []ColorCollection
func (l *LookerSDK) ColorCollectionsStandard(
	fields string,
	options *rtl.ApiSettings) ([]ColorCollection, error) {
	var result []ColorCollection
	err := l.session.Do(&result, "GET", "/4.0", "/color_collections/standard", map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Get the default color collection
//
// Use this to retrieve the default Color Collection.
//
// Set the default color collection with [ColorCollection](#!/ColorCollection/set_default_color_collection)
//
// GET /color_collections/default -> ColorCollection
func (l *LookerSDK) DefaultColorCollection(
	options *rtl.ApiSettings) (ColorCollection, error) {
	var result ColorCollection
	err := l.session.Do(&result, "GET", "/4.0", "/color_collections/default", nil, nil, options)
	return result, err

}

// ### Set the global default Color Collection by ID
//
// Returns the new specified default Color Collection object.
// **Note**: Only an API user with the Admin role can call this endpoint. Unauthorized requests will return `Not Found` (404) errors.
//
// PUT /color_collections/default -> ColorCollection
func (l *LookerSDK) SetDefaultColorCollection(
	collectionId string,
	options *rtl.ApiSettings) (ColorCollection, error) {
	var result ColorCollection
	err := l.session.Do(&result, "PUT", "/4.0", "/color_collections/default", map[string]interface{}{"collection_id": collectionId}, nil, options)
	return result, err

}

// ### Get a Color Collection by ID
//
// Use this to retrieve a specific Color Collection.
// Get a **single** color collection by id with [ColorCollection](#!/ColorCollection/color_collection)
//
// Get all **standard** color collections with [ColorCollection](#!/ColorCollection/color_collections_standard)
//
// Get all **custom** color collections with [ColorCollection](#!/ColorCollection/color_collections_custom)
//
// **Note**: Only an API user with the Admin role can call this endpoint. Unauthorized requests will return `Not Found` (404) errors.
//
// GET /color_collections/{collection_id} -> ColorCollection
func (l *LookerSDK) ColorCollection(
	collectionId string,
	fields string,
	options *rtl.ApiSettings) (ColorCollection, error) {
	collectionId = url.PathEscape(collectionId)
	var result ColorCollection
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/color_collections/%v", collectionId), map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Update a custom color collection by id.
// **Note**: Only an API user with the Admin role can call this endpoint. Unauthorized requests will return `Not Found` (404) errors.
//
// PATCH /color_collections/{collection_id} -> ColorCollection
func (l *LookerSDK) UpdateColorCollection(
	collectionId string,
	body WriteColorCollection,
	options *rtl.ApiSettings) (ColorCollection, error) {
	collectionId = url.PathEscape(collectionId)
	var result ColorCollection
	err := l.session.Do(&result, "PATCH", "/4.0", fmt.Sprintf("/color_collections/%v", collectionId), nil, body, options)
	return result, err

}

// ### Delete a custom color collection by id
//
// This operation permanently deletes the identified **Custom** color collection.
//
// **Standard** color collections cannot be deleted
//
// Because multiple color collections can have the same label, they must be deleted by ID, not name.
// **Note**: Only an API user with the Admin role can call this endpoint. Unauthorized requests will return `Not Found` (404) errors.
//
// DELETE /color_collections/{collection_id} -> string
func (l *LookerSDK) DeleteColorCollection(
	collectionId string,
	options *rtl.ApiSettings) (string, error) {
	collectionId = url.PathEscape(collectionId)
	var result string
	err := l.session.Do(&result, "DELETE", "/4.0", fmt.Sprintf("/color_collections/%v", collectionId), nil, nil, options)
	return result, err

}

// endregion ColorCollection: Manage Color Collections

// region Config: Manage General Configuration

// Get the current Cloud Storage Configuration.
//
// GET /cloud_storage -> BackupConfiguration
func (l *LookerSDK) CloudStorageConfiguration(
	options *rtl.ApiSettings) (BackupConfiguration, error) {
	var result BackupConfiguration
	err := l.session.Do(&result, "GET", "/4.0", "/cloud_storage", nil, nil, options)
	return result, err

}

// Update the current Cloud Storage Configuration.
//
// PATCH /cloud_storage -> BackupConfiguration
func (l *LookerSDK) UpdateCloudStorageConfiguration(
	body WriteBackupConfiguration,
	options *rtl.ApiSettings) (BackupConfiguration, error) {
	var result BackupConfiguration
	err := l.session.Do(&result, "PATCH", "/4.0", "/cloud_storage", nil, body, options)
	return result, err

}

// ### Get the current status and content of custom welcome emails
//
// GET /custom_welcome_email -> CustomWelcomeEmail
//
// Deprecated: This method is deprecated.
func (l *LookerSDK) CustomWelcomeEmail(
	options *rtl.ApiSettings) (CustomWelcomeEmail, error) {
	var result CustomWelcomeEmail
	err := l.session.Do(&result, "GET", "/4.0", "/custom_welcome_email", nil, nil, options)
	return result, err

}

// Update custom welcome email setting and values. Optionally send a test email with the new content to the currently logged in user.
//
// PATCH /custom_welcome_email -> CustomWelcomeEmail
//
// Deprecated: This method is deprecated.
func (l *LookerSDK) UpdateCustomWelcomeEmail(
	body CustomWelcomeEmail,
	sendTestWelcomeEmail bool,
	options *rtl.ApiSettings) (CustomWelcomeEmail, error) {
	var result CustomWelcomeEmail
	err := l.session.Do(&result, "PATCH", "/4.0", "/custom_welcome_email", map[string]interface{}{"send_test_welcome_email": sendTestWelcomeEmail}, body, options)
	return result, err

}

// Requests to this endpoint will send a welcome email with the custom content provided in the body to the currently logged in user.
//
// PUT /custom_welcome_email_test -> WelcomeEmailTest
func (l *LookerSDK) UpdateCustomWelcomeEmailTest(
	body WelcomeEmailTest,
	options *rtl.ApiSettings) (WelcomeEmailTest, error) {
	var result WelcomeEmailTest
	err := l.session.Do(&result, "PUT", "/4.0", "/custom_welcome_email_test", nil, body, options)
	return result, err

}

// ### Retrieve the value for whether or not digest emails is enabled
//
// GET /digest_emails_enabled -> DigestEmails
func (l *LookerSDK) DigestEmailsEnabled(
	options *rtl.ApiSettings) (DigestEmails, error) {
	var result DigestEmails
	err := l.session.Do(&result, "GET", "/4.0", "/digest_emails_enabled", nil, nil, options)
	return result, err

}

// ### Update the setting for enabling/disabling digest emails
//
// PATCH /digest_emails_enabled -> DigestEmails
func (l *LookerSDK) UpdateDigestEmailsEnabled(
	body DigestEmails,
	options *rtl.ApiSettings) (DigestEmails, error) {
	var result DigestEmails
	err := l.session.Do(&result, "PATCH", "/4.0", "/digest_emails_enabled", nil, body, options)
	return result, err

}

// ### Trigger the generation of digest email records and send them to Looker's internal system. This does not send
// any actual emails, it generates records containing content which may be of interest for users who have become inactive.
// Emails will be sent at a later time from Looker's internal system if the Digest Emails feature is enabled in settings.
//
// POST /digest_email_send -> DigestEmailSend
func (l *LookerSDK) CreateDigestEmailSend(
	options *rtl.ApiSettings) (DigestEmailSend, error) {
	var result DigestEmailSend
	err := l.session.Do(&result, "POST", "/4.0", "/digest_email_send", nil, nil, options)
	return result, err

}

// ### Get Egress IP Addresses
//
// # Returns the list of public egress IP Addresses for a hosted customer's instance
//
// Calls to this endpoint may be denied by [Looker (Google Cloud core)](https://cloud.google.com/looker/docs/r/looker-core/overview).
//
// GET /public_egress_ip_addresses -> EgressIpAddresses
func (l *LookerSDK) PublicEgressIpAddresses(
	options *rtl.ApiSettings) (EgressIpAddresses, error) {
	var result EgressIpAddresses
	err := l.session.Do(&result, "GET", "/4.0", "/public_egress_ip_addresses", nil, nil, options)
	return result, err

}

// ### Set the menu item name and content for internal help resources
//
// GET /internal_help_resources_content -> InternalHelpResourcesContent
func (l *LookerSDK) InternalHelpResourcesContent(
	options *rtl.ApiSettings) (InternalHelpResourcesContent, error) {
	var result InternalHelpResourcesContent
	err := l.session.Do(&result, "GET", "/4.0", "/internal_help_resources_content", nil, nil, options)
	return result, err

}

// Update internal help resources content
//
// PATCH /internal_help_resources_content -> InternalHelpResourcesContent
func (l *LookerSDK) UpdateInternalHelpResourcesContent(
	body WriteInternalHelpResourcesContent,
	options *rtl.ApiSettings) (InternalHelpResourcesContent, error) {
	var result InternalHelpResourcesContent
	err := l.session.Do(&result, "PATCH", "/4.0", "/internal_help_resources_content", nil, body, options)
	return result, err

}

// ### Get and set the options for internal help resources
//
// GET /internal_help_resources_enabled -> InternalHelpResources
func (l *LookerSDK) InternalHelpResources(
	options *rtl.ApiSettings) (InternalHelpResources, error) {
	var result InternalHelpResources
	err := l.session.Do(&result, "GET", "/4.0", "/internal_help_resources_enabled", nil, nil, options)
	return result, err

}

// Update internal help resources settings
//
// PATCH /internal_help_resources -> InternalHelpResources
func (l *LookerSDK) UpdateInternalHelpResources(
	body WriteInternalHelpResources,
	options *rtl.ApiSettings) (InternalHelpResources, error) {
	var result InternalHelpResources
	err := l.session.Do(&result, "PATCH", "/4.0", "/internal_help_resources", nil, body, options)
	return result, err

}

// ### Get all legacy features.
//
// Calls to this endpoint may be denied by [Looker (Google Cloud core)](https://cloud.google.com/looker/docs/r/looker-core/overview).
//
// GET /legacy_features -> []LegacyFeature
func (l *LookerSDK) AllLegacyFeatures(
	options *rtl.ApiSettings) ([]LegacyFeature, error) {
	var result []LegacyFeature
	err := l.session.Do(&result, "GET", "/4.0", "/legacy_features", nil, nil, options)
	return result, err

}

// ### Get information about the legacy feature with a specific id.
//
// Calls to this endpoint may be denied by [Looker (Google Cloud core)](https://cloud.google.com/looker/docs/r/looker-core/overview).
//
// GET /legacy_features/{legacy_feature_id} -> LegacyFeature
func (l *LookerSDK) LegacyFeature(
	legacyFeatureId string,
	options *rtl.ApiSettings) (LegacyFeature, error) {
	legacyFeatureId = url.PathEscape(legacyFeatureId)
	var result LegacyFeature
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/legacy_features/%v", legacyFeatureId), nil, nil, options)
	return result, err

}

// ### Update information about the legacy feature with a specific id.
//
// Calls to this endpoint may be denied by [Looker (Google Cloud core)](https://cloud.google.com/looker/docs/r/looker-core/overview).
//
// PATCH /legacy_features/{legacy_feature_id} -> LegacyFeature
func (l *LookerSDK) UpdateLegacyFeature(
	legacyFeatureId string,
	body WriteLegacyFeature,
	options *rtl.ApiSettings) (LegacyFeature, error) {
	legacyFeatureId = url.PathEscape(legacyFeatureId)
	var result LegacyFeature
	err := l.session.Do(&result, "PATCH", "/4.0", fmt.Sprintf("/legacy_features/%v", legacyFeatureId), nil, body, options)
	return result, err

}

// ### Get a list of locales that Looker supports.
//
// GET /locales -> []Locale
func (l *LookerSDK) AllLocales(
	options *rtl.ApiSettings) ([]Locale, error) {
	var result []Locale
	err := l.session.Do(&result, "GET", "/4.0", "/locales", nil, nil, options)
	return result, err

}

// ### Get all mobile settings.
//
// GET /mobile/settings -> MobileSettings
func (l *LookerSDK) MobileSettings(
	options *rtl.ApiSettings) (MobileSettings, error) {
	var result MobileSettings
	err := l.session.Do(&result, "GET", "/4.0", "/mobile/settings", nil, nil, options)
	return result, err

}

// ### Get Looker Settings
//
// Available settings are:
//   - allow_user_timezones
//   - custom_welcome_email
//   - data_connector_default_enabled
//   - extension_framework_enabled
//   - extension_load_url_enabled
//   - marketplace_auto_install_enabled
//   - marketplace_automation
//   - marketplace_terms_accepted
//   - marketplace_enabled
//   - marketplace_site
//   - onboarding_enabled
//   - privatelabel_configuration
//   - timezone
//   - host_url
//   - email_domain_allowlist
//   - embed_cookieless_v2
//   - embed_enabled
//   - embed_config
//
// GET /setting -> Setting
func (l *LookerSDK) GetSetting(
	fields string,
	options *rtl.ApiSettings) (Setting, error) {
	var result Setting
	err := l.session.Do(&result, "GET", "/4.0", "/setting", map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Configure Looker Settings
//
// Available settings are:
//   - allow_user_timezones
//   - custom_welcome_email
//   - data_connector_default_enabled
//   - extension_framework_enabled
//   - extension_load_url_enabled
//   - marketplace_auto_install_enabled
//   - marketplace_automation
//   - marketplace_terms_accepted
//   - marketplace_enabled
//   - marketplace_site
//   - onboarding_enabled
//   - privatelabel_configuration
//   - timezone
//   - host_url
//   - email_domain_allowlist
//   - embed_cookieless_v2
//   - embed_enabled
//   - embed_config
//
// See the `Setting` type for more information on the specific values that can be configured.
//
// If a setting update is rejected, the API error payload should provide information on the cause of the rejection.
//
// PATCH /setting -> Setting
func (l *LookerSDK) SetSetting(
	body WriteSetting,
	fields string,
	options *rtl.ApiSettings) (Setting, error) {
	var result Setting
	err := l.session.Do(&result, "PATCH", "/4.0", "/setting", map[string]interface{}{"fields": fields}, body, options)
	return result, err

}

// ### Configure SMTP Settings
//
//	This API allows users to configure the SMTP settings on the Looker instance.
//	Only admin users are authorised to call this API.
//
// POST /smtp_settings -> Void
func (l *LookerSDK) SetSmtpSettings(
	body SmtpSettings,
	options *rtl.ApiSettings) error {
	err := l.session.Do(nil, "POST", "/4.0", "/smtp_settings", nil, body, options)
	return err

}

// ### Get current SMTP status.
//
// GET /smtp_status -> SmtpStatus
func (l *LookerSDK) SmtpStatus(
	fields string,
	options *rtl.ApiSettings) (SmtpStatus, error) {
	var result SmtpStatus
	err := l.session.Do(&result, "GET", "/4.0", "/smtp_status", map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Get a list of timezones that Looker supports (e.g. useful for scheduling tasks).
//
// GET /timezones -> []Timezone
func (l *LookerSDK) AllTimezones(
	options *rtl.ApiSettings) ([]Timezone, error) {
	var result []Timezone
	err := l.session.Do(&result, "GET", "/4.0", "/timezones", nil, nil, options)
	return result, err

}

// ### Get information about all API versions supported by this Looker instance.
//
// GET /versions -> ApiVersion
func (l *LookerSDK) Versions(
	fields string,
	options *rtl.ApiSettings) (ApiVersion, error) {
	var result ApiVersion
	err := l.session.Do(&result, "GET", "/4.0", "/versions", map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Get an API specification for this Looker instance.
//
// # The specification is returned as a JSON document in Swagger 2.x format
//
// GET /api_spec/{api_version}/{specification} -> interface{}
func (l *LookerSDK) ApiSpec(
	apiVersion string,
	specification string,
	options *rtl.ApiSettings) (interface{}, error) {
	apiVersion = url.PathEscape(apiVersion)
	specification = url.PathEscape(specification)
	var result interface{}
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/api_spec/%v/%v", apiVersion, specification), nil, nil, options)
	return result, err

}

// ### This feature is enabled only by special license.
//
// This endpoint provides the private label configuration, which includes hiding documentation links, custom favicon uploading, etc.
//
// This endpoint is deprecated. [Get Setting](#!/Config/get_setting) should be used to retrieve private label settings instead
//
// GET /whitelabel_configuration -> WhitelabelConfiguration
//
// Deprecated: This method is deprecated.
func (l *LookerSDK) WhitelabelConfiguration(
	fields string,
	options *rtl.ApiSettings) (WhitelabelConfiguration, error) {
	var result WhitelabelConfiguration
	err := l.session.Do(&result, "GET", "/4.0", "/whitelabel_configuration", map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Update the private label configuration
//
// This endpoint is deprecated. [Set Setting](#!/Config/set_setting) should be used to update private label settings instead
//
// PUT /whitelabel_configuration -> WhitelabelConfiguration
//
// Deprecated: This method is deprecated.
func (l *LookerSDK) UpdateWhitelabelConfiguration(
	body WriteWhitelabelConfiguration,
	options *rtl.ApiSettings) (WhitelabelConfiguration, error) {
	var result WhitelabelConfiguration
	err := l.session.Do(&result, "PUT", "/4.0", "/whitelabel_configuration", nil, body, options)
	return result, err

}

// endregion Config: Manage General Configuration

// region Connection: Manage Database Connections

// ### Get information about all connections.
//
// GET /connections -> []DBConnection
func (l *LookerSDK) AllConnections(
	fields string,
	options *rtl.ApiSettings) ([]DBConnection, error) {
	var result []DBConnection
	err := l.session.Do(&result, "GET", "/4.0", "/connections", map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Create a connection using the specified configuration.
//
// POST /connections -> DBConnection
func (l *LookerSDK) CreateConnection(
	body WriteDBConnection,
	options *rtl.ApiSettings) (DBConnection, error) {
	var result DBConnection
	err := l.session.Do(&result, "POST", "/4.0", "/connections", nil, body, options)
	return result, err

}

// ### Get information about a connection.
//
// GET /connections/{connection_name} -> DBConnection
func (l *LookerSDK) Connection(
	connectionName string,
	fields string,
	options *rtl.ApiSettings) (DBConnection, error) {
	connectionName = url.PathEscape(connectionName)
	var result DBConnection
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/connections/%v", connectionName), map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Update a connection using the specified configuration.
//
// PATCH /connections/{connection_name} -> DBConnection
func (l *LookerSDK) UpdateConnection(
	connectionName string,
	body WriteDBConnection,
	options *rtl.ApiSettings) (DBConnection, error) {
	connectionName = url.PathEscape(connectionName)
	var result DBConnection
	err := l.session.Do(&result, "PATCH", "/4.0", fmt.Sprintf("/connections/%v", connectionName), nil, body, options)
	return result, err

}

// ### Delete a connection.
//
// DELETE /connections/{connection_name} -> string
func (l *LookerSDK) DeleteConnection(
	connectionName string,
	options *rtl.ApiSettings) (string, error) {
	connectionName = url.PathEscape(connectionName)
	var result string
	err := l.session.Do(&result, "DELETE", "/4.0", fmt.Sprintf("/connections/%v", connectionName), nil, nil, options)
	return result, err

}

// ### Delete a connection override.
//
// DELETE /connections/{connection_name}/connection_override/{override_context} -> string
func (l *LookerSDK) DeleteConnectionOverride(
	connectionName string,
	overrideContext string,
	options *rtl.ApiSettings) (string, error) {
	connectionName = url.PathEscape(connectionName)
	overrideContext = url.PathEscape(overrideContext)
	var result string
	err := l.session.Do(&result, "DELETE", "/4.0", fmt.Sprintf("/connections/%v/connection_override/%v", connectionName, overrideContext), nil, nil, options)
	return result, err

}

// ### Test an existing connection.
//
// Note that a connection's 'dialect' property has a 'connection_tests' property that lists the
// specific types of tests that the connection supports.
//
// This API is rate limited.
//
// Unsupported tests in the request will be ignored.
//
// PUT /connections/{connection_name}/test -> []DBConnectionTestResult
func (l *LookerSDK) TestConnection(
	connectionName string,
	tests rtl.DelimString,
	options *rtl.ApiSettings) ([]DBConnectionTestResult, error) {
	connectionName = url.PathEscape(connectionName)
	var result []DBConnectionTestResult
	err := l.session.Do(&result, "PUT", "/4.0", fmt.Sprintf("/connections/%v/test", connectionName), map[string]interface{}{"tests": tests}, nil, options)
	return result, err

}

// ### Test a connection configuration.
//
// Note that a connection's 'dialect' property has a 'connection_tests' property that lists the
// specific types of tests that the connection supports.
//
// This API is rate limited.
//
// Unsupported tests in the request will be ignored.
//
// PUT /connections/test -> []DBConnectionTestResult
func (l *LookerSDK) TestConnectionConfig(
	body WriteDBConnection,
	tests rtl.DelimString,
	options *rtl.ApiSettings) ([]DBConnectionTestResult, error) {
	var result []DBConnectionTestResult
	err := l.session.Do(&result, "PUT", "/4.0", "/connections/test", map[string]interface{}{"tests": tests}, body, options)
	return result, err

}

// ### Get information about all dialects.
//
// GET /dialect_info -> []DialectInfo
func (l *LookerSDK) AllDialectInfos(
	fields string,
	options *rtl.ApiSettings) ([]DialectInfo, error) {
	var result []DialectInfo
	err := l.session.Do(&result, "GET", "/4.0", "/dialect_info", map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Get all External OAuth Applications.
//
// This is an OAuth Application which Looker uses to access external systems.
//
// GET /external_oauth_applications -> []ExternalOauthApplication
func (l *LookerSDK) AllExternalOauthApplications(request RequestAllExternalOauthApplications,
	options *rtl.ApiSettings) ([]ExternalOauthApplication, error) {
	var result []ExternalOauthApplication
	err := l.session.Do(&result, "GET", "/4.0", "/external_oauth_applications", map[string]interface{}{"name": request.Name, "client_id": request.ClientId}, nil, options)
	return result, err

}

// ### Create an OAuth Application using the specified configuration.
//
// This is an OAuth Application which Looker uses to access external systems.
//
// POST /external_oauth_applications -> ExternalOauthApplication
func (l *LookerSDK) CreateExternalOauthApplication(
	body WriteExternalOauthApplication,
	options *rtl.ApiSettings) (ExternalOauthApplication, error) {
	var result ExternalOauthApplication
	err := l.session.Do(&result, "POST", "/4.0", "/external_oauth_applications", nil, body, options)
	return result, err

}

// ### Create OAuth User state.
//
// POST /external_oauth_applications/user_state -> CreateOAuthApplicationUserStateResponse
func (l *LookerSDK) CreateOauthApplicationUserState(
	body CreateOAuthApplicationUserStateRequest,
	options *rtl.ApiSettings) (CreateOAuthApplicationUserStateResponse, error) {
	var result CreateOAuthApplicationUserStateResponse
	err := l.session.Do(&result, "POST", "/4.0", "/external_oauth_applications/user_state", nil, body, options)
	return result, err

}

// ### Get information about all SSH Servers.
//
// GET /ssh_servers -> []SshServer
func (l *LookerSDK) AllSshServers(
	fields string,
	options *rtl.ApiSettings) ([]SshServer, error) {
	var result []SshServer
	err := l.session.Do(&result, "GET", "/4.0", "/ssh_servers", map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Create an SSH Server.
//
// POST /ssh_servers -> SshServer
func (l *LookerSDK) CreateSshServer(
	body WriteSshServer,
	options *rtl.ApiSettings) (SshServer, error) {
	var result SshServer
	err := l.session.Do(&result, "POST", "/4.0", "/ssh_servers", nil, body, options)
	return result, err

}

// ### Get information about an SSH Server.
//
// GET /ssh_server/{ssh_server_id} -> SshServer
func (l *LookerSDK) SshServer(
	sshServerId string,
	options *rtl.ApiSettings) (SshServer, error) {
	sshServerId = url.PathEscape(sshServerId)
	var result SshServer
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/ssh_server/%v", sshServerId), nil, nil, options)
	return result, err

}

// ### Update an SSH Server.
//
// PATCH /ssh_server/{ssh_server_id} -> SshServer
func (l *LookerSDK) UpdateSshServer(
	sshServerId string,
	body WriteSshServer,
	options *rtl.ApiSettings) (SshServer, error) {
	sshServerId = url.PathEscape(sshServerId)
	var result SshServer
	err := l.session.Do(&result, "PATCH", "/4.0", fmt.Sprintf("/ssh_server/%v", sshServerId), nil, body, options)
	return result, err

}

// ### Delete an SSH Server.
//
// DELETE /ssh_server/{ssh_server_id} -> string
func (l *LookerSDK) DeleteSshServer(
	sshServerId string,
	options *rtl.ApiSettings) (string, error) {
	sshServerId = url.PathEscape(sshServerId)
	var result string
	err := l.session.Do(&result, "DELETE", "/4.0", fmt.Sprintf("/ssh_server/%v", sshServerId), nil, nil, options)
	return result, err

}

// ### Test the SSH Server
//
// GET /ssh_server/{ssh_server_id}/test -> SshServer
func (l *LookerSDK) TestSshServer(
	sshServerId string,
	options *rtl.ApiSettings) (SshServer, error) {
	sshServerId = url.PathEscape(sshServerId)
	var result SshServer
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/ssh_server/%v/test", sshServerId), nil, nil, options)
	return result, err

}

// ### Get information about all SSH Tunnels.
//
// GET /ssh_tunnels -> []SshTunnel
func (l *LookerSDK) AllSshTunnels(
	fields string,
	options *rtl.ApiSettings) ([]SshTunnel, error) {
	var result []SshTunnel
	err := l.session.Do(&result, "GET", "/4.0", "/ssh_tunnels", map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Create an SSH Tunnel
//
// POST /ssh_tunnels -> SshTunnel
func (l *LookerSDK) CreateSshTunnel(
	body WriteSshTunnel,
	options *rtl.ApiSettings) (SshTunnel, error) {
	var result SshTunnel
	err := l.session.Do(&result, "POST", "/4.0", "/ssh_tunnels", nil, body, options)
	return result, err

}

// ### Get information about an SSH Tunnel.
//
// GET /ssh_tunnel/{ssh_tunnel_id} -> SshTunnel
func (l *LookerSDK) SshTunnel(
	sshTunnelId string,
	options *rtl.ApiSettings) (SshTunnel, error) {
	sshTunnelId = url.PathEscape(sshTunnelId)
	var result SshTunnel
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/ssh_tunnel/%v", sshTunnelId), nil, nil, options)
	return result, err

}

// ### Update an SSH Tunnel
//
// PATCH /ssh_tunnel/{ssh_tunnel_id} -> SshTunnel
func (l *LookerSDK) UpdateSshTunnel(
	sshTunnelId string,
	body WriteSshTunnel,
	options *rtl.ApiSettings) (SshTunnel, error) {
	sshTunnelId = url.PathEscape(sshTunnelId)
	var result SshTunnel
	err := l.session.Do(&result, "PATCH", "/4.0", fmt.Sprintf("/ssh_tunnel/%v", sshTunnelId), nil, body, options)
	return result, err

}

// ### Delete an SSH Tunnel
//
// DELETE /ssh_tunnel/{ssh_tunnel_id} -> string
func (l *LookerSDK) DeleteSshTunnel(
	sshTunnelId string,
	options *rtl.ApiSettings) (string, error) {
	sshTunnelId = url.PathEscape(sshTunnelId)
	var result string
	err := l.session.Do(&result, "DELETE", "/4.0", fmt.Sprintf("/ssh_tunnel/%v", sshTunnelId), nil, nil, options)
	return result, err

}

// ### Test the SSH Tunnel
//
// GET /ssh_tunnel/{ssh_tunnel_id}/test -> SshTunnel
func (l *LookerSDK) TestSshTunnel(
	sshTunnelId string,
	options *rtl.ApiSettings) (SshTunnel, error) {
	sshTunnelId = url.PathEscape(sshTunnelId)
	var result SshTunnel
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/ssh_tunnel/%v/test", sshTunnelId), nil, nil, options)
	return result, err

}

// ### Get the SSH public key
//
// Get the public key created for this instance to identify itself to a remote SSH server.
//
// GET /ssh_public_key -> SshPublicKey
func (l *LookerSDK) SshPublicKey(
	options *rtl.ApiSettings) (SshPublicKey, error) {
	var result SshPublicKey
	err := l.session.Do(&result, "GET", "/4.0", "/ssh_public_key", nil, nil, options)
	return result, err

}

// endregion Connection: Manage Database Connections

// region Content: Manage Content

// ### Search Favorite Content
//
// If multiple search params are given and `filter_or` is FALSE or not specified,
// search params are combined in a logical AND operation.
// Only rows that match *all* search param criteria will be returned.
//
// If `filter_or` is TRUE, multiple search params are combined in a logical OR operation.
// Results will include rows that match **any** of the search criteria.
//
// String search params use case-insensitive matching.
// String search params can contain `%` and '_' as SQL LIKE pattern match wildcard expressions.
// example="dan%" will match "danger" and "Danzig" but not "David"
// example="D_m%" will match "Damage" and "dump"
//
// Integer search params can accept a single value or a comma separated list of values. The multiple
// values will be combined under a logical OR operation - results will match at least one of
// the given values.
//
// Most search params can accept "IS NULL" and "NOT NULL" as special expressions to match
// or exclude (respectively) rows where the column is null.
//
// Boolean search params accept only "true" and "false" as values.
//
// GET /content_favorite/search -> []ContentFavorite
func (l *LookerSDK) SearchContentFavorites(request RequestSearchContentFavorites,
	options *rtl.ApiSettings) ([]ContentFavorite, error) {
	var result []ContentFavorite
	err := l.session.Do(&result, "GET", "/4.0", "/content_favorite/search", map[string]interface{}{"id": request.Id, "user_id": request.UserId, "content_metadata_id": request.ContentMetadataId, "dashboard_id": request.DashboardId, "look_id": request.LookId, "board_id": request.BoardId, "limit": request.Limit, "offset": request.Offset, "sorts": request.Sorts, "fields": request.Fields, "filter_or": request.FilterOr}, nil, options)
	return result, err

}

// ### Get favorite content by its id
//
// GET /content_favorite/{content_favorite_id} -> ContentFavorite
func (l *LookerSDK) ContentFavorite(
	contentFavoriteId string,
	fields string,
	options *rtl.ApiSettings) (ContentFavorite, error) {
	contentFavoriteId = url.PathEscape(contentFavoriteId)
	var result ContentFavorite
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/content_favorite/%v", contentFavoriteId), map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Delete favorite content
//
// DELETE /content_favorite/{content_favorite_id} -> string
func (l *LookerSDK) DeleteContentFavorite(
	contentFavoriteId string,
	options *rtl.ApiSettings) (string, error) {
	contentFavoriteId = url.PathEscape(contentFavoriteId)
	var result string
	err := l.session.Do(&result, "DELETE", "/4.0", fmt.Sprintf("/content_favorite/%v", contentFavoriteId), nil, nil, options)
	return result, err

}

// ### Create favorite content
//
// POST /content_favorite -> ContentFavorite
func (l *LookerSDK) CreateContentFavorite(
	body WriteContentFavorite,
	options *rtl.ApiSettings) (ContentFavorite, error) {
	var result ContentFavorite
	err := l.session.Do(&result, "POST", "/4.0", "/content_favorite", nil, body, options)
	return result, err

}

// ### Get information about all content metadata in a space.
//
// GET /content_metadata -> []ContentMeta
func (l *LookerSDK) AllContentMetadatas(
	parentId string,
	fields string,
	options *rtl.ApiSettings) ([]ContentMeta, error) {
	var result []ContentMeta
	err := l.session.Do(&result, "GET", "/4.0", "/content_metadata", map[string]interface{}{"parent_id": parentId, "fields": fields}, nil, options)
	return result, err

}

// ### Get information about an individual content metadata record.
//
// GET /content_metadata/{content_metadata_id} -> ContentMeta
func (l *LookerSDK) ContentMetadata(
	contentMetadataId string,
	fields string,
	options *rtl.ApiSettings) (ContentMeta, error) {
	contentMetadataId = url.PathEscape(contentMetadataId)
	var result ContentMeta
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/content_metadata/%v", contentMetadataId), map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Move a piece of content.
//
// PATCH /content_metadata/{content_metadata_id} -> ContentMeta
func (l *LookerSDK) UpdateContentMetadata(
	contentMetadataId string,
	body WriteContentMeta,
	options *rtl.ApiSettings) (ContentMeta, error) {
	contentMetadataId = url.PathEscape(contentMetadataId)
	var result ContentMeta
	err := l.session.Do(&result, "PATCH", "/4.0", fmt.Sprintf("/content_metadata/%v", contentMetadataId), nil, body, options)
	return result, err

}

// ### All content metadata access records for a content metadata item.
//
// GET /content_metadata_access -> []ContentMetaGroupUser
func (l *LookerSDK) AllContentMetadataAccesses(
	contentMetadataId string,
	fields string,
	options *rtl.ApiSettings) ([]ContentMetaGroupUser, error) {
	var result []ContentMetaGroupUser
	err := l.session.Do(&result, "GET", "/4.0", "/content_metadata_access", map[string]interface{}{"content_metadata_id": contentMetadataId, "fields": fields}, nil, options)
	return result, err

}

// ### Create content metadata access.
//
// POST /content_metadata_access -> ContentMetaGroupUser
func (l *LookerSDK) CreateContentMetadataAccess(
	body ContentMetaGroupUser,
	sendBoardsNotificationEmail bool,
	options *rtl.ApiSettings) (ContentMetaGroupUser, error) {
	var result ContentMetaGroupUser
	err := l.session.Do(&result, "POST", "/4.0", "/content_metadata_access", map[string]interface{}{"send_boards_notification_email": sendBoardsNotificationEmail}, body, options)
	return result, err

}

// ### Update type of access for content metadata.
//
// PUT /content_metadata_access/{content_metadata_access_id} -> ContentMetaGroupUser
func (l *LookerSDK) UpdateContentMetadataAccess(
	contentMetadataAccessId string,
	body ContentMetaGroupUser,
	options *rtl.ApiSettings) (ContentMetaGroupUser, error) {
	contentMetadataAccessId = url.PathEscape(contentMetadataAccessId)
	var result ContentMetaGroupUser
	err := l.session.Do(&result, "PUT", "/4.0", fmt.Sprintf("/content_metadata_access/%v", contentMetadataAccessId), nil, body, options)
	return result, err

}

// ### Remove content metadata access.
//
// DELETE /content_metadata_access/{content_metadata_access_id} -> string
func (l *LookerSDK) DeleteContentMetadataAccess(
	contentMetadataAccessId string,
	options *rtl.ApiSettings) (string, error) {
	contentMetadataAccessId = url.PathEscape(contentMetadataAccessId)
	var result string
	err := l.session.Do(&result, "DELETE", "/4.0", fmt.Sprintf("/content_metadata_access/%v", contentMetadataAccessId), nil, nil, options)
	return result, err

}

// ### Search across looks, dashboards, and lookml dashboards. The terms field will be matched against the
// title and description of the content and the closest results are returned. Content that has been frequently
// viewed and those pieces of content stored in public folders will be ranked more highly in the results.
//
// This endpoint does not return a full description of these content types. For more specific information
// about each type please refer to the individual content specific API endpoints.
//
// Get the **full details** of a specific dashboard (or lookml dashboard) by id with [dashboard()](#!/Dashboard/dashboard)
// Get the **full details** of a specific look by id with [look()](#!/Look/look)
//
// GET /content/{terms} -> []ContentSearch
func (l *LookerSDK) SearchContent(request RequestSearchContent,
	options *rtl.ApiSettings) ([]ContentSearch, error) {
	request.Terms = url.PathEscape(request.Terms)
	var result []ContentSearch
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/content/%v", request.Terms), map[string]interface{}{"fields": request.Fields, "types": request.Types, "limit": request.Limit, "offset": request.Offset, "page": request.Page, "per_page": request.PerPage}, nil, options)
	return result, err

}

// ### Get an image representing the contents of a dashboard or look.
//
// The returned thumbnail is an abstract representation of the contents of a dashboard or look and does not
// reflect the actual data displayed in the respective visualizations.
//
// GET /content_thumbnail/{type}/{resource_id} -> string
//
// **Note**: Binary content may be returned by this method.
func (l *LookerSDK) ContentThumbnail(request RequestContentThumbnail,
	options *rtl.ApiSettings) (string, error) {
	request.Type = url.PathEscape(request.Type)
	request.ResourceId = url.PathEscape(request.ResourceId)
	var result string
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/content_thumbnail/%v/%v", request.Type, request.ResourceId), map[string]interface{}{"reload": request.Reload, "theme": request.Theme, "format": request.Format, "width": request.Width, "height": request.Height}, nil, options)
	return result, err

}

// ### Validate All Content
//
// Performs validation of all looks and dashboards
// Returns a list of errors found as well as metadata about the content validation run.
//
// GET /content_validation -> ContentValidation
func (l *LookerSDK) ContentValidation(
	fields string,
	options *rtl.ApiSettings) (ContentValidation, error) {
	var result ContentValidation
	err := l.session.Do(&result, "GET", "/4.0", "/content_validation", map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Search Content Views
//
// If multiple search params are given and `filter_or` is FALSE or not specified,
// search params are combined in a logical AND operation.
// Only rows that match *all* search param criteria will be returned.
//
// If `filter_or` is TRUE, multiple search params are combined in a logical OR operation.
// Results will include rows that match **any** of the search criteria.
//
// String search params use case-insensitive matching.
// String search params can contain `%` and '_' as SQL LIKE pattern match wildcard expressions.
// example="dan%" will match "danger" and "Danzig" but not "David"
// example="D_m%" will match "Damage" and "dump"
//
// Integer search params can accept a single value or a comma separated list of values. The multiple
// values will be combined under a logical OR operation - results will match at least one of
// the given values.
//
// Most search params can accept "IS NULL" and "NOT NULL" as special expressions to match
// or exclude (respectively) rows where the column is null.
//
// Boolean search params accept only "true" and "false" as values.
//
// GET /content_view/search -> []ContentView
func (l *LookerSDK) SearchContentViews(request RequestSearchContentViews,
	options *rtl.ApiSettings) ([]ContentView, error) {
	var result []ContentView
	err := l.session.Do(&result, "GET", "/4.0", "/content_view/search", map[string]interface{}{"view_count": request.ViewCount, "group_id": request.GroupId, "look_id": request.LookId, "dashboard_id": request.DashboardId, "content_metadata_id": request.ContentMetadataId, "start_of_week_date": request.StartOfWeekDate, "all_time": request.AllTime, "user_id": request.UserId, "fields": request.Fields, "limit": request.Limit, "offset": request.Offset, "sorts": request.Sorts, "filter_or": request.FilterOr}, nil, options)
	return result, err

}

// ### Get a vector image representing the contents of a dashboard or look.
//
// # DEPRECATED:  Use [content_thumbnail()](#!/Content/content_thumbnail)
//
// The returned thumbnail is an abstract representation of the contents of a dashboard or look and does not
// reflect the actual data displayed in the respective visualizations.
//
// GET /vector_thumbnail/{type}/{resource_id} -> string
//
// Deprecated: This method is deprecated.
func (l *LookerSDK) VectorThumbnail(
	type0 string,
	resourceId string,
	reload string,
	options *rtl.ApiSettings) (string, error) {
	type0 = url.PathEscape(type0)
	resourceId = url.PathEscape(resourceId)
	var result string
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/vector_thumbnail/%v/%v", type0, resourceId), map[string]interface{}{"reload": reload}, nil, options)
	return result, err

}

// endregion Content: Manage Content

// region Dashboard: Manage Dashboards

// ### Get information about all active dashboards.
//
// Returns an array of **abbreviated dashboard objects**. Dashboards marked as deleted are excluded from this list.
//
// Get the **full details** of a specific dashboard by id with [dashboard()](#!/Dashboard/dashboard)
//
// Find **deleted dashboards** with [search_dashboards()](#!/Dashboard/search_dashboards)
//
// GET /dashboards -> []DashboardBase
func (l *LookerSDK) AllDashboards(
	fields string,
	options *rtl.ApiSettings) ([]DashboardBase, error) {
	var result []DashboardBase
	err := l.session.Do(&result, "GET", "/4.0", "/dashboards", map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Create a new dashboard
//
// Creates a new dashboard object and returns the details of the newly created dashboard.
//
// `Title` and `space_id` are required fields.
// `Space_id` must contain the id of an existing space.
// A dashboard's `title` must be unique within the space in which it resides.
//
// If you receive a 422 error response when creating a dashboard, be sure to look at the
// response body for information about exactly which fields are missing or contain invalid data.
//
// You can **update** an existing dashboard with [update_dashboard()](#!/Dashboard/update_dashboard)
//
// You can **permanently delete** an existing dashboard with [delete_dashboard()](#!/Dashboard/delete_dashboard)
//
// POST /dashboards -> Dashboard
func (l *LookerSDK) CreateDashboard(
	body WriteDashboard,
	options *rtl.ApiSettings) (Dashboard, error) {
	var result Dashboard
	err := l.session.Do(&result, "POST", "/4.0", "/dashboards", nil, body, options)
	return result, err

}

// ### Search Dashboards
//
// Returns an array of **user-defined dashboard** objects that match the specified search criteria.
// Note, [search_dashboards()](#!/Dashboard/search_dashboards) does not return LookML dashboard objects.
//
// If multiple search params are given and `filter_or` is FALSE or not specified,
// search params are combined in a logical AND operation.
// Only rows that match *all* search param criteria will be returned.
//
// If `filter_or` is TRUE, multiple search params are combined in a logical OR operation.
// Results will include rows that match **any** of the search criteria.
//
// String search params use case-insensitive matching.
// String search params can contain `%` and '_' as SQL LIKE pattern match wildcard expressions.
// example="dan%" will match "danger" and "Danzig" but not "David"
// example="D_m%" will match "Damage" and "dump"
//
// Integer search params can accept a single value or a comma separated list of values. The multiple
// values will be combined under a logical OR operation - results will match at least one of
// the given values.
//
// Most search params can accept "IS NULL" and "NOT NULL" as special expressions to match
// or exclude (respectively) rows where the column is null.
//
// Boolean search params accept only "true" and "false" as values.
//
// The parameters `limit`, and `offset` are recommended for fetching results in page-size chunks.
//
// Get a **single dashboard** by id with [dashboard()](#!/Dashboard/dashboard)
//
// GET /dashboards/search -> []Dashboard
func (l *LookerSDK) SearchDashboards(request RequestSearchDashboards,
	options *rtl.ApiSettings) ([]Dashboard, error) {
	var result []Dashboard
	err := l.session.Do(&result, "GET", "/4.0", "/dashboards/search", map[string]interface{}{"id": request.Id, "slug": request.Slug, "title": request.Title, "description": request.Description, "content_favorite_id": request.ContentFavoriteId, "folder_id": request.FolderId, "deleted": request.Deleted, "user_id": request.UserId, "view_count": request.ViewCount, "content_metadata_id": request.ContentMetadataId, "curate": request.Curate, "last_viewed_at": request.LastViewedAt, "fields": request.Fields, "page": request.Page, "per_page": request.PerPage, "limit": request.Limit, "offset": request.Offset, "sorts": request.Sorts, "filter_or": request.FilterOr, "not_owned_by": request.NotOwnedBy}, nil, options)
	return result, err

}

// ### Import a LookML dashboard to a space as a UDD
// Creates a UDD (a dashboard which exists in the Looker database rather than as a LookML file) from the LookML dashboard
// and places it in the space specified. The created UDD will have a lookml_link_id which links to the original LookML dashboard.
//
// To give the imported dashboard specify a (e.g. title: "my title") in the body of your request, otherwise the imported
// dashboard will have the same title as the original LookML dashboard.
//
// For this operation to succeed the user must have permission to see the LookML dashboard in question, and have permission to
// create content in the space the dashboard is being imported to.
//
// **Sync** a linked UDD with [sync_lookml_dashboard()](#!/Dashboard/sync_lookml_dashboard)
// **Unlink** a linked UDD by setting lookml_link_id to null with [update_dashboard()](#!/Dashboard/update_dashboard)
//
// POST /dashboards/{lookml_dashboard_id}/import/{space_id} -> Dashboard
func (l *LookerSDK) ImportLookmlDashboard(
	lookmlDashboardId string,
	spaceId string,
	body WriteDashboard,
	rawLocale bool,
	options *rtl.ApiSettings) (Dashboard, error) {
	lookmlDashboardId = url.PathEscape(lookmlDashboardId)
	spaceId = url.PathEscape(spaceId)
	var result Dashboard
	err := l.session.Do(&result, "POST", "/4.0", fmt.Sprintf("/dashboards/%v/import/%v", lookmlDashboardId, spaceId), map[string]interface{}{"raw_locale": rawLocale}, body, options)
	return result, err

}

// ### Update all linked dashboards to match the specified LookML dashboard.
//
// Any UDD (a dashboard which exists in the Looker database rather than as a LookML file) which has a `lookml_link_id`
// property value referring to a LookML dashboard's id (model::dashboardname) will be updated so that it matches the current state of the LookML dashboard.
//
// For this operation to succeed the user must have permission to view the LookML dashboard, and only linked dashboards
// that the user has permission to update will be synced.
//
// To **link** or **unlink** a UDD set the `lookml_link_id` property with [update_dashboard()](#!/Dashboard/update_dashboard)
//
// PATCH /dashboards/{lookml_dashboard_id}/sync -> []int64
func (l *LookerSDK) SyncLookmlDashboard(
	lookmlDashboardId string,
	body WriteDashboard,
	rawLocale bool,
	options *rtl.ApiSettings) ([]int64, error) {
	lookmlDashboardId = url.PathEscape(lookmlDashboardId)
	var result []int64
	err := l.session.Do(&result, "PATCH", "/4.0", fmt.Sprintf("/dashboards/%v/sync", lookmlDashboardId), map[string]interface{}{"raw_locale": rawLocale}, body, options)
	return result, err

}

// ### Get information about a dashboard
//
// # Returns the full details of the identified dashboard object
//
// Get a **summary list** of all active dashboards with [all_dashboards()](#!/Dashboard/all_dashboards)
//
// You can **Search** for dashboards with [search_dashboards()](#!/Dashboard/search_dashboards)
//
// GET /dashboards/{dashboard_id} -> Dashboard
func (l *LookerSDK) Dashboard(
	dashboardId string,
	fields string,
	options *rtl.ApiSettings) (Dashboard, error) {
	dashboardId = url.PathEscape(dashboardId)
	var result Dashboard
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/dashboards/%v", dashboardId), map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Update a dashboard
//
// You can use this function to change the string and integer properties of
// a dashboard. Nested objects such as filters, dashboard elements, or dashboard layout components
// cannot be modified by this function - use the update functions for the respective
// nested object types (like [update_dashboard_filter()](#!/Dashboard/update_dashboard_filter) to change a filter)
// to modify nested objects referenced by a dashboard.
//
// If you receive a 422 error response when updating a dashboard, be sure to look at the
// response body for information about exactly which fields are missing or contain invalid data.
//
// PATCH /dashboards/{dashboard_id} -> Dashboard
func (l *LookerSDK) UpdateDashboard(
	dashboardId string,
	body WriteDashboard,
	options *rtl.ApiSettings) (Dashboard, error) {
	dashboardId = url.PathEscape(dashboardId)
	var result Dashboard
	err := l.session.Do(&result, "PATCH", "/4.0", fmt.Sprintf("/dashboards/%v", dashboardId), nil, body, options)
	return result, err

}

// ### Delete the dashboard with the specified id
//
// Permanently **deletes** a dashboard. (The dashboard cannot be recovered after this operation.)
//
// "Soft" delete or hide a dashboard by setting its `deleted` status to `True` with [update_dashboard()](#!/Dashboard/update_dashboard).
//
// Note: When a dashboard is deleted in the UI, it is soft deleted. Use this API call to permanently remove it, if desired.
//
// DELETE /dashboards/{dashboard_id} -> string
func (l *LookerSDK) DeleteDashboard(
	dashboardId string,
	options *rtl.ApiSettings) (string, error) {
	dashboardId = url.PathEscape(dashboardId)
	var result string
	err := l.session.Do(&result, "DELETE", "/4.0", fmt.Sprintf("/dashboards/%v", dashboardId), nil, nil, options)
	return result, err

}

// ### Get Aggregate Table LookML for Each Query on a Dashboard
//
// # Returns a JSON object that contains the dashboard id and Aggregate Table lookml
//
// GET /dashboards/aggregate_table_lookml/{dashboard_id} -> DashboardAggregateTableLookml
func (l *LookerSDK) DashboardAggregateTableLookml(
	dashboardId string,
	options *rtl.ApiSettings) (DashboardAggregateTableLookml, error) {
	dashboardId = url.PathEscape(dashboardId)
	var result DashboardAggregateTableLookml
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/dashboards/aggregate_table_lookml/%v", dashboardId), nil, nil, options)
	return result, err

}

// ### Get lookml of a UDD
//
// # Returns a JSON object that contains the dashboard id and the full lookml
//
// GET /dashboards/lookml/{dashboard_id} -> DashboardLookml
func (l *LookerSDK) DashboardLookml(
	dashboardId string,
	options *rtl.ApiSettings) (DashboardLookml, error) {
	dashboardId = url.PathEscape(dashboardId)
	var result DashboardLookml
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/dashboards/lookml/%v", dashboardId), nil, nil, options)
	return result, err

}

// ### Move an existing dashboard
//
// Moves a dashboard to a specified folder, and returns the moved dashboard.
//
// `dashboard_id` and `folder_id` are required.
// `dashboard_id` and `folder_id` must already exist, and `folder_id` must be different from the current `folder_id` of the dashboard.
//
// PATCH /dashboards/{dashboard_id}/move -> Dashboard
func (l *LookerSDK) MoveDashboard(
	dashboardId string,
	folderId string,
	options *rtl.ApiSettings) (Dashboard, error) {
	dashboardId = url.PathEscape(dashboardId)
	var result Dashboard
	err := l.session.Do(&result, "PATCH", "/4.0", fmt.Sprintf("/dashboards/%v/move", dashboardId), map[string]interface{}{"folder_id": folderId}, nil, options)
	return result, err

}

// ### Creates a dashboard object based on LookML Dashboard YAML, and returns the details of the newly created dashboard.
//
// If a dashboard exists with the YAML-defined "preferred_slug", the new dashboard will overwrite it. Otherwise, a new
// dashboard will be created. Note that when a dashboard is overwritten, alerts will not be maintained.
//
// If a folder_id is specified: new dashboards will be placed in that folder, and overwritten dashboards will be moved to it
// If the folder_id isn't specified: new dashboards will be placed in the caller's personal folder, and overwritten dashboards
// will remain where they were
//
// LookML must contain valid LookML YAML code. It's recommended to use the LookML format returned
// from [dashboard_lookml()](#!/Dashboard/dashboard_lookml) as the input LookML (newlines replaced with
// ).
//
// Note that the created dashboard is not linked to any LookML Dashboard,
// i.e. [sync_lookml_dashboard()](#!/Dashboard/sync_lookml_dashboard) will not update dashboards created by this method.
//
// POST /dashboards/lookml -> Dashboard
func (l *LookerSDK) ImportDashboardFromLookml(
	body WriteDashboardLookml,
	options *rtl.ApiSettings) (Dashboard, error) {
	var result Dashboard
	err := l.session.Do(&result, "POST", "/4.0", "/dashboards/lookml", nil, body, options)
	return result, err

}

// # DEPRECATED:  Use [import_dashboard_from_lookml()](#!/Dashboard/import_dashboard_from_lookml)
//
// POST /dashboards/from_lookml -> Dashboard
func (l *LookerSDK) CreateDashboardFromLookml(
	body WriteDashboardLookml,
	options *rtl.ApiSettings) (Dashboard, error) {
	var result Dashboard
	err := l.session.Do(&result, "POST", "/4.0", "/dashboards/from_lookml", nil, body, options)
	return result, err

}

// ### Copy an existing dashboard
//
// Creates a copy of an existing dashboard, in a specified folder, and returns the copied dashboard.
//
// `dashboard_id` is required, `dashboard_id` and `folder_id` must already exist if specified.
// `folder_id` will default to the existing folder.
//
// If a dashboard with the same title already exists in the target folder, the copy will have '(copy)'
//
//	or '(copy <# of copies>)' appended.
//
// POST /dashboards/{dashboard_id}/copy -> Dashboard
func (l *LookerSDK) CopyDashboard(
	dashboardId string,
	folderId string,
	options *rtl.ApiSettings) (Dashboard, error) {
	dashboardId = url.PathEscape(dashboardId)
	var result Dashboard
	err := l.session.Do(&result, "POST", "/4.0", fmt.Sprintf("/dashboards/%v/copy", dashboardId), map[string]interface{}{"folder_id": folderId}, nil, options)
	return result, err

}

// ### Search Dashboard Elements
//
// Returns an **array of DashboardElement objects** that match the specified search criteria.
//
// If multiple search params are given and `filter_or` is FALSE or not specified,
// search params are combined in a logical AND operation.
// Only rows that match *all* search param criteria will be returned.
//
// If `filter_or` is TRUE, multiple search params are combined in a logical OR operation.
// Results will include rows that match **any** of the search criteria.
//
// String search params use case-insensitive matching.
// String search params can contain `%` and '_' as SQL LIKE pattern match wildcard expressions.
// example="dan%" will match "danger" and "Danzig" but not "David"
// example="D_m%" will match "Damage" and "dump"
//
// Integer search params can accept a single value or a comma separated list of values. The multiple
// values will be combined under a logical OR operation - results will match at least one of
// the given values.
//
// Most search params can accept "IS NULL" and "NOT NULL" as special expressions to match
// or exclude (respectively) rows where the column is null.
//
// Boolean search params accept only "true" and "false" as values.
//
// GET /dashboard_elements/search -> []DashboardElement
func (l *LookerSDK) SearchDashboardElements(request RequestSearchDashboardElements,
	options *rtl.ApiSettings) ([]DashboardElement, error) {
	var result []DashboardElement
	err := l.session.Do(&result, "GET", "/4.0", "/dashboard_elements/search", map[string]interface{}{"dashboard_id": request.DashboardId, "look_id": request.LookId, "title": request.Title, "deleted": request.Deleted, "fields": request.Fields, "filter_or": request.FilterOr, "sorts": request.Sorts}, nil, options)
	return result, err

}

// ### Get information about the dashboard element with a specific id.
//
// GET /dashboard_elements/{dashboard_element_id} -> DashboardElement
func (l *LookerSDK) DashboardElement(
	dashboardElementId string,
	fields string,
	options *rtl.ApiSettings) (DashboardElement, error) {
	dashboardElementId = url.PathEscape(dashboardElementId)
	var result DashboardElement
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/dashboard_elements/%v", dashboardElementId), map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Update the dashboard element with a specific id.
//
// PATCH /dashboard_elements/{dashboard_element_id} -> DashboardElement
func (l *LookerSDK) UpdateDashboardElement(
	dashboardElementId string,
	body WriteDashboardElement,
	fields string,
	options *rtl.ApiSettings) (DashboardElement, error) {
	dashboardElementId = url.PathEscape(dashboardElementId)
	var result DashboardElement
	err := l.session.Do(&result, "PATCH", "/4.0", fmt.Sprintf("/dashboard_elements/%v", dashboardElementId), map[string]interface{}{"fields": fields}, body, options)
	return result, err

}

// ### Delete a dashboard element with a specific id.
//
// DELETE /dashboard_elements/{dashboard_element_id} -> string
func (l *LookerSDK) DeleteDashboardElement(
	dashboardElementId string,
	options *rtl.ApiSettings) (string, error) {
	dashboardElementId = url.PathEscape(dashboardElementId)
	var result string
	err := l.session.Do(&result, "DELETE", "/4.0", fmt.Sprintf("/dashboard_elements/%v", dashboardElementId), nil, nil, options)
	return result, err

}

// ### Get information about all the dashboard elements on a dashboard with a specific id.
//
// GET /dashboards/{dashboard_id}/dashboard_elements -> []DashboardElement
func (l *LookerSDK) DashboardDashboardElements(
	dashboardId string,
	fields string,
	options *rtl.ApiSettings) ([]DashboardElement, error) {
	dashboardId = url.PathEscape(dashboardId)
	var result []DashboardElement
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/dashboards/%v/dashboard_elements", dashboardId), map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Create a dashboard element on the dashboard with a specific id.
//
// POST /dashboard_elements -> DashboardElement
func (l *LookerSDK) CreateDashboardElement(request RequestCreateDashboardElement,
	options *rtl.ApiSettings) (DashboardElement, error) {
	var result DashboardElement
	err := l.session.Do(&result, "POST", "/4.0", "/dashboard_elements", map[string]interface{}{"fields": request.Fields, "apply_filters": request.ApplyFilters}, request.Body, options)
	return result, err

}

// ### Get information about the dashboard filters with a specific id.
//
// GET /dashboard_filters/{dashboard_filter_id} -> DashboardFilter
func (l *LookerSDK) DashboardFilter(
	dashboardFilterId string,
	fields string,
	options *rtl.ApiSettings) (DashboardFilter, error) {
	dashboardFilterId = url.PathEscape(dashboardFilterId)
	var result DashboardFilter
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/dashboard_filters/%v", dashboardFilterId), map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Update the dashboard filter with a specific id.
//
// PATCH /dashboard_filters/{dashboard_filter_id} -> DashboardFilter
func (l *LookerSDK) UpdateDashboardFilter(
	dashboardFilterId string,
	body WriteDashboardFilter,
	fields string,
	options *rtl.ApiSettings) (DashboardFilter, error) {
	dashboardFilterId = url.PathEscape(dashboardFilterId)
	var result DashboardFilter
	err := l.session.Do(&result, "PATCH", "/4.0", fmt.Sprintf("/dashboard_filters/%v", dashboardFilterId), map[string]interface{}{"fields": fields}, body, options)
	return result, err

}

// ### Delete a dashboard filter with a specific id.
//
// DELETE /dashboard_filters/{dashboard_filter_id} -> string
func (l *LookerSDK) DeleteDashboardFilter(
	dashboardFilterId string,
	options *rtl.ApiSettings) (string, error) {
	dashboardFilterId = url.PathEscape(dashboardFilterId)
	var result string
	err := l.session.Do(&result, "DELETE", "/4.0", fmt.Sprintf("/dashboard_filters/%v", dashboardFilterId), nil, nil, options)
	return result, err

}

// ### Get information about all the dashboard filters on a dashboard with a specific id.
//
// GET /dashboards/{dashboard_id}/dashboard_filters -> []DashboardFilter
func (l *LookerSDK) DashboardDashboardFilters(
	dashboardId string,
	fields string,
	options *rtl.ApiSettings) ([]DashboardFilter, error) {
	dashboardId = url.PathEscape(dashboardId)
	var result []DashboardFilter
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/dashboards/%v/dashboard_filters", dashboardId), map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Create a dashboard filter on the dashboard with a specific id.
//
// POST /dashboard_filters -> DashboardFilter
func (l *LookerSDK) CreateDashboardFilter(
	body WriteCreateDashboardFilter,
	fields string,
	options *rtl.ApiSettings) (DashboardFilter, error) {
	var result DashboardFilter
	err := l.session.Do(&result, "POST", "/4.0", "/dashboard_filters", map[string]interface{}{"fields": fields}, body, options)
	return result, err

}

// ### Get information about the dashboard elements with a specific id.
//
// GET /dashboard_layout_components/{dashboard_layout_component_id} -> DashboardLayoutComponent
func (l *LookerSDK) DashboardLayoutComponent(
	dashboardLayoutComponentId string,
	fields string,
	options *rtl.ApiSettings) (DashboardLayoutComponent, error) {
	dashboardLayoutComponentId = url.PathEscape(dashboardLayoutComponentId)
	var result DashboardLayoutComponent
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/dashboard_layout_components/%v", dashboardLayoutComponentId), map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Update the dashboard element with a specific id.
//
// PATCH /dashboard_layout_components/{dashboard_layout_component_id} -> DashboardLayoutComponent
func (l *LookerSDK) UpdateDashboardLayoutComponent(
	dashboardLayoutComponentId string,
	body WriteDashboardLayoutComponent,
	fields string,
	options *rtl.ApiSettings) (DashboardLayoutComponent, error) {
	dashboardLayoutComponentId = url.PathEscape(dashboardLayoutComponentId)
	var result DashboardLayoutComponent
	err := l.session.Do(&result, "PATCH", "/4.0", fmt.Sprintf("/dashboard_layout_components/%v", dashboardLayoutComponentId), map[string]interface{}{"fields": fields}, body, options)
	return result, err

}

// ### Get information about all the dashboard layout components for a dashboard layout with a specific id.
//
// GET /dashboard_layouts/{dashboard_layout_id}/dashboard_layout_components -> []DashboardLayoutComponent
func (l *LookerSDK) DashboardLayoutDashboardLayoutComponents(
	dashboardLayoutId string,
	fields string,
	options *rtl.ApiSettings) ([]DashboardLayoutComponent, error) {
	dashboardLayoutId = url.PathEscape(dashboardLayoutId)
	var result []DashboardLayoutComponent
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/dashboard_layouts/%v/dashboard_layout_components", dashboardLayoutId), map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Get information about the dashboard layouts with a specific id.
//
// GET /dashboard_layouts/{dashboard_layout_id} -> DashboardLayout
func (l *LookerSDK) DashboardLayout(
	dashboardLayoutId string,
	fields string,
	options *rtl.ApiSettings) (DashboardLayout, error) {
	dashboardLayoutId = url.PathEscape(dashboardLayoutId)
	var result DashboardLayout
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/dashboard_layouts/%v", dashboardLayoutId), map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Update the dashboard layout with a specific id.
//
// PATCH /dashboard_layouts/{dashboard_layout_id} -> DashboardLayout
func (l *LookerSDK) UpdateDashboardLayout(
	dashboardLayoutId string,
	body WriteDashboardLayout,
	fields string,
	options *rtl.ApiSettings) (DashboardLayout, error) {
	dashboardLayoutId = url.PathEscape(dashboardLayoutId)
	var result DashboardLayout
	err := l.session.Do(&result, "PATCH", "/4.0", fmt.Sprintf("/dashboard_layouts/%v", dashboardLayoutId), map[string]interface{}{"fields": fields}, body, options)
	return result, err

}

// ### Delete a dashboard layout with a specific id.
//
// DELETE /dashboard_layouts/{dashboard_layout_id} -> string
func (l *LookerSDK) DeleteDashboardLayout(
	dashboardLayoutId string,
	options *rtl.ApiSettings) (string, error) {
	dashboardLayoutId = url.PathEscape(dashboardLayoutId)
	var result string
	err := l.session.Do(&result, "DELETE", "/4.0", fmt.Sprintf("/dashboard_layouts/%v", dashboardLayoutId), nil, nil, options)
	return result, err

}

// ### Get information about all the dashboard elements on a dashboard with a specific id.
//
// GET /dashboards/{dashboard_id}/dashboard_layouts -> []DashboardLayout
func (l *LookerSDK) DashboardDashboardLayouts(
	dashboardId string,
	fields string,
	options *rtl.ApiSettings) ([]DashboardLayout, error) {
	dashboardId = url.PathEscape(dashboardId)
	var result []DashboardLayout
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/dashboards/%v/dashboard_layouts", dashboardId), map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Create a dashboard layout on the dashboard with a specific id.
//
// POST /dashboard_layouts -> DashboardLayout
func (l *LookerSDK) CreateDashboardLayout(
	body WriteDashboardLayout,
	fields string,
	options *rtl.ApiSettings) (DashboardLayout, error) {
	var result DashboardLayout
	err := l.session.Do(&result, "POST", "/4.0", "/dashboard_layouts", map[string]interface{}{"fields": fields}, body, options)
	return result, err

}

// endregion Dashboard: Manage Dashboards

// region DataAction: Run Data Actions

// Perform a data action. The data action object can be obtained from query results, and used to perform an arbitrary action.
//
// POST /data_actions -> DataActionResponse
func (l *LookerSDK) PerformDataAction(
	body DataActionRequest,
	options *rtl.ApiSettings) (DataActionResponse, error) {
	var result DataActionResponse
	err := l.session.Do(&result, "POST", "/4.0", "/data_actions", nil, body, options)
	return result, err

}

// For some data actions, the remote server may supply a form requesting further user input. This endpoint takes a data action, asks the remote server to generate a form for it, and returns that form to you for presentation to the user.
//
// POST /data_actions/form -> DataActionForm
func (l *LookerSDK) FetchRemoteDataActionForm(
	body map[string]interface{},
	options *rtl.ApiSettings) (DataActionForm, error) {
	var result DataActionForm
	err := l.session.Do(&result, "POST", "/4.0", "/data_actions/form", nil, body, options)
	return result, err

}

// endregion DataAction: Run Data Actions

// region Datagroup: Manage Datagroups

// ### Get information about all datagroups.
//
// GET /datagroups -> []Datagroup
func (l *LookerSDK) AllDatagroups(
	options *rtl.ApiSettings) ([]Datagroup, error) {
	var result []Datagroup
	err := l.session.Do(&result, "GET", "/4.0", "/datagroups", nil, nil, options)
	return result, err

}

// ### Get information about a datagroup.
//
// GET /datagroups/{datagroup_id} -> Datagroup
func (l *LookerSDK) Datagroup(
	datagroupId string,
	options *rtl.ApiSettings) (Datagroup, error) {
	datagroupId = url.PathEscape(datagroupId)
	var result Datagroup
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/datagroups/%v", datagroupId), nil, nil, options)
	return result, err

}

// ### Update a datagroup using the specified params.
//
// PATCH /datagroups/{datagroup_id} -> Datagroup
func (l *LookerSDK) UpdateDatagroup(
	datagroupId string,
	body WriteDatagroup,
	options *rtl.ApiSettings) (Datagroup, error) {
	datagroupId = url.PathEscape(datagroupId)
	var result Datagroup
	err := l.session.Do(&result, "PATCH", "/4.0", fmt.Sprintf("/datagroups/%v", datagroupId), nil, body, options)
	return result, err

}

// endregion Datagroup: Manage Datagroups

// region DerivedTable: View Derived Table graphs

// ### Discover information about derived tables
//
// GET /derived_table/graph/model/{model} -> DependencyGraph
func (l *LookerSDK) GraphDerivedTablesForModel(request RequestGraphDerivedTablesForModel,
	options *rtl.ApiSettings) (DependencyGraph, error) {
	request.Model = url.PathEscape(request.Model)
	var result DependencyGraph
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/derived_table/graph/model/%v", request.Model), map[string]interface{}{"format": request.Format, "color": request.Color}, nil, options)
	return result, err

}

// ### Get the subgraph representing this derived table and its dependencies.
//
// GET /derived_table/graph/view/{view} -> DependencyGraph
func (l *LookerSDK) GraphDerivedTablesForView(request RequestGraphDerivedTablesForView,
	options *rtl.ApiSettings) (DependencyGraph, error) {
	request.View = url.PathEscape(request.View)
	var result DependencyGraph
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/derived_table/graph/view/%v", request.View), map[string]interface{}{"models": request.Models, "workspace": request.Workspace}, nil, options)
	return result, err

}

// Enqueue materialization for a PDT with the given model name and view name
//
// GET /derived_table/{model_name}/{view_name}/start -> MaterializePDT
func (l *LookerSDK) StartPdtBuild(request RequestStartPdtBuild,
	options *rtl.ApiSettings) (MaterializePDT, error) {
	request.ModelName = url.PathEscape(request.ModelName)
	request.ViewName = url.PathEscape(request.ViewName)
	var result MaterializePDT
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/derived_table/%v/%v/start", request.ModelName, request.ViewName), map[string]interface{}{"force_rebuild": request.ForceRebuild, "force_full_incremental": request.ForceFullIncremental, "workspace": request.Workspace, "source": request.Source}, nil, options)
	return result, err

}

// Check status of PDT materialization
//
// GET /derived_table/{materialization_id}/status -> MaterializePDT
func (l *LookerSDK) CheckPdtBuild(
	materializationId string,
	options *rtl.ApiSettings) (MaterializePDT, error) {
	materializationId = url.PathEscape(materializationId)
	var result MaterializePDT
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/derived_table/%v/status", materializationId), nil, nil, options)
	return result, err

}

// Stop a PDT materialization
//
// GET /derived_table/{materialization_id}/stop -> MaterializePDT
func (l *LookerSDK) StopPdtBuild(
	materializationId string,
	source string,
	options *rtl.ApiSettings) (MaterializePDT, error) {
	materializationId = url.PathEscape(materializationId)
	var result MaterializePDT
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/derived_table/%v/stop", materializationId), map[string]interface{}{"source": source}, nil, options)
	return result, err

}

// endregion DerivedTable: View Derived Table graphs

// region Folder: Manage Folders

// Search for folders by creator id, parent id, name, etc
//
// GET /folders/search -> []Folder
func (l *LookerSDK) SearchFolders(request RequestSearchFolders,
	options *rtl.ApiSettings) ([]Folder, error) {
	var result []Folder
	err := l.session.Do(&result, "GET", "/4.0", "/folders/search", map[string]interface{}{"fields": request.Fields, "page": request.Page, "per_page": request.PerPage, "limit": request.Limit, "offset": request.Offset, "sorts": request.Sorts, "name": request.Name, "id": request.Id, "parent_id": request.ParentId, "creator_id": request.CreatorId, "filter_or": request.FilterOr, "is_shared_root": request.IsSharedRoot, "is_users_root": request.IsUsersRoot}, nil, options)
	return result, err

}

// ### Get information about the folder with a specific id.
//
// GET /folders/{folder_id} -> Folder
func (l *LookerSDK) Folder(
	folderId string,
	fields string,
	options *rtl.ApiSettings) (Folder, error) {
	folderId = url.PathEscape(folderId)
	var result Folder
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/folders/%v", folderId), map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Update the folder with a specific id.
//
// PATCH /folders/{folder_id} -> Folder
func (l *LookerSDK) UpdateFolder(
	folderId string,
	body UpdateFolder,
	options *rtl.ApiSettings) (Folder, error) {
	folderId = url.PathEscape(folderId)
	var result Folder
	err := l.session.Do(&result, "PATCH", "/4.0", fmt.Sprintf("/folders/%v", folderId), nil, body, options)
	return result, err

}

// ### Delete the folder with a specific id including any children folders.
// **DANGER** this will delete all looks and dashboards in the folder.
//
// DELETE /folders/{folder_id} -> string
func (l *LookerSDK) DeleteFolder(
	folderId string,
	options *rtl.ApiSettings) (string, error) {
	folderId = url.PathEscape(folderId)
	var result string
	err := l.session.Do(&result, "DELETE", "/4.0", fmt.Sprintf("/folders/%v", folderId), nil, nil, options)
	return result, err

}

// ### Get information about all folders.
//
// All personal folders will be returned.
//
// GET /folders -> []Folder
func (l *LookerSDK) AllFolders(
	fields string,
	options *rtl.ApiSettings) ([]Folder, error) {
	var result []Folder
	err := l.session.Do(&result, "GET", "/4.0", "/folders", map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Create a folder with specified information.
//
// Caller must have permission to edit the parent folder and to create folders, otherwise the request
// returns 404 Not Found.
//
// POST /folders -> Folder
func (l *LookerSDK) CreateFolder(
	body CreateFolder,
	options *rtl.ApiSettings) (Folder, error) {
	var result Folder
	err := l.session.Do(&result, "POST", "/4.0", "/folders", nil, body, options)
	return result, err

}

// ### Get the children of a folder.
//
// GET /folders/{folder_id}/children -> []Folder
func (l *LookerSDK) FolderChildren(request RequestFolderChildren,
	options *rtl.ApiSettings) ([]Folder, error) {
	request.FolderId = url.PathEscape(request.FolderId)
	var result []Folder
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/folders/%v/children", request.FolderId), map[string]interface{}{"fields": request.Fields, "page": request.Page, "per_page": request.PerPage, "limit": request.Limit, "offset": request.Offset, "sorts": request.Sorts}, nil, options)
	return result, err

}

// ### Search the children of a folder
//
// GET /folders/{folder_id}/children/search -> []Folder
func (l *LookerSDK) FolderChildrenSearch(request RequestFolderChildrenSearch,
	options *rtl.ApiSettings) ([]Folder, error) {
	request.FolderId = url.PathEscape(request.FolderId)
	var result []Folder
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/folders/%v/children/search", request.FolderId), map[string]interface{}{"fields": request.Fields, "sorts": request.Sorts, "name": request.Name}, nil, options)
	return result, err

}

// ### Get the parent of a folder
//
// GET /folders/{folder_id}/parent -> Folder
func (l *LookerSDK) FolderParent(
	folderId string,
	fields string,
	options *rtl.ApiSettings) (Folder, error) {
	folderId = url.PathEscape(folderId)
	var result Folder
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/folders/%v/parent", folderId), map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Get the ancestors of a folder
//
// GET /folders/{folder_id}/ancestors -> []Folder
func (l *LookerSDK) FolderAncestors(
	folderId string,
	fields string,
	options *rtl.ApiSettings) ([]Folder, error) {
	folderId = url.PathEscape(folderId)
	var result []Folder
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/folders/%v/ancestors", folderId), map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Get all looks in a folder.
// In API 4.0+, all looks in a folder will be returned, excluding looks in the trash.
//
// GET /folders/{folder_id}/looks -> []LookWithQuery
func (l *LookerSDK) FolderLooks(
	folderId string,
	fields string,
	options *rtl.ApiSettings) ([]LookWithQuery, error) {
	folderId = url.PathEscape(folderId)
	var result []LookWithQuery
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/folders/%v/looks", folderId), map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Get the dashboards in a folder
//
// GET /folders/{folder_id}/dashboards -> []Dashboard
func (l *LookerSDK) FolderDashboards(
	folderId string,
	fields string,
	options *rtl.ApiSettings) ([]Dashboard, error) {
	folderId = url.PathEscape(folderId)
	var result []Dashboard
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/folders/%v/dashboards", folderId), map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// endregion Folder: Manage Folders

// region Group: Manage Groups

// ### Get information about all groups.
//
// GET /groups -> []Group
func (l *LookerSDK) AllGroups(request RequestAllGroups,
	options *rtl.ApiSettings) ([]Group, error) {
	var result []Group
	err := l.session.Do(&result, "GET", "/4.0", "/groups", map[string]interface{}{"fields": request.Fields, "page": request.Page, "per_page": request.PerPage, "limit": request.Limit, "offset": request.Offset, "sorts": request.Sorts, "ids": request.Ids, "content_metadata_id": request.ContentMetadataId, "can_add_to_content_metadata": request.CanAddToContentMetadata}, nil, options)
	return result, err

}

// ### Creates a new group (admin only).
//
// POST /groups -> Group
func (l *LookerSDK) CreateGroup(
	body WriteGroup,
	fields string,
	options *rtl.ApiSettings) (Group, error) {
	var result Group
	err := l.session.Do(&result, "POST", "/4.0", "/groups", map[string]interface{}{"fields": fields}, body, options)
	return result, err

}

// ### Search groups
//
// Returns all group records that match the given search criteria.
//
// If multiple search params are given and `filter_or` is FALSE or not specified,
// search params are combined in a logical AND operation.
// Only rows that match *all* search param criteria will be returned.
//
// If `filter_or` is TRUE, multiple search params are combined in a logical OR operation.
// Results will include rows that match **any** of the search criteria.
//
// String search params use case-insensitive matching.
// String search params can contain `%` and '_' as SQL LIKE pattern match wildcard expressions.
// example="dan%" will match "danger" and "Danzig" but not "David"
// example="D_m%" will match "Damage" and "dump"
//
// Integer search params can accept a single value or a comma separated list of values. The multiple
// values will be combined under a logical OR operation - results will match at least one of
// the given values.
//
// Most search params can accept "IS NULL" and "NOT NULL" as special expressions to match
// or exclude (respectively) rows where the column is null.
//
// Boolean search params accept only "true" and "false" as values.
//
// GET /groups/search -> []Group
func (l *LookerSDK) SearchGroups(request RequestSearchGroups,
	options *rtl.ApiSettings) ([]Group, error) {
	var result []Group
	err := l.session.Do(&result, "GET", "/4.0", "/groups/search", map[string]interface{}{"fields": request.Fields, "limit": request.Limit, "offset": request.Offset, "sorts": request.Sorts, "filter_or": request.FilterOr, "id": request.Id, "name": request.Name, "external_group_id": request.ExternalGroupId, "externally_managed": request.ExternallyManaged, "externally_orphaned": request.ExternallyOrphaned}, nil, options)
	return result, err

}

// ### Search groups include roles
//
// Returns all group records that match the given search criteria, and attaches any associated roles.
//
// If multiple search params are given and `filter_or` is FALSE or not specified,
// search params are combined in a logical AND operation.
// Only rows that match *all* search param criteria will be returned.
//
// If `filter_or` is TRUE, multiple search params are combined in a logical OR operation.
// Results will include rows that match **any** of the search criteria.
//
// String search params use case-insensitive matching.
// String search params can contain `%` and '_' as SQL LIKE pattern match wildcard expressions.
// example="dan%" will match "danger" and "Danzig" but not "David"
// example="D_m%" will match "Damage" and "dump"
//
// Integer search params can accept a single value or a comma separated list of values. The multiple
// values will be combined under a logical OR operation - results will match at least one of
// the given values.
//
// Most search params can accept "IS NULL" and "NOT NULL" as special expressions to match
// or exclude (respectively) rows where the column is null.
//
// Boolean search params accept only "true" and "false" as values.
//
// GET /groups/search/with_roles -> []GroupSearch
func (l *LookerSDK) SearchGroupsWithRoles(request RequestSearchGroupsWithRoles,
	options *rtl.ApiSettings) ([]GroupSearch, error) {
	var result []GroupSearch
	err := l.session.Do(&result, "GET", "/4.0", "/groups/search/with_roles", map[string]interface{}{"fields": request.Fields, "limit": request.Limit, "offset": request.Offset, "sorts": request.Sorts, "filter_or": request.FilterOr, "id": request.Id, "name": request.Name, "external_group_id": request.ExternalGroupId, "externally_managed": request.ExternallyManaged, "externally_orphaned": request.ExternallyOrphaned}, nil, options)
	return result, err

}

// ### Search groups include hierarchy
//
// Returns all group records that match the given search criteria, and attaches
// associated role_ids and parent group_ids.
//
// If multiple search params are given and `filter_or` is FALSE or not specified,
// search params are combined in a logical AND operation.
// Only rows that match *all* search param criteria will be returned.
//
// If `filter_or` is TRUE, multiple search params are combined in a logical OR operation.
// Results will include rows that match **any** of the search criteria.
//
// String search params use case-insensitive matching.
// String search params can contain `%` and '_' as SQL LIKE pattern match wildcard expressions.
// example="dan%" will match "danger" and "Danzig" but not "David"
// example="D_m%" will match "Damage" and "dump"
//
// Integer search params can accept a single value or a comma separated list of values. The multiple
// values will be combined under a logical OR operation - results will match at least one of
// the given values.
//
// Most search params can accept "IS NULL" and "NOT NULL" as special expressions to match
// or exclude (respectively) rows where the column is null.
//
// Boolean search params accept only "true" and "false" as values.
//
// GET /groups/search/with_hierarchy -> []GroupHierarchy
func (l *LookerSDK) SearchGroupsWithHierarchy(request RequestSearchGroupsWithHierarchy,
	options *rtl.ApiSettings) ([]GroupHierarchy, error) {
	var result []GroupHierarchy
	err := l.session.Do(&result, "GET", "/4.0", "/groups/search/with_hierarchy", map[string]interface{}{"fields": request.Fields, "limit": request.Limit, "offset": request.Offset, "sorts": request.Sorts, "filter_or": request.FilterOr, "id": request.Id, "name": request.Name, "external_group_id": request.ExternalGroupId, "externally_managed": request.ExternallyManaged, "externally_orphaned": request.ExternallyOrphaned}, nil, options)
	return result, err

}

// ### Get information about a group.
//
// GET /groups/{group_id} -> Group
func (l *LookerSDK) Group(
	groupId string,
	fields string,
	options *rtl.ApiSettings) (Group, error) {
	groupId = url.PathEscape(groupId)
	var result Group
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/groups/%v", groupId), map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Updates the a group (admin only).
//
// PATCH /groups/{group_id} -> Group
func (l *LookerSDK) UpdateGroup(
	groupId string,
	body WriteGroup,
	fields string,
	options *rtl.ApiSettings) (Group, error) {
	groupId = url.PathEscape(groupId)
	var result Group
	err := l.session.Do(&result, "PATCH", "/4.0", fmt.Sprintf("/groups/%v", groupId), map[string]interface{}{"fields": fields}, body, options)
	return result, err

}

// ### Deletes a group (admin only).
//
// DELETE /groups/{group_id} -> string
func (l *LookerSDK) DeleteGroup(
	groupId string,
	options *rtl.ApiSettings) (string, error) {
	groupId = url.PathEscape(groupId)
	var result string
	err := l.session.Do(&result, "DELETE", "/4.0", fmt.Sprintf("/groups/%v", groupId), nil, nil, options)
	return result, err

}

// ### Get information about all the groups in a group
//
// GET /groups/{group_id}/groups -> []Group
func (l *LookerSDK) AllGroupGroups(
	groupId string,
	fields string,
	options *rtl.ApiSettings) ([]Group, error) {
	groupId = url.PathEscape(groupId)
	var result []Group
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/groups/%v/groups", groupId), map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Adds a new group to a group.
//
// POST /groups/{group_id}/groups -> Group
func (l *LookerSDK) AddGroupGroup(
	groupId string,
	body GroupIdForGroupInclusion,
	options *rtl.ApiSettings) (Group, error) {
	groupId = url.PathEscape(groupId)
	var result Group
	err := l.session.Do(&result, "POST", "/4.0", fmt.Sprintf("/groups/%v/groups", groupId), nil, body, options)
	return result, err

}

// ### Get information about all the users directly included in a group.
//
// GET /groups/{group_id}/users -> []User
func (l *LookerSDK) AllGroupUsers(request RequestAllGroupUsers,
	options *rtl.ApiSettings) ([]User, error) {
	request.GroupId = url.PathEscape(request.GroupId)
	var result []User
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/groups/%v/users", request.GroupId), map[string]interface{}{"fields": request.Fields, "page": request.Page, "per_page": request.PerPage, "limit": request.Limit, "offset": request.Offset, "sorts": request.Sorts}, nil, options)
	return result, err

}

// ### Adds a new user to a group.
//
// POST /groups/{group_id}/users -> User
func (l *LookerSDK) AddGroupUser(
	groupId string,
	body GroupIdForGroupUserInclusion,
	options *rtl.ApiSettings) (User, error) {
	groupId = url.PathEscape(groupId)
	var result User
	err := l.session.Do(&result, "POST", "/4.0", fmt.Sprintf("/groups/%v/users", groupId), nil, body, options)
	return result, err

}

// ### Removes a user from a group.
//
// DELETE /groups/{group_id}/users/{user_id} -> Void
func (l *LookerSDK) DeleteGroupUser(
	groupId string,
	userId string,
	options *rtl.ApiSettings) error {
	groupId = url.PathEscape(groupId)
	userId = url.PathEscape(userId)
	err := l.session.Do(nil, "DELETE", "/4.0", fmt.Sprintf("/groups/%v/users/%v", groupId, userId), nil, nil, options)
	return err

}

// ### Removes a group from a group.
//
// DELETE /groups/{group_id}/groups/{deleting_group_id} -> Void
func (l *LookerSDK) DeleteGroupFromGroup(
	groupId string,
	deletingGroupId string,
	options *rtl.ApiSettings) error {
	groupId = url.PathEscape(groupId)
	deletingGroupId = url.PathEscape(deletingGroupId)
	err := l.session.Do(nil, "DELETE", "/4.0", fmt.Sprintf("/groups/%v/groups/%v", groupId, deletingGroupId), nil, nil, options)
	return err

}

// ### Set the value of a user attribute for a group.
//
// For information about how user attribute values are calculated, see [Set User Attribute Group Values](#!/UserAttribute/set_user_attribute_group_values).
//
// PATCH /groups/{group_id}/attribute_values/{user_attribute_id} -> UserAttributeGroupValue
func (l *LookerSDK) UpdateUserAttributeGroupValue(
	groupId string,
	userAttributeId string,
	body UserAttributeGroupValue,
	options *rtl.ApiSettings) (UserAttributeGroupValue, error) {
	groupId = url.PathEscape(groupId)
	userAttributeId = url.PathEscape(userAttributeId)
	var result UserAttributeGroupValue
	err := l.session.Do(&result, "PATCH", "/4.0", fmt.Sprintf("/groups/%v/attribute_values/%v", groupId, userAttributeId), nil, body, options)
	return result, err

}

// ### Remove a user attribute value from a group.
//
// DELETE /groups/{group_id}/attribute_values/{user_attribute_id} -> Void
func (l *LookerSDK) DeleteUserAttributeGroupValue(
	groupId string,
	userAttributeId string,
	options *rtl.ApiSettings) error {
	groupId = url.PathEscape(groupId)
	userAttributeId = url.PathEscape(userAttributeId)
	err := l.session.Do(nil, "DELETE", "/4.0", fmt.Sprintf("/groups/%v/attribute_values/%v", groupId, userAttributeId), nil, nil, options)
	return err

}

// endregion Group: Manage Groups

// region Homepage: Manage Homepage

// ### Get information about the primary homepage's sections.
//
// GET /primary_homepage_sections -> []HomepageSection
func (l *LookerSDK) AllPrimaryHomepageSections(
	fields string,
	options *rtl.ApiSettings) ([]HomepageSection, error) {
	var result []HomepageSection
	err := l.session.Do(&result, "GET", "/4.0", "/primary_homepage_sections", map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// endregion Homepage: Manage Homepage

// region Integration: Manage Integrations

// ### Get information about all Integration Hubs.
//
// GET /integration_hubs -> []IntegrationHub
func (l *LookerSDK) AllIntegrationHubs(
	fields string,
	options *rtl.ApiSettings) ([]IntegrationHub, error) {
	var result []IntegrationHub
	err := l.session.Do(&result, "GET", "/4.0", "/integration_hubs", map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Create a new Integration Hub.
//
// # This API is rate limited to prevent it from being used for SSRF attacks
//
// POST /integration_hubs -> IntegrationHub
func (l *LookerSDK) CreateIntegrationHub(
	body WriteIntegrationHub,
	fields string,
	options *rtl.ApiSettings) (IntegrationHub, error) {
	var result IntegrationHub
	err := l.session.Do(&result, "POST", "/4.0", "/integration_hubs", map[string]interface{}{"fields": fields}, body, options)
	return result, err

}

// ### Get information about a Integration Hub.
//
// GET /integration_hubs/{integration_hub_id} -> IntegrationHub
func (l *LookerSDK) IntegrationHub(
	integrationHubId string,
	fields string,
	options *rtl.ApiSettings) (IntegrationHub, error) {
	integrationHubId = url.PathEscape(integrationHubId)
	var result IntegrationHub
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/integration_hubs/%v", integrationHubId), map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Update a Integration Hub definition.
//
// # This API is rate limited to prevent it from being used for SSRF attacks
//
// PATCH /integration_hubs/{integration_hub_id} -> IntegrationHub
func (l *LookerSDK) UpdateIntegrationHub(
	integrationHubId string,
	body WriteIntegrationHub,
	fields string,
	options *rtl.ApiSettings) (IntegrationHub, error) {
	integrationHubId = url.PathEscape(integrationHubId)
	var result IntegrationHub
	err := l.session.Do(&result, "PATCH", "/4.0", fmt.Sprintf("/integration_hubs/%v", integrationHubId), map[string]interface{}{"fields": fields}, body, options)
	return result, err

}

// ### Delete a Integration Hub.
//
// DELETE /integration_hubs/{integration_hub_id} -> string
func (l *LookerSDK) DeleteIntegrationHub(
	integrationHubId string,
	options *rtl.ApiSettings) (string, error) {
	integrationHubId = url.PathEscape(integrationHubId)
	var result string
	err := l.session.Do(&result, "DELETE", "/4.0", fmt.Sprintf("/integration_hubs/%v", integrationHubId), nil, nil, options)
	return result, err

}

// Accepts the legal agreement for a given integration hub. This only works for integration hubs that have legal_agreement_required set to true and legal_agreement_signed set to false.
//
// POST /integration_hubs/{integration_hub_id}/accept_legal_agreement -> IntegrationHub
func (l *LookerSDK) AcceptIntegrationHubLegalAgreement(
	integrationHubId string,
	options *rtl.ApiSettings) (IntegrationHub, error) {
	integrationHubId = url.PathEscape(integrationHubId)
	var result IntegrationHub
	err := l.session.Do(&result, "POST", "/4.0", fmt.Sprintf("/integration_hubs/%v/accept_legal_agreement", integrationHubId), nil, nil, options)
	return result, err

}

// ### Get information about all Integrations.
//
// GET /integrations -> []Integration
func (l *LookerSDK) AllIntegrations(request RequestAllIntegrations,
	options *rtl.ApiSettings) ([]Integration, error) {
	var result []Integration
	err := l.session.Do(&result, "GET", "/4.0", "/integrations", map[string]interface{}{"fields": request.Fields, "integration_hub_id": request.IntegrationHubId}, nil, options)
	return result, err

}

// ### Get information about a Integration.
//
// GET /integrations/{integration_id} -> Integration
func (l *LookerSDK) Integration(
	integrationId string,
	fields string,
	options *rtl.ApiSettings) (Integration, error) {
	integrationId = url.PathEscape(integrationId)
	var result Integration
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/integrations/%v", integrationId), map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Update parameters on a Integration.
//
// PATCH /integrations/{integration_id} -> Integration
func (l *LookerSDK) UpdateIntegration(
	integrationId string,
	body WriteIntegration,
	fields string,
	options *rtl.ApiSettings) (Integration, error) {
	integrationId = url.PathEscape(integrationId)
	var result Integration
	err := l.session.Do(&result, "PATCH", "/4.0", fmt.Sprintf("/integrations/%v", integrationId), map[string]interface{}{"fields": fields}, body, options)
	return result, err

}

// Returns the Integration form for presentation to the user.
//
// POST /integrations/{integration_id}/form -> DataActionForm
func (l *LookerSDK) FetchIntegrationForm(
	integrationId string,
	body map[string]interface{},
	options *rtl.ApiSettings) (DataActionForm, error) {
	integrationId = url.PathEscape(integrationId)
	var result DataActionForm
	err := l.session.Do(&result, "POST", "/4.0", fmt.Sprintf("/integrations/%v/form", integrationId), nil, body, options)
	return result, err

}

// Tests the integration to make sure all the settings are working.
//
// POST /integrations/{integration_id}/test -> IntegrationTestResult
func (l *LookerSDK) TestIntegration(
	integrationId string,
	options *rtl.ApiSettings) (IntegrationTestResult, error) {
	integrationId = url.PathEscape(integrationId)
	var result IntegrationTestResult
	err := l.session.Do(&result, "POST", "/4.0", fmt.Sprintf("/integrations/%v/test", integrationId), nil, nil, options)
	return result, err

}

// endregion Integration: Manage Integrations

// region Look: Run and Manage Looks

// ### Get information about all active Looks
//
// Returns an array of **abbreviated Look objects** describing all the looks that the caller has access to. Soft-deleted Looks are **not** included.
//
// Get the **full details** of a specific look by id with [look(id)](#!/Look/look)
//
// Find **soft-deleted looks** with [search_looks()](#!/Look/search_looks)
//
// GET /looks -> []Look
func (l *LookerSDK) AllLooks(
	fields string,
	options *rtl.ApiSettings) ([]Look, error) {
	var result []Look
	err := l.session.Do(&result, "GET", "/4.0", "/looks", map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Create a Look
//
// To create a look to display query data, first create the query with [create_query()](#!/Query/create_query)
// then assign the query's id to the `query_id` property in the call to `create_look()`.
//
// To place the look into a particular space, assign the space's id to the `space_id` property
// in the call to `create_look()`.
//
// POST /looks -> LookWithQuery
func (l *LookerSDK) CreateLook(
	body WriteLookWithQuery,
	fields string,
	options *rtl.ApiSettings) (LookWithQuery, error) {
	var result LookWithQuery
	err := l.session.Do(&result, "POST", "/4.0", "/looks", map[string]interface{}{"fields": fields}, body, options)
	return result, err

}

// ### Search Looks
//
// Returns an **array of Look objects** that match the specified search criteria.
//
// If multiple search params are given and `filter_or` is FALSE or not specified,
// search params are combined in a logical AND operation.
// Only rows that match *all* search param criteria will be returned.
//
// If `filter_or` is TRUE, multiple search params are combined in a logical OR operation.
// Results will include rows that match **any** of the search criteria.
//
// String search params use case-insensitive matching.
// String search params can contain `%` and '_' as SQL LIKE pattern match wildcard expressions.
// example="dan%" will match "danger" and "Danzig" but not "David"
// example="D_m%" will match "Damage" and "dump"
//
// Integer search params can accept a single value or a comma separated list of values. The multiple
// values will be combined under a logical OR operation - results will match at least one of
// the given values.
//
// Most search params can accept "IS NULL" and "NOT NULL" as special expressions to match
// or exclude (respectively) rows where the column is null.
//
// Boolean search params accept only "true" and "false" as values.
//
// Get a **single look** by id with [look(id)](#!/Look/look)
//
// GET /looks/search -> []Look
func (l *LookerSDK) SearchLooks(request RequestSearchLooks,
	options *rtl.ApiSettings) ([]Look, error) {
	var result []Look
	err := l.session.Do(&result, "GET", "/4.0", "/looks/search", map[string]interface{}{"id": request.Id, "title": request.Title, "description": request.Description, "content_favorite_id": request.ContentFavoriteId, "folder_id": request.FolderId, "user_id": request.UserId, "view_count": request.ViewCount, "deleted": request.Deleted, "query_id": request.QueryId, "curate": request.Curate, "last_viewed_at": request.LastViewedAt, "fields": request.Fields, "page": request.Page, "per_page": request.PerPage, "limit": request.Limit, "offset": request.Offset, "sorts": request.Sorts, "filter_or": request.FilterOr}, nil, options)
	return result, err

}

// ### Get a Look.
//
// Returns detailed information about a Look and its associated Query.
//
// GET /looks/{look_id} -> LookWithQuery
func (l *LookerSDK) Look(
	lookId string,
	fields string,
	options *rtl.ApiSettings) (LookWithQuery, error) {
	lookId = url.PathEscape(lookId)
	var result LookWithQuery
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/looks/%v", lookId), map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Modify a Look
//
// Use this function to modify parts of a look. Property values given in a call to `update_look` are
// applied to the existing look, so there's no need to include properties whose values are not changing.
// It's best to specify only the properties you want to change and leave everything else out
// of your `update_look` call. **Look properties marked 'read-only' will be ignored.**
//
// When a user deletes a look in the Looker UI, the look data remains in the database but is
// marked with a deleted flag ("soft-deleted"). Soft-deleted looks can be undeleted (by an admin)
// if the delete was in error.
//
// To soft-delete a look via the API, use [update_look()](#!/Look/update_look) to change the look's `deleted` property to `true`.
// You can undelete a look by calling `update_look` to change the look's `deleted` property to `false`.
//
// Soft-deleted looks are excluded from the results of [all_looks()](#!/Look/all_looks) and [search_looks()](#!/Look/search_looks), so they
// essentially disappear from view even though they still reside in the db.
// You can pass `deleted: true` as a parameter to [search_looks()](#!/Look/search_looks) to list soft-deleted looks.
//
// NOTE: [delete_look()](#!/Look/delete_look) performs a "hard delete" - the look data is removed from the Looker
// database and destroyed. There is no "undo" for `delete_look()`.
//
// PATCH /looks/{look_id} -> LookWithQuery
func (l *LookerSDK) UpdateLook(
	lookId string,
	body WriteLookWithQuery,
	fields string,
	options *rtl.ApiSettings) (LookWithQuery, error) {
	lookId = url.PathEscape(lookId)
	var result LookWithQuery
	err := l.session.Do(&result, "PATCH", "/4.0", fmt.Sprintf("/looks/%v", lookId), map[string]interface{}{"fields": fields}, body, options)
	return result, err

}

// ### Permanently Delete a Look
//
// This operation **permanently** removes a look from the Looker database.
//
// NOTE: There is no "undo" for this kind of delete.
//
// For information about soft-delete (which can be undone) see [update_look()](#!/Look/update_look).
//
// DELETE /looks/{look_id} -> string
func (l *LookerSDK) DeleteLook(
	lookId string,
	options *rtl.ApiSettings) (string, error) {
	lookId = url.PathEscape(lookId)
	var result string
	err := l.session.Do(&result, "DELETE", "/4.0", fmt.Sprintf("/looks/%v", lookId), nil, nil, options)
	return result, err

}

// ### Run a Look
//
// Runs a given look's query and returns the results in the requested format.
//
// Supported formats:
//
// | result_format | Description
// | :-----------: | :--- |
// | json | Plain json
// | json_bi | (*RECOMMENDED*) Row data plus metadata describing the fields, pivots, table calcs, and other aspects of the query. See JsonBi type for schema
// | json_detail | (*LEGACY*) Row data plus metadata describing the fields, pivots, table calcs, and other aspects of the query
// | csv | Comma separated values with a header
// | txt | Tab separated values with a header
// | html | Simple html
// | md | Simple markdown
// | xlsx | MS Excel spreadsheet
// | sql | Returns the generated SQL rather than running the query
// | png | A PNG image of the visualization of the query
// | jpg | A JPG image of the visualization of the query
//
// GET /looks/{look_id}/run/{result_format} -> string
//
// **Note**: Binary content may be returned by this method.
func (l *LookerSDK) RunLook(request RequestRunLook,
	options *rtl.ApiSettings) (string, error) {
	request.LookId = url.PathEscape(request.LookId)
	request.ResultFormat = url.PathEscape(request.ResultFormat)
	var result string
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/looks/%v/run/%v", request.LookId, request.ResultFormat), map[string]interface{}{"limit": request.Limit, "apply_formatting": request.ApplyFormatting, "apply_vis": request.ApplyVis, "cache": request.Cache, "image_width": request.ImageWidth, "image_height": request.ImageHeight, "generate_drill_links": request.GenerateDrillLinks, "force_production": request.ForceProduction, "cache_only": request.CacheOnly, "path_prefix": request.PathPrefix, "rebuild_pdts": request.RebuildPdts, "server_table_calcs": request.ServerTableCalcs}, nil, options)
	return result, err

}

// ### Copy an existing look
//
// Creates a copy of an existing look, in a specified folder, and returns the copied look.
//
// `look_id` and `folder_id` are required.
//
// `look_id` and `folder_id` must already exist, and `folder_id` must be different from the current `folder_id` of the dashboard.
//
// POST /looks/{look_id}/copy -> LookWithQuery
func (l *LookerSDK) CopyLook(
	lookId string,
	folderId string,
	options *rtl.ApiSettings) (LookWithQuery, error) {
	lookId = url.PathEscape(lookId)
	var result LookWithQuery
	err := l.session.Do(&result, "POST", "/4.0", fmt.Sprintf("/looks/%v/copy", lookId), map[string]interface{}{"folder_id": folderId}, nil, options)
	return result, err

}

// ### Move an existing look
//
// Moves a look to a specified folder, and returns the moved look.
//
// `look_id` and `folder_id` are required.
// `look_id` and `folder_id` must already exist, and `folder_id` must be different from the current `folder_id` of the dashboard.
//
// PATCH /looks/{look_id}/move -> LookWithQuery
func (l *LookerSDK) MoveLook(
	lookId string,
	folderId string,
	options *rtl.ApiSettings) (LookWithQuery, error) {
	lookId = url.PathEscape(lookId)
	var result LookWithQuery
	err := l.session.Do(&result, "PATCH", "/4.0", fmt.Sprintf("/looks/%v/move", lookId), map[string]interface{}{"folder_id": folderId}, nil, options)
	return result, err

}

// endregion Look: Run and Manage Looks

// region LookmlModel: Manage LookML Models

// ### Get information about all lookml models.
//
// GET /lookml_models -> []LookmlModel
func (l *LookerSDK) AllLookmlModels(request RequestAllLookmlModels,
	options *rtl.ApiSettings) ([]LookmlModel, error) {
	var result []LookmlModel
	err := l.session.Do(&result, "GET", "/4.0", "/lookml_models", map[string]interface{}{"fields": request.Fields, "limit": request.Limit, "offset": request.Offset}, nil, options)
	return result, err

}

// ### Create a lookml model using the specified configuration.
//
// POST /lookml_models -> LookmlModel
func (l *LookerSDK) CreateLookmlModel(
	body WriteLookmlModel,
	options *rtl.ApiSettings) (LookmlModel, error) {
	var result LookmlModel
	err := l.session.Do(&result, "POST", "/4.0", "/lookml_models", nil, body, options)
	return result, err

}

// ### Get information about a lookml model.
//
// GET /lookml_models/{lookml_model_name} -> LookmlModel
func (l *LookerSDK) LookmlModel(
	lookmlModelName string,
	fields string,
	options *rtl.ApiSettings) (LookmlModel, error) {
	lookmlModelName = url.PathEscape(lookmlModelName)
	var result LookmlModel
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/lookml_models/%v", lookmlModelName), map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Update a lookml model using the specified configuration.
//
// PATCH /lookml_models/{lookml_model_name} -> LookmlModel
func (l *LookerSDK) UpdateLookmlModel(
	lookmlModelName string,
	body WriteLookmlModel,
	options *rtl.ApiSettings) (LookmlModel, error) {
	lookmlModelName = url.PathEscape(lookmlModelName)
	var result LookmlModel
	err := l.session.Do(&result, "PATCH", "/4.0", fmt.Sprintf("/lookml_models/%v", lookmlModelName), nil, body, options)
	return result, err

}

// ### Delete a lookml model.
//
// DELETE /lookml_models/{lookml_model_name} -> string
func (l *LookerSDK) DeleteLookmlModel(
	lookmlModelName string,
	options *rtl.ApiSettings) (string, error) {
	lookmlModelName = url.PathEscape(lookmlModelName)
	var result string
	err := l.session.Do(&result, "DELETE", "/4.0", fmt.Sprintf("/lookml_models/%v", lookmlModelName), nil, nil, options)
	return result, err

}

// ### Get information about a lookml model explore.
//
// GET /lookml_models/{lookml_model_name}/explores/{explore_name} -> LookmlModelExplore
func (l *LookerSDK) LookmlModelExplore(request RequestLookmlModelExplore,
	options *rtl.ApiSettings) (LookmlModelExplore, error) {
	request.LookmlModelName = url.PathEscape(request.LookmlModelName)
	request.ExploreName = url.PathEscape(request.ExploreName)
	var result LookmlModelExplore
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/lookml_models/%v/explores/%v", request.LookmlModelName, request.ExploreName), map[string]interface{}{"fields": request.Fields, "add_drills_metadata": request.AddDrillsMetadata}, nil, options)
	return result, err

}

// endregion LookmlModel: Manage LookML Models

// region Metadata: Connection Metadata Features

// ### Field name suggestions for a model and view
//
// `filters` is a string hash of values, with the key as the field name and the string value as the filter expression:
//
// ```ruby
// {'users.age': '>=60'}
// ```
//
// or
//
// ```ruby
// {'users.age': '<30'}
// ```
//
// or
//
// ```ruby
// {'users.age': '=50'}
// ```
//
// GET /models/{model_name}/views/{view_name}/fields/{field_name}/suggestions -> ModelFieldSuggestions
func (l *LookerSDK) ModelFieldnameSuggestions(request RequestModelFieldnameSuggestions,
	options *rtl.ApiSettings) (ModelFieldSuggestions, error) {
	request.ModelName = url.PathEscape(request.ModelName)
	request.ViewName = url.PathEscape(request.ViewName)
	request.FieldName = url.PathEscape(request.FieldName)
	var result ModelFieldSuggestions
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/models/%v/views/%v/fields/%v/suggestions", request.ModelName, request.ViewName, request.FieldName), map[string]interface{}{"term": request.Term, "filters": request.Filters}, nil, options)
	return result, err

}

// ### Get a single model
//
// GET /models/{model_name} -> Model
func (l *LookerSDK) GetModel(
	modelName string,
	options *rtl.ApiSettings) (Model, error) {
	modelName = url.PathEscape(modelName)
	var result Model
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/models/%v", modelName), nil, nil, options)
	return result, err

}

// ### List databases available to this connection
//
// Certain dialects can support multiple databases per single connection.
// If this connection supports multiple databases, the database names will be returned in an array.
//
// Connections using dialects that do not support multiple databases will return an empty array.
//
// **Note**: [Connection Features](#!/Metadata/connection_features) can be used to determine if a connection supports
// multiple databases.
//
// GET /connections/{connection_name}/databases -> []string
func (l *LookerSDK) ConnectionDatabases(
	connectionName string,
	options *rtl.ApiSettings) ([]string, error) {
	connectionName = url.PathEscape(connectionName)
	var result []string
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/connections/%v/databases", connectionName), nil, nil, options)
	return result, err

}

// ### Retrieve metadata features for this connection
//
// Returns a list of feature names with `true` (available) or `false` (not available)
//
// GET /connections/{connection_name}/features -> ConnectionFeatures
func (l *LookerSDK) ConnectionFeatures(
	connectionName string,
	fields string,
	options *rtl.ApiSettings) (ConnectionFeatures, error) {
	connectionName = url.PathEscape(connectionName)
	var result ConnectionFeatures
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/connections/%v/features", connectionName), map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Get the list of schemas and tables for a connection
//
// GET /connections/{connection_name}/schemas -> []Schema
func (l *LookerSDK) ConnectionSchemas(request RequestConnectionSchemas,
	options *rtl.ApiSettings) ([]Schema, error) {
	request.ConnectionName = url.PathEscape(request.ConnectionName)
	var result []Schema
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/connections/%v/schemas", request.ConnectionName), map[string]interface{}{"database": request.Database, "cache": request.Cache, "fields": request.Fields}, nil, options)
	return result, err

}

// ### Get the list of tables for a schema
//
// For dialects that support multiple databases, optionally identify which to use. If not provided, the default
// database for the connection will be used.
//
// For dialects that do **not** support multiple databases, **do not use** the database parameter
//
// GET /connections/{connection_name}/tables -> []SchemaTables
func (l *LookerSDK) ConnectionTables(request RequestConnectionTables,
	options *rtl.ApiSettings) ([]SchemaTables, error) {
	request.ConnectionName = url.PathEscape(request.ConnectionName)
	var result []SchemaTables
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/connections/%v/tables", request.ConnectionName), map[string]interface{}{"database": request.Database, "schema_name": request.SchemaName, "cache": request.Cache, "fields": request.Fields, "table_filter": request.TableFilter, "table_limit": request.TableLimit}, nil, options)
	return result, err

}

// ### Get the columns (and therefore also the tables) in a specific schema
//
// GET /connections/{connection_name}/columns -> []SchemaColumns
func (l *LookerSDK) ConnectionColumns(request RequestConnectionColumns,
	options *rtl.ApiSettings) ([]SchemaColumns, error) {
	request.ConnectionName = url.PathEscape(request.ConnectionName)
	var result []SchemaColumns
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/connections/%v/columns", request.ConnectionName), map[string]interface{}{"database": request.Database, "schema_name": request.SchemaName, "cache": request.Cache, "table_limit": request.TableLimit, "table_names": request.TableNames, "fields": request.Fields}, nil, options)
	return result, err

}

// ### Search a connection for columns matching the specified name
//
// **Note**: `column_name` must be a valid column name. It is not a search pattern.
//
// GET /connections/{connection_name}/search_columns -> []ColumnSearch
func (l *LookerSDK) ConnectionSearchColumns(request RequestConnectionSearchColumns,
	options *rtl.ApiSettings) ([]ColumnSearch, error) {
	request.ConnectionName = url.PathEscape(request.ConnectionName)
	var result []ColumnSearch
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/connections/%v/search_columns", request.ConnectionName), map[string]interface{}{"column_name": request.ColumnName, "fields": request.Fields}, nil, options)
	return result, err

}

// ### Connection cost estimating
//
// Assign a `sql` statement to the body of the request. e.g., for Ruby, `{sql: 'select * from users'}`
//
// **Note**: If the connection's dialect has no support for cost estimates, an error will be returned
//
// POST /connections/{connection_name}/cost_estimate -> CostEstimate
func (l *LookerSDK) ConnectionCostEstimate(
	connectionName string,
	body CreateCostEstimate,
	fields string,
	options *rtl.ApiSettings) (CostEstimate, error) {
	connectionName = url.PathEscape(connectionName)
	var result CostEstimate
	err := l.session.Do(&result, "POST", "/4.0", fmt.Sprintf("/connections/%v/cost_estimate", connectionName), map[string]interface{}{"fields": fields}, body, options)
	return result, err

}

// endregion Metadata: Connection Metadata Features

// region Project: Manage Projects

// ### Generate Lockfile for All LookML Dependencies
//
//	Git must have been configured, must be in dev mode and deploy permission required
//
//	Install_all is a two step process
//	1. For each remote_dependency in a project the dependency manager will resolve any ambiguous ref.
//	2. The project will then write out a lockfile including each remote_dependency with its resolved ref.
//
// POST /projects/{project_id}/manifest/lock_all -> string
func (l *LookerSDK) LockAll(
	projectId string,
	fields string,
	options *rtl.ApiSettings) (string, error) {
	projectId = url.PathEscape(projectId)
	var result string
	err := l.session.Do(&result, "POST", "/4.0", fmt.Sprintf("/projects/%v/manifest/lock_all", projectId), map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Get All Git Branches
//
// # Returns a list of git branches in the project repository
//
// GET /projects/{project_id}/git_branches -> []GitBranch
func (l *LookerSDK) AllGitBranches(
	projectId string,
	options *rtl.ApiSettings) ([]GitBranch, error) {
	projectId = url.PathEscape(projectId)
	var result []GitBranch
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/projects/%v/git_branches", projectId), nil, nil, options)
	return result, err

}

// ### Get the Current Git Branch
//
// # Returns the git branch currently checked out in the given project repository
//
// GET /projects/{project_id}/git_branch -> GitBranch
func (l *LookerSDK) GitBranch(
	projectId string,
	options *rtl.ApiSettings) (GitBranch, error) {
	projectId = url.PathEscape(projectId)
	var result GitBranch
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/projects/%v/git_branch", projectId), nil, nil, options)
	return result, err

}

// ### Checkout and/or reset --hard an existing Git Branch
//
// Only allowed in development mode
//   - Call `update_session` to select the 'dev' workspace.
//
// Checkout an existing branch if name field is different from the name of the currently checked out branch.
//
// Optionally specify a branch name, tag name or commit SHA to which the branch should be reset.
//
//	**DANGER** hard reset will be force pushed to the remote. Unsaved changes and commits may be permanently lost.
//
// PUT /projects/{project_id}/git_branch -> GitBranch
func (l *LookerSDK) UpdateGitBranch(
	projectId string,
	body WriteGitBranch,
	options *rtl.ApiSettings) (GitBranch, error) {
	projectId = url.PathEscape(projectId)
	var result GitBranch
	err := l.session.Do(&result, "PUT", "/4.0", fmt.Sprintf("/projects/%v/git_branch", projectId), nil, body, options)
	return result, err

}

// ### Create and Checkout a Git Branch
//
// Creates and checks out a new branch in the given project repository
// Only allowed in development mode
//   - Call `update_session` to select the 'dev' workspace.
//
// Optionally specify a branch name, tag name or commit SHA as the start point in the ref field.
//
//	If no ref is specified, HEAD of the current branch will be used as the start point for the new branch.
//
// POST /projects/{project_id}/git_branch -> GitBranch
func (l *LookerSDK) CreateGitBranch(
	projectId string,
	body WriteGitBranch,
	options *rtl.ApiSettings) (GitBranch, error) {
	projectId = url.PathEscape(projectId)
	var result GitBranch
	err := l.session.Do(&result, "POST", "/4.0", fmt.Sprintf("/projects/%v/git_branch", projectId), nil, body, options)
	return result, err

}

// ### Get the specified Git Branch
//
// Returns the git branch specified in branch_name path param if it exists in the given project repository
//
// GET /projects/{project_id}/git_branch/{branch_name} -> GitBranch
func (l *LookerSDK) FindGitBranch(
	projectId string,
	branchName string,
	options *rtl.ApiSettings) (GitBranch, error) {
	projectId = url.PathEscape(projectId)
	branchName = url.PathEscape(branchName)
	var result GitBranch
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/projects/%v/git_branch/%v", projectId, branchName), nil, nil, options)
	return result, err

}

// ### Delete the specified Git Branch
//
// Delete git branch specified in branch_name path param from local and remote of specified project repository
//
// DELETE /projects/{project_id}/git_branch/{branch_name} -> string
func (l *LookerSDK) DeleteGitBranch(
	projectId string,
	branchName string,
	options *rtl.ApiSettings) (string, error) {
	projectId = url.PathEscape(projectId)
	branchName = url.PathEscape(branchName)
	var result string
	err := l.session.Do(&result, "DELETE", "/4.0", fmt.Sprintf("/projects/%v/git_branch/%v", projectId, branchName), nil, nil, options)
	return result, err

}

// ### Deploy a Remote Branch or Ref to Production
//
// Git must have been configured and deploy permission required.
//
// Deploy is a one/two step process
// 1. If this is the first deploy of this project, create the production project with git repository.
// 2. Pull the branch or ref into the production project.
//
// Can only specify either a branch or a ref.
//
// POST /projects/{project_id}/deploy_ref_to_production -> string
func (l *LookerSDK) DeployRefToProduction(request RequestDeployRefToProduction,
	options *rtl.ApiSettings) (string, error) {
	request.ProjectId = url.PathEscape(request.ProjectId)
	var result string
	err := l.session.Do(&result, "POST", "/4.0", fmt.Sprintf("/projects/%v/deploy_ref_to_production", request.ProjectId), map[string]interface{}{"branch": request.Branch, "ref": request.Ref}, nil, options)
	return result, err

}

// ### Deploy LookML from this Development Mode Project to Production
//
// # Git must have been configured, must be in dev mode and deploy permission required
//
// Deploy is a two / three step process:
//
//  1. Push commits in current branch of dev mode project to the production branch (origin/master).
//     Note a. This step is skipped in read-only projects.
//     Note b. If this step is unsuccessful for any reason (e.g. rejected non-fastforward because production branch has
//     commits not in current branch), subsequent steps will be skipped.
//  2. If this is the first deploy of this project, create the production project with git repository.
//  3. Pull the production branch into the production project.
//
// POST /projects/{project_id}/deploy_to_production -> string
func (l *LookerSDK) DeployToProduction(
	projectId string,
	options *rtl.ApiSettings) (string, error) {
	projectId = url.PathEscape(projectId)
	var result string
	err := l.session.Do(&result, "POST", "/4.0", fmt.Sprintf("/projects/%v/deploy_to_production", projectId), nil, nil, options)
	return result, err

}

// ### Reset a project to the revision of the project that is in production.
//
// **DANGER** this will delete any changes that have not been pushed to a remote repository.
//
// POST /projects/{project_id}/reset_to_production -> string
func (l *LookerSDK) ResetProjectToProduction(
	projectId string,
	options *rtl.ApiSettings) (string, error) {
	projectId = url.PathEscape(projectId)
	var result string
	err := l.session.Do(&result, "POST", "/4.0", fmt.Sprintf("/projects/%v/reset_to_production", projectId), nil, nil, options)
	return result, err

}

// ### Reset a project development branch to the revision of the project that is on the remote.
//
// **DANGER** this will delete any changes that have not been pushed to a remote repository.
//
// POST /projects/{project_id}/reset_to_remote -> string
func (l *LookerSDK) ResetProjectToRemote(
	projectId string,
	options *rtl.ApiSettings) (string, error) {
	projectId = url.PathEscape(projectId)
	var result string
	err := l.session.Do(&result, "POST", "/4.0", fmt.Sprintf("/projects/%v/reset_to_remote", projectId), nil, nil, options)
	return result, err

}

// ### Get All Projects
//
// # Returns all projects visible to the current user
//
// GET /projects -> []Project
func (l *LookerSDK) AllProjects(
	fields string,
	options *rtl.ApiSettings) ([]Project, error) {
	var result []Project
	err := l.session.Do(&result, "GET", "/4.0", "/projects", map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Create A Project
//
// dev mode required.
// - Call `update_session` to select the 'dev' workspace.
//
// `name` is required.
// `git_remote_url` is not allowed. To configure Git for the newly created project, follow the instructions in `update_project`.
//
// POST /projects -> Project
func (l *LookerSDK) CreateProject(
	body WriteProject,
	options *rtl.ApiSettings) (Project, error) {
	var result Project
	err := l.session.Do(&result, "POST", "/4.0", "/projects", nil, body, options)
	return result, err

}

// ### Get A Project
//
// # Returns the project with the given project id
//
// GET /projects/{project_id} -> Project
func (l *LookerSDK) Project(
	projectId string,
	fields string,
	options *rtl.ApiSettings) (Project, error) {
	projectId = url.PathEscape(projectId)
	var result Project
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/projects/%v", projectId), map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Update Project Configuration
//
// Apply changes to a project's configuration.
//
// #### Configuring Git for a Project
//
// To set up a Looker project with a remote git repository, follow these steps:
//
// 1. Call `update_session` to select the 'dev' workspace.
// 1. Call `create_git_deploy_key` to create a new deploy key for the project
// 1. Copy the deploy key text into the remote git repository's ssh key configuration
// 1. Call `update_project` to set project's `git_remote_url` ()and `git_service_name`, if necessary).
//
// When you modify a project's `git_remote_url`, Looker connects to the remote repository to fetch
// metadata. The remote git repository MUST be configured with the Looker-generated deploy
// key for this project prior to setting the project's `git_remote_url`.
//
// To set up a Looker project with a git repository residing on the Looker server (a 'bare' git repo):
//
// 1. Call `update_session` to select the 'dev' workspace.
// 1. Call `update_project` setting `git_remote_url` to null and `git_service_name` to "bare".
//
// PATCH /projects/{project_id} -> Project
func (l *LookerSDK) UpdateProject(
	projectId string,
	body WriteProject,
	fields string,
	options *rtl.ApiSettings) (Project, error) {
	projectId = url.PathEscape(projectId)
	var result Project
	err := l.session.Do(&result, "PATCH", "/4.0", fmt.Sprintf("/projects/%v", projectId), map[string]interface{}{"fields": fields}, body, options)
	return result, err

}

// ### Get A Projects Manifest object
//
// # Returns the project with the given project id
//
// GET /projects/{project_id}/manifest -> Manifest
func (l *LookerSDK) Manifest(
	projectId string,
	options *rtl.ApiSettings) (Manifest, error) {
	projectId = url.PathEscape(projectId)
	var result Manifest
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/projects/%v/manifest", projectId), nil, nil, options)
	return result, err

}

// ### Git Deploy Key
//
// Returns the ssh public key previously created for a project's git repository.
//
// GET /projects/{project_id}/git/deploy_key -> string
func (l *LookerSDK) GitDeployKey(
	projectId string,
	options *rtl.ApiSettings) (string, error) {
	projectId = url.PathEscape(projectId)
	var result string
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/projects/%v/git/deploy_key", projectId), nil, nil, options)
	return result, err

}

// ### Create Git Deploy Key
//
// Create a public/private key pair for authenticating ssh git requests from Looker to a remote git repository
// for a particular Looker project.
//
// Returns the public key of the generated ssh key pair.
//
// Copy this public key to your remote git repository's ssh keys configuration so that the remote git service can
// validate and accept git requests from the Looker server.
//
// POST /projects/{project_id}/git/deploy_key -> string
func (l *LookerSDK) CreateGitDeployKey(
	projectId string,
	options *rtl.ApiSettings) (string, error) {
	projectId = url.PathEscape(projectId)
	var result string
	err := l.session.Do(&result, "POST", "/4.0", fmt.Sprintf("/projects/%v/git/deploy_key", projectId), nil, nil, options)
	return result, err

}

// ### Get Cached Project Validation Results
//
// Returns the cached results of a previous project validation calculation, if any.
// Returns http status 204 No Content if no validation results exist.
//
// Validating the content of all the files in a project can be computationally intensive
// for large projects. Use this API to simply fetch the results of the most recent
// project validation rather than revalidating the entire project from scratch.
//
// A value of `"stale": true` in the response indicates that the project has changed since
// the cached validation results were computed. The cached validation results may no longer
// reflect the current state of the project.
//
// GET /projects/{project_id}/validate -> ProjectValidationCache
func (l *LookerSDK) ProjectValidationResults(
	projectId string,
	fields string,
	options *rtl.ApiSettings) (ProjectValidationCache, error) {
	projectId = url.PathEscape(projectId)
	var result ProjectValidationCache
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/projects/%v/validate", projectId), map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Validate Project
//
// Performs lint validation of all lookml files in the project.
// Returns a list of errors found, if any.
//
// Validating the content of all the files in a project can be computationally intensive
// for large projects. For best performance, call `validate_project(project_id)` only
// when you really want to recompute project validation. To quickly display the results of
// the most recent project validation (without recomputing), use `project_validation_results(project_id)`
//
// POST /projects/{project_id}/validate -> ProjectValidation
func (l *LookerSDK) ValidateProject(
	projectId string,
	fields string,
	options *rtl.ApiSettings) (ProjectValidation, error) {
	projectId = url.PathEscape(projectId)
	var result ProjectValidation
	err := l.session.Do(&result, "POST", "/4.0", fmt.Sprintf("/projects/%v/validate", projectId), map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Get Project Workspace
//
// # Returns information about the state of the project files in the currently selected workspace
//
// GET /projects/{project_id}/current_workspace -> ProjectWorkspace
func (l *LookerSDK) ProjectWorkspace(
	projectId string,
	fields string,
	options *rtl.ApiSettings) (ProjectWorkspace, error) {
	projectId = url.PathEscape(projectId)
	var result ProjectWorkspace
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/projects/%v/current_workspace", projectId), map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Get All Project Files
//
// # Returns a list of the files in the project
//
// GET /projects/{project_id}/files -> []ProjectFile
func (l *LookerSDK) AllProjectFiles(
	projectId string,
	fields string,
	options *rtl.ApiSettings) ([]ProjectFile, error) {
	projectId = url.PathEscape(projectId)
	var result []ProjectFile
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/projects/%v/files", projectId), map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Get Project File Info
//
// # Returns information about a file in the project
//
// GET /projects/{project_id}/files/file -> ProjectFile
func (l *LookerSDK) ProjectFile(
	projectId string,
	fileId string,
	fields string,
	options *rtl.ApiSettings) (ProjectFile, error) {
	projectId = url.PathEscape(projectId)
	var result ProjectFile
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/projects/%v/files/file", projectId), map[string]interface{}{"file_id": fileId, "fields": fields}, nil, options)
	return result, err

}

// ### Get All Git Connection Tests
//
// dev mode required.
//   - Call `update_session` to select the 'dev' workspace.
//
// Returns a list of tests which can be run against a project's (or the dependency project for the provided remote_url) git connection. Call [Run Git Connection Test](#!/Project/run_git_connection_test) to execute each test in sequence.
//
// Tests are ordered by increasing specificity. Tests should be run in the order returned because later tests require functionality tested by tests earlier in the test list.
//
// For example, a late-stage test for write access is meaningless if connecting to the git server (an early test) is failing.
//
// GET /projects/{project_id}/git_connection_tests -> []GitConnectionTest
func (l *LookerSDK) AllGitConnectionTests(
	projectId string,
	remoteUrl string,
	options *rtl.ApiSettings) ([]GitConnectionTest, error) {
	projectId = url.PathEscape(projectId)
	var result []GitConnectionTest
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/projects/%v/git_connection_tests", projectId), map[string]interface{}{"remote_url": remoteUrl}, nil, options)
	return result, err

}

// ### Run a git connection test
//
// Run the named test on the git service used by this project (or the dependency project for the provided remote_url) and return the result. This
// is intended to help debug git connections when things do not work properly, to give
// more helpful information about why a git url is not working with Looker.
//
// Tests should be run in the order they are returned by [Get All Git Connection Tests](#!/Project/all_git_connection_tests).
//
// GET /projects/{project_id}/git_connection_tests/{test_id} -> GitConnectionTestResult
func (l *LookerSDK) RunGitConnectionTest(request RequestRunGitConnectionTest,
	options *rtl.ApiSettings) (GitConnectionTestResult, error) {
	request.ProjectId = url.PathEscape(request.ProjectId)
	request.TestId = url.PathEscape(request.TestId)
	var result GitConnectionTestResult
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/projects/%v/git_connection_tests/%v", request.ProjectId, request.TestId), map[string]interface{}{"remote_url": request.RemoteUrl, "use_production": request.UseProduction}, nil, options)
	return result, err

}

// ### Get All LookML Tests
//
// Returns a list of tests which can be run to validate a project's LookML code and/or the underlying data,
// optionally filtered by the file id.
// Call [Run LookML Test](#!/Project/run_lookml_test) to execute tests.
//
// GET /projects/{project_id}/lookml_tests -> []LookmlTest
func (l *LookerSDK) AllLookmlTests(
	projectId string,
	fileId string,
	options *rtl.ApiSettings) ([]LookmlTest, error) {
	projectId = url.PathEscape(projectId)
	var result []LookmlTest
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/projects/%v/lookml_tests", projectId), map[string]interface{}{"file_id": fileId}, nil, options)
	return result, err

}

// ### Run LookML Tests
//
// Runs all tests in the project, optionally filtered by file, test, and/or model.
//
// GET /projects/{project_id}/lookml_tests/run -> []LookmlTestResult
func (l *LookerSDK) RunLookmlTest(request RequestRunLookmlTest,
	options *rtl.ApiSettings) ([]LookmlTestResult, error) {
	request.ProjectId = url.PathEscape(request.ProjectId)
	var result []LookmlTestResult
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/projects/%v/lookml_tests/run", request.ProjectId), map[string]interface{}{"file_id": request.FileId, "test": request.Test, "model": request.Model}, nil, options)
	return result, err

}

// ### Creates a tag for the most recent commit, or a specific ref is a SHA is provided
//
// POST /projects/{project_id}/tag -> Project
func (l *LookerSDK) TagRef(request RequestTagRef,
	options *rtl.ApiSettings) (Project, error) {
	request.ProjectId = url.PathEscape(request.ProjectId)
	var result Project
	err := l.session.Do(&result, "POST", "/4.0", fmt.Sprintf("/projects/%v/tag", request.ProjectId), map[string]interface{}{"commit_sha": request.CommitSha, "tag_name": request.TagName, "tag_message": request.TagMessage}, request.Body, options)
	return result, err

}

// ### Configure Repository Credential for a remote dependency
//
// Admin required.
//
// `root_project_id` is required.
// `credential_id` is required.
//
// PUT /projects/{root_project_id}/credential/{credential_id} -> RepositoryCredential
func (l *LookerSDK) UpdateRepositoryCredential(
	rootProjectId string,
	credentialId string,
	body WriteRepositoryCredential,
	options *rtl.ApiSettings) (RepositoryCredential, error) {
	rootProjectId = url.PathEscape(rootProjectId)
	credentialId = url.PathEscape(credentialId)
	var result RepositoryCredential
	err := l.session.Do(&result, "PUT", "/4.0", fmt.Sprintf("/projects/%v/credential/%v", rootProjectId, credentialId), nil, body, options)
	return result, err

}

// ### Repository Credential for a remote dependency
//
// Admin required.
//
// `root_project_id` is required.
// `credential_id` is required.
//
// DELETE /projects/{root_project_id}/credential/{credential_id} -> string
func (l *LookerSDK) DeleteRepositoryCredential(
	rootProjectId string,
	credentialId string,
	options *rtl.ApiSettings) (string, error) {
	rootProjectId = url.PathEscape(rootProjectId)
	credentialId = url.PathEscape(credentialId)
	var result string
	err := l.session.Do(&result, "DELETE", "/4.0", fmt.Sprintf("/projects/%v/credential/%v", rootProjectId, credentialId), nil, nil, options)
	return result, err

}

// ### Get all Repository Credentials for a project
//
// `root_project_id` is required.
//
// GET /projects/{root_project_id}/credentials -> []RepositoryCredential
func (l *LookerSDK) GetAllRepositoryCredentials(
	rootProjectId string,
	options *rtl.ApiSettings) ([]RepositoryCredential, error) {
	rootProjectId = url.PathEscape(rootProjectId)
	var result []RepositoryCredential
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/projects/%v/credentials", rootProjectId), nil, nil, options)
	return result, err

}

// endregion Project: Manage Projects

// region Query: Run and Manage Queries

// ### Create an async query task
//
// Creates a query task (job) to run a previously created query asynchronously. Returns a Query Task ID.
//
// Use [query_task(query_task_id)](#!/Query/query_task) to check the execution status of the query task.
// After the query task status reaches "Complete", use [query_task_results(query_task_id)](#!/Query/query_task_results) to fetch the results of the query.
//
// POST /query_tasks -> QueryTask
func (l *LookerSDK) CreateQueryTask(request RequestCreateQueryTask,
	options *rtl.ApiSettings) (QueryTask, error) {
	var result QueryTask
	err := l.session.Do(&result, "POST", "/4.0", "/query_tasks", map[string]interface{}{"limit": request.Limit, "apply_formatting": request.ApplyFormatting, "apply_vis": request.ApplyVis, "cache": request.Cache, "generate_drill_links": request.GenerateDrillLinks, "force_production": request.ForceProduction, "cache_only": request.CacheOnly, "path_prefix": request.PathPrefix, "rebuild_pdts": request.RebuildPdts, "server_table_calcs": request.ServerTableCalcs, "fields": request.Fields}, request.Body, options)
	return result, err

}

// ### Fetch results of multiple async queries
//
// Returns the results of multiple async queries in one request.
//
// For Query Tasks that are not completed, the response will include the execution status of the Query Task but will not include query results.
// Query Tasks whose results have expired will have a status of 'expired'.
// If the user making the API request does not have sufficient privileges to view a Query Task result, the result will have a status of 'missing'
//
// GET /query_tasks/multi_results -> map[string]interface{}
func (l *LookerSDK) QueryTaskMultiResults(
	queryTaskIds rtl.DelimString,
	options *rtl.ApiSettings) (map[string]interface{}, error) {
	var result map[string]interface{}
	err := l.session.Do(&result, "GET", "/4.0", "/query_tasks/multi_results", map[string]interface{}{"query_task_ids": queryTaskIds}, nil, options)
	return result, err

}

// ### Get Query Task details
//
// Use this function to check the status of an async query task. After the status
// reaches "Complete", you can call [query_task_results(query_task_id)](#!/Query/query_task_results) to
// retrieve the results of the query.
//
// Use [create_query_task()](#!/Query/create_query_task) to create an async query task.
//
// GET /query_tasks/{query_task_id} -> QueryTask
func (l *LookerSDK) QueryTask(
	queryTaskId string,
	fields string,
	options *rtl.ApiSettings) (QueryTask, error) {
	queryTaskId = url.PathEscape(queryTaskId)
	var result QueryTask
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/query_tasks/%v", queryTaskId), map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Get Async Query Results
//
// Returns the results of an async query task if the query has completed.
//
// If the query task is still running or waiting to run, this function returns 204 No Content.
//
// If the query task ID is invalid or the cached results of the query task have expired, this function returns 404 Not Found.
//
// Use [query_task(query_task_id)](#!/Query/query_task) to check the execution status of the query task
// Call query_task_results only after the query task status reaches "Complete".
//
// You can also use [query_task_multi_results()](#!/Query/query_task_multi_results) retrieve the
// results of multiple async query tasks at the same time.
//
// #### SQL Error Handling:
// If the query fails due to a SQL db error, how this is communicated depends on the result_format you requested in `create_query_task()`.
//
// For `json_detail` result_format: `query_task_results()` will respond with HTTP status '200 OK' and db SQL error info
// will be in the `errors` property of the response object. The 'data' property will be empty.
//
// For all other result formats: `query_task_results()` will respond with HTTP status `400 Bad Request` and some db SQL error info
// will be in the message of the 400 error response, but not as detailed as expressed in `json_detail.errors`.
// These data formats can only carry row data, and error info is not row data.
//
// GET /query_tasks/{query_task_id}/results -> QueryTask
func (l *LookerSDK) QueryTaskResults(
	queryTaskId string,
	options *rtl.ApiSettings) (QueryTask, error) {
	queryTaskId = url.PathEscape(queryTaskId)
	var result QueryTask
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/query_tasks/%v/results", queryTaskId), nil, nil, options)
	return result, err

}

// ### Get a previously created query by id.
//
// A Looker query object includes the various parameters that define a database query that has been run or
// could be run in the future. These parameters include: model, view, fields, filters, pivots, etc.
// Query *results* are not part of the query object.
//
// Query objects are unique and immutable. Query objects are created automatically in Looker as users explore data.
// Looker does not delete them; they become part of the query history. When asked to create a query for
// any given set of parameters, Looker will first try to find an existing query object with matching
// parameters and will only create a new object when an appropriate object can not be found.
//
// This 'get' method is used to get the details about a query for a given id. See the other methods here
// to 'create' and 'run' queries.
//
// Note that some fields like 'filter_config' and 'vis_config' etc are specific to how the Looker UI
// builds queries and visualizations and are not generally useful for API use. They are not required when
// creating new queries and can usually just be ignored.
//
// GET /queries/{query_id} -> Query
func (l *LookerSDK) Query(
	queryId string,
	fields string,
	options *rtl.ApiSettings) (Query, error) {
	queryId = url.PathEscape(queryId)
	var result Query
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/queries/%v", queryId), map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Get the query for a given query slug.
//
// This returns the query for the 'slug' in a query share URL.
//
// The 'slug' is a randomly chosen short string that is used as an alternative to the query's id value
// for use in URLs etc. This method exists as a convenience to help you use the API to 'find' queries that
// have been created using the Looker UI.
//
// You can use the Looker explore page to build a query and then choose the 'Share' option to
// show the share url for the query. Share urls generally look something like 'https://looker.yourcompany/x/vwGSbfc'.
// The trailing 'vwGSbfc' is the share slug. You can pass that string to this api method to get details about the query.
// Those details include the 'id' that you can use to run the query. Or, you can copy the query body
// (perhaps with your own modification) and use that as the basis to make/run new queries.
//
// This will also work with slugs from Looker explore urls like
// 'https://looker.yourcompany/explore/ecommerce/orders?qid=aogBgL6o3cKK1jN3RoZl5s'. In this case
// 'aogBgL6o3cKK1jN3RoZl5s' is the slug.
//
// GET /queries/slug/{slug} -> Query
func (l *LookerSDK) QueryForSlug(
	slug string,
	fields string,
	options *rtl.ApiSettings) (Query, error) {
	slug = url.PathEscape(slug)
	var result Query
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/queries/slug/%v", slug), map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Create a query.
//
// This allows you to create a new query that you can later run. Looker queries are immutable once created
// and are not deleted. If you create a query that is exactly like an existing query then the existing query
// will be returned and no new query will be created. Whether a new query is created or not, you can use
// the 'id' in the returned query with the 'run' method.
//
// The query parameters are passed as json in the body of the request.
//
// POST /queries -> Query
func (l *LookerSDK) CreateQuery(
	body WriteQuery,
	fields string,
	options *rtl.ApiSettings) (Query, error) {
	var result Query
	err := l.session.Do(&result, "POST", "/4.0", "/queries", map[string]interface{}{"fields": fields}, body, options)
	return result, err

}

// ### Run a saved query.
//
// This runs a previously saved query. You can use this on a query that was generated in the Looker UI
// or one that you have explicitly created using the API. You can also use a query 'id' from a saved 'Look'.
//
// The 'result_format' parameter specifies the desired structure and format of the response.
//
// Supported formats:
//
// | result_format | Description
// | :-----------: | :--- |
// | json | Plain json
// | json_bi | (*RECOMMENDED*) Row data plus metadata describing the fields, pivots, table calcs, and other aspects of the query. See JsonBi type for schema
// | json_detail | (*LEGACY*) Row data plus metadata describing the fields, pivots, table calcs, and other aspects of the query
// | csv | Comma separated values with a header
// | txt | Tab separated values with a header
// | html | Simple html
// | md | Simple markdown
// | xlsx | MS Excel spreadsheet
// | sql | Returns the generated SQL rather than running the query
// | png | A PNG image of the visualization of the query
// | jpg | A JPG image of the visualization of the query
//
// GET /queries/{query_id}/run/{result_format} -> string
//
// **Note**: Binary content may be returned by this method.
func (l *LookerSDK) RunQuery(request RequestRunQuery,
	options *rtl.ApiSettings) (string, error) {
	request.QueryId = url.PathEscape(request.QueryId)
	request.ResultFormat = url.PathEscape(request.ResultFormat)
	var result string
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/queries/%v/run/%v", request.QueryId, request.ResultFormat), map[string]interface{}{"limit": request.Limit, "apply_formatting": request.ApplyFormatting, "apply_vis": request.ApplyVis, "cache": request.Cache, "image_width": request.ImageWidth, "image_height": request.ImageHeight, "generate_drill_links": request.GenerateDrillLinks, "force_production": request.ForceProduction, "cache_only": request.CacheOnly, "path_prefix": request.PathPrefix, "rebuild_pdts": request.RebuildPdts, "server_table_calcs": request.ServerTableCalcs, "source": request.Source}, nil, options)
	return result, err

}

// ### Run the query that is specified inline in the posted body.
//
// This allows running a query as defined in json in the posted body. This combines
// the two actions of posting & running a query into one step.
//
// Here is an example body in json:
// ```
//
//	{
//	  "model":"thelook",
//	  "view":"inventory_items",
//	  "fields":["category.name","inventory_items.days_in_inventory_tier","products.count"],
//	  "filters":{"category.name":"socks"},
//	  "sorts":["products.count desc 0"],
//	  "limit":"500",
//	  "query_timezone":"America/Los_Angeles"
//	}
//
// ```
//
// When using the Ruby SDK this would be passed as a Ruby hash like:
// ```
//
//	{
//	 :model=>"thelook",
//	 :view=>"inventory_items",
//	 :fields=>
//	  ["category.name",
//	   "inventory_items.days_in_inventory_tier",
//	   "products.count"],
//	 :filters=>{:"category.name"=>"socks"},
//	 :sorts=>["products.count desc 0"],
//	 :limit=>"500",
//	 :query_timezone=>"America/Los_Angeles",
//	}
//
// ```
//
// This will return the result of running the query in the format specified by the 'result_format' parameter.
//
// Supported formats:
//
// | result_format | Description
// | :-----------: | :--- |
// | json | Plain json
// | json_bi | (*RECOMMENDED*) Row data plus metadata describing the fields, pivots, table calcs, and other aspects of the query. See JsonBi type for schema
// | json_detail | (*LEGACY*) Row data plus metadata describing the fields, pivots, table calcs, and other aspects of the query
// | csv | Comma separated values with a header
// | txt | Tab separated values with a header
// | html | Simple html
// | md | Simple markdown
// | xlsx | MS Excel spreadsheet
// | sql | Returns the generated SQL rather than running the query
// | png | A PNG image of the visualization of the query
// | jpg | A JPG image of the visualization of the query
//
// POST /queries/run/{result_format} -> string
//
// **Note**: Binary content may be returned by this method.
func (l *LookerSDK) RunInlineQuery(request RequestRunInlineQuery,
	options *rtl.ApiSettings) (string, error) {
	request.ResultFormat = url.PathEscape(request.ResultFormat)
	var result string
	err := l.session.Do(&result, "POST", "/4.0", fmt.Sprintf("/queries/run/%v", request.ResultFormat), map[string]interface{}{"limit": request.Limit, "apply_formatting": request.ApplyFormatting, "apply_vis": request.ApplyVis, "cache": request.Cache, "image_width": request.ImageWidth, "image_height": request.ImageHeight, "generate_drill_links": request.GenerateDrillLinks, "force_production": request.ForceProduction, "cache_only": request.CacheOnly, "path_prefix": request.PathPrefix, "rebuild_pdts": request.RebuildPdts, "server_table_calcs": request.ServerTableCalcs}, request.Body, options)
	return result, err

}

// ### Run an URL encoded query.
//
// This requires the caller to encode the specifiers for the query into the URL query part using
// Looker-specific syntax as explained below.
//
// Generally, you would want to use one of the methods that takes the parameters as json in the POST body
// for creating and/or running queries. This method exists for cases where one really needs to encode the
// parameters into the URL of a single 'GET' request. This matches the way that the Looker UI formats
// 'explore' URLs etc.
//
// The parameters here are very similar to the json body formatting except that the filter syntax is
// tricky. Unfortunately, this format makes this method not currently callable via the 'Try it out!' button
// in this documentation page. But, this is callable when creating URLs manually or when using the Looker SDK.
//
// Here is an example inline query URL:
//
// ```
// https://looker.mycompany.com:19999/api/4.0/queries/models/thelook/views/inventory_items/run/json?fields=category.name,inventory_items.days_in_inventory_tier,products.count&f[category.name]=socks&sorts=products.count+desc+0&limit=500&query_timezone=America/Los_Angeles
// ```
//
// When invoking this endpoint with the Ruby SDK, pass the query parameter parts as a hash. The hash to match the above would look like:
//
// ```ruby
// query_params =
//
//	{
//	  fields: "category.name,inventory_items.days_in_inventory_tier,products.count",
//	  :"f[category.name]" => "socks",
//	  sorts: "products.count desc 0",
//	  limit: "500",
//	  query_timezone: "America/Los_Angeles"
//	}
//
// response = ruby_sdk.run_url_encoded_query('thelook','inventory_items','json', query_params)
//
// ```
//
// Again, it is generally easier to use the variant of this method that passes the full query in the POST body.
// This method is available for cases where other alternatives won't fit the need.
//
// Supported formats:
//
// | result_format | Description
// | :-----------: | :--- |
// | json | Plain json
// | json_bi | (*RECOMMENDED*) Row data plus metadata describing the fields, pivots, table calcs, and other aspects of the query. See JsonBi type for schema
// | json_detail | (*LEGACY*) Row data plus metadata describing the fields, pivots, table calcs, and other aspects of the query
// | csv | Comma separated values with a header
// | txt | Tab separated values with a header
// | html | Simple html
// | md | Simple markdown
// | xlsx | MS Excel spreadsheet
// | sql | Returns the generated SQL rather than running the query
// | png | A PNG image of the visualization of the query
// | jpg | A JPG image of the visualization of the query
//
// GET /queries/models/{model_name}/views/{view_name}/run/{result_format} -> string
//
// **Note**: Binary content may be returned by this method.
func (l *LookerSDK) RunUrlEncodedQuery(
	modelName string,
	viewName string,
	resultFormat string,
	options *rtl.ApiSettings) (string, error) {
	modelName = url.PathEscape(modelName)
	viewName = url.PathEscape(viewName)
	resultFormat = url.PathEscape(resultFormat)
	var result string
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/queries/models/%v/views/%v/run/%v", modelName, viewName, resultFormat), nil, nil, options)
	return result, err

}

// ### Get Merge Query
//
// Returns a merge query object given its id.
//
// GET /merge_queries/{merge_query_id} -> MergeQuery
func (l *LookerSDK) MergeQuery(
	mergeQueryId string,
	fields string,
	options *rtl.ApiSettings) (MergeQuery, error) {
	mergeQueryId = url.PathEscape(mergeQueryId)
	var result MergeQuery
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/merge_queries/%v", mergeQueryId), map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Create Merge Query
//
// Creates a new merge query object.
//
// A merge query takes the results of one or more queries and combines (merges) the results
// according to field mapping definitions. The result is similar to a SQL left outer join.
//
// A merge query can merge results of queries from different SQL databases.
//
// The order that queries are defined in the source_queries array property is significant. The
// first query in the array defines the primary key into which the results of subsequent
// queries will be merged.
//
// Like model/view query objects, merge queries are immutable and have structural identity - if
// you make a request to create a new merge query that is identical to an existing merge query,
// the existing merge query will be returned instead of creating a duplicate. Conversely, any
// change to the contents of a merge query will produce a new object with a new id.
//
// POST /merge_queries -> MergeQuery
func (l *LookerSDK) CreateMergeQuery(
	body WriteMergeQuery,
	fields string,
	options *rtl.ApiSettings) (MergeQuery, error) {
	var result MergeQuery
	err := l.session.Do(&result, "POST", "/4.0", "/merge_queries", map[string]interface{}{"fields": fields}, body, options)
	return result, err

}

// Get information about all running queries.
//
// GET /running_queries -> []RunningQueries
func (l *LookerSDK) AllRunningQueries(
	options *rtl.ApiSettings) ([]RunningQueries, error) {
	var result []RunningQueries
	err := l.session.Do(&result, "GET", "/4.0", "/running_queries", nil, nil, options)
	return result, err

}

// Kill a query with a specific query_task_id.
//
// DELETE /running_queries/{query_task_id} -> string
func (l *LookerSDK) KillQuery(
	queryTaskId string,
	options *rtl.ApiSettings) (string, error) {
	queryTaskId = url.PathEscape(queryTaskId)
	var result string
	err := l.session.Do(&result, "DELETE", "/4.0", fmt.Sprintf("/running_queries/%v", queryTaskId), nil, nil, options)
	return result, err

}

// ### Create a SQL Runner Query
//
// Either the `connection_name` or `model_name` parameter MUST be provided.
//
// POST /sql_queries -> SqlQuery
func (l *LookerSDK) CreateSqlQuery(
	body SqlQueryCreate,
	options *rtl.ApiSettings) (SqlQuery, error) {
	var result SqlQuery
	err := l.session.Do(&result, "POST", "/4.0", "/sql_queries", nil, body, options)
	return result, err

}

// Get a SQL Runner query.
//
// GET /sql_queries/{slug} -> SqlQuery
func (l *LookerSDK) SqlQuery(
	slug string,
	options *rtl.ApiSettings) (SqlQuery, error) {
	slug = url.PathEscape(slug)
	var result SqlQuery
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/sql_queries/%v", slug), nil, nil, options)
	return result, err

}

// Execute a SQL Runner query in a given result_format.
//
// POST /sql_queries/{slug}/run/{result_format} -> string
func (l *LookerSDK) RunSqlQuery(
	slug string,
	resultFormat string,
	download string,
	options *rtl.ApiSettings) (string, error) {
	slug = url.PathEscape(slug)
	resultFormat = url.PathEscape(resultFormat)
	var result string
	err := l.session.Do(&result, "POST", "/4.0", fmt.Sprintf("/sql_queries/%v/run/%v", slug, resultFormat), map[string]interface{}{"download": download}, nil, options)
	return result, err

}

// endregion Query: Run and Manage Queries

// region RenderTask: Manage Render Tasks

// ### Create a new task to render a look to an image.
//
// Returns a render task object.
// To check the status of a render task, pass the render_task.id to [Get Render Task](#!/RenderTask/get_render_task).
// Once the render task is complete, you can download the resulting document or image using [Get Render Task Results](#!/RenderTask/get_render_task_results).
//
// POST /render_tasks/looks/{look_id}/{result_format} -> RenderTask
func (l *LookerSDK) CreateLookRenderTask(
	lookId string,
	resultFormat string,
	width int64,
	height int64,
	fields string,
	options *rtl.ApiSettings) (RenderTask, error) {
	lookId = url.PathEscape(lookId)
	resultFormat = url.PathEscape(resultFormat)
	var result RenderTask
	err := l.session.Do(&result, "POST", "/4.0", fmt.Sprintf("/render_tasks/looks/%v/%v", lookId, resultFormat), map[string]interface{}{"width": width, "height": height, "fields": fields}, nil, options)
	return result, err

}

// ### Create a new task to render an existing query to an image.
//
// Returns a render task object.
// To check the status of a render task, pass the render_task.id to [Get Render Task](#!/RenderTask/get_render_task).
// Once the render task is complete, you can download the resulting document or image using [Get Render Task Results](#!/RenderTask/get_render_task_results).
//
// POST /render_tasks/queries/{query_id}/{result_format} -> RenderTask
func (l *LookerSDK) CreateQueryRenderTask(
	queryId string,
	resultFormat string,
	width int64,
	height int64,
	fields string,
	options *rtl.ApiSettings) (RenderTask, error) {
	queryId = url.PathEscape(queryId)
	resultFormat = url.PathEscape(resultFormat)
	var result RenderTask
	err := l.session.Do(&result, "POST", "/4.0", fmt.Sprintf("/render_tasks/queries/%v/%v", queryId, resultFormat), map[string]interface{}{"width": width, "height": height, "fields": fields}, nil, options)
	return result, err

}

// ### Create a new task to render a dashboard to a document or image.
//
// Returns a render task object.
// To check the status of a render task, pass the render_task.id to [Get Render Task](#!/RenderTask/get_render_task).
// Once the render task is complete, you can download the resulting document or image using [Get Render Task Results](#!/RenderTask/get_render_task_results).
//
// POST /render_tasks/dashboards/{dashboard_id}/{result_format} -> RenderTask
func (l *LookerSDK) CreateDashboardRenderTask(request RequestCreateDashboardRenderTask,
	options *rtl.ApiSettings) (RenderTask, error) {
	request.DashboardId = url.PathEscape(request.DashboardId)
	request.ResultFormat = url.PathEscape(request.ResultFormat)
	var result RenderTask
	err := l.session.Do(&result, "POST", "/4.0", fmt.Sprintf("/render_tasks/dashboards/%v/%v", request.DashboardId, request.ResultFormat), map[string]interface{}{"width": request.Width, "height": request.Height, "fields": request.Fields, "pdf_paper_size": request.PdfPaperSize, "pdf_landscape": request.PdfLandscape, "long_tables": request.LongTables, "theme": request.Theme}, request.Body, options)
	return result, err

}

// ### Get information about a render task.
//
// Returns a render task object.
// To check the status of a render task, pass the render_task.id to [Get Render Task](#!/RenderTask/get_render_task).
// Once the render task is complete, you can download the resulting document or image using [Get Render Task Results](#!/RenderTask/get_render_task_results).
//
// GET /render_tasks/{render_task_id} -> RenderTask
func (l *LookerSDK) RenderTask(
	renderTaskId string,
	fields string,
	options *rtl.ApiSettings) (RenderTask, error) {
	renderTaskId = url.PathEscape(renderTaskId)
	var result RenderTask
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/render_tasks/%v", renderTaskId), map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Get the document or image produced by a completed render task.
//
// Note that the PDF or image result will be a binary blob in the HTTP response, as indicated by the
// Content-Type in the response headers. This may require specialized (or at least different) handling than text
// responses such as JSON. You may need to tell your HTTP client that the response is binary so that it does not
// attempt to parse the binary data as text.
//
// If the render task exists but has not finished rendering the results, the response HTTP status will be
// **202 Accepted**, the response body will be empty, and the response will have a Retry-After header indicating
// that the caller should repeat the request at a later time.
//
// Returns 404 if the render task cannot be found, if the cached result has expired, or if the caller
// does not have permission to view the results.
//
// For detailed information about the status of the render task, use [Render Task](#!/RenderTask/render_task).
// Polling loops waiting for completion of a render task would be better served by polling **render_task(id)** until
// the task status reaches completion (or error) instead of polling **render_task_results(id)** alone.
//
// GET /render_tasks/{render_task_id}/results -> string
//
// **Note**: Binary content is returned by this method.
func (l *LookerSDK) RenderTaskResults(
	renderTaskId string,
	options *rtl.ApiSettings) (string, error) {
	renderTaskId = url.PathEscape(renderTaskId)
	var result string
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/render_tasks/%v/results", renderTaskId), nil, nil, options)
	return result, err

}

// ### Create a new task to render a dashboard element to an image.
//
// Returns a render task object.
// To check the status of a render task, pass the render_task.id to [Get Render Task](#!/RenderTask/get_render_task).
// Once the render task is complete, you can download the resulting document or image using [Get Render Task Results](#!/RenderTask/get_render_task_results).
//
// POST /render_tasks/dashboard_elements/{dashboard_element_id}/{result_format} -> RenderTask
func (l *LookerSDK) CreateDashboardElementRenderTask(
	dashboardElementId string,
	resultFormat string,
	width int64,
	height int64,
	fields string,
	options *rtl.ApiSettings) (RenderTask, error) {
	dashboardElementId = url.PathEscape(dashboardElementId)
	resultFormat = url.PathEscape(resultFormat)
	var result RenderTask
	err := l.session.Do(&result, "POST", "/4.0", fmt.Sprintf("/render_tasks/dashboard_elements/%v/%v", dashboardElementId, resultFormat), map[string]interface{}{"width": width, "height": height, "fields": fields}, nil, options)
	return result, err

}

// endregion RenderTask: Manage Render Tasks

// region Role: Manage Roles

// ### Search model sets
// Returns all model set records that match the given search criteria.
// If multiple search params are given and `filter_or` is FALSE or not specified,
// search params are combined in a logical AND operation.
// Only rows that match *all* search param criteria will be returned.
//
// If `filter_or` is TRUE, multiple search params are combined in a logical OR operation.
// Results will include rows that match **any** of the search criteria.
//
// String search params use case-insensitive matching.
// String search params can contain `%` and '_' as SQL LIKE pattern match wildcard expressions.
// example="dan%" will match "danger" and "Danzig" but not "David"
// example="D_m%" will match "Damage" and "dump"
//
// Integer search params can accept a single value or a comma separated list of values. The multiple
// values will be combined under a logical OR operation - results will match at least one of
// the given values.
//
// Most search params can accept "IS NULL" and "NOT NULL" as special expressions to match
// or exclude (respectively) rows where the column is null.
//
// Boolean search params accept only "true" and "false" as values.
//
// GET /model_sets/search -> []ModelSet
func (l *LookerSDK) SearchModelSets(request RequestSearchModelSets,
	options *rtl.ApiSettings) ([]ModelSet, error) {
	var result []ModelSet
	err := l.session.Do(&result, "GET", "/4.0", "/model_sets/search", map[string]interface{}{"fields": request.Fields, "limit": request.Limit, "offset": request.Offset, "sorts": request.Sorts, "id": request.Id, "name": request.Name, "all_access": request.AllAccess, "built_in": request.BuiltIn, "filter_or": request.FilterOr}, nil, options)
	return result, err

}

// ### Get information about the model set with a specific id.
//
// GET /model_sets/{model_set_id} -> ModelSet
func (l *LookerSDK) ModelSet(
	modelSetId string,
	fields string,
	options *rtl.ApiSettings) (ModelSet, error) {
	modelSetId = url.PathEscape(modelSetId)
	var result ModelSet
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/model_sets/%v", modelSetId), map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Update information about the model set with a specific id.
//
// PATCH /model_sets/{model_set_id} -> ModelSet
func (l *LookerSDK) UpdateModelSet(
	modelSetId string,
	body WriteModelSet,
	options *rtl.ApiSettings) (ModelSet, error) {
	modelSetId = url.PathEscape(modelSetId)
	var result ModelSet
	err := l.session.Do(&result, "PATCH", "/4.0", fmt.Sprintf("/model_sets/%v", modelSetId), nil, body, options)
	return result, err

}

// ### Delete the model set with a specific id.
//
// DELETE /model_sets/{model_set_id} -> string
func (l *LookerSDK) DeleteModelSet(
	modelSetId string,
	options *rtl.ApiSettings) (string, error) {
	modelSetId = url.PathEscape(modelSetId)
	var result string
	err := l.session.Do(&result, "DELETE", "/4.0", fmt.Sprintf("/model_sets/%v", modelSetId), nil, nil, options)
	return result, err

}

// ### Get information about all model sets.
//
// GET /model_sets -> []ModelSet
func (l *LookerSDK) AllModelSets(
	fields string,
	options *rtl.ApiSettings) ([]ModelSet, error) {
	var result []ModelSet
	err := l.session.Do(&result, "GET", "/4.0", "/model_sets", map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Create a model set with the specified information. Model sets are used by Roles.
//
// POST /model_sets -> ModelSet
func (l *LookerSDK) CreateModelSet(
	body WriteModelSet,
	options *rtl.ApiSettings) (ModelSet, error) {
	var result ModelSet
	err := l.session.Do(&result, "POST", "/4.0", "/model_sets", nil, body, options)
	return result, err

}

// ### Get all supported permissions.
//
// GET /permissions -> []Permission
func (l *LookerSDK) AllPermissions(
	options *rtl.ApiSettings) ([]Permission, error) {
	var result []Permission
	err := l.session.Do(&result, "GET", "/4.0", "/permissions", nil, nil, options)
	return result, err

}

// ### Search permission sets
// Returns all permission set records that match the given search criteria.
// If multiple search params are given and `filter_or` is FALSE or not specified,
// search params are combined in a logical AND operation.
// Only rows that match *all* search param criteria will be returned.
//
// If `filter_or` is TRUE, multiple search params are combined in a logical OR operation.
// Results will include rows that match **any** of the search criteria.
//
// String search params use case-insensitive matching.
// String search params can contain `%` and '_' as SQL LIKE pattern match wildcard expressions.
// example="dan%" will match "danger" and "Danzig" but not "David"
// example="D_m%" will match "Damage" and "dump"
//
// Integer search params can accept a single value or a comma separated list of values. The multiple
// values will be combined under a logical OR operation - results will match at least one of
// the given values.
//
// Most search params can accept "IS NULL" and "NOT NULL" as special expressions to match
// or exclude (respectively) rows where the column is null.
//
// Boolean search params accept only "true" and "false" as values.
//
// GET /permission_sets/search -> []PermissionSet
func (l *LookerSDK) SearchPermissionSets(request RequestSearchPermissionSets,
	options *rtl.ApiSettings) ([]PermissionSet, error) {
	var result []PermissionSet
	err := l.session.Do(&result, "GET", "/4.0", "/permission_sets/search", map[string]interface{}{"fields": request.Fields, "limit": request.Limit, "offset": request.Offset, "sorts": request.Sorts, "id": request.Id, "name": request.Name, "all_access": request.AllAccess, "built_in": request.BuiltIn, "filter_or": request.FilterOr}, nil, options)
	return result, err

}

// ### Get information about the permission set with a specific id.
//
// GET /permission_sets/{permission_set_id} -> PermissionSet
func (l *LookerSDK) PermissionSet(
	permissionSetId string,
	fields string,
	options *rtl.ApiSettings) (PermissionSet, error) {
	permissionSetId = url.PathEscape(permissionSetId)
	var result PermissionSet
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/permission_sets/%v", permissionSetId), map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Update information about the permission set with a specific id.
// Providing save_content permission alone will also provide you the abilities of save_looks and save_dashboards.
//
// PATCH /permission_sets/{permission_set_id} -> PermissionSet
func (l *LookerSDK) UpdatePermissionSet(
	permissionSetId string,
	body WritePermissionSet,
	options *rtl.ApiSettings) (PermissionSet, error) {
	permissionSetId = url.PathEscape(permissionSetId)
	var result PermissionSet
	err := l.session.Do(&result, "PATCH", "/4.0", fmt.Sprintf("/permission_sets/%v", permissionSetId), nil, body, options)
	return result, err

}

// ### Delete the permission set with a specific id.
//
// DELETE /permission_sets/{permission_set_id} -> string
func (l *LookerSDK) DeletePermissionSet(
	permissionSetId string,
	options *rtl.ApiSettings) (string, error) {
	permissionSetId = url.PathEscape(permissionSetId)
	var result string
	err := l.session.Do(&result, "DELETE", "/4.0", fmt.Sprintf("/permission_sets/%v", permissionSetId), nil, nil, options)
	return result, err

}

// ### Get information about all permission sets.
//
// GET /permission_sets -> []PermissionSet
func (l *LookerSDK) AllPermissionSets(
	fields string,
	options *rtl.ApiSettings) ([]PermissionSet, error) {
	var result []PermissionSet
	err := l.session.Do(&result, "GET", "/4.0", "/permission_sets", map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Create a permission set with the specified information. Permission sets are used by Roles.
// Providing save_content permission alone will also provide you the abilities of save_looks and save_dashboards.
//
// POST /permission_sets -> PermissionSet
func (l *LookerSDK) CreatePermissionSet(
	body WritePermissionSet,
	options *rtl.ApiSettings) (PermissionSet, error) {
	var result PermissionSet
	err := l.session.Do(&result, "POST", "/4.0", "/permission_sets", nil, body, options)
	return result, err

}

// ### Get information about all roles.
//
// GET /roles -> []Role
func (l *LookerSDK) AllRoles(request RequestAllRoles,
	options *rtl.ApiSettings) ([]Role, error) {
	var result []Role
	err := l.session.Do(&result, "GET", "/4.0", "/roles", map[string]interface{}{"fields": request.Fields, "ids": request.Ids}, nil, options)
	return result, err

}

// ### Create a role with the specified information.
//
// POST /roles -> Role
func (l *LookerSDK) CreateRole(
	body WriteRole,
	options *rtl.ApiSettings) (Role, error) {
	var result Role
	err := l.session.Do(&result, "POST", "/4.0", "/roles", nil, body, options)
	return result, err

}

// ### Search roles
//
// Returns all role records that match the given search criteria.
//
// If multiple search params are given and `filter_or` is FALSE or not specified,
// search params are combined in a logical AND operation.
// Only rows that match *all* search param criteria will be returned.
//
// If `filter_or` is TRUE, multiple search params are combined in a logical OR operation.
// Results will include rows that match **any** of the search criteria.
//
// String search params use case-insensitive matching.
// String search params can contain `%` and '_' as SQL LIKE pattern match wildcard expressions.
// example="dan%" will match "danger" and "Danzig" but not "David"
// example="D_m%" will match "Damage" and "dump"
//
// Integer search params can accept a single value or a comma separated list of values. The multiple
// values will be combined under a logical OR operation - results will match at least one of
// the given values.
//
// Most search params can accept "IS NULL" and "NOT NULL" as special expressions to match
// or exclude (respectively) rows where the column is null.
//
// Boolean search params accept only "true" and "false" as values.
//
// GET /roles/search -> []Role
func (l *LookerSDK) SearchRoles(request RequestSearchRoles,
	options *rtl.ApiSettings) ([]Role, error) {
	var result []Role
	err := l.session.Do(&result, "GET", "/4.0", "/roles/search", map[string]interface{}{"fields": request.Fields, "limit": request.Limit, "offset": request.Offset, "sorts": request.Sorts, "id": request.Id, "name": request.Name, "built_in": request.BuiltIn, "filter_or": request.FilterOr}, nil, options)
	return result, err

}

// ### Search roles include user count
//
// Returns all role records that match the given search criteria, and attaches
// associated user counts.
//
// If multiple search params are given and `filter_or` is FALSE or not specified,
// search params are combined in a logical AND operation.
// Only rows that match *all* search param criteria will be returned.
//
// If `filter_or` is TRUE, multiple search params are combined in a logical OR operation.
// Results will include rows that match **any** of the search criteria.
//
// String search params use case-insensitive matching.
// String search params can contain `%` and '_' as SQL LIKE pattern match wildcard expressions.
// example="dan%" will match "danger" and "Danzig" but not "David"
// example="D_m%" will match "Damage" and "dump"
//
// Integer search params can accept a single value or a comma separated list of values. The multiple
// values will be combined under a logical OR operation - results will match at least one of
// the given values.
//
// Most search params can accept "IS NULL" and "NOT NULL" as special expressions to match
// or exclude (respectively) rows where the column is null.
//
// Boolean search params accept only "true" and "false" as values.
//
// GET /roles/search/with_user_count -> []RoleSearch
func (l *LookerSDK) SearchRolesWithUserCount(request RequestSearchRolesWithUserCount,
	options *rtl.ApiSettings) ([]RoleSearch, error) {
	var result []RoleSearch
	err := l.session.Do(&result, "GET", "/4.0", "/roles/search/with_user_count", map[string]interface{}{"fields": request.Fields, "limit": request.Limit, "offset": request.Offset, "sorts": request.Sorts, "id": request.Id, "name": request.Name, "built_in": request.BuiltIn, "filter_or": request.FilterOr}, nil, options)
	return result, err

}

// ### Get information about the role with a specific id.
//
// GET /roles/{role_id} -> Role
func (l *LookerSDK) Role(
	roleId string,
	options *rtl.ApiSettings) (Role, error) {
	roleId = url.PathEscape(roleId)
	var result Role
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/roles/%v", roleId), nil, nil, options)
	return result, err

}

// ### Update information about the role with a specific id.
//
// PATCH /roles/{role_id} -> Role
func (l *LookerSDK) UpdateRole(
	roleId string,
	body WriteRole,
	options *rtl.ApiSettings) (Role, error) {
	roleId = url.PathEscape(roleId)
	var result Role
	err := l.session.Do(&result, "PATCH", "/4.0", fmt.Sprintf("/roles/%v", roleId), nil, body, options)
	return result, err

}

// ### Delete the role with a specific id.
//
// DELETE /roles/{role_id} -> string
func (l *LookerSDK) DeleteRole(
	roleId string,
	options *rtl.ApiSettings) (string, error) {
	roleId = url.PathEscape(roleId)
	var result string
	err := l.session.Do(&result, "DELETE", "/4.0", fmt.Sprintf("/roles/%v", roleId), nil, nil, options)
	return result, err

}

// ### Get information about all the groups with the role that has a specific id.
//
// GET /roles/{role_id}/groups -> []Group
func (l *LookerSDK) RoleGroups(
	roleId string,
	fields string,
	options *rtl.ApiSettings) ([]Group, error) {
	roleId = url.PathEscape(roleId)
	var result []Group
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/roles/%v/groups", roleId), map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Set all groups for a role, removing all existing group associations from that role.
//
// Calls to this endpoint may be denied by [Looker (Google Cloud core)](https://cloud.google.com/looker/docs/r/looker-core/overview).
//
// PUT /roles/{role_id}/groups -> []Group
func (l *LookerSDK) SetRoleGroups(
	roleId string,
	body []string,
	options *rtl.ApiSettings) ([]Group, error) {
	roleId = url.PathEscape(roleId)
	var result []Group
	err := l.session.Do(&result, "PUT", "/4.0", fmt.Sprintf("/roles/%v/groups", roleId), nil, body, options)
	return result, err

}

// ### Get information about all the users with the role that has a specific id.
//
// GET /roles/{role_id}/users -> []User
func (l *LookerSDK) RoleUsers(request RequestRoleUsers,
	options *rtl.ApiSettings) ([]User, error) {
	request.RoleId = url.PathEscape(request.RoleId)
	var result []User
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/roles/%v/users", request.RoleId), map[string]interface{}{"fields": request.Fields, "direct_association_only": request.DirectAssociationOnly}, nil, options)
	return result, err

}

// ### Set all the users of the role with a specific id.
//
// PUT /roles/{role_id}/users -> []User
func (l *LookerSDK) SetRoleUsers(
	roleId string,
	body []string,
	options *rtl.ApiSettings) ([]User, error) {
	roleId = url.PathEscape(roleId)
	var result []User
	err := l.session.Do(&result, "PUT", "/4.0", fmt.Sprintf("/roles/%v/users", roleId), nil, body, options)
	return result, err

}

// endregion Role: Manage Roles

// region ScheduledPlan: Manage Scheduled Plans

// ### Get Scheduled Plans for a Space
//
// Returns scheduled plans owned by the caller for a given space id.
//
// GET /scheduled_plans/space/{space_id} -> []ScheduledPlan
func (l *LookerSDK) ScheduledPlansForSpace(
	spaceId string,
	fields string,
	options *rtl.ApiSettings) ([]ScheduledPlan, error) {
	spaceId = url.PathEscape(spaceId)
	var result []ScheduledPlan
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/scheduled_plans/space/%v", spaceId), map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Get Information About a Scheduled Plan
//
// Admins can fetch information about other users' Scheduled Plans.
//
// GET /scheduled_plans/{scheduled_plan_id} -> ScheduledPlan
func (l *LookerSDK) ScheduledPlan(
	scheduledPlanId string,
	fields string,
	options *rtl.ApiSettings) (ScheduledPlan, error) {
	scheduledPlanId = url.PathEscape(scheduledPlanId)
	var result ScheduledPlan
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/scheduled_plans/%v", scheduledPlanId), map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Update a Scheduled Plan
//
// Admins can update other users' Scheduled Plans.
//
// Note: Any scheduled plan destinations specified in an update will **replace** all scheduled plan destinations
// currently defined for the scheduled plan.
//
// For Example: If a scheduled plan has destinations A, B, and C, and you call update on this scheduled plan
// specifying only B in the destinations, then destinations A and C will be deleted by the update.
//
// Updating a scheduled plan to assign null or an empty array to the scheduled_plan_destinations property is an error, as a scheduled plan must always have at least one destination.
//
// If you omit the scheduled_plan_destinations property from the object passed to update, then the destinations
// defined on the original scheduled plan will remain unchanged.
//
// #### Email Permissions:
//
// For details about permissions required to schedule delivery to email and the safeguards
// Looker offers to protect against sending to unauthorized email destinations, see [Email Domain Allow List for Scheduled Looks](https://cloud.google.com/looker/docs/r/api/embed-permissions).
//
// #### Scheduled Plan Destination Formats
//
// Scheduled plan destinations must specify the data format to produce and send to the destination.
//
// Formats:
//
// | format | Description
// | :-----------: | :--- |
// | json | A JSON object containing a `data` property which contains an array of JSON objects, one per row. No metadata.
// | json_detail | Row data plus metadata describing the fields, pivots, table calcs, and other aspects of the query
// | inline_json | Same as the JSON format, except that the `data` property is a string containing JSON-escaped row data. Additional properties describe the data operation. This format is primarily used to send data to web hooks so that the web hook doesn't have to re-encode the JSON row data in order to pass it on to its ultimate destination.
// | csv | Comma separated values with a header
// | txt | Tab separated values with a header
// | html | Simple html
// | xlsx | MS Excel spreadsheet
// | wysiwyg_pdf | Dashboard rendered in a tiled layout to produce a PDF document
// | assembled_pdf | Dashboard rendered in a single column layout to produce a PDF document
// | wysiwyg_png | Dashboard rendered in a tiled layout to produce a PNG image
// ||
//
// Valid formats vary by destination type and source object. `wysiwyg_pdf` is only valid for dashboards, for example.
//
// PATCH /scheduled_plans/{scheduled_plan_id} -> ScheduledPlan
func (l *LookerSDK) UpdateScheduledPlan(
	scheduledPlanId string,
	body WriteScheduledPlan,
	options *rtl.ApiSettings) (ScheduledPlan, error) {
	scheduledPlanId = url.PathEscape(scheduledPlanId)
	var result ScheduledPlan
	err := l.session.Do(&result, "PATCH", "/4.0", fmt.Sprintf("/scheduled_plans/%v", scheduledPlanId), nil, body, options)
	return result, err

}

// ### Delete a Scheduled Plan
//
// Normal users can only delete their own scheduled plans.
// Admins can delete other users' scheduled plans.
// This delete cannot be undone.
//
// DELETE /scheduled_plans/{scheduled_plan_id} -> string
func (l *LookerSDK) DeleteScheduledPlan(
	scheduledPlanId string,
	options *rtl.ApiSettings) (string, error) {
	scheduledPlanId = url.PathEscape(scheduledPlanId)
	var result string
	err := l.session.Do(&result, "DELETE", "/4.0", fmt.Sprintf("/scheduled_plans/%v", scheduledPlanId), nil, nil, options)
	return result, err

}

// ### List All Scheduled Plans
//
// Returns all scheduled plans which belong to the caller or given user.
//
// If no user_id is provided, this function returns the scheduled plans owned by the caller.
//
// To list all schedules for all users, pass `all_users=true`.
//
// The caller must have `see_schedules` permission to see other users' scheduled plans.
//
// GET /scheduled_plans -> []ScheduledPlan
func (l *LookerSDK) AllScheduledPlans(request RequestAllScheduledPlans,
	options *rtl.ApiSettings) ([]ScheduledPlan, error) {
	var result []ScheduledPlan
	err := l.session.Do(&result, "GET", "/4.0", "/scheduled_plans", map[string]interface{}{"user_id": request.UserId, "fields": request.Fields, "all_users": request.AllUsers}, nil, options)
	return result, err

}

// ### Create a Scheduled Plan
//
// Create a scheduled plan to render a Look or Dashboard on a recurring schedule.
//
// To create a scheduled plan, you MUST provide values for the following fields:
// `name`
// and
// `look_id`, `dashboard_id`, `lookml_dashboard_id`, or `query_id`
// and
// `cron_tab` or `datagroup`
// and
// at least one scheduled_plan_destination
//
// A scheduled plan MUST have at least one scheduled_plan_destination defined.
//
// When `look_id` is set, `require_no_results`, `require_results`, and `require_change` are all required.
//
// If `create_scheduled_plan` fails with a 422 error, be sure to look at the error messages in the response which will explain exactly what fields are missing or values that are incompatible.
//
// The queries that provide the data for the look or dashboard are run in the context of user account that owns the scheduled plan.
//
// When `run_as_recipient` is `false` or not specified, the queries that provide the data for the
// look or dashboard are run in the context of user account that owns the scheduled plan.
//
// When `run_as_recipient` is `true` and all the email recipients are Looker user accounts, the
// queries are run in the context of each recipient, so different recipients may see different
// data from the same scheduled render of a look or dashboard. For more details, see [Run As Recipient](https://cloud.google.com/looker/docs/r/admin/run-as-recipient).
//
// Admins can create and modify scheduled plans on behalf of other users by specifying a user id.
// Non-admin users may not create or modify scheduled plans by or for other users.
//
// #### Email Permissions:
//
// For details about permissions required to schedule delivery to email and the safeguards
// Looker offers to protect against sending to unauthorized email destinations, see [Email Domain Allow List for Scheduled Looks](https://cloud.google.com/looker/docs/r/api/embed-permissions).
//
// #### Scheduled Plan Destination Formats
//
// Scheduled plan destinations must specify the data format to produce and send to the destination.
//
// Formats:
//
// | format | Description
// | :-----------: | :--- |
// | json | A JSON object containing a `data` property which contains an array of JSON objects, one per row. No metadata.
// | json_detail | Row data plus metadata describing the fields, pivots, table calcs, and other aspects of the query
// | inline_json | Same as the JSON format, except that the `data` property is a string containing JSON-escaped row data. Additional properties describe the data operation. This format is primarily used to send data to web hooks so that the web hook doesn't have to re-encode the JSON row data in order to pass it on to its ultimate destination.
// | csv | Comma separated values with a header
// | txt | Tab separated values with a header
// | html | Simple html
// | xlsx | MS Excel spreadsheet
// | wysiwyg_pdf | Dashboard rendered in a tiled layout to produce a PDF document
// | assembled_pdf | Dashboard rendered in a single column layout to produce a PDF document
// | wysiwyg_png | Dashboard rendered in a tiled layout to produce a PNG image
// ||
//
// Valid formats vary by destination type and source object. `wysiwyg_pdf` is only valid for dashboards, for example.
//
// POST /scheduled_plans -> ScheduledPlan
func (l *LookerSDK) CreateScheduledPlan(
	body WriteScheduledPlan,
	options *rtl.ApiSettings) (ScheduledPlan, error) {
	var result ScheduledPlan
	err := l.session.Do(&result, "POST", "/4.0", "/scheduled_plans", nil, body, options)
	return result, err

}

// ### Run a Scheduled Plan Immediately
//
// Create a scheduled plan that runs only once, and immediately.
//
// This can be useful for testing a Scheduled Plan before committing to a production schedule.
//
// Admins can create scheduled plans on behalf of other users by specifying a user id.
//
// # This API is rate limited to prevent it from being used for relay spam or DoS attacks
//
// #### Email Permissions:
//
// For details about permissions required to schedule delivery to email and the safeguards
// Looker offers to protect against sending to unauthorized email destinations, see [Email Domain Allow List for Scheduled Looks](https://cloud.google.com/looker/docs/r/api/embed-permissions).
//
// #### Scheduled Plan Destination Formats
//
// Scheduled plan destinations must specify the data format to produce and send to the destination.
//
// Formats:
//
// | format | Description
// | :-----------: | :--- |
// | json | A JSON object containing a `data` property which contains an array of JSON objects, one per row. No metadata.
// | json_detail | Row data plus metadata describing the fields, pivots, table calcs, and other aspects of the query
// | inline_json | Same as the JSON format, except that the `data` property is a string containing JSON-escaped row data. Additional properties describe the data operation. This format is primarily used to send data to web hooks so that the web hook doesn't have to re-encode the JSON row data in order to pass it on to its ultimate destination.
// | csv | Comma separated values with a header
// | txt | Tab separated values with a header
// | html | Simple html
// | xlsx | MS Excel spreadsheet
// | wysiwyg_pdf | Dashboard rendered in a tiled layout to produce a PDF document
// | assembled_pdf | Dashboard rendered in a single column layout to produce a PDF document
// | wysiwyg_png | Dashboard rendered in a tiled layout to produce a PNG image
// ||
//
// Valid formats vary by destination type and source object. `wysiwyg_pdf` is only valid for dashboards, for example.
//
// POST /scheduled_plans/run_once -> ScheduledPlan
func (l *LookerSDK) ScheduledPlanRunOnce(
	body WriteScheduledPlan,
	options *rtl.ApiSettings) (ScheduledPlan, error) {
	var result ScheduledPlan
	err := l.session.Do(&result, "POST", "/4.0", "/scheduled_plans/run_once", nil, body, options)
	return result, err

}

// ### Get Scheduled Plans for a Look
//
// Returns all scheduled plans for a look which belong to the caller or given user.
//
// If no user_id is provided, this function returns the scheduled plans owned by the caller.
//
// To list all schedules for all users, pass `all_users=true`.
//
// The caller must have `see_schedules` permission to see other users' scheduled plans.
//
// GET /scheduled_plans/look/{look_id} -> []ScheduledPlan
func (l *LookerSDK) ScheduledPlansForLook(request RequestScheduledPlansForLook,
	options *rtl.ApiSettings) ([]ScheduledPlan, error) {
	request.LookId = url.PathEscape(request.LookId)
	var result []ScheduledPlan
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/scheduled_plans/look/%v", request.LookId), map[string]interface{}{"user_id": request.UserId, "fields": request.Fields, "all_users": request.AllUsers}, nil, options)
	return result, err

}

// ### Get Scheduled Plans for a Dashboard
//
// Returns all scheduled plans for a dashboard which belong to the caller or given user.
//
// If no user_id is provided, this function returns the scheduled plans owned by the caller.
//
// To list all schedules for all users, pass `all_users=true`.
//
// The caller must have `see_schedules` permission to see other users' scheduled plans.
//
// GET /scheduled_plans/dashboard/{dashboard_id} -> []ScheduledPlan
func (l *LookerSDK) ScheduledPlansForDashboard(request RequestScheduledPlansForDashboard,
	options *rtl.ApiSettings) ([]ScheduledPlan, error) {
	request.DashboardId = url.PathEscape(request.DashboardId)
	var result []ScheduledPlan
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/scheduled_plans/dashboard/%v", request.DashboardId), map[string]interface{}{"user_id": request.UserId, "all_users": request.AllUsers, "fields": request.Fields}, nil, options)
	return result, err

}

// ### Get Scheduled Plans for a LookML Dashboard
//
// Returns all scheduled plans for a LookML Dashboard which belong to the caller or given user.
//
// If no user_id is provided, this function returns the scheduled plans owned by the caller.
//
// To list all schedules for all users, pass `all_users=true`.
//
// The caller must have `see_schedules` permission to see other users' scheduled plans.
//
// GET /scheduled_plans/lookml_dashboard/{lookml_dashboard_id} -> []ScheduledPlan
func (l *LookerSDK) ScheduledPlansForLookmlDashboard(request RequestScheduledPlansForLookmlDashboard,
	options *rtl.ApiSettings) ([]ScheduledPlan, error) {
	request.LookmlDashboardId = url.PathEscape(request.LookmlDashboardId)
	var result []ScheduledPlan
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/scheduled_plans/lookml_dashboard/%v", request.LookmlDashboardId), map[string]interface{}{"user_id": request.UserId, "fields": request.Fields, "all_users": request.AllUsers}, nil, options)
	return result, err

}

// ### Run a Scheduled Plan By Id Immediately
// This function creates a run-once schedule plan based on an existing scheduled plan,
// applies modifications (if any) to the new scheduled plan, and runs the new schedule plan immediately.
// This can be useful for testing modifications to an existing scheduled plan before committing to a production schedule.
//
// This function internally performs the following operations:
//
// 1. Copies the properties of the existing scheduled plan into a new scheduled plan
// 2. Copies any properties passed in the JSON body of this request into the new scheduled plan (replacing the original values)
// 3. Creates the new scheduled plan
// 4. Runs the new scheduled plan
//
// The original scheduled plan is not modified by this operation.
// Admins can create, modify, and run scheduled plans on behalf of other users by specifying a user id.
// Non-admins can only create, modify, and run their own scheduled plans.
//
// #### Email Permissions:
//
// For details about permissions required to schedule delivery to email and the safeguards
// Looker offers to protect against sending to unauthorized email destinations, see [Email Domain Allow List for Scheduled Looks](https://cloud.google.com/looker/docs/r/api/embed-permissions).
//
// #### Scheduled Plan Destination Formats
//
// Scheduled plan destinations must specify the data format to produce and send to the destination.
//
// Formats:
//
// | format | Description
// | :-----------: | :--- |
// | json | A JSON object containing a `data` property which contains an array of JSON objects, one per row. No metadata.
// | json_detail | Row data plus metadata describing the fields, pivots, table calcs, and other aspects of the query
// | inline_json | Same as the JSON format, except that the `data` property is a string containing JSON-escaped row data. Additional properties describe the data operation. This format is primarily used to send data to web hooks so that the web hook doesn't have to re-encode the JSON row data in order to pass it on to its ultimate destination.
// | csv | Comma separated values with a header
// | txt | Tab separated values with a header
// | html | Simple html
// | xlsx | MS Excel spreadsheet
// | wysiwyg_pdf | Dashboard rendered in a tiled layout to produce a PDF document
// | assembled_pdf | Dashboard rendered in a single column layout to produce a PDF document
// | wysiwyg_png | Dashboard rendered in a tiled layout to produce a PNG image
// ||
//
// Valid formats vary by destination type and source object. `wysiwyg_pdf` is only valid for dashboards, for example.
//
// # This API is rate limited to prevent it from being used for relay spam or DoS attacks
//
// POST /scheduled_plans/{scheduled_plan_id}/run_once -> ScheduledPlan
func (l *LookerSDK) ScheduledPlanRunOnceById(
	scheduledPlanId string,
	body WriteScheduledPlan,
	options *rtl.ApiSettings) (ScheduledPlan, error) {
	scheduledPlanId = url.PathEscape(scheduledPlanId)
	var result ScheduledPlan
	err := l.session.Do(&result, "POST", "/4.0", fmt.Sprintf("/scheduled_plans/%v/run_once", scheduledPlanId), nil, body, options)
	return result, err

}

// endregion ScheduledPlan: Manage Scheduled Plans

// region Session: Session Information

// ### Get API Session
//
// Returns information about the current API session, such as which workspace is selected for the session.
//
// GET /session -> ApiSession
func (l *LookerSDK) Session(
	options *rtl.ApiSettings) (ApiSession, error) {
	var result ApiSession
	err := l.session.Do(&result, "GET", "/4.0", "/session", nil, nil, options)
	return result, err

}

// ### Update API Session
//
// #### API Session Workspace
//
// You can use this endpoint to change the active workspace for the current API session.
//
// Only one workspace can be active in a session. The active workspace can be changed
// any number of times in a session.
//
// The default workspace for API sessions is the "production" workspace.
//
// All Looker APIs that use projects or lookml models (such as running queries) will
// use the version of project and model files defined by this workspace for the lifetime of the
// current API session or until the session workspace is changed again.
//
// An API session has the same lifetime as the access_token used to authenticate API requests. Each successful
// API login generates a new access_token and a new API session.
//
// If your Looker API client application needs to work in a dev workspace across multiple
// API sessions, be sure to select the dev workspace after each login.
//
// PATCH /session -> ApiSession
func (l *LookerSDK) UpdateSession(
	body WriteApiSession,
	options *rtl.ApiSettings) (ApiSession, error) {
	var result ApiSession
	err := l.session.Do(&result, "PATCH", "/4.0", "/session", nil, body, options)
	return result, err

}

// endregion Session: Session Information

// region SqlInterfaceQuery: Run and Manage SQL Interface Queries

// ### Handles Avatica RPC metadata requests for SQL Interface queries
//
// GET /sql_interface_queries/metadata -> SqlInterfaceQueryMetadata
func (l *LookerSDK) SqlInterfaceMetadata(
	avaticaRequest string,
	options *rtl.ApiSettings) (SqlInterfaceQueryMetadata, error) {
	var result SqlInterfaceQueryMetadata
	err := l.session.Do(&result, "GET", "/4.0", "/sql_interface_queries/metadata", map[string]interface{}{"avatica_request": avaticaRequest}, nil, options)
	return result, err

}

// ### Run a saved SQL interface query.
//
// This runs a previously created SQL interface query.
//
// The 'result_format' parameter specifies the desired structure and format of the response.
//
// Supported formats:
//
// | result_format | Description
// | :-----------: | :--- |
// | json | Plain json
// | json_bi | (*RECOMMENDED*) Row data plus metadata describing the fields, pivots, table calcs, and other aspects of the query
// | json_detail | (*LEGACY*) Row data plus metadata describing the fields, pivots, table calcs, and other aspects of the query
// | csv | Comma separated values with a header
// | txt | Tab separated values with a header
// | html | Simple html
// | md | Simple markdown
// | xlsx | MS Excel spreadsheet
// | sql | Returns the generated SQL rather than running the query
//
// GET /sql_interface_queries/{query_id}/run/{result_format} -> QueryFormats
func (l *LookerSDK) RunSqlInterfaceQuery(
	queryId int64,
	resultFormat string,
	options *rtl.ApiSettings) (QueryFormats, error) {
	resultFormat = url.PathEscape(resultFormat)
	var result QueryFormats
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/sql_interface_queries/%v/run/%v", queryId, resultFormat), nil, nil, options)
	return result, err

}

// ### Create a SQL interface query.
//
// This allows you to create a new SQL interface query that you can later run. Looker queries are immutable once created
// and are not deleted. If you create a query that is exactly like an existing query then the existing query
// will be returned and no new query will be created. Whether a new query is created or not, you can use
// the 'id' in the returned query with the 'run' method.
//
// The query parameters are passed as json in the body of the request.
//
// POST /sql_interface_queries -> SqlInterfaceQuery
func (l *LookerSDK) CreateSqlInterfaceQuery(
	body WriteSqlInterfaceQueryCreate,
	options *rtl.ApiSettings) (SqlInterfaceQuery, error) {
	var result SqlInterfaceQuery
	err := l.session.Do(&result, "POST", "/4.0", "/sql_interface_queries", nil, body, options)
	return result, err

}

// endregion SqlInterfaceQuery: Run and Manage SQL Interface Queries

// region Theme: Manage Themes

// ### Get an array of all existing themes
//
// Get a **single theme** by id with [Theme](#!/Theme/theme)
//
// This method returns an array of all existing themes. The active time for the theme is not considered.
//
// **Note**: Custom themes needs to be enabled by Looker. Unless custom themes are enabled, only the automatically generated default theme can be used. Please contact your Account Manager or https://console.cloud.google.com/support/cases/ to update your license for this feature.
//
// GET /themes -> []Theme
func (l *LookerSDK) AllThemes(
	fields string,
	options *rtl.ApiSettings) ([]Theme, error) {
	var result []Theme
	err := l.session.Do(&result, "GET", "/4.0", "/themes", map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Create a theme
//
// Creates a new theme object, returning the theme details, including the created id.
//
// If `settings` are not specified, the default theme settings will be copied into the new theme.
//
// The theme `name` can only contain alphanumeric characters or underscores. Theme names should not contain any confidential information, such as customer names.
//
// **Update** an existing theme with [Update Theme](#!/Theme/update_theme)
//
// **Permanently delete** an existing theme with [Delete Theme](#!/Theme/delete_theme)
//
// For more information, see [Creating and Applying Themes](https://cloud.google.com/looker/docs/r/admin/themes).
//
// **Note**: Custom themes needs to be enabled by Looker. Unless custom themes are enabled, only the automatically generated default theme can be used. Please contact your Account Manager or https://console.cloud.google.com/support/cases/ to update your license for this feature.
//
// POST /themes -> Theme
func (l *LookerSDK) CreateTheme(
	body WriteTheme,
	options *rtl.ApiSettings) (Theme, error) {
	var result Theme
	err := l.session.Do(&result, "POST", "/4.0", "/themes", nil, body, options)
	return result, err

}

// ### Search all themes for matching criteria.
//
// Returns an **array of theme objects** that match the specified search criteria.
//
// | Search Parameters | Description
// | :-------------------: | :------ |
// | `begin_at` only | Find themes active at or after `begin_at`
// | `end_at` only | Find themes active at or before `end_at`
// | both set | Find themes with an active inclusive period between `begin_at` and `end_at`
//
// Note: Range matching requires boolean AND logic.
// When using `begin_at` and `end_at` together, do not use `filter_or`=TRUE
//
// If multiple search params are given and `filter_or` is FALSE or not specified,
// search params are combined in a logical AND operation.
// Only rows that match *all* search param criteria will be returned.
//
// If `filter_or` is TRUE, multiple search params are combined in a logical OR operation.
// Results will include rows that match **any** of the search criteria.
//
// String search params use case-insensitive matching.
// String search params can contain `%` and '_' as SQL LIKE pattern match wildcard expressions.
// example="dan%" will match "danger" and "Danzig" but not "David"
// example="D_m%" will match "Damage" and "dump"
//
// Integer search params can accept a single value or a comma separated list of values. The multiple
// values will be combined under a logical OR operation - results will match at least one of
// the given values.
//
// Most search params can accept "IS NULL" and "NOT NULL" as special expressions to match
// or exclude (respectively) rows where the column is null.
//
// Boolean search params accept only "true" and "false" as values.
//
// Get a **single theme** by id with [Theme](#!/Theme/theme)
//
// **Note**: Custom themes needs to be enabled by Looker. Unless custom themes are enabled, only the automatically generated default theme can be used. Please contact your Account Manager or https://console.cloud.google.com/support/cases/ to update your license for this feature.
//
// GET /themes/search -> []Theme
func (l *LookerSDK) SearchThemes(request RequestSearchThemes,
	options *rtl.ApiSettings) ([]Theme, error) {
	var result []Theme
	err := l.session.Do(&result, "GET", "/4.0", "/themes/search", map[string]interface{}{"id": request.Id, "name": request.Name, "begin_at": request.BeginAt, "end_at": request.EndAt, "limit": request.Limit, "offset": request.Offset, "sorts": request.Sorts, "fields": request.Fields, "filter_or": request.FilterOr}, nil, options)
	return result, err

}

// ### Get the default theme
//
// Returns the active theme object set as the default.
//
// The **default** theme name can be set in the UI on the Admin|Theme UI page
//
// The optional `ts` parameter can specify a different timestamp than "now." If specified, it returns the default theme at the time indicated.
//
// GET /themes/default -> Theme
func (l *LookerSDK) DefaultTheme(
	ts time.Time,
	options *rtl.ApiSettings) (Theme, error) {
	var result Theme
	err := l.session.Do(&result, "GET", "/4.0", "/themes/default", map[string]interface{}{"ts": ts}, nil, options)
	return result, err

}

// ### Set the global default theme by theme name
//
// Only Admin users can call this function.
//
// Only an active theme with no expiration (`end_at` not set) can be assigned as the default theme. As long as a theme has an active record with no expiration, it can be set as the default.
//
// [Create Theme](#!/Theme/create) has detailed information on rules for default and active themes
//
// Returns the new specified default theme object.
//
// **Note**: Custom themes needs to be enabled by Looker. Unless custom themes are enabled, only the automatically generated default theme can be used. Please contact your Account Manager or https://console.cloud.google.com/support/cases/ to update your license for this feature.
//
// PUT /themes/default -> Theme
func (l *LookerSDK) SetDefaultTheme(
	name string,
	options *rtl.ApiSettings) (Theme, error) {
	var result Theme
	err := l.session.Do(&result, "PUT", "/4.0", "/themes/default", map[string]interface{}{"name": name}, nil, options)
	return result, err

}

// ### Get active themes
//
// Returns an array of active themes.
//
// If the `name` parameter is specified, it will return an array with one theme if it's active and found.
//
// The optional `ts` parameter can specify a different timestamp than "now."
//
// **Note**: Custom themes needs to be enabled by Looker. Unless custom themes are enabled, only the automatically generated default theme can be used. Please contact your Account Manager or https://console.cloud.google.com/support/cases/ to update your license for this feature.
//
// GET /themes/active -> []Theme
func (l *LookerSDK) ActiveThemes(request RequestActiveThemes,
	options *rtl.ApiSettings) ([]Theme, error) {
	var result []Theme
	err := l.session.Do(&result, "GET", "/4.0", "/themes/active", map[string]interface{}{"name": request.Name, "ts": request.Ts, "fields": request.Fields}, nil, options)
	return result, err

}

// ### Get the named theme if it's active. Otherwise, return the default theme
//
// The optional `ts` parameter can specify a different timestamp than "now."
// Note: API users with `show` ability can call this function
//
// **Note**: Custom themes needs to be enabled by Looker. Unless custom themes are enabled, only the automatically generated default theme can be used. Please contact your Account Manager or https://console.cloud.google.com/support/cases/ to update your license for this feature.
//
// GET /themes/theme_or_default -> Theme
func (l *LookerSDK) ThemeOrDefault(
	name string,
	ts time.Time,
	options *rtl.ApiSettings) (Theme, error) {
	var result Theme
	err := l.session.Do(&result, "GET", "/4.0", "/themes/theme_or_default", map[string]interface{}{"name": name, "ts": ts}, nil, options)
	return result, err

}

// ### Validate a theme with the specified information
//
// # Validates all values set for the theme, returning any errors encountered, or 200 OK if valid
//
// See [Create Theme](#!/Theme/create_theme) for constraints
//
// **Note**: Custom themes needs to be enabled by Looker. Unless custom themes are enabled, only the automatically generated default theme can be used. Please contact your Account Manager or https://console.cloud.google.com/support/cases/ to update your license for this feature.
//
// POST /themes/validate -> ValidationError
func (l *LookerSDK) ValidateTheme(
	body WriteTheme,
	options *rtl.ApiSettings) (ValidationError, error) {
	var result ValidationError
	err := l.session.Do(&result, "POST", "/4.0", "/themes/validate", nil, body, options)
	return result, err

}

// ### Get a theme by ID
//
// Use this to retrieve a specific theme, whether or not it's currently active.
//
// **Note**: Custom themes needs to be enabled by Looker. Unless custom themes are enabled, only the automatically generated default theme can be used. Please contact your Account Manager or https://console.cloud.google.com/support/cases/ to update your license for this feature.
//
// GET /themes/{theme_id} -> Theme
func (l *LookerSDK) Theme(
	themeId string,
	fields string,
	options *rtl.ApiSettings) (Theme, error) {
	themeId = url.PathEscape(themeId)
	var result Theme
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/themes/%v", themeId), map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Update the theme by id.
//
// **Note**: Custom themes needs to be enabled by Looker. Unless custom themes are enabled, only the automatically generated default theme can be used. Please contact your Account Manager or https://console.cloud.google.com/support/cases/ to update your license for this feature.
//
// PATCH /themes/{theme_id} -> Theme
func (l *LookerSDK) UpdateTheme(
	themeId string,
	body WriteTheme,
	options *rtl.ApiSettings) (Theme, error) {
	themeId = url.PathEscape(themeId)
	var result Theme
	err := l.session.Do(&result, "PATCH", "/4.0", fmt.Sprintf("/themes/%v", themeId), nil, body, options)
	return result, err

}

// ### Delete a specific theme by id
//
// This operation permanently deletes the identified theme from the database.
//
// Because multiple themes can have the same name (with different activation time spans) themes can only be deleted by ID.
//
// All IDs associated with a theme name can be retrieved by searching for the theme name with [Theme Search](#!/Theme/search).
//
// **Note**: Custom themes needs to be enabled by Looker. Unless custom themes are enabled, only the automatically generated default theme can be used. Please contact your Account Manager or https://console.cloud.google.com/support/cases/ to update your license for this feature.
//
// DELETE /themes/{theme_id} -> string
func (l *LookerSDK) DeleteTheme(
	themeId string,
	options *rtl.ApiSettings) (string, error) {
	themeId = url.PathEscape(themeId)
	var result string
	err := l.session.Do(&result, "DELETE", "/4.0", fmt.Sprintf("/themes/%v", themeId), nil, nil, options)
	return result, err

}

// endregion Theme: Manage Themes

// region User: Manage Users

// ### Search email credentials
//
// Returns all credentials_email records that match the given search criteria.
//
// If multiple search params are given and `filter_or` is FALSE or not specified,
// search params are combined in a logical AND operation.
// Only rows that match *all* search param criteria will be returned.
//
// If `filter_or` is TRUE, multiple search params are combined in a logical OR operation.
// Results will include rows that match **any** of the search criteria.
//
// String search params use case-insensitive matching.
// String search params can contain `%` and '_' as SQL LIKE pattern match wildcard expressions.
// example="dan%" will match "danger" and "Danzig" but not "David"
// example="D_m%" will match "Damage" and "dump"
//
// Integer search params can accept a single value or a comma separated list of values. The multiple
// values will be combined under a logical OR operation - results will match at least one of
// the given values.
//
// Most search params can accept "IS NULL" and "NOT NULL" as special expressions to match
// or exclude (respectively) rows where the column is null.
//
// Boolean search params accept only "true" and "false" as values.
//
// Calls to this endpoint may be denied by [Looker (Google Cloud core)](https://cloud.google.com/looker/docs/r/looker-core/overview).
//
// GET /credentials_email/search -> []CredentialsEmailSearch
func (l *LookerSDK) SearchCredentialsEmail(request RequestSearchCredentialsEmail,
	options *rtl.ApiSettings) ([]CredentialsEmailSearch, error) {
	var result []CredentialsEmailSearch
	err := l.session.Do(&result, "GET", "/4.0", "/credentials_email/search", map[string]interface{}{"fields": request.Fields, "limit": request.Limit, "offset": request.Offset, "sorts": request.Sorts, "id": request.Id, "email": request.Email, "emails": request.Emails, "filter_or": request.FilterOr}, nil, options)
	return result, err

}

// ### Get information about the current user; i.e. the user account currently calling the API.
//
// GET /user -> User
func (l *LookerSDK) Me(
	fields string,
	options *rtl.ApiSettings) (User, error) {
	var result User
	err := l.session.Do(&result, "GET", "/4.0", "/user", map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Get information about all users.
//
// GET /users -> []User
func (l *LookerSDK) AllUsers(request RequestAllUsers,
	options *rtl.ApiSettings) ([]User, error) {
	var result []User
	err := l.session.Do(&result, "GET", "/4.0", "/users", map[string]interface{}{"fields": request.Fields, "page": request.Page, "per_page": request.PerPage, "limit": request.Limit, "offset": request.Offset, "sorts": request.Sorts, "ids": request.Ids}, nil, options)
	return result, err

}

// ### Create a user with the specified information.
//
// POST /users -> User
func (l *LookerSDK) CreateUser(
	body WriteUser,
	fields string,
	options *rtl.ApiSettings) (User, error) {
	var result User
	err := l.session.Do(&result, "POST", "/4.0", "/users", map[string]interface{}{"fields": fields}, body, options)
	return result, err

}

// ### Search users
//
// Returns all<sup>*</sup> user records that match the given search criteria.
//
// If multiple search params are given and `filter_or` is FALSE or not specified,
// search params are combined in a logical AND operation.
// Only rows that match *all* search param criteria will be returned.
//
// If `filter_or` is TRUE, multiple search params are combined in a logical OR operation.
// Results will include rows that match **any** of the search criteria.
//
// String search params use case-insensitive matching.
// String search params can contain `%` and '_' as SQL LIKE pattern match wildcard expressions.
// example="dan%" will match "danger" and "Danzig" but not "David"
// example="D_m%" will match "Damage" and "dump"
//
// Integer search params can accept a single value or a comma separated list of values. The multiple
// values will be combined under a logical OR operation - results will match at least one of
// the given values.
//
// Most search params can accept "IS NULL" and "NOT NULL" as special expressions to match
// or exclude (respectively) rows where the column is null.
//
// Boolean search params accept only "true" and "false" as values.
//
// (<sup>*</sup>) Results are always filtered to the level of information the caller is permitted to view.
// Looker admins can see all user details; normal users in an open system can see
// names of other users but no details; normal users in a closed system can only see
// names of other users who are members of the same group as the user.
//
// GET /users/search -> []User
func (l *LookerSDK) SearchUsers(request RequestSearchUsers,
	options *rtl.ApiSettings) ([]User, error) {
	var result []User
	err := l.session.Do(&result, "GET", "/4.0", "/users/search", map[string]interface{}{"fields": request.Fields, "page": request.Page, "per_page": request.PerPage, "limit": request.Limit, "offset": request.Offset, "sorts": request.Sorts, "id": request.Id, "first_name": request.FirstName, "last_name": request.LastName, "verified_looker_employee": request.VerifiedLookerEmployee, "embed_user": request.EmbedUser, "email": request.Email, "is_disabled": request.IsDisabled, "filter_or": request.FilterOr, "content_metadata_id": request.ContentMetadataId, "group_id": request.GroupId}, nil, options)
	return result, err

}

// ### Search for user accounts by name
//
// Returns all user accounts where `first_name` OR `last_name` OR `email` field values match a pattern.
// The pattern can contain `%` and `_` wildcards as in SQL LIKE expressions.
//
// Any additional search params will be combined into a logical AND expression.
//
// GET /users/search/names/{pattern} -> []User
func (l *LookerSDK) SearchUsersNames(request RequestSearchUsersNames,
	options *rtl.ApiSettings) ([]User, error) {
	request.Pattern = url.PathEscape(request.Pattern)
	var result []User
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/users/search/names/%v", request.Pattern), map[string]interface{}{"fields": request.Fields, "page": request.Page, "per_page": request.PerPage, "limit": request.Limit, "offset": request.Offset, "sorts": request.Sorts, "id": request.Id, "first_name": request.FirstName, "last_name": request.LastName, "verified_looker_employee": request.VerifiedLookerEmployee, "email": request.Email, "is_disabled": request.IsDisabled}, nil, options)
	return result, err

}

// ### Get information about the user with a specific id.
//
// If the caller is an admin or the caller is the user being specified, then full user information will
// be returned. Otherwise, a minimal 'public' variant of the user information will be returned. This contains
// The user name and avatar url, but no sensitive information.
//
// GET /users/{user_id} -> User
func (l *LookerSDK) User(
	userId string,
	fields string,
	options *rtl.ApiSettings) (User, error) {
	userId = url.PathEscape(userId)
	var result User
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/users/%v", userId), map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Update information about the user with a specific id.
//
// PATCH /users/{user_id} -> User
func (l *LookerSDK) UpdateUser(
	userId string,
	body WriteUser,
	fields string,
	options *rtl.ApiSettings) (User, error) {
	userId = url.PathEscape(userId)
	var result User
	err := l.session.Do(&result, "PATCH", "/4.0", fmt.Sprintf("/users/%v", userId), map[string]interface{}{"fields": fields}, body, options)
	return result, err

}

// ### Delete the user with a specific id.
//
// **DANGER** this will delete the user and all looks and other information owned by the user.
//
// DELETE /users/{user_id} -> string
func (l *LookerSDK) DeleteUser(
	userId string,
	options *rtl.ApiSettings) (string, error) {
	userId = url.PathEscape(userId)
	var result string
	err := l.session.Do(&result, "DELETE", "/4.0", fmt.Sprintf("/users/%v", userId), nil, nil, options)
	return result, err

}

// ### Get information about the user with a credential of given type with specific id.
//
// This is used to do things like find users by their embed external_user_id. Or, find the user with
// a given api3 client_id, etc. The 'credential_type' matches the 'type' name of the various credential
// types. It must be one of the values listed in the table below. The 'credential_id' is your unique Id
// for the user and is specific to each type of credential.
//
// An example using the Ruby sdk might look like:
//
// `sdk.user_for_credential('embed', 'customer-4959425')`
//
// This table shows the supported 'Credential Type' strings. The right column is for reference; it shows
// which field in the given credential type is actually searched when finding a user with the supplied
// 'credential_id'.
//
// | Credential Types | Id Field Matched |
// | ---------------- | ---------------- |
// | email            | email            |
// | google           | google_user_id   |
// | saml             | saml_user_id     |
// | oidc             | oidc_user_id     |
// | ldap             | ldap_id          |
// | api              | token            |
// | api3             | client_id        |
// | embed            | external_user_id |
// | looker_openid    | email            |
//
// **NOTE**: The 'api' credential type was only used with the legacy Looker query API and is no longer supported. The credential type for API you are currently looking at is 'api3'.
//
// Calls to this endpoint may be denied by [Looker (Google Cloud core)](https://cloud.google.com/looker/docs/r/looker-core/overview).
//
// GET /users/credential/{credential_type}/{credential_id} -> User
func (l *LookerSDK) UserForCredential(
	credentialType string,
	credentialId string,
	fields string,
	options *rtl.ApiSettings) (User, error) {
	credentialType = url.PathEscape(credentialType)
	credentialId = url.PathEscape(credentialId)
	var result User
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/users/credential/%v/%v", credentialType, credentialId), map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Email/password login information for the specified user.
//
// Calls to this endpoint may be denied by [Looker (Google Cloud core)](https://cloud.google.com/looker/docs/r/looker-core/overview).
//
// GET /users/{user_id}/credentials_email -> CredentialsEmail
func (l *LookerSDK) UserCredentialsEmail(
	userId string,
	fields string,
	options *rtl.ApiSettings) (CredentialsEmail, error) {
	userId = url.PathEscape(userId)
	var result CredentialsEmail
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/users/%v/credentials_email", userId), map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Email/password login information for the specified user.
//
// Calls to this endpoint may be denied by [Looker (Google Cloud core)](https://cloud.google.com/looker/docs/r/looker-core/overview).
//
// POST /users/{user_id}/credentials_email -> CredentialsEmail
func (l *LookerSDK) CreateUserCredentialsEmail(
	userId string,
	body WriteCredentialsEmail,
	fields string,
	options *rtl.ApiSettings) (CredentialsEmail, error) {
	userId = url.PathEscape(userId)
	var result CredentialsEmail
	err := l.session.Do(&result, "POST", "/4.0", fmt.Sprintf("/users/%v/credentials_email", userId), map[string]interface{}{"fields": fields}, body, options)
	return result, err

}

// ### Email/password login information for the specified user.
//
// Calls to this endpoint may be denied by [Looker (Google Cloud core)](https://cloud.google.com/looker/docs/r/looker-core/overview).
//
// PATCH /users/{user_id}/credentials_email -> CredentialsEmail
func (l *LookerSDK) UpdateUserCredentialsEmail(
	userId string,
	body WriteCredentialsEmail,
	fields string,
	options *rtl.ApiSettings) (CredentialsEmail, error) {
	userId = url.PathEscape(userId)
	var result CredentialsEmail
	err := l.session.Do(&result, "PATCH", "/4.0", fmt.Sprintf("/users/%v/credentials_email", userId), map[string]interface{}{"fields": fields}, body, options)
	return result, err

}

// ### Email/password login information for the specified user.
//
// Calls to this endpoint may be denied by [Looker (Google Cloud core)](https://cloud.google.com/looker/docs/r/looker-core/overview).
//
// DELETE /users/{user_id}/credentials_email -> string
func (l *LookerSDK) DeleteUserCredentialsEmail(
	userId string,
	options *rtl.ApiSettings) (string, error) {
	userId = url.PathEscape(userId)
	var result string
	err := l.session.Do(&result, "DELETE", "/4.0", fmt.Sprintf("/users/%v/credentials_email", userId), nil, nil, options)
	return result, err

}

// ### Two-factor login information for the specified user.
//
// Calls to this endpoint may be denied by [Looker (Google Cloud core)](https://cloud.google.com/looker/docs/r/looker-core/overview).
//
// GET /users/{user_id}/credentials_totp -> CredentialsTotp
func (l *LookerSDK) UserCredentialsTotp(
	userId string,
	fields string,
	options *rtl.ApiSettings) (CredentialsTotp, error) {
	userId = url.PathEscape(userId)
	var result CredentialsTotp
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/users/%v/credentials_totp", userId), map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Two-factor login information for the specified user.
//
// Calls to this endpoint may be denied by [Looker (Google Cloud core)](https://cloud.google.com/looker/docs/r/looker-core/overview).
//
// POST /users/{user_id}/credentials_totp -> CredentialsTotp
func (l *LookerSDK) CreateUserCredentialsTotp(
	userId string,
	body CredentialsTotp,
	fields string,
	options *rtl.ApiSettings) (CredentialsTotp, error) {
	userId = url.PathEscape(userId)
	var result CredentialsTotp
	err := l.session.Do(&result, "POST", "/4.0", fmt.Sprintf("/users/%v/credentials_totp", userId), map[string]interface{}{"fields": fields}, body, options)
	return result, err

}

// ### Two-factor login information for the specified user.
//
// Calls to this endpoint may be denied by [Looker (Google Cloud core)](https://cloud.google.com/looker/docs/r/looker-core/overview).
//
// DELETE /users/{user_id}/credentials_totp -> string
func (l *LookerSDK) DeleteUserCredentialsTotp(
	userId string,
	options *rtl.ApiSettings) (string, error) {
	userId = url.PathEscape(userId)
	var result string
	err := l.session.Do(&result, "DELETE", "/4.0", fmt.Sprintf("/users/%v/credentials_totp", userId), nil, nil, options)
	return result, err

}

// ### LDAP login information for the specified user.
//
// Calls to this endpoint may be denied by [Looker (Google Cloud core)](https://cloud.google.com/looker/docs/r/looker-core/overview).
//
// GET /users/{user_id}/credentials_ldap -> CredentialsLDAP
func (l *LookerSDK) UserCredentialsLdap(
	userId string,
	fields string,
	options *rtl.ApiSettings) (CredentialsLDAP, error) {
	userId = url.PathEscape(userId)
	var result CredentialsLDAP
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/users/%v/credentials_ldap", userId), map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### LDAP login information for the specified user.
//
// Calls to this endpoint may be denied by [Looker (Google Cloud core)](https://cloud.google.com/looker/docs/r/looker-core/overview).
//
// DELETE /users/{user_id}/credentials_ldap -> string
func (l *LookerSDK) DeleteUserCredentialsLdap(
	userId string,
	options *rtl.ApiSettings) (string, error) {
	userId = url.PathEscape(userId)
	var result string
	err := l.session.Do(&result, "DELETE", "/4.0", fmt.Sprintf("/users/%v/credentials_ldap", userId), nil, nil, options)
	return result, err

}

// ### Google authentication login information for the specified user.
//
// Calls to this endpoint may be denied by [Looker (Google Cloud core)](https://cloud.google.com/looker/docs/r/looker-core/overview).
//
// GET /users/{user_id}/credentials_google -> CredentialsGoogle
func (l *LookerSDK) UserCredentialsGoogle(
	userId string,
	fields string,
	options *rtl.ApiSettings) (CredentialsGoogle, error) {
	userId = url.PathEscape(userId)
	var result CredentialsGoogle
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/users/%v/credentials_google", userId), map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Google authentication login information for the specified user.
//
// Calls to this endpoint may be denied by [Looker (Google Cloud core)](https://cloud.google.com/looker/docs/r/looker-core/overview).
//
// DELETE /users/{user_id}/credentials_google -> string
func (l *LookerSDK) DeleteUserCredentialsGoogle(
	userId string,
	options *rtl.ApiSettings) (string, error) {
	userId = url.PathEscape(userId)
	var result string
	err := l.session.Do(&result, "DELETE", "/4.0", fmt.Sprintf("/users/%v/credentials_google", userId), nil, nil, options)
	return result, err

}

// ### Saml authentication login information for the specified user.
//
// Calls to this endpoint may be denied by [Looker (Google Cloud core)](https://cloud.google.com/looker/docs/r/looker-core/overview).
//
// GET /users/{user_id}/credentials_saml -> CredentialsSaml
func (l *LookerSDK) UserCredentialsSaml(
	userId string,
	fields string,
	options *rtl.ApiSettings) (CredentialsSaml, error) {
	userId = url.PathEscape(userId)
	var result CredentialsSaml
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/users/%v/credentials_saml", userId), map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Saml authentication login information for the specified user.
//
// Calls to this endpoint may be denied by [Looker (Google Cloud core)](https://cloud.google.com/looker/docs/r/looker-core/overview).
//
// DELETE /users/{user_id}/credentials_saml -> string
func (l *LookerSDK) DeleteUserCredentialsSaml(
	userId string,
	options *rtl.ApiSettings) (string, error) {
	userId = url.PathEscape(userId)
	var result string
	err := l.session.Do(&result, "DELETE", "/4.0", fmt.Sprintf("/users/%v/credentials_saml", userId), nil, nil, options)
	return result, err

}

// ### OpenID Connect (OIDC) authentication login information for the specified user.
//
// Calls to this endpoint may be denied by [Looker (Google Cloud core)](https://cloud.google.com/looker/docs/r/looker-core/overview).
//
// GET /users/{user_id}/credentials_oidc -> CredentialsOIDC
func (l *LookerSDK) UserCredentialsOidc(
	userId string,
	fields string,
	options *rtl.ApiSettings) (CredentialsOIDC, error) {
	userId = url.PathEscape(userId)
	var result CredentialsOIDC
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/users/%v/credentials_oidc", userId), map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### OpenID Connect (OIDC) authentication login information for the specified user.
//
// Calls to this endpoint may be denied by [Looker (Google Cloud core)](https://cloud.google.com/looker/docs/r/looker-core/overview).
//
// DELETE /users/{user_id}/credentials_oidc -> string
func (l *LookerSDK) DeleteUserCredentialsOidc(
	userId string,
	options *rtl.ApiSettings) (string, error) {
	userId = url.PathEscape(userId)
	var result string
	err := l.session.Do(&result, "DELETE", "/4.0", fmt.Sprintf("/users/%v/credentials_oidc", userId), nil, nil, options)
	return result, err

}

// ### API login information for the specified user. This is for the newer API keys that can be added for any user.
//
// Calls to this endpoint may be denied by [Looker (Google Cloud core)](https://cloud.google.com/looker/docs/r/looker-core/overview).
//
// GET /users/{user_id}/credentials_api3/{credentials_api3_id} -> CredentialsApi3
func (l *LookerSDK) UserCredentialsApi3(
	userId string,
	credentialsApi3Id string,
	fields string,
	options *rtl.ApiSettings) (CredentialsApi3, error) {
	userId = url.PathEscape(userId)
	credentialsApi3Id = url.PathEscape(credentialsApi3Id)
	var result CredentialsApi3
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/users/%v/credentials_api3/%v", userId, credentialsApi3Id), map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### API login information for the specified user. This is for the newer API keys that can be added for any user.
//
// Calls to this endpoint may be denied by [Looker (Google Cloud core)](https://cloud.google.com/looker/docs/r/looker-core/overview).
//
// DELETE /users/{user_id}/credentials_api3/{credentials_api3_id} -> string
func (l *LookerSDK) DeleteUserCredentialsApi3(
	userId string,
	credentialsApi3Id string,
	options *rtl.ApiSettings) (string, error) {
	userId = url.PathEscape(userId)
	credentialsApi3Id = url.PathEscape(credentialsApi3Id)
	var result string
	err := l.session.Do(&result, "DELETE", "/4.0", fmt.Sprintf("/users/%v/credentials_api3/%v", userId, credentialsApi3Id), nil, nil, options)
	return result, err

}

// ### API login information for the specified user. This is for the newer API keys that can be added for any user.
//
// Calls to this endpoint may be denied by [Looker (Google Cloud core)](https://cloud.google.com/looker/docs/r/looker-core/overview).
//
// GET /users/{user_id}/credentials_api3 -> []CredentialsApi3
func (l *LookerSDK) AllUserCredentialsApi3s(
	userId string,
	fields string,
	options *rtl.ApiSettings) ([]CredentialsApi3, error) {
	userId = url.PathEscape(userId)
	var result []CredentialsApi3
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/users/%v/credentials_api3", userId), map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### API login information for the specified user. This is for the newer API keys that can be added for any user.
//
// Calls to this endpoint may be denied by [Looker (Google Cloud core)](https://cloud.google.com/looker/docs/r/looker-core/overview).
//
// POST /users/{user_id}/credentials_api3 -> CreateCredentialsApi3
func (l *LookerSDK) CreateUserCredentialsApi3(
	userId string,
	fields string,
	options *rtl.ApiSettings) (CreateCredentialsApi3, error) {
	userId = url.PathEscape(userId)
	var result CreateCredentialsApi3
	err := l.session.Do(&result, "POST", "/4.0", fmt.Sprintf("/users/%v/credentials_api3", userId), map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Embed login information for the specified user.
//
// Calls to this endpoint require [Embedding](https://cloud.google.com/looker/docs/r/looker-core-feature-embed) to be enabled
//
// GET /users/{user_id}/credentials_embed/{credentials_embed_id} -> CredentialsEmbed
func (l *LookerSDK) UserCredentialsEmbed(
	userId string,
	credentialsEmbedId string,
	fields string,
	options *rtl.ApiSettings) (CredentialsEmbed, error) {
	userId = url.PathEscape(userId)
	credentialsEmbedId = url.PathEscape(credentialsEmbedId)
	var result CredentialsEmbed
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/users/%v/credentials_embed/%v", userId, credentialsEmbedId), map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Embed login information for the specified user.
//
// Calls to this endpoint require [Embedding](https://cloud.google.com/looker/docs/r/looker-core-feature-embed) to be enabled
//
// DELETE /users/{user_id}/credentials_embed/{credentials_embed_id} -> string
func (l *LookerSDK) DeleteUserCredentialsEmbed(
	userId string,
	credentialsEmbedId string,
	options *rtl.ApiSettings) (string, error) {
	userId = url.PathEscape(userId)
	credentialsEmbedId = url.PathEscape(credentialsEmbedId)
	var result string
	err := l.session.Do(&result, "DELETE", "/4.0", fmt.Sprintf("/users/%v/credentials_embed/%v", userId, credentialsEmbedId), nil, nil, options)
	return result, err

}

// ### Embed login information for the specified user.
//
// Calls to this endpoint require [Embedding](https://cloud.google.com/looker/docs/r/looker-core-feature-embed) to be enabled
//
// GET /users/{user_id}/credentials_embed -> []CredentialsEmbed
func (l *LookerSDK) AllUserCredentialsEmbeds(
	userId string,
	fields string,
	options *rtl.ApiSettings) ([]CredentialsEmbed, error) {
	userId = url.PathEscape(userId)
	var result []CredentialsEmbed
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/users/%v/credentials_embed", userId), map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Looker Openid login information for the specified user. Used by Looker Analysts.
//
// Calls to this endpoint may be denied by [Looker (Google Cloud core)](https://cloud.google.com/looker/docs/r/looker-core/overview).
//
// GET /users/{user_id}/credentials_looker_openid -> CredentialsLookerOpenid
func (l *LookerSDK) UserCredentialsLookerOpenid(
	userId string,
	fields string,
	options *rtl.ApiSettings) (CredentialsLookerOpenid, error) {
	userId = url.PathEscape(userId)
	var result CredentialsLookerOpenid
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/users/%v/credentials_looker_openid", userId), map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Looker Openid login information for the specified user. Used by Looker Analysts.
//
// Calls to this endpoint may be denied by [Looker (Google Cloud core)](https://cloud.google.com/looker/docs/r/looker-core/overview).
//
// DELETE /users/{user_id}/credentials_looker_openid -> string
func (l *LookerSDK) DeleteUserCredentialsLookerOpenid(
	userId string,
	options *rtl.ApiSettings) (string, error) {
	userId = url.PathEscape(userId)
	var result string
	err := l.session.Do(&result, "DELETE", "/4.0", fmt.Sprintf("/users/%v/credentials_looker_openid", userId), nil, nil, options)
	return result, err

}

// ### Web login session for the specified user.
//
// Calls to this endpoint may be denied by [Looker (Google Cloud core)](https://cloud.google.com/looker/docs/r/looker-core/overview).
//
// GET /users/{user_id}/sessions/{session_id} -> Session
func (l *LookerSDK) UserSession(
	userId string,
	sessionId string,
	fields string,
	options *rtl.ApiSettings) (Session, error) {
	userId = url.PathEscape(userId)
	sessionId = url.PathEscape(sessionId)
	var result Session
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/users/%v/sessions/%v", userId, sessionId), map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Web login session for the specified user.
//
// Calls to this endpoint may be denied by [Looker (Google Cloud core)](https://cloud.google.com/looker/docs/r/looker-core/overview).
//
// DELETE /users/{user_id}/sessions/{session_id} -> string
func (l *LookerSDK) DeleteUserSession(
	userId string,
	sessionId string,
	options *rtl.ApiSettings) (string, error) {
	userId = url.PathEscape(userId)
	sessionId = url.PathEscape(sessionId)
	var result string
	err := l.session.Do(&result, "DELETE", "/4.0", fmt.Sprintf("/users/%v/sessions/%v", userId, sessionId), nil, nil, options)
	return result, err

}

// ### Web login session for the specified user.
//
// Calls to this endpoint may be denied by [Looker (Google Cloud core)](https://cloud.google.com/looker/docs/r/looker-core/overview).
//
// GET /users/{user_id}/sessions -> []Session
func (l *LookerSDK) AllUserSessions(
	userId string,
	fields string,
	options *rtl.ApiSettings) ([]Session, error) {
	userId = url.PathEscape(userId)
	var result []Session
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/users/%v/sessions", userId), map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Create a password reset token.
// This will create a cryptographically secure random password reset token for the user.
// If the user already has a password reset token then this invalidates the old token and creates a new one.
// The token is expressed as the 'password_reset_url' of the user's email/password credential object.
// This takes an optional 'expires' param to indicate if the new token should be an expiring token.
// Tokens that expire are typically used for self-service password resets for existing users.
// Invitation emails for new users typically are not set to expire.
// The expire period is always 60 minutes when expires is enabled.
// This method can be called with an empty body.
//
// Calls to this endpoint may be denied by [Looker (Google Cloud core)](https://cloud.google.com/looker/docs/r/looker-core/overview).
//
// POST /users/{user_id}/credentials_email/password_reset -> CredentialsEmail
func (l *LookerSDK) CreateUserCredentialsEmailPasswordReset(request RequestCreateUserCredentialsEmailPasswordReset,
	options *rtl.ApiSettings) (CredentialsEmail, error) {
	request.UserId = url.PathEscape(request.UserId)
	var result CredentialsEmail
	err := l.session.Do(&result, "POST", "/4.0", fmt.Sprintf("/users/%v/credentials_email/password_reset", request.UserId), map[string]interface{}{"expires": request.Expires, "fields": request.Fields}, nil, options)
	return result, err

}

// ### Get information about roles of a given user
//
// GET /users/{user_id}/roles -> []Role
func (l *LookerSDK) UserRoles(request RequestUserRoles,
	options *rtl.ApiSettings) ([]Role, error) {
	request.UserId = url.PathEscape(request.UserId)
	var result []Role
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/users/%v/roles", request.UserId), map[string]interface{}{"fields": request.Fields, "direct_association_only": request.DirectAssociationOnly}, nil, options)
	return result, err

}

// ### Set roles of the user with a specific id.
//
// PUT /users/{user_id}/roles -> []Role
func (l *LookerSDK) SetUserRoles(
	userId string,
	body []string,
	fields string,
	options *rtl.ApiSettings) ([]Role, error) {
	userId = url.PathEscape(userId)
	var result []Role
	err := l.session.Do(&result, "PUT", "/4.0", fmt.Sprintf("/users/%v/roles", userId), map[string]interface{}{"fields": fields}, body, options)
	return result, err

}

// ### Get user attribute values for a given user.
//
// Returns the values of specified user attributes (or all user attributes) for a certain user.
//
// A value for each user attribute is searched for in the following locations, in this order:
//
// 1. in the user's account information
// 1. in groups that the user is a member of
// 1. the default value of the user attribute
//
// If more than one group has a value defined for a user attribute, the group with the lowest rank wins.
//
// The response will only include user attributes for which values were found. Use `include_unset=true` to include
// empty records for user attributes with no value.
//
// The value of all hidden user attributes will be blank.
//
// GET /users/{user_id}/attribute_values -> []UserAttributeWithValue
func (l *LookerSDK) UserAttributeUserValues(request RequestUserAttributeUserValues,
	options *rtl.ApiSettings) ([]UserAttributeWithValue, error) {
	request.UserId = url.PathEscape(request.UserId)
	var result []UserAttributeWithValue
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/users/%v/attribute_values", request.UserId), map[string]interface{}{"fields": request.Fields, "user_attribute_ids": request.UserAttributeIds, "all_values": request.AllValues, "include_unset": request.IncludeUnset}, nil, options)
	return result, err

}

// ### Store a custom value for a user attribute in a user's account settings.
//
// Per-user user attribute values take precedence over group or default values.
//
// PATCH /users/{user_id}/attribute_values/{user_attribute_id} -> UserAttributeWithValue
func (l *LookerSDK) SetUserAttributeUserValue(
	userId string,
	userAttributeId string,
	body WriteUserAttributeWithValue,
	options *rtl.ApiSettings) (UserAttributeWithValue, error) {
	userId = url.PathEscape(userId)
	userAttributeId = url.PathEscape(userAttributeId)
	var result UserAttributeWithValue
	err := l.session.Do(&result, "PATCH", "/4.0", fmt.Sprintf("/users/%v/attribute_values/%v", userId, userAttributeId), nil, body, options)
	return result, err

}

// ### Delete a user attribute value from a user's account settings.
//
// After the user attribute value is deleted from the user's account settings, subsequent requests
// for the user attribute value for this user will draw from the user's groups or the default
// value of the user attribute. See [Get User Attribute Values](#!/User/user_attribute_user_values) for more
// information about how user attribute values are resolved.
//
// DELETE /users/{user_id}/attribute_values/{user_attribute_id} -> Void
func (l *LookerSDK) DeleteUserAttributeUserValue(
	userId string,
	userAttributeId string,
	options *rtl.ApiSettings) error {
	userId = url.PathEscape(userId)
	userAttributeId = url.PathEscape(userAttributeId)
	err := l.session.Do(nil, "DELETE", "/4.0", fmt.Sprintf("/users/%v/attribute_values/%v", userId, userAttributeId), nil, nil, options)
	return err

}

// ### Send a password reset token.
// This will send a password reset email to the user. If a password reset token does not already exist
// for this user, it will create one and then send it.
// If the user has not yet set up their account, it will send a setup email to the user.
// The URL sent in the email is expressed as the 'password_reset_url' of the user's email/password credential object.
// Password reset URLs will expire in 60 minutes.
// This method can be called with an empty body.
//
// Calls to this endpoint may be denied by [Looker (Google Cloud core)](https://cloud.google.com/looker/docs/r/looker-core/overview).
//
// POST /users/{user_id}/credentials_email/send_password_reset -> CredentialsEmail
func (l *LookerSDK) SendUserCredentialsEmailPasswordReset(
	userId string,
	fields string,
	options *rtl.ApiSettings) (CredentialsEmail, error) {
	userId = url.PathEscape(userId)
	var result CredentialsEmail
	err := l.session.Do(&result, "POST", "/4.0", fmt.Sprintf("/users/%v/credentials_email/send_password_reset", userId), map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Change a disabled user's email addresses
//
// Allows the admin to change the email addresses for all the user's
// associated credentials.  Will overwrite all associated email addresses with
// the value supplied in the 'email' body param.
// The user's 'is_disabled' status must be true.
// If the user has a credential email, they will receive a verification email and the user will be disabled until they verify the email
//
// Calls to this endpoint may be denied by [Looker (Google Cloud core)](https://cloud.google.com/looker/docs/r/looker-core/overview).
//
// POST /users/{user_id}/update_emails -> User
func (l *LookerSDK) WipeoutUserEmails(
	userId string,
	body UserEmailOnly,
	fields string,
	options *rtl.ApiSettings) (User, error) {
	userId = url.PathEscape(userId)
	var result User
	err := l.session.Do(&result, "POST", "/4.0", fmt.Sprintf("/users/%v/update_emails", userId), map[string]interface{}{"fields": fields}, body, options)
	return result, err

}

// Create an embed user from an external user ID
//
// Calls to this endpoint require [Embedding](https://cloud.google.com/looker/docs/r/looker-core-feature-embed) to be enabled
//
// POST /users/embed_user -> UserPublic
func (l *LookerSDK) CreateEmbedUser(
	body CreateEmbedUserRequest,
	options *rtl.ApiSettings) (UserPublic, error) {
	var result UserPublic
	err := l.session.Do(&result, "POST", "/4.0", "/users/embed_user", nil, body, options)
	return result, err

}

// endregion User: Manage Users

// region UserAttribute: Manage User Attributes

// ### Get information about all user attributes.
//
// GET /user_attributes -> []UserAttribute
func (l *LookerSDK) AllUserAttributes(request RequestAllUserAttributes,
	options *rtl.ApiSettings) ([]UserAttribute, error) {
	var result []UserAttribute
	err := l.session.Do(&result, "GET", "/4.0", "/user_attributes", map[string]interface{}{"fields": request.Fields, "sorts": request.Sorts}, nil, options)
	return result, err

}

// ### Create a new user attribute
//
// Permission information for a user attribute is conveyed through the `can` and `user_can_edit` fields.
// The `user_can_edit` field indicates whether an attribute is user-editable _anywhere_ in the application.
// The `can` field gives more granular access information, with the `set_value` child field indicating whether
// an attribute's value can be set by [Setting the User Attribute User Value](#!/User/set_user_attribute_user_value).
//
// Note: `name` and `label` fields must be unique across all user attributes in the Looker instance.
// Attempting to create a new user attribute with a name or label that duplicates an existing
// user attribute will fail with a 422 error.
//
// POST /user_attributes -> UserAttribute
func (l *LookerSDK) CreateUserAttribute(
	body WriteUserAttribute,
	fields string,
	options *rtl.ApiSettings) (UserAttribute, error) {
	var result UserAttribute
	err := l.session.Do(&result, "POST", "/4.0", "/user_attributes", map[string]interface{}{"fields": fields}, body, options)
	return result, err

}

// ### Get information about a user attribute.
//
// GET /user_attributes/{user_attribute_id} -> UserAttribute
func (l *LookerSDK) UserAttribute(
	userAttributeId string,
	fields string,
	options *rtl.ApiSettings) (UserAttribute, error) {
	userAttributeId = url.PathEscape(userAttributeId)
	var result UserAttribute
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/user_attributes/%v", userAttributeId), map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Update a user attribute definition.
//
// PATCH /user_attributes/{user_attribute_id} -> UserAttribute
func (l *LookerSDK) UpdateUserAttribute(
	userAttributeId string,
	body WriteUserAttribute,
	fields string,
	options *rtl.ApiSettings) (UserAttribute, error) {
	userAttributeId = url.PathEscape(userAttributeId)
	var result UserAttribute
	err := l.session.Do(&result, "PATCH", "/4.0", fmt.Sprintf("/user_attributes/%v", userAttributeId), map[string]interface{}{"fields": fields}, body, options)
	return result, err

}

// ### Delete a user attribute (admin only).
//
// DELETE /user_attributes/{user_attribute_id} -> string
func (l *LookerSDK) DeleteUserAttribute(
	userAttributeId string,
	options *rtl.ApiSettings) (string, error) {
	userAttributeId = url.PathEscape(userAttributeId)
	var result string
	err := l.session.Do(&result, "DELETE", "/4.0", fmt.Sprintf("/user_attributes/%v", userAttributeId), nil, nil, options)
	return result, err

}

// ### Returns all values of a user attribute defined by user groups, in precedence order.
//
// A user may be a member of multiple groups which define different values for a given user attribute.
// The order of group-values in the response determines precedence for selecting which group-value applies
// to a given user.  For more information, see [Set User Attribute Group Values](#!/UserAttribute/set_user_attribute_group_values).
//
// Results will only include groups that the caller's user account has permission to see.
//
// GET /user_attributes/{user_attribute_id}/group_values -> []UserAttributeGroupValue
func (l *LookerSDK) AllUserAttributeGroupValues(
	userAttributeId string,
	fields string,
	options *rtl.ApiSettings) ([]UserAttributeGroupValue, error) {
	userAttributeId = url.PathEscape(userAttributeId)
	var result []UserAttributeGroupValue
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/user_attributes/%v/group_values", userAttributeId), map[string]interface{}{"fields": fields}, nil, options)
	return result, err

}

// ### Define values for a user attribute across a set of groups, in priority order.
//
// This function defines all values for a user attribute defined by user groups. This is a global setting, potentially affecting
// all users in the system. This function replaces any existing group value definitions for the indicated user attribute.
//
// The value of a user attribute for a given user is determined by searching the following locations, in this order:
//
// 1. the user's account settings
// 2. the groups that the user is a member of
// 3. the default value of the user attribute, if any
//
// The user may be a member of multiple groups which define different values for that user attribute. The order of items in the group_values parameter
// determines which group takes priority for that user. Lowest array index wins.
//
// An alternate method to indicate the selection precedence of group-values is to assign numbers to the 'rank' property of each
// group-value object in the array. Lowest 'rank' value wins. If you use this technique, you must assign a
// rank value to every group-value object in the array.
//
//	To set a user attribute value for a single user, see [Set User Attribute User Value](#!/User/set_user_attribute_user_value).
//
// To set a user attribute value for all members of a group, see [Set User Attribute Group Value](#!/Group/update_user_attribute_group_value).
//
// POST /user_attributes/{user_attribute_id}/group_values -> []UserAttributeGroupValue
func (l *LookerSDK) SetUserAttributeGroupValues(
	userAttributeId string,
	body []UserAttributeGroupValue,
	options *rtl.ApiSettings) ([]UserAttributeGroupValue, error) {
	userAttributeId = url.PathEscape(userAttributeId)
	var result []UserAttributeGroupValue
	err := l.session.Do(&result, "POST", "/4.0", fmt.Sprintf("/user_attributes/%v/group_values", userAttributeId), nil, body, options)
	return result, err

}

// endregion UserAttribute: Manage User Attributes

// region Workspace: Manage Workspaces

// ### Get All Workspaces
//
// Returns all workspaces available to the calling user.
//
// GET /workspaces -> []Workspace
func (l *LookerSDK) AllWorkspaces(
	options *rtl.ApiSettings) ([]Workspace, error) {
	var result []Workspace
	err := l.session.Do(&result, "GET", "/4.0", "/workspaces", nil, nil, options)
	return result, err

}

// ### Get A Workspace
//
// Returns information about a workspace such as the git status and selected branches
// of all projects available to the caller's user account.
//
// A workspace defines which versions of project files will be used to evaluate expressions
// and operations that use model definitions - operations such as running queries or rendering dashboards.
// Each project has its own git repository, and each project in a workspace may be configured to reference
// particular branch or revision within their respective repositories.
//
// There are two predefined workspaces available: "production" and "dev".
//
// The production workspace is shared across all Looker users. Models in the production workspace are read-only.
// Changing files in production is accomplished by modifying files in a git branch and using Pull Requests
// to merge the changes from the dev branch into the production branch, and then telling
// Looker to sync with production.
//
// The dev workspace is local to each Looker user. Changes made to project/model files in the dev workspace only affect
// that user, and only when the dev workspace is selected as the active workspace for the API session.
// (See set_session_workspace()).
//
// The dev workspace is NOT unique to an API session. Two applications accessing the Looker API using
// the same user account will see the same files in the dev workspace. To avoid collisions between
// API clients it's best to have each client login with API credentials for a different user account.
//
// Changes made to files in a dev workspace are persistent across API sessions. It's a good
// idea to commit any changes you've made to the git repository, but not strictly required. Your modified files
// reside in a special user-specific directory on the Looker server and will still be there when you login in again
// later and use update_session(workspace_id: "dev") to select the dev workspace for the new API session.
//
// GET /workspaces/{workspace_id} -> Workspace
func (l *LookerSDK) Workspace(
	workspaceId string,
	options *rtl.ApiSettings) (Workspace, error) {
	workspaceId = url.PathEscape(workspaceId)
	var result Workspace
	err := l.session.Do(&result, "GET", "/4.0", fmt.Sprintf("/workspaces/%v", workspaceId), nil, nil, options)
	return result, err

}

// endregion Workspace: Manage Workspaces