/**

 MIT License

 Copyright (c) 2021 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.

 */

/**
 * 459 API methods
 */


// NOTE: Do not edit this file generated by Looker SDK Codegen for API 4.0
package com.looker.sdk

import com.looker.rtl.*
import java.util.*

class LookerSDKStream(authSession: AuthSession) : APIMethods(authSession) {


    //region Alert: Alert


    /**
     * Follow an alert.
     *
     * @param {String} alert_id ID of an alert
     *
     * POST /alerts/{alert_id}/follow -> ByteArray
     */
    fun follow_alert(
        alert_id: String
    ) : SDKResponse {
        val path_alert_id = encodeParam(alert_id)
            return this.post<ByteArray>("/alerts/${path_alert_id}/follow", mapOf())
    }


    /**
     * Unfollow an alert.
     *
     * @param {String} alert_id ID of an alert
     *
     * DELETE /alerts/{alert_id}/follow -> ByteArray
     */
    fun unfollow_alert(
        alert_id: String
    ) : SDKResponse {
        val path_alert_id = encodeParam(alert_id)
            return this.delete<ByteArray>("/alerts/${path_alert_id}/follow", mapOf())
    }


    /**
     * ### Search Alerts
     *
     * @param {Long} limit (Optional) Number of results to return (used with `offset`).
     * @param {Long} offset (Optional) Number of results to skip before returning any (used with `limit`).
     * @param {String} group_by (Optional) Dimension by which to order the results(`dashboard` | `owner`)
     * @param {String} fields (Optional) Requested fields.
     * @param {Boolean} disabled (Optional) Filter on returning only enabled or disabled alerts.
     * @param {String} frequency (Optional) Filter on alert frequency, such as: monthly, weekly, daily, hourly, minutes
     * @param {Boolean} condition_met (Optional) Filter on whether the alert has met its condition when it last executed
     * @param {String} last_run_start (Optional) Filter on the start range of the last time the alerts were run. Example: 2021-01-01T01:01:01-08:00.
     * @param {String} last_run_end (Optional) Filter on the start range of the last time the alerts were run. Example: 2021-01-01T01:01:01-08:00.
     * @param {Boolean} all_owners (Admin only) (Optional) Filter for all owners.
     *
     * GET /alerts/search -> ByteArray
     */
    @JvmOverloads fun search_alerts(
        limit: Long? = null,
        offset: Long? = null,
        group_by: String? = null,
        fields: String? = null,
        disabled: Boolean? = null,
        frequency: String? = null,
        condition_met: Boolean? = null,
        last_run_start: String? = null,
        last_run_end: String? = null,
        all_owners: Boolean? = null
    ) : SDKResponse {
            return this.get<ByteArray>("/alerts/search", 
                mapOf("limit" to limit,
                     "offset" to offset,
                     "group_by" to group_by,
                     "fields" to fields,
                     "disabled" to disabled,
                     "frequency" to frequency,
                     "condition_met" to condition_met,
                     "last_run_start" to last_run_start,
                     "last_run_end" to last_run_end,
                     "all_owners" to all_owners))
    }


    /**
     * ### Get an alert by a given alert ID
     *
     * @param {String} alert_id ID of an alert
     *
     * GET /alerts/{alert_id} -> ByteArray
     */
    fun get_alert(
        alert_id: String
    ) : SDKResponse {
        val path_alert_id = encodeParam(alert_id)
            return this.get<ByteArray>("/alerts/${path_alert_id}", mapOf())
    }


    /**
     * ### Update an alert
     * # Required fields: `owner_id`, `field`, `destinations`, `comparison_type`, `threshold`, `cron`
     * #
     *
     * @param {String} alert_id ID of an alert
     * @param {WriteAlert} body
     *
     * PUT /alerts/{alert_id} -> ByteArray
     */
    fun update_alert(
        alert_id: String,
        body: WriteAlert
    ) : SDKResponse {
        val path_alert_id = encodeParam(alert_id)
            return this.put<ByteArray>("/alerts/${path_alert_id}", mapOf(), body)
    }


    /**
     * ### Update select alert fields
     * # Available fields: `owner_id`, `is_disabled`, `disabled_reason`, `is_public`, `threshold`
     * #
     *
     * @param {String} alert_id ID of an alert
     * @param {AlertPatch} body
     *
     * PATCH /alerts/{alert_id} -> ByteArray
     */
    fun update_alert_field(
        alert_id: String,
        body: AlertPatch
    ) : SDKResponse {
        val path_alert_id = encodeParam(alert_id)
            return this.patch<ByteArray>("/alerts/${path_alert_id}", mapOf(), body)
    }


    /**
     * ### Delete an alert by a given alert ID
     *
     * @param {String} alert_id ID of an alert
     *
     * DELETE /alerts/{alert_id} -> ByteArray
     */
    fun delete_alert(
        alert_id: String
    ) : SDKResponse {
        val path_alert_id = encodeParam(alert_id)
            return this.delete<ByteArray>("/alerts/${path_alert_id}", mapOf())
    }


    /**
     * ### 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
     * }
     * ```
     *
     * @param {WriteAlert} body
     *
     * POST /alerts -> ByteArray
     */
    fun create_alert(
        body: WriteAlert
    ) : SDKResponse {
            return this.post<ByteArray>("/alerts", mapOf(), body)
    }


    /**
     * ### Enqueue an Alert by ID
     *
     * @param {String} alert_id ID of an alert
     * @param {Boolean} force Whether to enqueue an alert again if its already running.
     *
     * POST /alerts/{alert_id}/enqueue -> ByteArray
     */
    @JvmOverloads fun enqueue_alert(
        alert_id: String,
        force: Boolean? = null
    ) : SDKResponse {
        val path_alert_id = encodeParam(alert_id)
            return this.post<ByteArray>("/alerts/${path_alert_id}/enqueue", 
                mapOf("force" to force))
    }


    /**
     * # 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.
     *
     * @param {Long} limit (Optional) Number of results to return (used with `offset`).
     * @param {Long} offset (Optional) Number of results to skip before returning any (used with `limit`).
     *
     * GET /alert_notifications -> ByteArray
     */
    @JvmOverloads fun alert_notifications(
        limit: Long? = null,
        offset: Long? = null
    ) : SDKResponse {
            return this.get<ByteArray>("/alert_notifications", 
                mapOf("limit" to limit,
                     "offset" to offset))
    }


    /**
     * # 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.
     *
     * @param {String} alert_notification_id ID of a notification
     *
     * PATCH /alert_notifications/{alert_notification_id} -> ByteArray
     */
    fun read_alert_notification(
        alert_notification_id: String
    ) : SDKResponse {
        val path_alert_notification_id = encodeParam(alert_notification_id)
            return this.patch<ByteArray>("/alert_notifications/${path_alert_notification_id}", mapOf())
    }

    //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://docs.looker.com/r/api/outh2_resource_owner_pc) pattern.
     * The client credentials required for this login must be obtained by creating an API3 key on a user account
     * in the Looker Admin console. The API3 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 API3](https://github.com/looker/looker-sdk-ruby/blob/master/authentication.md).
     *
     * @param {String} client_id client_id part of API3 Key.
     * @param {String} client_secret client_secret part of API3 Key.
     *
     * POST /login -> ByteArray
     */
    @JvmOverloads fun login(
        client_id: String? = null,
        client_secret: String? = null
    ) : SDKResponse {
            return this.post<ByteArray>("/login", 
                mapOf("client_id" to client_id,
                     "client_secret" to client_secret))
    }


    /**
     * ### 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.
     *
     * @param {String} user_id Id of user.
     * @param {Boolean} associative When true (default), API calls using the returned access_token are attributed to the admin user who created the access_token. When false, API activity is attributed to the user the access_token runs as. False requires a looker license.
     *
     * POST /login/{user_id} -> ByteArray
     */
    @JvmOverloads fun login_user(
        user_id: String,
        associative: Boolean? = null
    ) : SDKResponse {
        val path_user_id = encodeParam(user_id)
            return this.post<ByteArray>("/login/${path_user_id}", 
                mapOf("associative" to associative))
    }


    /**
     * ### Logout of the API and invalidate the current access token.
     *
     * DELETE /logout -> ByteArray
     */
    fun logout(

    ) : SDKResponse {
            return this.delete<ByteArray>("/logout", mapOf())
    }

    //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.
     *
     * @param {String} fields Comma-delimited names of fields to return in responses. Omit for all fields
     *
     * GET /artifact/usage -> ByteArray
     */
    @JvmOverloads fun artifact_usage(
        fields: String? = null
    ) : SDKResponse {
            return this.get<ByteArray>("/artifact/usage", 
                mapOf("fields" to fields))
    }


    /**
     * 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.
     *
     * @param {String} fields Comma-delimited names of fields to return in responses. Omit for all fields
     * @param {Long} limit Number of results to return. (used with offset)
     * @param {Long} offset Number of results to skip before returning any. (used with limit)
     *
     * GET /artifact/namespaces -> ByteArray
     */
    @JvmOverloads fun artifact_namespaces(
        fields: String? = null,
        limit: Long? = null,
        offset: Long? = null
    ) : SDKResponse {
            return this.get<ByteArray>("/artifact/namespaces", 
                mapOf("fields" to fields,
                     "limit" to limit,
                     "offset" to offset))
    }


    /**
     * ### 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.
     *
     * @param {String} namespace Artifact storage namespace
     * @param {String} key Artifact storage key. Namespace + Key must be unique
     *
     * GET /artifact/{namespace}/value -> ByteArray
     */
    @JvmOverloads fun artifact_value(
        namespace: String,
        key: String? = null
    ) : SDKResponse {
        val path_namespace = encodeParam(namespace)
            return this.get<ByteArray>("/artifact/${path_namespace}/value", 
                mapOf("key" to key))
    }


    /**
     * Remove *all* artifacts from a namespace. Purged artifacts are permanently deleted
     *
     * **Note**: The artifact storage API can only be used by Looker-built extensions.
     *
     * @param {String} namespace Artifact storage namespace
     *
     * DELETE /artifact/{namespace}/purge -> ByteArray
     */
    fun purge_artifacts(
        namespace: String
    ) : SDKResponse {
        val path_namespace = encodeParam(namespace)
            return this.delete<ByteArray>("/artifact/${path_namespace}/purge", mapOf())
    }


    /**
     * ### 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.
     *
     * @param {String} namespace Artifact storage namespace
     * @param {String} fields Comma-delimited names of fields to return in responses. Omit for all fields
     * @param {String} key Key pattern to match
     * @param {String} user_ids Ids of users who created or updated the artifact (comma-delimited list)
     * @param {Long} min_size Minimum storage size of the artifact
     * @param {Long} max_size Maximum storage size of the artifact
     * @param {Long} limit Number of results to return. (used with offset)
     * @param {Long} offset Number of results to skip before returning any. (used with limit)
     *
     * GET /artifact/{namespace}/search -> ByteArray
     */
    @JvmOverloads fun search_artifacts(
        namespace: String,
        fields: String? = null,
        key: String? = null,
        user_ids: String? = null,
        min_size: Long? = null,
        max_size: Long? = null,
        limit: Long? = null,
        offset: Long? = null
    ) : SDKResponse {
        val path_namespace = encodeParam(namespace)
            return this.get<ByteArray>("/artifact/${path_namespace}/search", 
                mapOf("fields" to fields,
                     "key" to key,
                     "user_ids" to user_ids,
                     "min_size" to min_size,
                     "max_size" to max_size,
                     "limit" to limit,
                     "offset" to offset))
    }


    /**
     * ### 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.
     *
     * @param {String} namespace Artifact storage namespace
     * @param {String} key Comma-delimited list of keys. Wildcards not allowed.
     * @param {String} fields Comma-delimited names of fields to return in responses. Omit for all fields
     * @param {Long} limit Number of results to return. (used with offset)
     * @param {Long} offset Number of results to skip before returning any. (used with limit)
     *
     * GET /artifact/{namespace} -> ByteArray
     */
    @JvmOverloads fun artifact(
        namespace: String,
        key: String,
        fields: String? = null,
        limit: Long? = null,
        offset: Long? = null
    ) : SDKResponse {
        val path_namespace = encodeParam(namespace)
            return this.get<ByteArray>("/artifact/${path_namespace}", 
                mapOf("key" to key,
                     "fields" to fields,
                     "limit" to limit,
                     "offset" to offset))
    }


    /**
     * ### 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.
     *
     * @param {String} namespace Artifact storage namespace
     * @param {String} key Comma-delimited list of keys. Wildcards not allowed.
     *
     * DELETE /artifact/{namespace} -> ByteArray
     */
    fun delete_artifact(
        namespace: String,
        key: String
    ) : SDKResponse {
        val path_namespace = encodeParam(namespace)
            return this.delete<ByteArray>("/artifact/${path_namespace}", 
                mapOf("key" to key))
    }


    /**
     * ### 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.
     *
     * @param {String} namespace Artifact storage namespace
     * @param {Array<UpdateArtifact>} body
     * @param {String} fields Comma-delimited names of fields to return in responses. Omit for all fields
     *
     * PUT /artifacts/{namespace} -> ByteArray
     */
    @JvmOverloads fun update_artifacts(
        namespace: String,
        body: Array<UpdateArtifact>,
        fields: String? = null
    ) : SDKResponse {
        val path_namespace = encodeParam(namespace)
            return this.put<ByteArray>("/artifacts/${path_namespace}", 
                mapOf("fields" to fields), body)
    }

    //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.
     *
     * @param {WriteEmbedSecret} body
     *
     * POST /embed_config/secrets -> ByteArray
     */
    @JvmOverloads fun create_embed_secret(
        body: WriteEmbedSecret? = null
    ) : SDKResponse {
            return this.post<ByteArray>("/embed_config/secrets", mapOf(), body)
    }


    /**
     * ### Delete an embed secret.
     *
     * @param {String} embed_secret_id Id of Embed Secret
     *
     * DELETE /embed_config/secrets/{embed_secret_id} -> ByteArray
     */
    fun delete_embed_secret(
        embed_secret_id: String
    ) : SDKResponse {
        val path_embed_secret_id = encodeParam(embed_secret_id)
            return this.delete<ByteArray>("/embed_config/secrets/${path_embed_secret_id}", mapOf())
    }


    /**
     * ### Create SSO Embed URL
     *
     * Creates an SSO 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 this URL - any change may invalidate the signature and
     * cause the URL to fail to load a Looker embed session.
     *
     * A signed SSO embed URL can only be used once. 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 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,
     * copy the URL shown in the browser address bar 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
     * SSO 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 newest active secret defined in the Looker instance.
     *
     * #### 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.
     *
     * @param {EmbedSsoParams} body
     *
     * POST /embed/sso_url -> ByteArray
     */
    fun create_sso_embed_url(
        body: EmbedSsoParams
    ) : SDKResponse {
            return this.post<ByteArray>("/embed/sso_url", mapOf(), body)
    }


    /**
     * ### 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://docs.looker.com/r/admin/embed/private-embed). Instead of
     * 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 embed 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.
     *
     * @param {EmbedParams} body
     *
     * POST /embed/token_url/me -> ByteArray
     */
    fun create_embed_url_as_me(
        body: EmbedParams
    ) : SDKResponse {
            return this.post<ByteArray>("/embed/token_url/me", mapOf(), body)
    }


    /**
     * ### 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 it if it does not exist,
     * otherwise it reuses it. Note that this endpoint will not update the user, user attributes or group
     * attributes if the embed user already exists. This is the same behavior as the embed SSO login.
     *
     * 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 will NOT be extended in this scenario, in other words the session_length parameter is ignored.
     *
     * If the session_reference_token has expired, it will be ignored and a new embed session will be created.
     *
     * If the credentials do not match the credentials associated with an exisiting 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.
     *
     * @param {EmbedCookielessSessionAcquire} body
     *
     * POST /embed/cookieless_session/acquire -> ByteArray
     */
    fun acquire_embed_cookieless_session(
        body: EmbedCookielessSessionAcquire
    ) : SDKResponse {
            return this.post<ByteArray>("/embed/cookieless_session/acquire", mapOf(), body)
    }


    /**
     * ### 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.
     *
     * @param {String} session_reference_token Embed session reference token
     *
     * DELETE /embed/cookieless_session/{session_reference_token} -> ByteArray
     */
    fun delete_embed_cookieless_session(
        session_reference_token: String
    ) : SDKResponse {
        val path_session_reference_token = encodeParam(session_reference_token)
            return this.delete<ByteArray>("/embed/cookieless_session/${path_session_reference_token}", mapOf())
    }


    /**
     * ### 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).
     *
     * @param {EmbedCookielessSessionGenerateTokens} body
     *
     * PUT /embed/cookieless_session/generate_tokens -> ByteArray
     */
    fun generate_tokens_for_cookieless_session(
        body: EmbedCookielessSessionGenerateTokens
    ) : SDKResponse {
            return this.put<ByteArray>("/embed/cookieless_session/generate_tokens", mapOf(), body)
    }


    /**
     * ### 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://docs.looker.com/r/api/ldap_setup) for additional information.
     *
     * GET /ldap_config -> ByteArray
     */
    fun ldap_config(

    ) : SDKResponse {
            return this.get<ByteArray>("/ldap_config", mapOf())
    }


    /**
     * ### 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://docs.looker.com/r/api/ldap_setup) for additional information.
     *
     * @param {WriteLDAPConfig} body
     *
     * PATCH /ldap_config -> ByteArray
     */
    fun update_ldap_config(
        body: WriteLDAPConfig
    ) : SDKResponse {
            return this.patch<ByteArray>("/ldap_config", mapOf(), body)
    }


    /**
     * ### 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.
     *
     * @param {WriteLDAPConfig} body
     *
     * PUT /ldap_config/test_connection -> ByteArray
     */
    fun test_ldap_config_connection(
        body: WriteLDAPConfig
    ) : SDKResponse {
            return this.put<ByteArray>("/ldap_config/test_connection", mapOf(), body)
    }


    /**
     * ### 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.
     *
     * @param {WriteLDAPConfig} body
     *
     * PUT /ldap_config/test_auth -> ByteArray
     */
    fun test_ldap_config_auth(
        body: WriteLDAPConfig
    ) : SDKResponse {
            return this.put<ByteArray>("/ldap_config/test_auth", mapOf(), body)
    }


    /**
     * ### 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 without      needing to authenticate as that user.
     *
     * This test accepts a full LDAP configuration along with a username and attempts to find the full info      for the user from the LDAP server without actually authenticating the user. So, user password is not      required.The configuration is validated before attempting to contact the server.
     *
     * **test_ldap_user** is required.
     *
     * The active LDAP settings are not modified.
     *
     * @param {WriteLDAPConfig} body
     *
     * PUT /ldap_config/test_user_info -> ByteArray
     */
    fun test_ldap_config_user_info(
        body: WriteLDAPConfig
    ) : SDKResponse {
            return this.put<ByteArray>("/ldap_config/test_user_info", mapOf(), body)
    }


    /**
     * ### 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.
     *
     * @param {WriteLDAPConfig} body
     *
     * PUT /ldap_config/test_user_auth -> ByteArray
     */
    fun test_ldap_config_user_auth(
        body: WriteLDAPConfig
    ) : SDKResponse {
            return this.put<ByteArray>("/ldap_config/test_user_auth", mapOf(), body)
    }


    /**
     * ### Registers a mobile device.
     * # Required fields: [:device_token, :device_type]
     *
     * @param {WriteMobileToken} body
     *
     * POST /mobile/device -> ByteArray
     */
    fun register_mobile_device(
        body: WriteMobileToken
    ) : SDKResponse {
            return this.post<ByteArray>("/mobile/device", mapOf(), body)
    }


    /**
     * ### Updates the mobile device registration
     *
     * @param {String} device_id Unique id of the device.
     *
     * PATCH /mobile/device/{device_id} -> ByteArray
     */
    fun update_mobile_device_registration(
        device_id: String
    ) : SDKResponse {
        val path_device_id = encodeParam(device_id)
            return this.patch<ByteArray>("/mobile/device/${path_device_id}", mapOf())
    }


    /**
     * ### Deregister a mobile device.
     *
     * @param {String} device_id Unique id of the device.
     *
     * DELETE /mobile/device/{device_id} -> ByteArray
     */
    fun deregister_mobile_device(
        device_id: String
    ) : SDKResponse {
        val path_device_id = encodeParam(device_id)
            return this.delete<ByteArray>("/mobile/device/${path_device_id}", mapOf())
    }


    /**
     * ### 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.
     *
     * @param {String} fields Requested fields.
     *
     * GET /oauth_client_apps -> ByteArray
     */
    @JvmOverloads fun all_oauth_client_apps(
        fields: String? = null
    ) : SDKResponse {
            return this.get<ByteArray>("/oauth_client_apps", 
                mapOf("fields" to fields))
    }


    /**
     * ### Get Oauth Client App
     *
     * Returns the registered app client with matching client_guid.
     *
     * @param {String} client_guid The unique id of this application
     * @param {String} fields Requested fields.
     *
     * GET /oauth_client_apps/{client_guid} -> ByteArray
     */
    @JvmOverloads fun oauth_client_app(
        client_guid: String,
        fields: String? = null
    ) : SDKResponse {
        val path_client_guid = encodeParam(client_guid)
            return this.get<ByteArray>("/oauth_client_apps/${path_client_guid}", 
                mapOf("fields" to fields))
    }


    /**
     * ### 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.
     *
     * @param {String} client_guid The unique id of this application
     * @param {WriteOauthClientApp} body
     * @param {String} fields Requested fields.
     *
     * POST /oauth_client_apps/{client_guid} -> ByteArray
     */
    @JvmOverloads fun register_oauth_client_app(
        client_guid: String,
        body: WriteOauthClientApp,
        fields: String? = null
    ) : SDKResponse {
        val path_client_guid = encodeParam(client_guid)
            return this.post<ByteArray>("/oauth_client_apps/${path_client_guid}", 
                mapOf("fields" to fields), body)
    }


    /**
     * ### Update OAuth2 Client App Details
     *
     * Modifies the details a previously registered OAuth2 login client app.
     *
     * @param {String} client_guid The unique id of this application
     * @param {WriteOauthClientApp} body
     * @param {String} fields Requested fields.
     *
     * PATCH /oauth_client_apps/{client_guid} -> ByteArray
     */
    @JvmOverloads fun update_oauth_client_app(
        client_guid: String,
        body: WriteOauthClientApp,
        fields: String? = null
    ) : SDKResponse {
        val path_client_guid = encodeParam(client_guid)
            return this.patch<ByteArray>("/oauth_client_apps/${path_client_guid}", 
                mapOf("fields" to fields), body)
    }


    /**
     * ### 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.
     *
     * @param {String} client_guid The unique id of this application
     *
     * DELETE /oauth_client_apps/{client_guid} -> ByteArray
     */
    fun delete_oauth_client_app(
        client_guid: String
    ) : SDKResponse {
        val path_client_guid = encodeParam(client_guid)
            return this.delete<ByteArray>("/oauth_client_apps/${path_client_guid}", mapOf())
    }


    /**
     * ### 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.
     *
     * @param {String} client_guid The unique id of the application
     *
     * DELETE /oauth_client_apps/{client_guid}/tokens -> ByteArray
     */
    fun invalidate_tokens(
        client_guid: String
    ) : SDKResponse {
        val path_client_guid = encodeParam(client_guid)
            return this.delete<ByteArray>("/oauth_client_apps/${path_client_guid}/tokens", mapOf())
    }


    /**
     * ### 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.
     *
     * @param {String} client_guid The unique id of this application
     * @param {String} user_id The id of the user to enable use of this app
     * @param {String} fields Requested fields.
     *
     * POST /oauth_client_apps/{client_guid}/users/{user_id} -> ByteArray
     */
    @JvmOverloads fun activate_app_user(
        client_guid: String,
        user_id: String,
        fields: String? = null
    ) : SDKResponse {
        val path_client_guid = encodeParam(client_guid)
        val path_user_id = encodeParam(user_id)
            return this.post<ByteArray>("/oauth_client_apps/${path_client_guid}/users/${path_user_id}", 
                mapOf("fields" to fields))
    }


    /**
     * ### 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.
     *
     * @param {String} client_guid The unique id of this application
     * @param {String} user_id The id of the user to enable use of this app
     * @param {String} fields Requested fields.
     *
     * DELETE /oauth_client_apps/{client_guid}/users/{user_id} -> ByteArray
     */
    @JvmOverloads fun deactivate_app_user(
        client_guid: String,
        user_id: String,
        fields: String? = null
    ) : SDKResponse {
        val path_client_guid = encodeParam(client_guid)
        val path_user_id = encodeParam(user_id)
            return this.delete<ByteArray>("/oauth_client_apps/${path_client_guid}/users/${path_user_id}", 
                mapOf("fields" to fields))
    }


    /**
     * ### 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 configuation. 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.
     *
     * GET /oidc_config -> ByteArray
     */
    fun oidc_config(

    ) : SDKResponse {
            return this.get<ByteArray>("/oidc_config", mapOf())
    }


    /**
     * ### 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.
     *
     * @param {WriteOIDCConfig} body
     *
     * PATCH /oidc_config -> ByteArray
     */
    fun update_oidc_config(
        body: WriteOIDCConfig
    ) : SDKResponse {
            return this.patch<ByteArray>("/oidc_config", mapOf(), body)
    }


    /**
     * ### Get a OIDC test configuration by test_slug.
     *
     * @param {String} test_slug Slug of test config
     *
     * GET /oidc_test_configs/{test_slug} -> ByteArray
     */
    fun oidc_test_config(
        test_slug: String
    ) : SDKResponse {
        val path_test_slug = encodeParam(test_slug)
            return this.get<ByteArray>("/oidc_test_configs/${path_test_slug}", mapOf())
    }


    /**
     * ### Delete a OIDC test configuration.
     *
     * @param {String} test_slug Slug of test config
     *
     * DELETE /oidc_test_configs/{test_slug} -> ByteArray
     */
    fun delete_oidc_test_config(
        test_slug: String
    ) : SDKResponse {
        val path_test_slug = encodeParam(test_slug)
            return this.delete<ByteArray>("/oidc_test_configs/${path_test_slug}", mapOf())
    }


    /**
     * ### Create a OIDC test configuration.
     *
     * @param {WriteOIDCConfig} body
     *
     * POST /oidc_test_configs -> ByteArray
     */
    fun create_oidc_test_config(
        body: WriteOIDCConfig
    ) : SDKResponse {
            return this.post<ByteArray>("/oidc_test_configs", mapOf(), body)
    }


    /**
     * ### Get password config.
     *
     * GET /password_config -> ByteArray
     */
    fun password_config(

    ) : SDKResponse {
            return this.get<ByteArray>("/password_config", mapOf())
    }


    /**
     * ### Update password config.
     *
     * @param {WritePasswordConfig} body
     *
     * PATCH /password_config -> ByteArray
     */
    fun update_password_config(
        body: WritePasswordConfig
    ) : SDKResponse {
            return this.patch<ByteArray>("/password_config", mapOf(), body)
    }


    /**
     * ### Force all credentials_email users to reset their login passwords upon their next login.
     *
     * PUT /password_config/force_password_reset_at_next_login_for_all_users -> ByteArray
     */
    fun force_password_reset_at_next_login_for_all_users(

    ) : SDKResponse {
            return this.put<ByteArray>("/password_config/force_password_reset_at_next_login_for_all_users", mapOf())
    }


    /**
     * ### 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 configuation. 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.
     *
     * GET /saml_config -> ByteArray
     */
    fun saml_config(

    ) : SDKResponse {
            return this.get<ByteArray>("/saml_config", mapOf())
    }


    /**
     * ### 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.
     *
     * @param {WriteSamlConfig} body
     *
     * PATCH /saml_config -> ByteArray
     */
    fun update_saml_config(
        body: WriteSamlConfig
    ) : SDKResponse {
            return this.patch<ByteArray>("/saml_config", mapOf(), body)
    }


    /**
     * ### Get a SAML test configuration by test_slug.
     *
     * @param {String} test_slug Slug of test config
     *
     * GET /saml_test_configs/{test_slug} -> ByteArray
     */
    fun saml_test_config(
        test_slug: String
    ) : SDKResponse {
        val path_test_slug = encodeParam(test_slug)
            return this.get<ByteArray>("/saml_test_configs/${path_test_slug}", mapOf())
    }


    /**
     * ### Delete a SAML test configuration.
     *
     * @param {String} test_slug Slug of test config
     *
     * DELETE /saml_test_configs/{test_slug} -> ByteArray
     */
    fun delete_saml_test_config(
        test_slug: String
    ) : SDKResponse {
        val path_test_slug = encodeParam(test_slug)
            return this.delete<ByteArray>("/saml_test_configs/${path_test_slug}", mapOf())
    }


    /**
     * ### Create a SAML test configuration.
     *
     * @param {WriteSamlConfig} body
     *
     * POST /saml_test_configs -> ByteArray
     */
    fun create_saml_test_config(
        body: WriteSamlConfig
    ) : SDKResponse {
            return this.post<ByteArray>("/saml_test_configs", mapOf(), body)
    }


    /**
     * ### Parse the given xml as a SAML IdP metadata document and return the result.
     *
     * @param {String} body
     *
     * POST /parse_saml_idp_metadata -> ByteArray
     */
    fun parse_saml_idp_metadata(
        body: String
    ) : SDKResponse {
            return this.post<ByteArray>("/parse_saml_idp_metadata", mapOf(), body)
    }


    /**
     * ### 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.
     *
     * @param {String} body
     *
     * POST /fetch_and_parse_saml_idp_metadata -> ByteArray
     */
    fun fetch_and_parse_saml_idp_metadata(
        body: String
    ) : SDKResponse {
            return this.post<ByteArray>("/fetch_and_parse_saml_idp_metadata", mapOf(), body)
    }


    /**
     * ### Get session config.
     *
     * GET /session_config -> ByteArray
     */
    fun session_config(

    ) : SDKResponse {
            return this.get<ByteArray>("/session_config", mapOf())
    }


    /**
     * ### Update session config.
     *
     * @param {WriteSessionConfig} body
     *
     * PATCH /session_config -> ByteArray
     */
    fun update_session_config(
        body: WriteSessionConfig
    ) : SDKResponse {
            return this.patch<ByteArray>("/session_config", mapOf(), body)
    }


    /**
     * ### Get Support Access Allowlist Users
     *
     * Returns the users that have been added to the Support Access Allowlist
     *
     * @param {String} fields Requested fields.
     *
     * GET /support_access/allowlist -> ByteArray
     */
    @JvmOverloads fun get_support_access_allowlist_entries(
        fields: String? = null
    ) : SDKResponse {
            return this.get<ByteArray>("/support_access/allowlist", 
                mapOf("fields" to fields))
    }


    /**
     * ### Add Support Access Allowlist Users
     *
     * Adds a list of emails to the Allowlist, using the provided reason
     *
     * @param {SupportAccessAddEntries} body
     *
     * POST /support_access/allowlist -> ByteArray
     */
    fun add_support_access_allowlist_entries(
        body: SupportAccessAddEntries
    ) : SDKResponse {
            return this.post<ByteArray>("/support_access/allowlist", mapOf(), body)
    }


    /**
     * ### Delete Support Access Allowlist User
     *
     * Deletes the specified Allowlist Entry Id
     *
     * @param {String} entry_id Id of Allowlist Entry
     *
     * DELETE /support_access/allowlist/{entry_id} -> ByteArray
     */
    fun delete_support_access_allowlist_entry(
        entry_id: String
    ) : SDKResponse {
        val path_entry_id = encodeParam(entry_id)
            return this.delete<ByteArray>("/support_access/allowlist/${path_entry_id}", mapOf())
    }


    /**
     * ### Enable Support Access
     *
     * Enables Support Access for the provided duration
     *
     * @param {SupportAccessEnable} body
     *
     * PUT /support_access/enable -> ByteArray
     */
    fun enable_support_access(
        body: SupportAccessEnable
    ) : SDKResponse {
            return this.put<ByteArray>("/support_access/enable", mapOf(), body)
    }


    /**
     * ### Disable Support Access
     *
     * Disables Support Access immediately
     *
     * PUT /support_access/disable -> ByteArray
     */
    fun disable_support_access(

    ) : SDKResponse {
            return this.put<ByteArray>("/support_access/disable", mapOf())
    }


    /**
     * ### Support Access Status
     *
     * Returns the current Support Access Status
     *
     * GET /support_access/status -> ByteArray
     */
    fun support_access_status(

    ) : SDKResponse {
            return this.get<ByteArray>("/support_access/status", mapOf())
    }


    /**
     * ### Get currently locked-out users.
     *
     * @param {String} fields Include only these fields in the response
     *
     * GET /user_login_lockouts -> ByteArray
     */
    @JvmOverloads fun all_user_login_lockouts(
        fields: String? = null
    ) : SDKResponse {
            return this.get<ByteArray>("/user_login_lockouts", 
                mapOf("fields" to fields))
    }


    /**
     * ### Search currently locked-out users.
     *
     * @param {String} fields Include only these fields in the response
     * @param {Long} page DEPRECATED. Use limit and offset instead. Return only page N of paginated results
     * @param {Long} per_page DEPRECATED. Use limit and offset instead. Return N rows of data per page
     * @param {Long} limit Number of results to return. (used with offset and takes priority over page and per_page)
     * @param {Long} offset Number of results to skip before returning any. (used with limit and takes priority over page and per_page)
     * @param {String} sorts Fields to sort by.
     * @param {String} auth_type Auth type user is locked out for (email, ldap, totp, api)
     * @param {String} full_name Match name
     * @param {String} email Match email
     * @param {String} remote_id Match remote LDAP ID
     * @param {Boolean} filter_or Combine given search criteria in a boolean OR expression
     *
     * GET /user_login_lockouts/search -> ByteArray
     */
    @JvmOverloads fun search_user_login_lockouts(
        fields: String? = null,
        page: Long? = null,
        per_page: Long? = null,
        limit: Long? = null,
        offset: Long? = null,
        sorts: String? = null,
        auth_type: String? = null,
        full_name: String? = null,
        email: String? = null,
        remote_id: String? = null,
        filter_or: Boolean? = null
    ) : SDKResponse {
            return this.get<ByteArray>("/user_login_lockouts/search", 
                mapOf("fields" to fields,
                     "page" to page,
                     "per_page" to per_page,
                     "limit" to limit,
                     "offset" to offset,
                     "sorts" to sorts,
                     "auth_type" to auth_type,
                     "full_name" to full_name,
                     "email" to email,
                     "remote_id" to remote_id,
                     "filter_or" to filter_or))
    }


    /**
     * ### Removes login lockout for the associated user.
     *
     * @param {String} key The key associated with the locked user
     *
     * DELETE /user_login_lockout/{key} -> ByteArray
     */
    fun delete_user_login_lockout(
        key: String
    ) : SDKResponse {
        val path_key = encodeParam(key)
            return this.delete<ByteArray>("/user_login_lockout/${path_key}", mapOf())
    }

    //endregion Auth: Manage User Authentication Configuration

    //region Board: Manage Boards


    /**
     * ### Get information about all boards.
     *
     * @param {String} fields Requested fields.
     *
     * GET /boards -> ByteArray
     */
    @JvmOverloads fun all_boards(
        fields: String? = null
    ) : SDKResponse {
            return this.get<ByteArray>("/boards", 
                mapOf("fields" to fields))
    }


    /**
     * ### Create a new board.
     *
     * @param {WriteBoard} body
     * @param {String} fields Requested fields.
     *
     * POST /boards -> ByteArray
     */
    @JvmOverloads fun create_board(
        body: WriteBoard,
        fields: String? = null
    ) : SDKResponse {
            return this.post<ByteArray>("/boards", 
                mapOf("fields" to fields), body)
    }


    /**
     * ### 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.
     *
     * @param {String} title Matches board title.
     * @param {String} created_at Matches the timestamp for when the board was created.
     * @param {String} first_name The first name of the user who created this board.
     * @param {String} last_name The last name of the user who created this board.
     * @param {String} fields Requested fields.
     * @param {Boolean} favorited Return favorited boards when true.
     * @param {String} creator_id Filter on boards created by a particular user.
     * @param {String} sorts The fields to sort the results by
     * @param {Long} page The page to return. DEPRECATED. Use offset instead.
     * @param {Long} per_page The number of items in the returned page. DEPRECATED. Use limit instead.
     * @param {Long} offset The number of items to skip before returning any. (used with limit and takes priority over page and per_page)
     * @param {Long} limit The maximum number of items to return. (used with offset and takes priority over page and per_page)
     * @param {Boolean} filter_or Combine given search criteria in a boolean OR expression
     * @param {String} permission Filter results based on permission, either show (default) or update
     *
     * GET /boards/search -> ByteArray
     */
    @JvmOverloads fun search_boards(
        title: String? = null,
        created_at: String? = null,
        first_name: String? = null,
        last_name: String? = null,
        fields: String? = null,
        favorited: Boolean? = null,
        creator_id: String? = null,
        sorts: String? = null,
        page: Long? = null,
        per_page: Long? = null,
        offset: Long? = null,
        limit: Long? = null,
        filter_or: Boolean? = null,
        permission: String? = null
    ) : SDKResponse {
            return this.get<ByteArray>("/boards/search", 
                mapOf("title" to title,
                     "created_at" to created_at,
                     "first_name" to first_name,
                     "last_name" to last_name,
                     "fields" to fields,
                     "favorited" to favorited,
                     "creator_id" to creator_id,
                     "sorts" to sorts,
                     "page" to page,
                     "per_page" to per_page,
                     "offset" to offset,
                     "limit" to limit,
                     "filter_or" to filter_or,
                     "permission" to permission))
    }


    /**
     * ### Get information about a board.
     *
     * @param {String} board_id Id of board
     * @param {String} fields Requested fields.
     *
     * GET /boards/{board_id} -> ByteArray
     */
    @JvmOverloads fun board(
        board_id: String,
        fields: String? = null
    ) : SDKResponse {
        val path_board_id = encodeParam(board_id)
            return this.get<ByteArray>("/boards/${path_board_id}", 
                mapOf("fields" to fields))
    }


    /**
     * ### Update a board definition.
     *
     * @param {String} board_id Id of board
     * @param {WriteBoard} body
     * @param {String} fields Requested fields.
     *
     * PATCH /boards/{board_id} -> ByteArray
     */
    @JvmOverloads fun update_board(
        board_id: String,
        body: WriteBoard,
        fields: String? = null
    ) : SDKResponse {
        val path_board_id = encodeParam(board_id)
            return this.patch<ByteArray>("/boards/${path_board_id}", 
                mapOf("fields" to fields), body)
    }


    /**
     * ### Delete a board.
     *
     * @param {String} board_id Id of board
     *
     * DELETE /boards/{board_id} -> ByteArray
     */
    fun delete_board(
        board_id: String
    ) : SDKResponse {
        val path_board_id = encodeParam(board_id)
            return this.delete<ByteArray>("/boards/${path_board_id}", mapOf())
    }


    /**
     * ### Get information about all board items.
     *
     * @param {String} fields Requested fields.
     * @param {String} sorts Fields to sort by.
     * @param {String} board_section_id Filter to a specific board section
     *
     * GET /board_items -> ByteArray
     */
    @JvmOverloads fun all_board_items(
        fields: String? = null,
        sorts: String? = null,
        board_section_id: String? = null
    ) : SDKResponse {
            return this.get<ByteArray>("/board_items", 
                mapOf("fields" to fields,
                     "sorts" to sorts,
                     "board_section_id" to board_section_id))
    }


    /**
     * ### Create a new board item.
     *
     * @param {WriteBoardItem} body
     * @param {String} fields Requested fields.
     *
     * POST /board_items -> ByteArray
     */
    @JvmOverloads fun create_board_item(
        body: WriteBoardItem,
        fields: String? = null
    ) : SDKResponse {
            return this.post<ByteArray>("/board_items", 
                mapOf("fields" to fields), body)
    }


    /**
     * ### Get information about a board item.
     *
     * @param {String} board_item_id Id of board item
     * @param {String} fields Requested fields.
     *
     * GET /board_items/{board_item_id} -> ByteArray
     */
    @JvmOverloads fun board_item(
        board_item_id: String,
        fields: String? = null
    ) : SDKResponse {
        val path_board_item_id = encodeParam(board_item_id)
            return this.get<ByteArray>("/board_items/${path_board_item_id}", 
                mapOf("fields" to fields))
    }


    /**
     * ### Update a board item definition.
     *
     * @param {String} board_item_id Id of board item
     * @param {WriteBoardItem} body
     * @param {String} fields Requested fields.
     *
     * PATCH /board_items/{board_item_id} -> ByteArray
     */
    @JvmOverloads fun update_board_item(
        board_item_id: String,
        body: WriteBoardItem,
        fields: String? = null
    ) : SDKResponse {
        val path_board_item_id = encodeParam(board_item_id)
            return this.patch<ByteArray>("/board_items/${path_board_item_id}", 
                mapOf("fields" to fields), body)
    }


    /**
     * ### Delete a board item.
     *
     * @param {String} board_item_id Id of board item
     *
     * DELETE /board_items/{board_item_id} -> ByteArray
     */
    fun delete_board_item(
        board_item_id: String
    ) : SDKResponse {
        val path_board_item_id = encodeParam(board_item_id)
            return this.delete<ByteArray>("/board_items/${path_board_item_id}", mapOf())
    }


    /**
     * ### Get information about all board sections.
     *
     * @param {String} fields Requested fields.
     * @param {String} sorts Fields to sort by.
     *
     * GET /board_sections -> ByteArray
     */
    @JvmOverloads fun all_board_sections(
        fields: String? = null,
        sorts: String? = null
    ) : SDKResponse {
            return this.get<ByteArray>("/board_sections", 
                mapOf("fields" to fields,
                     "sorts" to sorts))
    }


    /**
     * ### Create a new board section.
     *
     * @param {WriteBoardSection} body
     * @param {String} fields Requested fields.
     *
     * POST /board_sections -> ByteArray
     */
    @JvmOverloads fun create_board_section(
        body: WriteBoardSection,
        fields: String? = null
    ) : SDKResponse {
            return this.post<ByteArray>("/board_sections", 
                mapOf("fields" to fields), body)
    }


    /**
     * ### Get information about a board section.
     *
     * @param {String} board_section_id Id of board section
     * @param {String} fields Requested fields.
     *
     * GET /board_sections/{board_section_id} -> ByteArray
     */
    @JvmOverloads fun board_section(
        board_section_id: String,
        fields: String? = null
    ) : SDKResponse {
        val path_board_section_id = encodeParam(board_section_id)
            return this.get<ByteArray>("/board_sections/${path_board_section_id}", 
                mapOf("fields" to fields))
    }


    /**
     * ### Update a board section definition.
     *
     * @param {String} board_section_id Id of board section
     * @param {WriteBoardSection} body
     * @param {String} fields Requested fields.
     *
     * PATCH /board_sections/{board_section_id} -> ByteArray
     */
    @JvmOverloads fun update_board_section(
        board_section_id: String,
        body: WriteBoardSection,
        fields: String? = null
    ) : SDKResponse {
        val path_board_section_id = encodeParam(board_section_id)
            return this.patch<ByteArray>("/board_sections/${path_board_section_id}", 
                mapOf("fields" to fields), body)
    }


    /**
     * ### Delete a board section.
     *
     * @param {String} board_section_id Id of board section
     *
     * DELETE /board_sections/{board_section_id} -> ByteArray
     */
    fun delete_board_section(
        board_section_id: String
    ) : SDKResponse {
        val path_board_section_id = encodeParam(board_section_id)
            return this.delete<ByteArray>("/board_sections/${path_board_section_id}", mapOf())
    }

    //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.
     *
     * @param {String} fields Requested fields.
     *
     * GET /color_collections -> ByteArray
     */
    @JvmOverloads fun all_color_collections(
        fields: String? = null
    ) : SDKResponse {
            return this.get<ByteArray>("/color_collections", 
                mapOf("fields" to fields))
    }


    /**
     * ### 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.
     *
     * @param {WriteColorCollection} body
     *
     * POST /color_collections -> ByteArray
     */
    fun create_color_collection(
        body: WriteColorCollection
    ) : SDKResponse {
            return this.post<ByteArray>("/color_collections", mapOf(), body)
    }


    /**
     * ### 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.
     *
     * @param {String} fields Requested fields.
     *
     * GET /color_collections/custom -> ByteArray
     */
    @JvmOverloads fun color_collections_custom(
        fields: String? = null
    ) : SDKResponse {
            return this.get<ByteArray>("/color_collections/custom", 
                mapOf("fields" to fields))
    }


    /**
     * ### 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.
     *
     * @param {String} fields Requested fields.
     *
     * GET /color_collections/standard -> ByteArray
     */
    @JvmOverloads fun color_collections_standard(
        fields: String? = null
    ) : SDKResponse {
            return this.get<ByteArray>("/color_collections/standard", 
                mapOf("fields" to fields))
    }


    /**
     * ### 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 -> ByteArray
     */
    fun default_color_collection(

    ) : SDKResponse {
            return this.get<ByteArray>("/color_collections/default", mapOf())
    }


    /**
     * ### 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.
     *
     * @param {String} collection_id ID of color collection to set as default
     *
     * PUT /color_collections/default -> ByteArray
     */
    fun set_default_color_collection(
        collection_id: String
    ) : SDKResponse {
            return this.put<ByteArray>("/color_collections/default", 
                mapOf("collection_id" to collection_id))
    }


    /**
     * ### 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.
     *
     * @param {String} collection_id Id of Color Collection
     * @param {String} fields Requested fields.
     *
     * GET /color_collections/{collection_id} -> ByteArray
     */
    @JvmOverloads fun color_collection(
        collection_id: String,
        fields: String? = null
    ) : SDKResponse {
        val path_collection_id = encodeParam(collection_id)
            return this.get<ByteArray>("/color_collections/${path_collection_id}", 
                mapOf("fields" to fields))
    }


    /**
     * ### 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.
     *
     * @param {String} collection_id Id of Custom Color Collection
     * @param {WriteColorCollection} body
     *
     * PATCH /color_collections/{collection_id} -> ByteArray
     */
    fun update_color_collection(
        collection_id: String,
        body: WriteColorCollection
    ) : SDKResponse {
        val path_collection_id = encodeParam(collection_id)
            return this.patch<ByteArray>("/color_collections/${path_collection_id}", mapOf(), body)
    }


    /**
     * ### 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.
     *
     * @param {String} collection_id Id of Color Collection
     *
     * DELETE /color_collections/{collection_id} -> ByteArray
     */
    fun delete_color_collection(
        collection_id: String
    ) : SDKResponse {
        val path_collection_id = encodeParam(collection_id)
            return this.delete<ByteArray>("/color_collections/${path_collection_id}", mapOf())
    }

    //endregion ColorCollection: Manage Color Collections

    //region Config: Manage General Configuration


    /**
     * Get the current Cloud Storage Configuration.
     *
     * GET /cloud_storage -> ByteArray
     */
    fun cloud_storage_configuration(

    ) : SDKResponse {
            return this.get<ByteArray>("/cloud_storage", mapOf())
    }


    /**
     * Update the current Cloud Storage Configuration.
     *
     * @param {WriteBackupConfiguration} body
     *
     * PATCH /cloud_storage -> ByteArray
     */
    fun update_cloud_storage_configuration(
        body: WriteBackupConfiguration
    ) : SDKResponse {
            return this.patch<ByteArray>("/cloud_storage", mapOf(), body)
    }


    /**
     * ### Looker Configuration Refresh
     *
     * This is an endpoint for manually calling refresh on Configuration manager.
     *
     * PUT /configuration_force_refresh -> ByteArray
     */
    fun configuration_force_refresh(

    ) : SDKResponse {
            return this.put<ByteArray>("/configuration_force_refresh", mapOf())
    }


    /**
     * ### Get the current status and content of custom welcome emails
     *
     * GET /custom_welcome_email -> ByteArray
     */
    @Deprecated(message = "Deprecated method")
    fun custom_welcome_email(

    ) : SDKResponse {
            return this.get<ByteArray>("/custom_welcome_email", mapOf())
    }


    /**
     * Update custom welcome email setting and values. Optionally send a test email with the new content to the currently logged in user.
     *
     * @param {CustomWelcomeEmail} body
     * @param {Boolean} send_test_welcome_email If true a test email with the content from the request will be sent to the current user after saving
     *
     * PATCH /custom_welcome_email -> ByteArray
     */
    @Deprecated(message = "Deprecated method")
    @JvmOverloads fun update_custom_welcome_email(
        body: CustomWelcomeEmail,
        send_test_welcome_email: Boolean? = null
    ) : SDKResponse {
            return this.patch<ByteArray>("/custom_welcome_email", 
                mapOf("send_test_welcome_email" to send_test_welcome_email), body)
    }


    /**
     * Requests to this endpoint will send a welcome email with the custom content provided in the body to the currently logged in user.
     *
     * @param {WelcomeEmailTest} body
     *
     * PUT /custom_welcome_email_test -> ByteArray
     */
    fun update_custom_welcome_email_test(
        body: WelcomeEmailTest
    ) : SDKResponse {
            return this.put<ByteArray>("/custom_welcome_email_test", mapOf(), body)
    }


    /**
     * ### Retrieve the value for whether or not digest emails is enabled
     *
     * GET /digest_emails_enabled -> ByteArray
     */
    fun digest_emails_enabled(

    ) : SDKResponse {
            return this.get<ByteArray>("/digest_emails_enabled", mapOf())
    }


    /**
     * ### Update the setting for enabling/disabling digest emails
     *
     * @param {DigestEmails} body
     *
     * PATCH /digest_emails_enabled -> ByteArray
     */
    fun update_digest_emails_enabled(
        body: DigestEmails
    ) : SDKResponse {
            return this.patch<ByteArray>("/digest_emails_enabled", mapOf(), body)
    }


    /**
     * ### 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 -> ByteArray
     */
    fun create_digest_email_send(

    ) : SDKResponse {
            return this.post<ByteArray>("/digest_email_send", mapOf())
    }


    /**
     * ### Get Egress IP Addresses
     *
     * Returns the list of public egress IP Addresses for a hosted customer's instance
     *
     * GET /public_egress_ip_addresses -> ByteArray
     */
    fun public_egress_ip_addresses(

    ) : SDKResponse {
            return this.get<ByteArray>("/public_egress_ip_addresses", mapOf())
    }


    /**
     * ### Set the menu item name and content for internal help resources
     *
     * GET /internal_help_resources_content -> ByteArray
     */
    fun internal_help_resources_content(

    ) : SDKResponse {
            return this.get<ByteArray>("/internal_help_resources_content", mapOf())
    }


    /**
     * Update internal help resources content
     *
     * @param {WriteInternalHelpResourcesContent} body
     *
     * PATCH /internal_help_resources_content -> ByteArray
     */
    fun update_internal_help_resources_content(
        body: WriteInternalHelpResourcesContent
    ) : SDKResponse {
            return this.patch<ByteArray>("/internal_help_resources_content", mapOf(), body)
    }


    /**
     * ### Get and set the options for internal help resources
     *
     * GET /internal_help_resources_enabled -> ByteArray
     */
    fun internal_help_resources(

    ) : SDKResponse {
            return this.get<ByteArray>("/internal_help_resources_enabled", mapOf())
    }


    /**
     * Update internal help resources settings
     *
     * @param {WriteInternalHelpResources} body
     *
     * PATCH /internal_help_resources -> ByteArray
     */
    fun update_internal_help_resources(
        body: WriteInternalHelpResources
    ) : SDKResponse {
            return this.patch<ByteArray>("/internal_help_resources", mapOf(), body)
    }


    /**
     * ### Get all legacy features.
     *
     * GET /legacy_features -> ByteArray
     */
    fun all_legacy_features(

    ) : SDKResponse {
            return this.get<ByteArray>("/legacy_features", mapOf())
    }


    /**
     * ### Get information about the legacy feature with a specific id.
     *
     * @param {String} legacy_feature_id id of legacy feature
     *
     * GET /legacy_features/{legacy_feature_id} -> ByteArray
     */
    fun legacy_feature(
        legacy_feature_id: String
    ) : SDKResponse {
        val path_legacy_feature_id = encodeParam(legacy_feature_id)
            return this.get<ByteArray>("/legacy_features/${path_legacy_feature_id}", mapOf())
    }


    /**
     * ### Update information about the legacy feature with a specific id.
     *
     * @param {String} legacy_feature_id id of legacy feature
     * @param {WriteLegacyFeature} body
     *
     * PATCH /legacy_features/{legacy_feature_id} -> ByteArray
     */
    fun update_legacy_feature(
        legacy_feature_id: String,
        body: WriteLegacyFeature
    ) : SDKResponse {
        val path_legacy_feature_id = encodeParam(legacy_feature_id)
            return this.patch<ByteArray>("/legacy_features/${path_legacy_feature_id}", mapOf(), body)
    }


    /**
     * ### Get a list of locales that Looker supports.
     *
     * GET /locales -> ByteArray
     */
    fun all_locales(

    ) : SDKResponse {
            return this.get<ByteArray>("/locales", mapOf())
    }


    /**
     * ### Get all mobile settings.
     *
     * GET /mobile/settings -> ByteArray
     */
    fun mobile_settings(

    ) : SDKResponse {
            return this.get<ByteArray>("/mobile/settings", mapOf())
    }


    /**
     * ### 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_enabled
     *  - onboarding_enabled
     *  - privatelabel_configuration
     *  - timezone
     *
     * @param {String} fields Requested fields
     *
     * GET /setting -> ByteArray
     */
    @JvmOverloads fun get_setting(
        fields: String? = null
    ) : SDKResponse {
            return this.get<ByteArray>("/setting", 
                mapOf("fields" to fields))
    }


    /**
     * ### 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_enabled
     *  - onboarding_enabled
     *  - privatelabel_configuration
     *  - timezone
     *
     * See the `Setting` type for more information on the specific values that can be configured.
     *
     * @param {WriteSetting} body
     * @param {String} fields Requested fields
     *
     * PATCH /setting -> ByteArray
     */
    @JvmOverloads fun set_setting(
        body: WriteSetting,
        fields: String? = null
    ) : SDKResponse {
            return this.patch<ByteArray>("/setting", 
                mapOf("fields" to fields), body)
    }


    /**
     * ### Configure SMTP Settings
     *   This API allows users to configure the SMTP settings on the Looker instance.
     *   This API is only supported in the OEM jar. Additionally, only admin users are authorised to call this API.
     *
     * @param {SmtpSettings} body
     *
     * POST /smtp_settings -> ByteArray
     */
    fun set_smtp_settings(
        body: SmtpSettings
    ) : SDKResponse {
            return this.post<ByteArray>("/smtp_settings", mapOf(), body)
    }


    /**
     * ### Get current SMTP status.
     *
     * @param {String} fields Include only these fields in the response
     *
     * GET /smtp_status -> ByteArray
     */
    @JvmOverloads fun smtp_status(
        fields: String? = null
    ) : SDKResponse {
            return this.get<ByteArray>("/smtp_status", 
                mapOf("fields" to fields))
    }


    /**
     * ### Get a list of timezones that Looker supports (e.g. useful for scheduling tasks).
     *
     * GET /timezones -> ByteArray
     */
    fun all_timezones(

    ) : SDKResponse {
            return this.get<ByteArray>("/timezones", mapOf())
    }


    /**
     * ### Get information about all API versions supported by this Looker instance.
     *
     * @param {String} fields Requested fields.
     *
     * GET /versions -> ByteArray
     */
    @JvmOverloads fun versions(
        fields: String? = null
    ) : SDKResponse {
            return this.get<ByteArray>("/versions", 
                mapOf("fields" to fields))
    }


    /**
     * ### Get an API specification for this Looker instance.
     *
     * The specification is returned as a JSON document in Swagger 2.x format
     *
     * @param {String} api_version API version
     * @param {String} specification Specification name. Typically, this is "swagger.json"
     *
     * GET /api_spec/{api_version}/{specification} -> ByteArray
     */
    fun api_spec(
        api_version: String,
        specification: String
    ) : SDKResponse {
        val path_api_version = encodeParam(api_version)
        val path_specification = encodeParam(specification)
            return this.get<ByteArray>("/api_spec/${path_api_version}/${path_specification}", mapOf())
    }


    /**
     * ### This feature is enabled only by special license.
     * ### Gets the whitelabel configuration, which includes hiding documentation links, custom favicon uploading, etc.
     *
     * @param {String} fields Requested fields.
     *
     * GET /whitelabel_configuration -> ByteArray
     */
    @Deprecated(message = "Deprecated method")
    @JvmOverloads fun whitelabel_configuration(
        fields: String? = null
    ) : SDKResponse {
            return this.get<ByteArray>("/whitelabel_configuration", 
                mapOf("fields" to fields))
    }


    /**
     * ### Update the whitelabel configuration
     *
     * @param {WriteWhitelabelConfiguration} body
     *
     * PUT /whitelabel_configuration -> ByteArray
     */
    @Deprecated(message = "Deprecated method")
    fun update_whitelabel_configuration(
        body: WriteWhitelabelConfiguration
    ) : SDKResponse {
            return this.put<ByteArray>("/whitelabel_configuration", mapOf(), body)
    }

    //endregion Config: Manage General Configuration

    //region Connection: Manage Database Connections


    /**
     * ### Get information about all connections.
     *
     * @param {String} fields Requested fields.
     *
     * GET /connections -> ByteArray
     */
    @JvmOverloads fun all_connections(
        fields: String? = null
    ) : SDKResponse {
            return this.get<ByteArray>("/connections", 
                mapOf("fields" to fields))
    }


    /**
     * ### Create a connection using the specified configuration.
     *
     * @param {WriteDBConnection} body
     *
     * POST /connections -> ByteArray
     */
    fun create_connection(
        body: WriteDBConnection
    ) : SDKResponse {
            return this.post<ByteArray>("/connections", mapOf(), body)
    }


    /**
     * ### Get information about a connection.
     *
     * @param {String} connection_name Name of connection
     * @param {String} fields Requested fields.
     *
     * GET /connections/{connection_name} -> ByteArray
     */
    @JvmOverloads fun connection(
        connection_name: String,
        fields: String? = null
    ) : SDKResponse {
        val path_connection_name = encodeParam(connection_name)
            return this.get<ByteArray>("/connections/${path_connection_name}", 
                mapOf("fields" to fields))
    }


    /**
     * ### Update a connection using the specified configuration.
     *
     * @param {String} connection_name Name of connection
     * @param {WriteDBConnection} body
     *
     * PATCH /connections/{connection_name} -> ByteArray
     */
    fun update_connection(
        connection_name: String,
        body: WriteDBConnection
    ) : SDKResponse {
        val path_connection_name = encodeParam(connection_name)
            return this.patch<ByteArray>("/connections/${path_connection_name}", mapOf(), body)
    }


    /**
     * ### Delete a connection.
     *
     * @param {String} connection_name Name of connection
     *
     * DELETE /connections/{connection_name} -> ByteArray
     */
    fun delete_connection(
        connection_name: String
    ) : SDKResponse {
        val path_connection_name = encodeParam(connection_name)
            return this.delete<ByteArray>("/connections/${path_connection_name}", mapOf())
    }


    /**
     * ### Delete a connection override.
     *
     * @param {String} connection_name Name of connection
     * @param {String} override_context Context of connection override
     *
     * DELETE /connections/{connection_name}/connection_override/{override_context} -> ByteArray
     */
    fun delete_connection_override(
        connection_name: String,
        override_context: String
    ) : SDKResponse {
        val path_connection_name = encodeParam(connection_name)
        val path_override_context = encodeParam(override_context)
            return this.delete<ByteArray>("/connections/${path_connection_name}/connection_override/${path_override_context}", mapOf())
    }


    /**
     * ### 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.
     *
     * @param {String} connection_name Name of connection
     * @param {DelimArray<String>} tests Array of names of tests to run
     *
     * PUT /connections/{connection_name}/test -> ByteArray
     */
    @JvmOverloads fun test_connection(
        connection_name: String,
        tests: DelimArray<String>? = null
    ) : SDKResponse {
        val path_connection_name = encodeParam(connection_name)
            return this.put<ByteArray>("/connections/${path_connection_name}/test", 
                mapOf("tests" to tests))
    }


    /**
     * ### 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.
     *
     * @param {WriteDBConnection} body
     * @param {DelimArray<String>} tests Array of names of tests to run
     *
     * PUT /connections/test -> ByteArray
     */
    @JvmOverloads fun test_connection_config(
        body: WriteDBConnection,
        tests: DelimArray<String>? = null
    ) : SDKResponse {
            return this.put<ByteArray>("/connections/test", 
                mapOf("tests" to tests), body)
    }


    /**
     * ### Get information about all dialects.
     *
     * @param {String} fields Requested fields.
     *
     * GET /dialect_info -> ByteArray
     */
    @JvmOverloads fun all_dialect_infos(
        fields: String? = null
    ) : SDKResponse {
            return this.get<ByteArray>("/dialect_info", 
                mapOf("fields" to fields))
    }


    /**
     * ### Get all External OAuth Applications.
     *
     * This is an OAuth Application which Looker uses to access external systems.
     *
     * @param {String} name Application name
     * @param {String} client_id Application Client ID
     *
     * GET /external_oauth_applications -> ByteArray
     */
    @JvmOverloads fun all_external_oauth_applications(
        name: String? = null,
        client_id: String? = null
    ) : SDKResponse {
            return this.get<ByteArray>("/external_oauth_applications", 
                mapOf("name" to name,
                     "client_id" to client_id))
    }


    /**
     * ### Create an OAuth Application using the specified configuration.
     *
     * This is an OAuth Application which Looker uses to access external systems.
     *
     * @param {WriteExternalOauthApplication} body
     *
     * POST /external_oauth_applications -> ByteArray
     */
    fun create_external_oauth_application(
        body: WriteExternalOauthApplication
    ) : SDKResponse {
            return this.post<ByteArray>("/external_oauth_applications", mapOf(), body)
    }


    /**
     * ### Create OAuth User state.
     *
     * @param {CreateOAuthApplicationUserStateRequest} body
     *
     * POST /external_oauth_applications/user_state -> ByteArray
     */
    fun create_oauth_application_user_state(
        body: CreateOAuthApplicationUserStateRequest
    ) : SDKResponse {
            return this.post<ByteArray>("/external_oauth_applications/user_state", mapOf(), body)
    }


    /**
     * ### Get information about all SSH Servers.
     *
     * @param {String} fields Requested fields.
     *
     * GET /ssh_servers -> ByteArray
     */
    @JvmOverloads fun all_ssh_servers(
        fields: String? = null
    ) : SDKResponse {
            return this.get<ByteArray>("/ssh_servers", 
                mapOf("fields" to fields))
    }


    /**
     * ### Create an SSH Server.
     *
     * @param {WriteSshServer} body
     *
     * POST /ssh_servers -> ByteArray
     */
    fun create_ssh_server(
        body: WriteSshServer
    ) : SDKResponse {
            return this.post<ByteArray>("/ssh_servers", mapOf(), body)
    }


    /**
     * ### Get information about an SSH Server.
     *
     * @param {String} ssh_server_id Id of SSH Server
     *
     * GET /ssh_server/{ssh_server_id} -> ByteArray
     */
    fun ssh_server(
        ssh_server_id: String
    ) : SDKResponse {
        val path_ssh_server_id = encodeParam(ssh_server_id)
            return this.get<ByteArray>("/ssh_server/${path_ssh_server_id}", mapOf())
    }


    /**
     * ### Update an SSH Server.
     *
     * @param {String} ssh_server_id Id of SSH Server
     * @param {WriteSshServer} body
     *
     * PATCH /ssh_server/{ssh_server_id} -> ByteArray
     */
    fun update_ssh_server(
        ssh_server_id: String,
        body: WriteSshServer
    ) : SDKResponse {
        val path_ssh_server_id = encodeParam(ssh_server_id)
            return this.patch<ByteArray>("/ssh_server/${path_ssh_server_id}", mapOf(), body)
    }


    /**
     * ### Delete an SSH Server.
     *
     * @param {String} ssh_server_id Id of SSH Server
     *
     * DELETE /ssh_server/{ssh_server_id} -> ByteArray
     */
    fun delete_ssh_server(
        ssh_server_id: String
    ) : SDKResponse {
        val path_ssh_server_id = encodeParam(ssh_server_id)
            return this.delete<ByteArray>("/ssh_server/${path_ssh_server_id}", mapOf())
    }


    /**
     * ### Test the SSH Server
     *
     * @param {String} ssh_server_id Id of SSH Server
     *
     * GET /ssh_server/{ssh_server_id}/test -> ByteArray
     */
    fun test_ssh_server(
        ssh_server_id: String
    ) : SDKResponse {
        val path_ssh_server_id = encodeParam(ssh_server_id)
            return this.get<ByteArray>("/ssh_server/${path_ssh_server_id}/test", mapOf())
    }


    /**
     * ### Get information about all SSH Tunnels.
     *
     * @param {String} fields Requested fields.
     *
     * GET /ssh_tunnels -> ByteArray
     */
    @JvmOverloads fun all_ssh_tunnels(
        fields: String? = null
    ) : SDKResponse {
            return this.get<ByteArray>("/ssh_tunnels", 
                mapOf("fields" to fields))
    }


    /**
     * ### Create an SSH Tunnel
     *
     * @param {WriteSshTunnel} body
     *
     * POST /ssh_tunnels -> ByteArray
     */
    fun create_ssh_tunnel(
        body: WriteSshTunnel
    ) : SDKResponse {
            return this.post<ByteArray>("/ssh_tunnels", mapOf(), body)
    }


    /**
     * ### Get information about an SSH Tunnel.
     *
     * @param {String} ssh_tunnel_id Id of SSH Tunnel
     *
     * GET /ssh_tunnel/{ssh_tunnel_id} -> ByteArray
     */
    fun ssh_tunnel(
        ssh_tunnel_id: String
    ) : SDKResponse {
        val path_ssh_tunnel_id = encodeParam(ssh_tunnel_id)
            return this.get<ByteArray>("/ssh_tunnel/${path_ssh_tunnel_id}", mapOf())
    }


    /**
     * ### Update an SSH Tunnel
     *
     * @param {String} ssh_tunnel_id Id of SSH Tunnel
     * @param {WriteSshTunnel} body
     *
     * PATCH /ssh_tunnel/{ssh_tunnel_id} -> ByteArray
     */
    fun update_ssh_tunnel(
        ssh_tunnel_id: String,
        body: WriteSshTunnel
    ) : SDKResponse {
        val path_ssh_tunnel_id = encodeParam(ssh_tunnel_id)
            return this.patch<ByteArray>("/ssh_tunnel/${path_ssh_tunnel_id}", mapOf(), body)
    }


    /**
     * ### Delete an SSH Tunnel
     *
     * @param {String} ssh_tunnel_id Id of SSH Tunnel
     *
     * DELETE /ssh_tunnel/{ssh_tunnel_id} -> ByteArray
     */
    fun delete_ssh_tunnel(
        ssh_tunnel_id: String
    ) : SDKResponse {
        val path_ssh_tunnel_id = encodeParam(ssh_tunnel_id)
            return this.delete<ByteArray>("/ssh_tunnel/${path_ssh_tunnel_id}", mapOf())
    }


    /**
     * ### Test the SSH Tunnel
     *
     * @param {String} ssh_tunnel_id Id of SSH Tunnel
     *
     * GET /ssh_tunnel/{ssh_tunnel_id}/test -> ByteArray
     */
    fun test_ssh_tunnel(
        ssh_tunnel_id: String
    ) : SDKResponse {
        val path_ssh_tunnel_id = encodeParam(ssh_tunnel_id)
            return this.get<ByteArray>("/ssh_tunnel/${path_ssh_tunnel_id}/test", mapOf())
    }


    /**
     * ### 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 -> ByteArray
     */
    fun ssh_public_key(

    ) : SDKResponse {
            return this.get<ByteArray>("/ssh_public_key", mapOf())
    }

    //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.
     *
     * @param {String} id Match content favorite id(s)
     * @param {String} user_id Match user id(s).To create a list of multiple ids, use commas as separators
     * @param {String} content_metadata_id Match content metadata id(s).To create a list of multiple ids, use commas as separators
     * @param {String} dashboard_id Match dashboard id(s).To create a list of multiple ids, use commas as separators
     * @param {String} look_id Match look id(s).To create a list of multiple ids, use commas as separators
     * @param {String} board_id Match board id(s).To create a list of multiple ids, use commas as separators
     * @param {Long} limit Number of results to return. (used with offset)
     * @param {Long} offset Number of results to skip before returning any. (used with limit)
     * @param {String} sorts Fields to sort by.
     * @param {String} fields Requested fields.
     * @param {Boolean} filter_or Combine given search criteria in a boolean OR expression
     *
     * GET /content_favorite/search -> ByteArray
     */
    @JvmOverloads fun search_content_favorites(
        id: String? = null,
        user_id: String? = null,
        content_metadata_id: String? = null,
        dashboard_id: String? = null,
        look_id: String? = null,
        board_id: String? = null,
        limit: Long? = null,
        offset: Long? = null,
        sorts: String? = null,
        fields: String? = null,
        filter_or: Boolean? = null
    ) : SDKResponse {
            return this.get<ByteArray>("/content_favorite/search", 
                mapOf("id" to id,
                     "user_id" to user_id,
                     "content_metadata_id" to content_metadata_id,
                     "dashboard_id" to dashboard_id,
                     "look_id" to look_id,
                     "board_id" to board_id,
                     "limit" to limit,
                     "offset" to offset,
                     "sorts" to sorts,
                     "fields" to fields,
                     "filter_or" to filter_or))
    }


    /**
     * ### Get favorite content by its id
     *
     * @param {String} content_favorite_id Id of favorite content
     * @param {String} fields Requested fields.
     *
     * GET /content_favorite/{content_favorite_id} -> ByteArray
     */
    @JvmOverloads fun content_favorite(
        content_favorite_id: String,
        fields: String? = null
    ) : SDKResponse {
        val path_content_favorite_id = encodeParam(content_favorite_id)
            return this.get<ByteArray>("/content_favorite/${path_content_favorite_id}", 
                mapOf("fields" to fields))
    }


    /**
     * ### Delete favorite content
     *
     * @param {String} content_favorite_id Id of favorite content
     *
     * DELETE /content_favorite/{content_favorite_id} -> ByteArray
     */
    fun delete_content_favorite(
        content_favorite_id: String
    ) : SDKResponse {
        val path_content_favorite_id = encodeParam(content_favorite_id)
            return this.delete<ByteArray>("/content_favorite/${path_content_favorite_id}", mapOf())
    }


    /**
     * ### Create favorite content
     *
     * @param {WriteContentFavorite} body
     *
     * POST /content_favorite -> ByteArray
     */
    fun create_content_favorite(
        body: WriteContentFavorite
    ) : SDKResponse {
            return this.post<ByteArray>("/content_favorite", mapOf(), body)
    }


    /**
     * ### Get information about all content metadata in a space.
     *
     * @param {String} parent_id Parent space of content.
     * @param {String} fields Requested fields.
     *
     * GET /content_metadata -> ByteArray
     */
    @JvmOverloads fun all_content_metadatas(
        parent_id: String,
        fields: String? = null
    ) : SDKResponse {
            return this.get<ByteArray>("/content_metadata", 
                mapOf("parent_id" to parent_id,
                     "fields" to fields))
    }


    /**
     * ### Get information about an individual content metadata record.
     *
     * @param {String} content_metadata_id Id of content metadata
     * @param {String} fields Requested fields.
     *
     * GET /content_metadata/{content_metadata_id} -> ByteArray
     */
    @JvmOverloads fun content_metadata(
        content_metadata_id: String,
        fields: String? = null
    ) : SDKResponse {
        val path_content_metadata_id = encodeParam(content_metadata_id)
            return this.get<ByteArray>("/content_metadata/${path_content_metadata_id}", 
                mapOf("fields" to fields))
    }


    /**
     * ### Move a piece of content.
     *
     * @param {String} content_metadata_id Id of content metadata
     * @param {WriteContentMeta} body
     *
     * PATCH /content_metadata/{content_metadata_id} -> ByteArray
     */
    fun update_content_metadata(
        content_metadata_id: String,
        body: WriteContentMeta
    ) : SDKResponse {
        val path_content_metadata_id = encodeParam(content_metadata_id)
            return this.patch<ByteArray>("/content_metadata/${path_content_metadata_id}", mapOf(), body)
    }


    /**
     * ### All content metadata access records for a content metadata item.
     *
     * @param {String} content_metadata_id Id of content metadata
     * @param {String} fields Requested fields.
     *
     * GET /content_metadata_access -> ByteArray
     */
    @JvmOverloads fun all_content_metadata_accesses(
        content_metadata_id: String,
        fields: String? = null
    ) : SDKResponse {
            return this.get<ByteArray>("/content_metadata_access", 
                mapOf("content_metadata_id" to content_metadata_id,
                     "fields" to fields))
    }


    /**
     * ### Create content metadata access.
     *
     * @param {ContentMetaGroupUser} body WARNING: no writeable properties found for POST, PUT, or PATCH
     * @param {Boolean} send_boards_notification_email Optionally sends notification email when granting access to a board.
     *
     * POST /content_metadata_access -> ByteArray
     */
    @JvmOverloads fun create_content_metadata_access(
        body: ContentMetaGroupUser,
        send_boards_notification_email: Boolean? = null
    ) : SDKResponse {
            return this.post<ByteArray>("/content_metadata_access", 
                mapOf("send_boards_notification_email" to send_boards_notification_email), body)
    }


    /**
     * ### Update type of access for content metadata.
     *
     * @param {String} content_metadata_access_id Id of content metadata access
     * @param {ContentMetaGroupUser} body WARNING: no writeable properties found for POST, PUT, or PATCH
     *
     * PUT /content_metadata_access/{content_metadata_access_id} -> ByteArray
     */
    fun update_content_metadata_access(
        content_metadata_access_id: String,
        body: ContentMetaGroupUser
    ) : SDKResponse {
        val path_content_metadata_access_id = encodeParam(content_metadata_access_id)
            return this.put<ByteArray>("/content_metadata_access/${path_content_metadata_access_id}", mapOf(), body)
    }


    /**
     * ### Remove content metadata access.
     *
     * @param {String} content_metadata_access_id Id of content metadata access
     *
     * DELETE /content_metadata_access/{content_metadata_access_id} -> ByteArray
     */
    fun delete_content_metadata_access(
        content_metadata_access_id: String
    ) : SDKResponse {
        val path_content_metadata_access_id = encodeParam(content_metadata_access_id)
            return this.delete<ByteArray>("/content_metadata_access/${path_content_metadata_access_id}", mapOf())
    }


    /**
     * ### Get an image representing the contents of a dashboard or look.
     *
     * The returned thumbnail is an abstract representation of the contents of a dashbord or look and does not
     * reflect the actual data displayed in the respective visualizations.
     *
     * @param {String} type Either dashboard or look
     * @param {String} resource_id ID of the dashboard or look to render
     * @param {String} reload Whether or not to refresh the rendered image with the latest content
     * @param {String} format A value of png produces a thumbnail in PNG format instead of SVG (default)
     * @param {Long} width The width of the image if format is supplied
     * @param {Long} height The height of the image if format is supplied
     *
     * GET /content_thumbnail/{type}/{resource_id} -> ByteArray
     *
     * **Note**: Binary content may be returned by this method.
     */
    @JvmOverloads fun content_thumbnail(
        type: String,
        resource_id: String,
        reload: String? = null,
        format: String? = null,
        width: Long? = null,
        height: Long? = null
    ) : SDKResponse {
        val path_type = encodeParam(type)
        val path_resource_id = encodeParam(resource_id)
            return this.get<ByteArray>("/content_thumbnail/${path_type}/${path_resource_id}", 
                mapOf("reload" to reload,
                     "format" to format,
                     "width" to width,
                     "height" to height))
    }


    /**
     * ### 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.
     *
     * @param {String} fields Requested fields.
     *
     * GET /content_validation -> ByteArray
     */
    @JvmOverloads fun content_validation(
        fields: String? = null
    ) : SDKResponse {
            return this.get<ByteArray>("/content_validation", 
                mapOf("fields" to fields))
    }


    /**
     * ### 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.
     *
     * @param {String} view_count Match view count
     * @param {String} group_id Match Group Id
     * @param {String} look_id Match look_id
     * @param {String} dashboard_id Match dashboard_id
     * @param {String} content_metadata_id Match content metadata id
     * @param {String} start_of_week_date Match start of week date (format is "YYYY-MM-DD")
     * @param {Boolean} all_time True if only all time view records should be returned
     * @param {String} user_id Match user id
     * @param {String} fields Requested fields
     * @param {Long} limit Number of results to return. Use with `offset` to manage pagination of results
     * @param {Long} offset Number of results to skip before returning data
     * @param {String} sorts Fields to sort by
     * @param {Boolean} filter_or Combine given search criteria in a boolean OR expression
     *
     * GET /content_view/search -> ByteArray
     */
    @JvmOverloads fun search_content_views(
        view_count: String? = null,
        group_id: String? = null,
        look_id: String? = null,
        dashboard_id: String? = null,
        content_metadata_id: String? = null,
        start_of_week_date: String? = null,
        all_time: Boolean? = null,
        user_id: String? = null,
        fields: String? = null,
        limit: Long? = null,
        offset: Long? = null,
        sorts: String? = null,
        filter_or: Boolean? = null
    ) : SDKResponse {
            return this.get<ByteArray>("/content_view/search", 
                mapOf("view_count" to view_count,
                     "group_id" to group_id,
                     "look_id" to look_id,
                     "dashboard_id" to dashboard_id,
                     "content_metadata_id" to content_metadata_id,
                     "start_of_week_date" to start_of_week_date,
                     "all_time" to all_time,
                     "user_id" to user_id,
                     "fields" to fields,
                     "limit" to limit,
                     "offset" to offset,
                     "sorts" to sorts,
                     "filter_or" to filter_or))
    }


    /**
     * ### 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 dashbord or look and does not
     * reflect the actual data displayed in the respective visualizations.
     *
     * @param {String} type Either dashboard or look
     * @param {String} resource_id ID of the dashboard or look to render
     * @param {String} reload Whether or not to refresh the rendered image with the latest content
     *
     * GET /vector_thumbnail/{type}/{resource_id} -> ByteArray
     */
    @Deprecated(message = "Deprecated method")
    @JvmOverloads fun vector_thumbnail(
        type: String,
        resource_id: String,
        reload: String? = null
    ) : SDKResponse {
        val path_type = encodeParam(type)
        val path_resource_id = encodeParam(resource_id)
            return this.get<ByteArray>("/vector_thumbnail/${path_type}/${path_resource_id}", 
                mapOf("reload" to reload))
    }

    //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)
     *
     * @param {String} fields Requested fields.
     *
     * GET /dashboards -> ByteArray
     */
    @JvmOverloads fun all_dashboards(
        fields: String? = null
    ) : SDKResponse {
            return this.get<ByteArray>("/dashboards", 
                mapOf("fields" to fields))
    }


    /**
     * ### 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)
     *
     * @param {WriteDashboard} body
     *
     * POST /dashboards -> ByteArray
     */
    fun create_dashboard(
        body: WriteDashboard
    ) : SDKResponse {
            return this.post<ByteArray>("/dashboards", mapOf(), body)
    }


    /**
     * ### Search Dashboards
     *
     * Returns an **array of dashboard 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.
     *
     *
     * The parameters `limit`, and `offset` are recommended for fetching results in page-size chunks.
     *
     * Get a **single dashboard** by id with [dashboard()](#!/Dashboard/dashboard)
     *
     * @param {String} id Match dashboard id.
     * @param {String} slug Match dashboard slug.
     * @param {String} title Match Dashboard title.
     * @param {String} description Match Dashboard description.
     * @param {String} content_favorite_id Filter on a content favorite id.
     * @param {String} folder_id Filter on a particular space.
     * @param {String} deleted Filter on dashboards deleted status.
     * @param {String} user_id Filter on dashboards created by a particular user.
     * @param {String} view_count Filter on a particular value of view_count
     * @param {String} content_metadata_id Filter on a content favorite id.
     * @param {Boolean} curate Exclude items that exist only in personal spaces other than the users
     * @param {String} last_viewed_at Select dashboards based on when they were last viewed
     * @param {String} fields Requested fields.
     * @param {Long} page DEPRECATED. Use limit and offset instead. Return only page N of paginated results
     * @param {Long} per_page DEPRECATED. Use limit and offset instead. Return N rows of data per page
     * @param {Long} limit Number of results to return. (used with offset and takes priority over page and per_page)
     * @param {Long} offset Number of results to skip before returning any. (used with limit and takes priority over page and per_page)
     * @param {String} sorts One or more fields to sort by. Sortable fields: [:title, :user_id, :id, :created_at, :space_id, :folder_id, :description, :view_count, :favorite_count, :slug, :content_favorite_id, :content_metadata_id, :deleted, :deleted_at, :last_viewed_at, :last_accessed_at]
     * @param {Boolean} filter_or Combine given search criteria in a boolean OR expression
     *
     * GET /dashboards/search -> ByteArray
     */
    @JvmOverloads fun search_dashboards(
        id: String? = null,
        slug: String? = null,
        title: String? = null,
        description: String? = null,
        content_favorite_id: String? = null,
        folder_id: String? = null,
        deleted: String? = null,
        user_id: String? = null,
        view_count: String? = null,
        content_metadata_id: String? = null,
        curate: Boolean? = null,
        last_viewed_at: String? = null,
        fields: String? = null,
        page: Long? = null,
        per_page: Long? = null,
        limit: Long? = null,
        offset: Long? = null,
        sorts: String? = null,
        filter_or: Boolean? = null
    ) : SDKResponse {
            return this.get<ByteArray>("/dashboards/search", 
                mapOf("id" to id,
                     "slug" to slug,
                     "title" to title,
                     "description" to description,
                     "content_favorite_id" to content_favorite_id,
                     "folder_id" to folder_id,
                     "deleted" to deleted,
                     "user_id" to user_id,
                     "view_count" to view_count,
                     "content_metadata_id" to content_metadata_id,
                     "curate" to curate,
                     "last_viewed_at" to last_viewed_at,
                     "fields" to fields,
                     "page" to page,
                     "per_page" to per_page,
                     "limit" to limit,
                     "offset" to offset,
                     "sorts" to sorts,
                     "filter_or" to filter_or))
    }


    /**
     * ### 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)
     *
     * @param {String} lookml_dashboard_id Id of LookML dashboard
     * @param {String} space_id Id of space to import the dashboard to
     * @param {WriteDashboard} body
     * @param {Boolean} raw_locale If true, and this dashboard is localized, export it with the raw keys, not localized.
     *
     * POST /dashboards/{lookml_dashboard_id}/import/{space_id} -> ByteArray
     */
    @JvmOverloads fun import_lookml_dashboard(
        lookml_dashboard_id: String,
        space_id: String,
        body: WriteDashboard? = null,
        raw_locale: Boolean? = null
    ) : SDKResponse {
        val path_lookml_dashboard_id = encodeParam(lookml_dashboard_id)
        val path_space_id = encodeParam(space_id)
            return this.post<ByteArray>("/dashboards/${path_lookml_dashboard_id}/import/${path_space_id}", 
                mapOf("raw_locale" to raw_locale), body)
    }


    /**
     * ### 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)
     *
     * @param {String} lookml_dashboard_id Id of LookML dashboard, in the form 'model::dashboardname'
     * @param {WriteDashboard} body
     * @param {Boolean} raw_locale If true, and this dashboard is localized, export it with the raw keys, not localized.
     *
     * PATCH /dashboards/{lookml_dashboard_id}/sync -> ByteArray
     */
    @JvmOverloads fun sync_lookml_dashboard(
        lookml_dashboard_id: String,
        body: WriteDashboard,
        raw_locale: Boolean? = null
    ) : SDKResponse {
        val path_lookml_dashboard_id = encodeParam(lookml_dashboard_id)
            return this.patch<ByteArray>("/dashboards/${path_lookml_dashboard_id}/sync", 
                mapOf("raw_locale" to raw_locale), body)
    }


    /**
     * ### 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)
     *
     * @param {String} dashboard_id Id of dashboard
     * @param {String} fields Requested fields.
     *
     * GET /dashboards/{dashboard_id} -> ByteArray
     */
    @JvmOverloads fun dashboard(
        dashboard_id: String,
        fields: String? = null
    ) : SDKResponse {
        val path_dashboard_id = encodeParam(dashboard_id)
            return this.get<ByteArray>("/dashboards/${path_dashboard_id}", 
                mapOf("fields" to fields))
    }


    /**
     * ### 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()](#!/3.1/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.
     *
     * @param {String} dashboard_id Id of dashboard
     * @param {WriteDashboard} body
     *
     * PATCH /dashboards/{dashboard_id} -> ByteArray
     */
    fun update_dashboard(
        dashboard_id: String,
        body: WriteDashboard
    ) : SDKResponse {
        val path_dashboard_id = encodeParam(dashboard_id)
            return this.patch<ByteArray>("/dashboards/${path_dashboard_id}", mapOf(), body)
    }


    /**
     * ### 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.
     *
     * @param {String} dashboard_id Id of dashboard
     *
     * DELETE /dashboards/{dashboard_id} -> ByteArray
     */
    fun delete_dashboard(
        dashboard_id: String
    ) : SDKResponse {
        val path_dashboard_id = encodeParam(dashboard_id)
            return this.delete<ByteArray>("/dashboards/${path_dashboard_id}", mapOf())
    }


    /**
     * ### Get Aggregate Table LookML for Each Query on a Dahboard
     *
     * Returns a JSON object that contains the dashboard id and Aggregate Table lookml
     *
     * @param {String} dashboard_id Id of dashboard
     *
     * GET /dashboards/aggregate_table_lookml/{dashboard_id} -> ByteArray
     */
    fun dashboard_aggregate_table_lookml(
        dashboard_id: String
    ) : SDKResponse {
        val path_dashboard_id = encodeParam(dashboard_id)
            return this.get<ByteArray>("/dashboards/aggregate_table_lookml/${path_dashboard_id}", mapOf())
    }


    /**
     * ### Get lookml of a UDD
     *
     * Returns a JSON object that contains the dashboard id and the full lookml
     *
     * @param {String} dashboard_id Id of dashboard
     *
     * GET /dashboards/lookml/{dashboard_id} -> ByteArray
     */
    fun dashboard_lookml(
        dashboard_id: String
    ) : SDKResponse {
        val path_dashboard_id = encodeParam(dashboard_id)
            return this.get<ByteArray>("/dashboards/lookml/${path_dashboard_id}", mapOf())
    }


    /**
     * ### 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.
     *
     * @param {String} dashboard_id Dashboard id to move.
     * @param {String} folder_id Folder id to move to.
     *
     * PATCH /dashboards/{dashboard_id}/move -> ByteArray
     */
    fun move_dashboard(
        dashboard_id: String,
        folder_id: String
    ) : SDKResponse {
        val path_dashboard_id = encodeParam(dashboard_id)
            return this.patch<ByteArray>("/dashboards/${path_dashboard_id}/move", 
                mapOf("folder_id" to folder_id))
    }


    /**
     * ### 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.
     *
     * @param {WriteDashboardLookml} body
     *
     * POST /dashboards/lookml -> ByteArray
     */
    fun import_dashboard_from_lookml(
        body: WriteDashboardLookml
    ) : SDKResponse {
            return this.post<ByteArray>("/dashboards/lookml", mapOf(), body)
    }


    /**
     * # DEPRECATED:  Use [import_dashboard_from_lookml()](#!/Dashboard/import_dashboard_from_lookml)
     *
     * @param {WriteDashboardLookml} body
     *
     * POST /dashboards/from_lookml -> ByteArray
     */
    fun create_dashboard_from_lookml(
        body: WriteDashboardLookml
    ) : SDKResponse {
            return this.post<ByteArray>("/dashboards/from_lookml", mapOf(), body)
    }


    /**
     * ### 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.
     *
     * @param {String} dashboard_id Dashboard id to copy.
     * @param {String} folder_id Folder id to copy to.
     *
     * POST /dashboards/{dashboard_id}/copy -> ByteArray
     */
    @JvmOverloads fun copy_dashboard(
        dashboard_id: String,
        folder_id: String? = null
    ) : SDKResponse {
        val path_dashboard_id = encodeParam(dashboard_id)
            return this.post<ByteArray>("/dashboards/${path_dashboard_id}/copy", 
                mapOf("folder_id" to folder_id))
    }


    /**
     * ### 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.
     *
     * @param {String} dashboard_id Select elements that refer to a given dashboard id
     * @param {String} look_id Select elements that refer to a given look id
     * @param {String} title Match the title of element
     * @param {Boolean} deleted Select soft-deleted dashboard elements
     * @param {String} fields Requested fields.
     * @param {Boolean} filter_or Combine given search criteria in a boolean OR expression
     * @param {String} sorts Fields to sort by. Sortable fields: [:look_id, :dashboard_id, :deleted, :title]
     *
     * GET /dashboard_elements/search -> ByteArray
     */
    @JvmOverloads fun search_dashboard_elements(
        dashboard_id: String? = null,
        look_id: String? = null,
        title: String? = null,
        deleted: Boolean? = null,
        fields: String? = null,
        filter_or: Boolean? = null,
        sorts: String? = null
    ) : SDKResponse {
            return this.get<ByteArray>("/dashboard_elements/search", 
                mapOf("dashboard_id" to dashboard_id,
                     "look_id" to look_id,
                     "title" to title,
                     "deleted" to deleted,
                     "fields" to fields,
                     "filter_or" to filter_or,
                     "sorts" to sorts))
    }


    /**
     * ### Get information about the dashboard element with a specific id.
     *
     * @param {String} dashboard_element_id Id of dashboard element
     * @param {String} fields Requested fields.
     *
     * GET /dashboard_elements/{dashboard_element_id} -> ByteArray
     */
    @JvmOverloads fun dashboard_element(
        dashboard_element_id: String,
        fields: String? = null
    ) : SDKResponse {
        val path_dashboard_element_id = encodeParam(dashboard_element_id)
            return this.get<ByteArray>("/dashboard_elements/${path_dashboard_element_id}", 
                mapOf("fields" to fields))
    }


    /**
     * ### Update the dashboard element with a specific id.
     *
     * @param {String} dashboard_element_id Id of dashboard element
     * @param {WriteDashboardElement} body
     * @param {String} fields Requested fields.
     *
     * PATCH /dashboard_elements/{dashboard_element_id} -> ByteArray
     */
    @JvmOverloads fun update_dashboard_element(
        dashboard_element_id: String,
        body: WriteDashboardElement,
        fields: String? = null
    ) : SDKResponse {
        val path_dashboard_element_id = encodeParam(dashboard_element_id)
            return this.patch<ByteArray>("/dashboard_elements/${path_dashboard_element_id}", 
                mapOf("fields" to fields), body)
    }


    /**
     * ### Delete a dashboard element with a specific id.
     *
     * @param {String} dashboard_element_id Id of dashboard element
     *
     * DELETE /dashboard_elements/{dashboard_element_id} -> ByteArray
     */
    fun delete_dashboard_element(
        dashboard_element_id: String
    ) : SDKResponse {
        val path_dashboard_element_id = encodeParam(dashboard_element_id)
            return this.delete<ByteArray>("/dashboard_elements/${path_dashboard_element_id}", mapOf())
    }


    /**
     * ### Get information about all the dashboard elements on a dashboard with a specific id.
     *
     * @param {String} dashboard_id Id of dashboard
     * @param {String} fields Requested fields.
     *
     * GET /dashboards/{dashboard_id}/dashboard_elements -> ByteArray
     */
    @JvmOverloads fun dashboard_dashboard_elements(
        dashboard_id: String,
        fields: String? = null
    ) : SDKResponse {
        val path_dashboard_id = encodeParam(dashboard_id)
            return this.get<ByteArray>("/dashboards/${path_dashboard_id}/dashboard_elements", 
                mapOf("fields" to fields))
    }


    /**
     * ### Create a dashboard element on the dashboard with a specific id.
     *
     * @param {WriteDashboardElement} body
     * @param {String} fields Requested fields.
     * @param {Boolean} apply_filters Apply relevant filters on dashboard to this tile
     *
     * POST /dashboard_elements -> ByteArray
     */
    @JvmOverloads fun create_dashboard_element(
        body: WriteDashboardElement,
        fields: String? = null,
        apply_filters: Boolean? = null
    ) : SDKResponse {
            return this.post<ByteArray>("/dashboard_elements", 
                mapOf("fields" to fields,
                     "apply_filters" to apply_filters), body)
    }


    /**
     * ### Get information about the dashboard filters with a specific id.
     *
     * @param {String} dashboard_filter_id Id of dashboard filters
     * @param {String} fields Requested fields.
     *
     * GET /dashboard_filters/{dashboard_filter_id} -> ByteArray
     */
    @JvmOverloads fun dashboard_filter(
        dashboard_filter_id: String,
        fields: String? = null
    ) : SDKResponse {
        val path_dashboard_filter_id = encodeParam(dashboard_filter_id)
            return this.get<ByteArray>("/dashboard_filters/${path_dashboard_filter_id}", 
                mapOf("fields" to fields))
    }


    /**
     * ### Update the dashboard filter with a specific id.
     *
     * @param {String} dashboard_filter_id Id of dashboard filter
     * @param {WriteDashboardFilter} body
     * @param {String} fields Requested fields.
     *
     * PATCH /dashboard_filters/{dashboard_filter_id} -> ByteArray
     */
    @JvmOverloads fun update_dashboard_filter(
        dashboard_filter_id: String,
        body: WriteDashboardFilter,
        fields: String? = null
    ) : SDKResponse {
        val path_dashboard_filter_id = encodeParam(dashboard_filter_id)
            return this.patch<ByteArray>("/dashboard_filters/${path_dashboard_filter_id}", 
                mapOf("fields" to fields), body)
    }


    /**
     * ### Delete a dashboard filter with a specific id.
     *
     * @param {String} dashboard_filter_id Id of dashboard filter
     *
     * DELETE /dashboard_filters/{dashboard_filter_id} -> ByteArray
     */
    fun delete_dashboard_filter(
        dashboard_filter_id: String
    ) : SDKResponse {
        val path_dashboard_filter_id = encodeParam(dashboard_filter_id)
            return this.delete<ByteArray>("/dashboard_filters/${path_dashboard_filter_id}", mapOf())
    }


    /**
     * ### Get information about all the dashboard filters on a dashboard with a specific id.
     *
     * @param {String} dashboard_id Id of dashboard
     * @param {String} fields Requested fields.
     *
     * GET /dashboards/{dashboard_id}/dashboard_filters -> ByteArray
     */
    @JvmOverloads fun dashboard_dashboard_filters(
        dashboard_id: String,
        fields: String? = null
    ) : SDKResponse {
        val path_dashboard_id = encodeParam(dashboard_id)
            return this.get<ByteArray>("/dashboards/${path_dashboard_id}/dashboard_filters", 
                mapOf("fields" to fields))
    }


    /**
     * ### Create a dashboard filter on the dashboard with a specific id.
     *
     * @param {WriteCreateDashboardFilter} body
     * @param {String} fields Requested fields
     *
     * POST /dashboard_filters -> ByteArray
     */
    @JvmOverloads fun create_dashboard_filter(
        body: WriteCreateDashboardFilter,
        fields: String? = null
    ) : SDKResponse {
            return this.post<ByteArray>("/dashboard_filters", 
                mapOf("fields" to fields), body)
    }


    /**
     * ### Get information about the dashboard elements with a specific id.
     *
     * @param {String} dashboard_layout_component_id Id of dashboard layout component
     * @param {String} fields Requested fields.
     *
     * GET /dashboard_layout_components/{dashboard_layout_component_id} -> ByteArray
     */
    @JvmOverloads fun dashboard_layout_component(
        dashboard_layout_component_id: String,
        fields: String? = null
    ) : SDKResponse {
        val path_dashboard_layout_component_id = encodeParam(dashboard_layout_component_id)
            return this.get<ByteArray>("/dashboard_layout_components/${path_dashboard_layout_component_id}", 
                mapOf("fields" to fields))
    }


    /**
     * ### Update the dashboard element with a specific id.
     *
     * @param {String} dashboard_layout_component_id Id of dashboard layout component
     * @param {WriteDashboardLayoutComponent} body
     * @param {String} fields Requested fields.
     *
     * PATCH /dashboard_layout_components/{dashboard_layout_component_id} -> ByteArray
     */
    @JvmOverloads fun update_dashboard_layout_component(
        dashboard_layout_component_id: String,
        body: WriteDashboardLayoutComponent,
        fields: String? = null
    ) : SDKResponse {
        val path_dashboard_layout_component_id = encodeParam(dashboard_layout_component_id)
            return this.patch<ByteArray>("/dashboard_layout_components/${path_dashboard_layout_component_id}", 
                mapOf("fields" to fields), body)
    }


    /**
     * ### Get information about all the dashboard layout components for a dashboard layout with a specific id.
     *
     * @param {String} dashboard_layout_id Id of dashboard layout component
     * @param {String} fields Requested fields.
     *
     * GET /dashboard_layouts/{dashboard_layout_id}/dashboard_layout_components -> ByteArray
     */
    @JvmOverloads fun dashboard_layout_dashboard_layout_components(
        dashboard_layout_id: String,
        fields: String? = null
    ) : SDKResponse {
        val path_dashboard_layout_id = encodeParam(dashboard_layout_id)
            return this.get<ByteArray>("/dashboard_layouts/${path_dashboard_layout_id}/dashboard_layout_components", 
                mapOf("fields" to fields))
    }


    /**
     * ### Get information about the dashboard layouts with a specific id.
     *
     * @param {String} dashboard_layout_id Id of dashboard layouts
     * @param {String} fields Requested fields.
     *
     * GET /dashboard_layouts/{dashboard_layout_id} -> ByteArray
     */
    @JvmOverloads fun dashboard_layout(
        dashboard_layout_id: String,
        fields: String? = null
    ) : SDKResponse {
        val path_dashboard_layout_id = encodeParam(dashboard_layout_id)
            return this.get<ByteArray>("/dashboard_layouts/${path_dashboard_layout_id}", 
                mapOf("fields" to fields))
    }


    /**
     * ### Update the dashboard layout with a specific id.
     *
     * @param {String} dashboard_layout_id Id of dashboard layout
     * @param {WriteDashboardLayout} body
     * @param {String} fields Requested fields.
     *
     * PATCH /dashboard_layouts/{dashboard_layout_id} -> ByteArray
     */
    @JvmOverloads fun update_dashboard_layout(
        dashboard_layout_id: String,
        body: WriteDashboardLayout,
        fields: String? = null
    ) : SDKResponse {
        val path_dashboard_layout_id = encodeParam(dashboard_layout_id)
            return this.patch<ByteArray>("/dashboard_layouts/${path_dashboard_layout_id}", 
                mapOf("fields" to fields), body)
    }


    /**
     * ### Delete a dashboard layout with a specific id.
     *
     * @param {String} dashboard_layout_id Id of dashboard layout
     *
     * DELETE /dashboard_layouts/{dashboard_layout_id} -> ByteArray
     */
    fun delete_dashboard_layout(
        dashboard_layout_id: String
    ) : SDKResponse {
        val path_dashboard_layout_id = encodeParam(dashboard_layout_id)
            return this.delete<ByteArray>("/dashboard_layouts/${path_dashboard_layout_id}", mapOf())
    }


    /**
     * ### Get information about all the dashboard elements on a dashboard with a specific id.
     *
     * @param {String} dashboard_id Id of dashboard
     * @param {String} fields Requested fields.
     *
     * GET /dashboards/{dashboard_id}/dashboard_layouts -> ByteArray
     */
    @JvmOverloads fun dashboard_dashboard_layouts(
        dashboard_id: String,
        fields: String? = null
    ) : SDKResponse {
        val path_dashboard_id = encodeParam(dashboard_id)
            return this.get<ByteArray>("/dashboards/${path_dashboard_id}/dashboard_layouts", 
                mapOf("fields" to fields))
    }


    /**
     * ### Create a dashboard layout on the dashboard with a specific id.
     *
     * @param {WriteDashboardLayout} body
     * @param {String} fields Requested fields.
     *
     * POST /dashboard_layouts -> ByteArray
     */
    @JvmOverloads fun create_dashboard_layout(
        body: WriteDashboardLayout,
        fields: String? = null
    ) : SDKResponse {
            return this.post<ByteArray>("/dashboard_layouts", 
                mapOf("fields" to fields), body)
    }

    //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.
     *
     * @param {DataActionRequest} body
     *
     * POST /data_actions -> ByteArray
     */
    fun perform_data_action(
        body: DataActionRequest
    ) : SDKResponse {
            return this.post<ByteArray>("/data_actions", mapOf(), body)
    }


    /**
     * 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.
     *
     * @param {Map<String,Any>} body
     *
     * POST /data_actions/form -> ByteArray
     */
    fun fetch_remote_data_action_form(
        body: Map<String,Any>
    ) : SDKResponse {
            return this.post<ByteArray>("/data_actions/form", mapOf(), body)
    }

    //endregion DataAction: Run Data Actions

    //region Datagroup: Manage Datagroups


    /**
     * ### Get information about all datagroups.
     *
     * GET /datagroups -> ByteArray
     */
    fun all_datagroups(

    ) : SDKResponse {
            return this.get<ByteArray>("/datagroups", mapOf())
    }


    /**
     * ### Get information about a datagroup.
     *
     * @param {String} datagroup_id ID of datagroup.
     *
     * GET /datagroups/{datagroup_id} -> ByteArray
     */
    fun datagroup(
        datagroup_id: String
    ) : SDKResponse {
        val path_datagroup_id = encodeParam(datagroup_id)
            return this.get<ByteArray>("/datagroups/${path_datagroup_id}", mapOf())
    }


    /**
     * ### Update a datagroup using the specified params.
     *
     * @param {String} datagroup_id ID of datagroup.
     * @param {WriteDatagroup} body
     *
     * PATCH /datagroups/{datagroup_id} -> ByteArray
     */
    fun update_datagroup(
        datagroup_id: String,
        body: WriteDatagroup
    ) : SDKResponse {
        val path_datagroup_id = encodeParam(datagroup_id)
            return this.patch<ByteArray>("/datagroups/${path_datagroup_id}", mapOf(), body)
    }

    //endregion Datagroup: Manage Datagroups

    //region DerivedTable: View Derived Table graphs


    /**
     * ### Discover information about derived tables
     *
     * @param {String} model The name of the Lookml model.
     * @param {String} format The format of the graph. Valid values are [dot]. Default is `dot`
     * @param {String} color Color denoting the build status of the graph. Grey = not built, green = built, yellow = building, red = error.
     *
     * GET /derived_table/graph/model/{model} -> ByteArray
     */
    @JvmOverloads fun graph_derived_tables_for_model(
        model: String,
        format: String? = null,
        color: String? = null
    ) : SDKResponse {
        val path_model = encodeParam(model)
            return this.get<ByteArray>("/derived_table/graph/model/${path_model}", 
                mapOf("format" to format,
                     "color" to color))
    }


    /**
     * ### Get the subgraph representing this derived table and its dependencies.
     *
     * @param {String} view The derived table's view name.
     * @param {String} models The models where this derived table is defined.
     * @param {String} workspace The model directory to look in, either `dev` or `production`.
     *
     * GET /derived_table/graph/view/{view} -> ByteArray
     */
    @JvmOverloads fun graph_derived_tables_for_view(
        view: String,
        models: String? = null,
        workspace: String? = null
    ) : SDKResponse {
        val path_view = encodeParam(view)
            return this.get<ByteArray>("/derived_table/graph/view/${path_view}", 
                mapOf("models" to models,
                     "workspace" to workspace))
    }


    /**
     * Enqueue materialization for a PDT with the given model name and view name
     *
     * @param {String} model_name The model of the PDT to start building.
     * @param {String} view_name The view name of the PDT to start building.
     * @param {String} force_rebuild Force rebuild of required dependent PDTs, even if they are already materialized.
     * @param {String} force_full_incremental Force involved incremental PDTs to fully re-materialize.
     * @param {String} workspace Workspace in which to materialize selected PDT ('dev' or default 'production').
     * @param {String} source The source of this request.
     *
     * GET /derived_table/{model_name}/{view_name}/start -> ByteArray
     */
    @JvmOverloads fun start_pdt_build(
        model_name: String,
        view_name: String,
        force_rebuild: String? = null,
        force_full_incremental: String? = null,
        workspace: String? = null,
        source: String? = null
    ) : SDKResponse {
        val path_model_name = encodeParam(model_name)
        val path_view_name = encodeParam(view_name)
            return this.get<ByteArray>("/derived_table/${path_model_name}/${path_view_name}/start", 
                mapOf("force_rebuild" to force_rebuild,
                     "force_full_incremental" to force_full_incremental,
                     "workspace" to workspace,
                     "source" to source))
    }


    /**
     * Check status of PDT materialization
     *
     * @param {String} materialization_id The materialization id to check status for.
     *
     * GET /derived_table/{materialization_id}/status -> ByteArray
     */
    fun check_pdt_build(
        materialization_id: String
    ) : SDKResponse {
        val path_materialization_id = encodeParam(materialization_id)
            return this.get<ByteArray>("/derived_table/${path_materialization_id}/status", mapOf())
    }


    /**
     * Stop a PDT materialization
     *
     * @param {String} materialization_id The materialization id to stop.
     * @param {String} source The source of this request.
     *
     * GET /derived_table/{materialization_id}/stop -> ByteArray
     */
    @JvmOverloads fun stop_pdt_build(
        materialization_id: String,
        source: String? = null
    ) : SDKResponse {
        val path_materialization_id = encodeParam(materialization_id)
            return this.get<ByteArray>("/derived_table/${path_materialization_id}/stop", 
                mapOf("source" to source))
    }

    //endregion DerivedTable: View Derived Table graphs

    //region Folder: Manage Folders


    /**
     * Search for folders by creator id, parent id, name, etc
     *
     * @param {String} fields Requested fields.
     * @param {Long} page DEPRECATED. Use limit and offset instead. Return only page N of paginated results
     * @param {Long} per_page DEPRECATED. Use limit and offset instead. Return N rows of data per page
     * @param {Long} limit Number of results to return. (used with offset and takes priority over page and per_page)
     * @param {Long} offset Number of results to skip before returning any. (used with limit and takes priority over page and per_page)
     * @param {String} sorts Fields to sort by.
     * @param {String} name Match Space title.
     * @param {String} id Match Space id
     * @param {String} parent_id Filter on a children of a particular folder.
     * @param {String} creator_id Filter on folder created by a particular user.
     * @param {Boolean} filter_or Combine given search criteria in a boolean OR expression
     * @param {Boolean} is_shared_root Match is shared root
     *
     * GET /folders/search -> ByteArray
     */
    @JvmOverloads fun search_folders(
        fields: String? = null,
        page: Long? = null,
        per_page: Long? = null,
        limit: Long? = null,
        offset: Long? = null,
        sorts: String? = null,
        name: String? = null,
        id: String? = null,
        parent_id: String? = null,
        creator_id: String? = null,
        filter_or: Boolean? = null,
        is_shared_root: Boolean? = null
    ) : SDKResponse {
            return this.get<ByteArray>("/folders/search", 
                mapOf("fields" to fields,
                     "page" to page,
                     "per_page" to per_page,
                     "limit" to limit,
                     "offset" to offset,
                     "sorts" to sorts,
                     "name" to name,
                     "id" to id,
                     "parent_id" to parent_id,
                     "creator_id" to creator_id,
                     "filter_or" to filter_or,
                     "is_shared_root" to is_shared_root))
    }


    /**
     * ### Get information about the folder with a specific id.
     *
     * @param {String} folder_id Id of folder
     * @param {String} fields Requested fields.
     *
     * GET /folders/{folder_id} -> ByteArray
     */
    @JvmOverloads fun folder(
        folder_id: String,
        fields: String? = null
    ) : SDKResponse {
        val path_folder_id = encodeParam(folder_id)
            return this.get<ByteArray>("/folders/${path_folder_id}", 
                mapOf("fields" to fields))
    }


    /**
     * ### Update the folder with a specific id.
     *
     * @param {String} folder_id Id of folder
     * @param {UpdateFolder} body
     *
     * PATCH /folders/{folder_id} -> ByteArray
     */
    fun update_folder(
        folder_id: String,
        body: UpdateFolder
    ) : SDKResponse {
        val path_folder_id = encodeParam(folder_id)
            return this.patch<ByteArray>("/folders/${path_folder_id}", mapOf(), body)
    }


    /**
     * ### Delete the folder with a specific id including any children folders.
     * **DANGER** this will delete all looks and dashboards in the folder.
     *
     * @param {String} folder_id Id of folder
     *
     * DELETE /folders/{folder_id} -> ByteArray
     */
    fun delete_folder(
        folder_id: String
    ) : SDKResponse {
        val path_folder_id = encodeParam(folder_id)
            return this.delete<ByteArray>("/folders/${path_folder_id}", mapOf())
    }


    /**
     * ### Get information about all folders.
     *
     * In API 3.x, this will not return empty personal folders, unless they belong to the calling user,
     * or if they contain soft-deleted content.
     *
     * In API 4.0+, all personal folders will be returned.
     *
     * @param {String} fields Requested fields.
     *
     * GET /folders -> ByteArray
     */
    @JvmOverloads fun all_folders(
        fields: String? = null
    ) : SDKResponse {
            return this.get<ByteArray>("/folders", 
                mapOf("fields" to fields))
    }


    /**
     * ### 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.
     *
     * @param {CreateFolder} body
     *
     * POST /folders -> ByteArray
     */
    fun create_folder(
        body: CreateFolder
    ) : SDKResponse {
            return this.post<ByteArray>("/folders", mapOf(), body)
    }


    /**
     * ### Get the children of a folder.
     *
     * @param {String} folder_id Id of folder
     * @param {String} fields Requested fields.
     * @param {Long} page DEPRECATED. Use limit and offset instead. Return only page N of paginated results
     * @param {Long} per_page DEPRECATED. Use limit and offset instead. Return N rows of data per page
     * @param {Long} limit Number of results to return. (used with offset and takes priority over page and per_page)
     * @param {Long} offset Number of results to skip before returning any. (used with limit and takes priority over page and per_page)
     * @param {String} sorts Fields to sort by.
     *
     * GET /folders/{folder_id}/children -> ByteArray
     */
    @JvmOverloads fun folder_children(
        folder_id: String,
        fields: String? = null,
        page: Long? = null,
        per_page: Long? = null,
        limit: Long? = null,
        offset: Long? = null,
        sorts: String? = null
    ) : SDKResponse {
        val path_folder_id = encodeParam(folder_id)
            return this.get<ByteArray>("/folders/${path_folder_id}/children", 
                mapOf("fields" to fields,
                     "page" to page,
                     "per_page" to per_page,
                     "limit" to limit,
                     "offset" to offset,
                     "sorts" to sorts))
    }


    /**
     * ### Search the children of a folder
     *
     * @param {String} folder_id Id of folder
     * @param {String} fields Requested fields.
     * @param {String} sorts Fields to sort by.
     * @param {String} name Match folder name.
     *
     * GET /folders/{folder_id}/children/search -> ByteArray
     */
    @JvmOverloads fun folder_children_search(
        folder_id: String,
        fields: String? = null,
        sorts: String? = null,
        name: String? = null
    ) : SDKResponse {
        val path_folder_id = encodeParam(folder_id)
            return this.get<ByteArray>("/folders/${path_folder_id}/children/search", 
                mapOf("fields" to fields,
                     "sorts" to sorts,
                     "name" to name))
    }


    /**
     * ### Get the parent of a folder
     *
     * @param {String} folder_id Id of folder
     * @param {String} fields Requested fields.
     *
     * GET /folders/{folder_id}/parent -> ByteArray
     */
    @JvmOverloads fun folder_parent(
        folder_id: String,
        fields: String? = null
    ) : SDKResponse {
        val path_folder_id = encodeParam(folder_id)
            return this.get<ByteArray>("/folders/${path_folder_id}/parent", 
                mapOf("fields" to fields))
    }


    /**
     * ### Get the ancestors of a folder
     *
     * @param {String} folder_id Id of folder
     * @param {String} fields Requested fields.
     *
     * GET /folders/{folder_id}/ancestors -> ByteArray
     */
    @JvmOverloads fun folder_ancestors(
        folder_id: String,
        fields: String? = null
    ) : SDKResponse {
        val path_folder_id = encodeParam(folder_id)
            return this.get<ByteArray>("/folders/${path_folder_id}/ancestors", 
                mapOf("fields" to fields))
    }


    /**
     * ### Get all looks in a folder.
     * In API 3.x, this will return all looks in a folder, including looks in the trash.
     * In API 4.0+, all looks in a folder will be returned, excluding looks in the trash.
     *
     * @param {String} folder_id Id of folder
     * @param {String} fields Requested fields.
     *
     * GET /folders/{folder_id}/looks -> ByteArray
     */
    @JvmOverloads fun folder_looks(
        folder_id: String,
        fields: String? = null
    ) : SDKResponse {
        val path_folder_id = encodeParam(folder_id)
            return this.get<ByteArray>("/folders/${path_folder_id}/looks", 
                mapOf("fields" to fields))
    }


    /**
     * ### Get the dashboards in a folder
     *
     * @param {String} folder_id Id of folder
     * @param {String} fields Requested fields.
     *
     * GET /folders/{folder_id}/dashboards -> ByteArray
     */
    @JvmOverloads fun folder_dashboards(
        folder_id: String,
        fields: String? = null
    ) : SDKResponse {
        val path_folder_id = encodeParam(folder_id)
            return this.get<ByteArray>("/folders/${path_folder_id}/dashboards", 
                mapOf("fields" to fields))
    }

    //endregion Folder: Manage Folders

    //region Group: Manage Groups


    /**
     * ### Get information about all groups.
     *
     * @param {String} fields Requested fields.
     * @param {Long} page DEPRECATED. Use limit and offset instead. Return only page N of paginated results
     * @param {Long} per_page DEPRECATED. Use limit and offset instead. Return N rows of data per page
     * @param {Long} limit Number of results to return. (used with offset and takes priority over page and per_page)
     * @param {Long} offset Number of results to skip before returning any. (used with limit and takes priority over page and per_page)
     * @param {String} sorts Fields to sort by.
     * @param {DelimArray<String>} ids Optional of ids to get specific groups.
     * @param {String} content_metadata_id Id of content metadata to which groups must have access.
     * @param {Boolean} can_add_to_content_metadata Select only groups that either can/cannot be given access to content.
     *
     * GET /groups -> ByteArray
     */
    @JvmOverloads fun all_groups(
        fields: String? = null,
        page: Long? = null,
        per_page: Long? = null,
        limit: Long? = null,
        offset: Long? = null,
        sorts: String? = null,
        ids: DelimArray<String>? = null,
        content_metadata_id: String? = null,
        can_add_to_content_metadata: Boolean? = null
    ) : SDKResponse {
            return this.get<ByteArray>("/groups", 
                mapOf("fields" to fields,
                     "page" to page,
                     "per_page" to per_page,
                     "limit" to limit,
                     "offset" to offset,
                     "sorts" to sorts,
                     "ids" to ids,
                     "content_metadata_id" to content_metadata_id,
                     "can_add_to_content_metadata" to can_add_to_content_metadata))
    }


    /**
     * ### Creates a new group (admin only).
     *
     * @param {WriteGroup} body
     * @param {String} fields Requested fields.
     *
     * POST /groups -> ByteArray
     */
    @JvmOverloads fun create_group(
        body: WriteGroup,
        fields: String? = null
    ) : SDKResponse {
            return this.post<ByteArray>("/groups", 
                mapOf("fields" to fields), body)
    }


    /**
     * ### 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.
     *
     * @param {String} fields Requested fields.
     * @param {Long} limit Number of results to return (used with `offset`).
     * @param {Long} offset Number of results to skip before returning any (used with `limit`).
     * @param {String} sorts Fields to sort by.
     * @param {Boolean} filter_or Combine given search criteria in a boolean OR expression
     * @param {String} id Match group id.
     * @param {String} name Match group name.
     * @param {String} external_group_id Match group external_group_id.
     * @param {Boolean} externally_managed Match group externally_managed.
     * @param {Boolean} externally_orphaned Match group externally_orphaned.
     *
     * GET /groups/search -> ByteArray
     */
    @JvmOverloads fun search_groups(
        fields: String? = null,
        limit: Long? = null,
        offset: Long? = null,
        sorts: String? = null,
        filter_or: Boolean? = null,
        id: String? = null,
        name: String? = null,
        external_group_id: String? = null,
        externally_managed: Boolean? = null,
        externally_orphaned: Boolean? = null
    ) : SDKResponse {
            return this.get<ByteArray>("/groups/search", 
                mapOf("fields" to fields,
                     "limit" to limit,
                     "offset" to offset,
                     "sorts" to sorts,
                     "filter_or" to filter_or,
                     "id" to id,
                     "name" to name,
                     "external_group_id" to external_group_id,
                     "externally_managed" to externally_managed,
                     "externally_orphaned" to externally_orphaned))
    }


    /**
     * ### 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.
     *
     * @param {String} fields Requested fields.
     * @param {Long} limit Number of results to return (used with `offset`).
     * @param {Long} offset Number of results to skip before returning any (used with `limit`).
     * @param {String} sorts Fields to sort by.
     * @param {Boolean} filter_or Combine given search criteria in a boolean OR expression
     * @param {String} id Match group id.
     * @param {String} name Match group name.
     * @param {String} external_group_id Match group external_group_id.
     * @param {Boolean} externally_managed Match group externally_managed.
     * @param {Boolean} externally_orphaned Match group externally_orphaned.
     *
     * GET /groups/search/with_roles -> ByteArray
     */
    @JvmOverloads fun search_groups_with_roles(
        fields: String? = null,
        limit: Long? = null,
        offset: Long? = null,
        sorts: String? = null,
        filter_or: Boolean? = null,
        id: String? = null,
        name: String? = null,
        external_group_id: String? = null,
        externally_managed: Boolean? = null,
        externally_orphaned: Boolean? = null
    ) : SDKResponse {
            return this.get<ByteArray>("/groups/search/with_roles", 
                mapOf("fields" to fields,
                     "limit" to limit,
                     "offset" to offset,
                     "sorts" to sorts,
                     "filter_or" to filter_or,
                     "id" to id,
                     "name" to name,
                     "external_group_id" to external_group_id,
                     "externally_managed" to externally_managed,
                     "externally_orphaned" to externally_orphaned))
    }


    /**
     * ### 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.
     *
     * @param {String} fields Requested fields.
     * @param {Long} limit Number of results to return (used with `offset`).
     * @param {Long} offset Number of results to skip before returning any (used with `limit`).
     * @param {String} sorts Fields to sort by.
     * @param {Boolean} filter_or Combine given search criteria in a boolean OR expression
     * @param {String} id Match group id.
     * @param {String} name Match group name.
     * @param {String} external_group_id Match group external_group_id.
     * @param {Boolean} externally_managed Match group externally_managed.
     * @param {Boolean} externally_orphaned Match group externally_orphaned.
     *
     * GET /groups/search/with_hierarchy -> ByteArray
     */
    @JvmOverloads fun search_groups_with_hierarchy(
        fields: String? = null,
        limit: Long? = null,
        offset: Long? = null,
        sorts: String? = null,
        filter_or: Boolean? = null,
        id: String? = null,
        name: String? = null,
        external_group_id: String? = null,
        externally_managed: Boolean? = null,
        externally_orphaned: Boolean? = null
    ) : SDKResponse {
            return this.get<ByteArray>("/groups/search/with_hierarchy", 
                mapOf("fields" to fields,
                     "limit" to limit,
                     "offset" to offset,
                     "sorts" to sorts,
                     "filter_or" to filter_or,
                     "id" to id,
                     "name" to name,
                     "external_group_id" to external_group_id,
                     "externally_managed" to externally_managed,
                     "externally_orphaned" to externally_orphaned))
    }


    /**
     * ### Get information about a group.
     *
     * @param {String} group_id Id of group
     * @param {String} fields Requested fields.
     *
     * GET /groups/{group_id} -> ByteArray
     */
    @JvmOverloads fun group(
        group_id: String,
        fields: String? = null
    ) : SDKResponse {
        val path_group_id = encodeParam(group_id)
            return this.get<ByteArray>("/groups/${path_group_id}", 
                mapOf("fields" to fields))
    }


    /**
     * ### Updates the a group (admin only).
     *
     * @param {String} group_id Id of group
     * @param {WriteGroup} body
     * @param {String} fields Requested fields.
     *
     * PATCH /groups/{group_id} -> ByteArray
     */
    @JvmOverloads fun update_group(
        group_id: String,
        body: WriteGroup,
        fields: String? = null
    ) : SDKResponse {
        val path_group_id = encodeParam(group_id)
            return this.patch<ByteArray>("/groups/${path_group_id}", 
                mapOf("fields" to fields), body)
    }


    /**
     * ### Deletes a group (admin only).
     *
     * @param {String} group_id Id of group
     *
     * DELETE /groups/{group_id} -> ByteArray
     */
    fun delete_group(
        group_id: String
    ) : SDKResponse {
        val path_group_id = encodeParam(group_id)
            return this.delete<ByteArray>("/groups/${path_group_id}", mapOf())
    }


    /**
     * ### Get information about all the groups in a group
     *
     * @param {String} group_id Id of group
     * @param {String} fields Requested fields.
     *
     * GET /groups/{group_id}/groups -> ByteArray
     */
    @JvmOverloads fun all_group_groups(
        group_id: String,
        fields: String? = null
    ) : SDKResponse {
        val path_group_id = encodeParam(group_id)
            return this.get<ByteArray>("/groups/${path_group_id}/groups", 
                mapOf("fields" to fields))
    }


    /**
     * ### Adds a new group to a group.
     *
     * @param {String} group_id Id of group
     * @param {GroupIdForGroupInclusion} body WARNING: no writeable properties found for POST, PUT, or PATCH
     *
     * POST /groups/{group_id}/groups -> ByteArray
     */
    fun add_group_group(
        group_id: String,
        body: GroupIdForGroupInclusion
    ) : SDKResponse {
        val path_group_id = encodeParam(group_id)
            return this.post<ByteArray>("/groups/${path_group_id}/groups", mapOf(), body)
    }


    /**
     * ### Get information about all the users directly included in a group.
     *
     * @param {String} group_id Id of group
     * @param {String} fields Requested fields.
     * @param {Long} page DEPRECATED. Use limit and offset instead. Return only page N of paginated results
     * @param {Long} per_page DEPRECATED. Use limit and offset instead. Return N rows of data per page
     * @param {Long} limit Number of results to return. (used with offset and takes priority over page and per_page)
     * @param {Long} offset Number of results to skip before returning any. (used with limit and takes priority over page and per_page)
     * @param {String} sorts Fields to sort by.
     *
     * GET /groups/{group_id}/users -> ByteArray
     */
    @JvmOverloads fun all_group_users(
        group_id: String,
        fields: String? = null,
        page: Long? = null,
        per_page: Long? = null,
        limit: Long? = null,
        offset: Long? = null,
        sorts: String? = null
    ) : SDKResponse {
        val path_group_id = encodeParam(group_id)
            return this.get<ByteArray>("/groups/${path_group_id}/users", 
                mapOf("fields" to fields,
                     "page" to page,
                     "per_page" to per_page,
                     "limit" to limit,
                     "offset" to offset,
                     "sorts" to sorts))
    }


    /**
     * ### Adds a new user to a group.
     *
     * @param {String} group_id Id of group
     * @param {GroupIdForGroupUserInclusion} body WARNING: no writeable properties found for POST, PUT, or PATCH
     *
     * POST /groups/{group_id}/users -> ByteArray
     */
    fun add_group_user(
        group_id: String,
        body: GroupIdForGroupUserInclusion
    ) : SDKResponse {
        val path_group_id = encodeParam(group_id)
            return this.post<ByteArray>("/groups/${path_group_id}/users", mapOf(), body)
    }


    /**
     * ### Removes a user from a group.
     *
     * @param {String} group_id Id of group
     * @param {String} user_id Id of user to remove from group
     *
     * DELETE /groups/{group_id}/users/{user_id} -> ByteArray
     */
    fun delete_group_user(
        group_id: String,
        user_id: String
    ) : SDKResponse {
        val path_group_id = encodeParam(group_id)
        val path_user_id = encodeParam(user_id)
            return this.delete<ByteArray>("/groups/${path_group_id}/users/${path_user_id}", mapOf())
    }


    /**
     * ### Removes a group from a group.
     *
     * @param {String} group_id Id of group
     * @param {String} deleting_group_id Id of group to delete
     *
     * DELETE /groups/{group_id}/groups/{deleting_group_id} -> ByteArray
     */
    fun delete_group_from_group(
        group_id: String,
        deleting_group_id: String
    ) : SDKResponse {
        val path_group_id = encodeParam(group_id)
        val path_deleting_group_id = encodeParam(deleting_group_id)
            return this.delete<ByteArray>("/groups/${path_group_id}/groups/${path_deleting_group_id}", mapOf())
    }


    /**
     * ### 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).
     *
     * @param {String} group_id Id of group
     * @param {String} user_attribute_id Id of user attribute
     * @param {UserAttributeGroupValue} body WARNING: no writeable properties found for POST, PUT, or PATCH
     *
     * PATCH /groups/{group_id}/attribute_values/{user_attribute_id} -> ByteArray
     */
    fun update_user_attribute_group_value(
        group_id: String,
        user_attribute_id: String,
        body: UserAttributeGroupValue
    ) : SDKResponse {
        val path_group_id = encodeParam(group_id)
        val path_user_attribute_id = encodeParam(user_attribute_id)
            return this.patch<ByteArray>("/groups/${path_group_id}/attribute_values/${path_user_attribute_id}", mapOf(), body)
    }


    /**
     * ### Remove a user attribute value from a group.
     *
     * @param {String} group_id Id of group
     * @param {String} user_attribute_id Id of user attribute
     *
     * DELETE /groups/{group_id}/attribute_values/{user_attribute_id} -> ByteArray
     */
    fun delete_user_attribute_group_value(
        group_id: String,
        user_attribute_id: String
    ) : SDKResponse {
        val path_group_id = encodeParam(group_id)
        val path_user_attribute_id = encodeParam(user_attribute_id)
            return this.delete<ByteArray>("/groups/${path_group_id}/attribute_values/${path_user_attribute_id}", mapOf())
    }

    //endregion Group: Manage Groups

    //region Homepage: Manage Homepage


    /**
     * ### Get information about the primary homepage's sections.
     *
     * @param {String} fields Requested fields.
     *
     * GET /primary_homepage_sections -> ByteArray
     */
    @JvmOverloads fun all_primary_homepage_sections(
        fields: String? = null
    ) : SDKResponse {
            return this.get<ByteArray>("/primary_homepage_sections", 
                mapOf("fields" to fields))
    }

    //endregion Homepage: Manage Homepage

    //region Integration: Manage Integrations


    /**
     * ### Get information about all Integration Hubs.
     *
     * @param {String} fields Requested fields.
     *
     * GET /integration_hubs -> ByteArray
     */
    @JvmOverloads fun all_integration_hubs(
        fields: String? = null
    ) : SDKResponse {
            return this.get<ByteArray>("/integration_hubs", 
                mapOf("fields" to fields))
    }


    /**
     * ### Create a new Integration Hub.
     *
     * This API is rate limited to prevent it from being used for SSRF attacks
     *
     * @param {WriteIntegrationHub} body
     * @param {String} fields Requested fields.
     *
     * POST /integration_hubs -> ByteArray
     */
    @JvmOverloads fun create_integration_hub(
        body: WriteIntegrationHub,
        fields: String? = null
    ) : SDKResponse {
            return this.post<ByteArray>("/integration_hubs", 
                mapOf("fields" to fields), body)
    }


    /**
     * ### Get information about a Integration Hub.
     *
     * @param {String} integration_hub_id Id of integration_hub
     * @param {String} fields Requested fields.
     *
     * GET /integration_hubs/{integration_hub_id} -> ByteArray
     */
    @JvmOverloads fun integration_hub(
        integration_hub_id: String,
        fields: String? = null
    ) : SDKResponse {
        val path_integration_hub_id = encodeParam(integration_hub_id)
            return this.get<ByteArray>("/integration_hubs/${path_integration_hub_id}", 
                mapOf("fields" to fields))
    }


    /**
     * ### Update a Integration Hub definition.
     *
     * This API is rate limited to prevent it from being used for SSRF attacks
     *
     * @param {String} integration_hub_id Id of integration_hub
     * @param {WriteIntegrationHub} body
     * @param {String} fields Requested fields.
     *
     * PATCH /integration_hubs/{integration_hub_id} -> ByteArray
     */
    @JvmOverloads fun update_integration_hub(
        integration_hub_id: String,
        body: WriteIntegrationHub,
        fields: String? = null
    ) : SDKResponse {
        val path_integration_hub_id = encodeParam(integration_hub_id)
            return this.patch<ByteArray>("/integration_hubs/${path_integration_hub_id}", 
                mapOf("fields" to fields), body)
    }


    /**
     * ### Delete a Integration Hub.
     *
     * @param {String} integration_hub_id Id of integration_hub
     *
     * DELETE /integration_hubs/{integration_hub_id} -> ByteArray
     */
    fun delete_integration_hub(
        integration_hub_id: String
    ) : SDKResponse {
        val path_integration_hub_id = encodeParam(integration_hub_id)
            return this.delete<ByteArray>("/integration_hubs/${path_integration_hub_id}", mapOf())
    }


    /**
     * 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.
     *
     * @param {String} integration_hub_id Id of integration_hub
     *
     * POST /integration_hubs/{integration_hub_id}/accept_legal_agreement -> ByteArray
     */
    fun accept_integration_hub_legal_agreement(
        integration_hub_id: String
    ) : SDKResponse {
        val path_integration_hub_id = encodeParam(integration_hub_id)
            return this.post<ByteArray>("/integration_hubs/${path_integration_hub_id}/accept_legal_agreement", mapOf())
    }


    /**
     * ### Get information about all Integrations.
     *
     * @param {String} fields Requested fields.
     * @param {String} integration_hub_id Filter to a specific provider
     *
     * GET /integrations -> ByteArray
     */
    @JvmOverloads fun all_integrations(
        fields: String? = null,
        integration_hub_id: String? = null
    ) : SDKResponse {
            return this.get<ByteArray>("/integrations", 
                mapOf("fields" to fields,
                     "integration_hub_id" to integration_hub_id))
    }


    /**
     * ### Get information about a Integration.
     *
     * @param {String} integration_id Id of integration
     * @param {String} fields Requested fields.
     *
     * GET /integrations/{integration_id} -> ByteArray
     */
    @JvmOverloads fun integration(
        integration_id: String,
        fields: String? = null
    ) : SDKResponse {
        val path_integration_id = encodeParam(integration_id)
            return this.get<ByteArray>("/integrations/${path_integration_id}", 
                mapOf("fields" to fields))
    }


    /**
     * ### Update parameters on a Integration.
     *
     * @param {String} integration_id Id of integration
     * @param {WriteIntegration} body
     * @param {String} fields Requested fields.
     *
     * PATCH /integrations/{integration_id} -> ByteArray
     */
    @JvmOverloads fun update_integration(
        integration_id: String,
        body: WriteIntegration,
        fields: String? = null
    ) : SDKResponse {
        val path_integration_id = encodeParam(integration_id)
            return this.patch<ByteArray>("/integrations/${path_integration_id}", 
                mapOf("fields" to fields), body)
    }


    /**
     * Returns the Integration form for presentation to the user.
     *
     * @param {String} integration_id Id of integration
     * @param {Map<String,Any>} body
     *
     * POST /integrations/{integration_id}/form -> ByteArray
     */
    @JvmOverloads fun fetch_integration_form(
        integration_id: String,
        body: Map<String,Any>? = null
    ) : SDKResponse {
        val path_integration_id = encodeParam(integration_id)
            return this.post<ByteArray>("/integrations/${path_integration_id}/form", mapOf(), body)
    }


    /**
     * Tests the integration to make sure all the settings are working.
     *
     * @param {String} integration_id Id of integration
     *
     * POST /integrations/{integration_id}/test -> ByteArray
     */
    fun test_integration(
        integration_id: String
    ) : SDKResponse {
        val path_integration_id = encodeParam(integration_id)
            return this.post<ByteArray>("/integrations/${path_integration_id}/test", mapOf())
    }

    //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)
     *
     * @param {String} fields Requested fields.
     *
     * GET /looks -> ByteArray
     */
    @JvmOverloads fun all_looks(
        fields: String? = null
    ) : SDKResponse {
            return this.get<ByteArray>("/looks", 
                mapOf("fields" to fields))
    }


    /**
     * ### 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()`.
     *
     * @param {WriteLookWithQuery} body
     * @param {String} fields Requested fields.
     *
     * POST /looks -> ByteArray
     */
    @JvmOverloads fun create_look(
        body: WriteLookWithQuery,
        fields: String? = null
    ) : SDKResponse {
            return this.post<ByteArray>("/looks", 
                mapOf("fields" to fields), body)
    }


    /**
     * ### 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)
     *
     * @param {String} id Match look id.
     * @param {String} title Match Look title.
     * @param {String} description Match Look description.
     * @param {String} content_favorite_id Select looks with a particular content favorite id
     * @param {String} folder_id Select looks in a particular folder.
     * @param {String} user_id Select looks created by a particular user.
     * @param {String} view_count Select looks with particular view_count value
     * @param {Boolean} deleted Select soft-deleted looks
     * @param {String} query_id Select looks that reference a particular query by query_id
     * @param {Boolean} curate Exclude items that exist only in personal spaces other than the users
     * @param {String} last_viewed_at Select looks based on when they were last viewed
     * @param {String} fields Requested fields.
     * @param {Long} page DEPRECATED. Use limit and offset instead. Return only page N of paginated results
     * @param {Long} per_page DEPRECATED. Use limit and offset instead. Return N rows of data per page
     * @param {Long} limit Number of results to return. (used with offset and takes priority over page and per_page)
     * @param {Long} offset Number of results to skip before returning any. (used with limit and takes priority over page and per_page)
     * @param {String} sorts One or more fields to sort results by. Sortable fields: [:title, :user_id, :id, :created_at, :space_id, :folder_id, :description, :updated_at, :last_updater_id, :view_count, :favorite_count, :content_favorite_id, :deleted, :deleted_at, :last_viewed_at, :last_accessed_at, :query_id]
     * @param {Boolean} filter_or Combine given search criteria in a boolean OR expression
     *
     * GET /looks/search -> ByteArray
     */
    @JvmOverloads fun search_looks(
        id: String? = null,
        title: String? = null,
        description: String? = null,
        content_favorite_id: String? = null,
        folder_id: String? = null,
        user_id: String? = null,
        view_count: String? = null,
        deleted: Boolean? = null,
        query_id: String? = null,
        curate: Boolean? = null,
        last_viewed_at: String? = null,
        fields: String? = null,
        page: Long? = null,
        per_page: Long? = null,
        limit: Long? = null,
        offset: Long? = null,
        sorts: String? = null,
        filter_or: Boolean? = null
    ) : SDKResponse {
            return this.get<ByteArray>("/looks/search", 
                mapOf("id" to id,
                     "title" to title,
                     "description" to description,
                     "content_favorite_id" to content_favorite_id,
                     "folder_id" to folder_id,
                     "user_id" to user_id,
                     "view_count" to view_count,
                     "deleted" to deleted,
                     "query_id" to query_id,
                     "curate" to curate,
                     "last_viewed_at" to last_viewed_at,
                     "fields" to fields,
                     "page" to page,
                     "per_page" to per_page,
                     "limit" to limit,
                     "offset" to offset,
                     "sorts" to sorts,
                     "filter_or" to filter_or))
    }


    /**
     * ### Get a Look.
     *
     * Returns detailed information about a Look and its associated Query.
     *
     * @param {String} look_id Id of look
     * @param {String} fields Requested fields.
     *
     * GET /looks/{look_id} -> ByteArray
     */
    @JvmOverloads fun look(
        look_id: String,
        fields: String? = null
    ) : SDKResponse {
        val path_look_id = encodeParam(look_id)
            return this.get<ByteArray>("/looks/${path_look_id}", 
                mapOf("fields" to fields))
    }


    /**
     * ### 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.
     * In API 3.1 and later, you can pass `deleted: true` as a parameter to [search_looks()](#!/3.1/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()`.
     *
     * @param {String} look_id Id of look
     * @param {WriteLookWithQuery} body
     * @param {String} fields Requested fields.
     *
     * PATCH /looks/{look_id} -> ByteArray
     */
    @JvmOverloads fun update_look(
        look_id: String,
        body: WriteLookWithQuery,
        fields: String? = null
    ) : SDKResponse {
        val path_look_id = encodeParam(look_id)
            return this.patch<ByteArray>("/looks/${path_look_id}", 
                mapOf("fields" to fields), body)
    }


    /**
     * ### 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).
     *
     * @param {String} look_id Id of look
     *
     * DELETE /looks/{look_id} -> ByteArray
     */
    fun delete_look(
        look_id: String
    ) : SDKResponse {
        val path_look_id = encodeParam(look_id)
            return this.delete<ByteArray>("/looks/${path_look_id}", mapOf())
    }


    /**
     * ### 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_detail | 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
     *
     * @param {String} look_id Id of look
     * @param {String} result_format Format of result
     * @param {Long} limit Row limit (may override the limit in the saved query).
     * @param {Boolean} apply_formatting Apply model-specified formatting to each result.
     * @param {Boolean} apply_vis Apply visualization options to results.
     * @param {Boolean} cache Get results from cache if available.
     * @param {Long} image_width Render width for image formats.
     * @param {Long} image_height Render height for image formats.
     * @param {Boolean} generate_drill_links Generate drill links (only applicable to 'json_detail' format.
     * @param {Boolean} force_production Force use of production models even if the user is in development mode. Note that this flag being false does not guarantee development models will be used.
     * @param {Boolean} cache_only Retrieve any results from cache even if the results have expired.
     * @param {String} path_prefix Prefix to use for drill links (url encoded).
     * @param {Boolean} rebuild_pdts Rebuild PDTS used in query.
     * @param {Boolean} server_table_calcs Perform table calculations on query results
     *
     * GET /looks/{look_id}/run/{result_format} -> ByteArray
     *
     * **Note**: Binary content may be returned by this method.
     */
    @JvmOverloads fun run_look(
        look_id: String,
        result_format: String,
        limit: Long? = null,
        apply_formatting: Boolean? = null,
        apply_vis: Boolean? = null,
        cache: Boolean? = null,
        image_width: Long? = null,
        image_height: Long? = null,
        generate_drill_links: Boolean? = null,
        force_production: Boolean? = null,
        cache_only: Boolean? = null,
        path_prefix: String? = null,
        rebuild_pdts: Boolean? = null,
        server_table_calcs: Boolean? = null
    ) : SDKResponse {
        val path_look_id = encodeParam(look_id)
        val path_result_format = encodeParam(result_format)
            return this.get<ByteArray>("/looks/${path_look_id}/run/${path_result_format}", 
                mapOf("limit" to limit,
                     "apply_formatting" to apply_formatting,
                     "apply_vis" to apply_vis,
                     "cache" to cache,
                     "image_width" to image_width,
                     "image_height" to image_height,
                     "generate_drill_links" to generate_drill_links,
                     "force_production" to force_production,
                     "cache_only" to cache_only,
                     "path_prefix" to path_prefix,
                     "rebuild_pdts" to rebuild_pdts,
                     "server_table_calcs" to server_table_calcs))
    }


    /**
     * ### 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.
     *
     * @param {String} look_id Look id to copy.
     * @param {String} folder_id Folder id to copy to.
     *
     * POST /looks/{look_id}/copy -> ByteArray
     */
    @JvmOverloads fun copy_look(
        look_id: String,
        folder_id: String? = null
    ) : SDKResponse {
        val path_look_id = encodeParam(look_id)
            return this.post<ByteArray>("/looks/${path_look_id}/copy", 
                mapOf("folder_id" to folder_id))
    }


    /**
     * ### 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.
     *
     * @param {String} look_id Look id to move.
     * @param {String} folder_id Folder id to move to.
     *
     * PATCH /looks/{look_id}/move -> ByteArray
     */
    fun move_look(
        look_id: String,
        folder_id: String
    ) : SDKResponse {
        val path_look_id = encodeParam(look_id)
            return this.patch<ByteArray>("/looks/${path_look_id}/move", 
                mapOf("folder_id" to folder_id))
    }

    //endregion Look: Run and Manage Looks

    //region LookmlModel: Manage LookML Models


    /**
     * ### Get information about all lookml models.
     *
     * @param {String} fields Requested fields.
     * @param {Long} limit Number of results to return. (can be used with offset)
     * @param {Long} offset Number of results to skip before returning any. (Defaults to 0 if not set when limit is used)
     *
     * GET /lookml_models -> ByteArray
     */
    @JvmOverloads fun all_lookml_models(
        fields: String? = null,
        limit: Long? = null,
        offset: Long? = null
    ) : SDKResponse {
            return this.get<ByteArray>("/lookml_models", 
                mapOf("fields" to fields,
                     "limit" to limit,
                     "offset" to offset))
    }


    /**
     * ### Create a lookml model using the specified configuration.
     *
     * @param {WriteLookmlModel} body
     *
     * POST /lookml_models -> ByteArray
     */
    fun create_lookml_model(
        body: WriteLookmlModel
    ) : SDKResponse {
            return this.post<ByteArray>("/lookml_models", mapOf(), body)
    }


    /**
     * ### Get information about a lookml model.
     *
     * @param {String} lookml_model_name Name of lookml model.
     * @param {String} fields Requested fields.
     *
     * GET /lookml_models/{lookml_model_name} -> ByteArray
     */
    @JvmOverloads fun lookml_model(
        lookml_model_name: String,
        fields: String? = null
    ) : SDKResponse {
        val path_lookml_model_name = encodeParam(lookml_model_name)
            return this.get<ByteArray>("/lookml_models/${path_lookml_model_name}", 
                mapOf("fields" to fields))
    }


    /**
     * ### Update a lookml model using the specified configuration.
     *
     * @param {String} lookml_model_name Name of lookml model.
     * @param {WriteLookmlModel} body
     *
     * PATCH /lookml_models/{lookml_model_name} -> ByteArray
     */
    fun update_lookml_model(
        lookml_model_name: String,
        body: WriteLookmlModel
    ) : SDKResponse {
        val path_lookml_model_name = encodeParam(lookml_model_name)
            return this.patch<ByteArray>("/lookml_models/${path_lookml_model_name}", mapOf(), body)
    }


    /**
     * ### Delete a lookml model.
     *
     * @param {String} lookml_model_name Name of lookml model.
     *
     * DELETE /lookml_models/{lookml_model_name} -> ByteArray
     */
    fun delete_lookml_model(
        lookml_model_name: String
    ) : SDKResponse {
        val path_lookml_model_name = encodeParam(lookml_model_name)
            return this.delete<ByteArray>("/lookml_models/${path_lookml_model_name}", mapOf())
    }


    /**
     * ### Get information about a lookml model explore.
     *
     * @param {String} lookml_model_name Name of lookml model.
     * @param {String} explore_name Name of explore.
     * @param {String} fields Requested fields.
     *
     * GET /lookml_models/{lookml_model_name}/explores/{explore_name} -> ByteArray
     */
    @JvmOverloads fun lookml_model_explore(
        lookml_model_name: String,
        explore_name: String,
        fields: String? = null
    ) : SDKResponse {
        val path_lookml_model_name = encodeParam(lookml_model_name)
        val path_explore_name = encodeParam(explore_name)
            return this.get<ByteArray>("/lookml_models/${path_lookml_model_name}/explores/${path_explore_name}", 
                mapOf("fields" to fields))
    }

    //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'}
     * ```
     *
     * @param {String} model_name Name of model
     * @param {String} view_name Name of view
     * @param {String} field_name Name of field to use for suggestions
     * @param {String} term Search term pattern (evaluated as as `%term%`)
     * @param {Any} filters Suggestion filters with field name keys and comparison expressions
     *
     * GET /models/{model_name}/views/{view_name}/fields/{field_name}/suggestions -> ByteArray
     */
    @JvmOverloads fun model_fieldname_suggestions(
        model_name: String,
        view_name: String,
        field_name: String,
        term: String? = null,
        filters: Any? = null
    ) : SDKResponse {
        val path_model_name = encodeParam(model_name)
        val path_view_name = encodeParam(view_name)
        val path_field_name = encodeParam(field_name)
            return this.get<ByteArray>("/models/${path_model_name}/views/${path_view_name}/fields/${path_field_name}/suggestions", 
                mapOf("term" to term,
                     "filters" to filters))
    }


    /**
     * ### Get a single model
     *
     * @param {String} model_name Name of model
     *
     * GET /models/{model_name} -> ByteArray
     */
    fun get_model(
        model_name: String
    ) : SDKResponse {
        val path_model_name = encodeParam(model_name)
            return this.get<ByteArray>("/models/${path_model_name}", mapOf())
    }


    /**
     * ### 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.
     *
     * @param {String} connection_name Name of connection
     *
     * GET /connections/{connection_name}/databases -> ByteArray
     */
    fun connection_databases(
        connection_name: String
    ) : SDKResponse {
        val path_connection_name = encodeParam(connection_name)
            return this.get<ByteArray>("/connections/${path_connection_name}/databases", mapOf())
    }


    /**
     * ### Retrieve metadata features for this connection
     *
     * Returns a list of feature names with `true` (available) or `false` (not available)
     *
     * @param {String} connection_name Name of connection
     * @param {String} fields Requested fields.
     *
     * GET /connections/{connection_name}/features -> ByteArray
     */
    @JvmOverloads fun connection_features(
        connection_name: String,
        fields: String? = null
    ) : SDKResponse {
        val path_connection_name = encodeParam(connection_name)
            return this.get<ByteArray>("/connections/${path_connection_name}/features", 
                mapOf("fields" to fields))
    }


    /**
     * ### Get the list of schemas and tables for a connection
     *
     * @param {String} connection_name Name of connection
     * @param {String} database For dialects that support multiple databases, optionally identify which to use
     * @param {Boolean} cache True to use fetch from cache, false to load fresh
     * @param {String} fields Requested fields.
     *
     * GET /connections/{connection_name}/schemas -> ByteArray
     */
    @JvmOverloads fun connection_schemas(
        connection_name: String,
        database: String? = null,
        cache: Boolean? = null,
        fields: String? = null
    ) : SDKResponse {
        val path_connection_name = encodeParam(connection_name)
            return this.get<ByteArray>("/connections/${path_connection_name}/schemas", 
                mapOf("database" to database,
                     "cache" to cache,
                     "fields" to fields))
    }


    /**
     * ### 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
     *
     * @param {String} connection_name Name of connection
     * @param {String} database Optional. Name of database to use for the query, only if applicable
     * @param {String} schema_name Optional. Return only tables for this schema
     * @param {Boolean} cache True to fetch from cache, false to load fresh
     * @param {String} fields Requested fields.
     * @param {String} table_filter Optional. Return tables with names that contain this value
     * @param {Long} table_limit Optional. Return tables up to the table_limit
     *
     * GET /connections/{connection_name}/tables -> ByteArray
     */
    @JvmOverloads fun connection_tables(
        connection_name: String,
        database: String? = null,
        schema_name: String? = null,
        cache: Boolean? = null,
        fields: String? = null,
        table_filter: String? = null,
        table_limit: Long? = null
    ) : SDKResponse {
        val path_connection_name = encodeParam(connection_name)
            return this.get<ByteArray>("/connections/${path_connection_name}/tables", 
                mapOf("database" to database,
                     "schema_name" to schema_name,
                     "cache" to cache,
                     "fields" to fields,
                     "table_filter" to table_filter,
                     "table_limit" to table_limit))
    }


    /**
     * ### Get the columns (and therefore also the tables) in a specific schema
     *
     * @param {String} connection_name Name of connection
     * @param {String} database For dialects that support multiple databases, optionally identify which to use
     * @param {String} schema_name Name of schema to use.
     * @param {Boolean} cache True to fetch from cache, false to load fresh
     * @param {Long} table_limit limits the tables per schema returned
     * @param {String} table_names only fetch columns for a given (comma-separated) list of tables
     * @param {String} fields Requested fields.
     *
     * GET /connections/{connection_name}/columns -> ByteArray
     */
    @JvmOverloads fun connection_columns(
        connection_name: String,
        database: String? = null,
        schema_name: String? = null,
        cache: Boolean? = null,
        table_limit: Long? = null,
        table_names: String? = null,
        fields: String? = null
    ) : SDKResponse {
        val path_connection_name = encodeParam(connection_name)
            return this.get<ByteArray>("/connections/${path_connection_name}/columns", 
                mapOf("database" to database,
                     "schema_name" to schema_name,
                     "cache" to cache,
                     "table_limit" to table_limit,
                     "table_names" to table_names,
                     "fields" to fields))
    }


    /**
     * ### Search a connection for columns matching the specified name
     *
     * **Note**: `column_name` must be a valid column name. It is not a search pattern.
     *
     * @param {String} connection_name Name of connection
     * @param {String} column_name Column name to find
     * @param {String} fields Requested fields.
     *
     * GET /connections/{connection_name}/search_columns -> ByteArray
     */
    @JvmOverloads fun connection_search_columns(
        connection_name: String,
        column_name: String? = null,
        fields: String? = null
    ) : SDKResponse {
        val path_connection_name = encodeParam(connection_name)
            return this.get<ByteArray>("/connections/${path_connection_name}/search_columns", 
                mapOf("column_name" to column_name,
                     "fields" to fields))
    }


    /**
     * ### 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
     *
     * @param {String} connection_name Name of connection
     * @param {CreateCostEstimate} body WARNING: no writeable properties found for POST, PUT, or PATCH
     * @param {String} fields Requested fields.
     *
     * POST /connections/{connection_name}/cost_estimate -> ByteArray
     */
    @JvmOverloads fun connection_cost_estimate(
        connection_name: String,
        body: CreateCostEstimate,
        fields: String? = null
    ) : SDKResponse {
        val path_connection_name = encodeParam(connection_name)
            return this.post<ByteArray>("/connections/${path_connection_name}/cost_estimate", 
                mapOf("fields" to fields), body)
    }

    //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.
     *
     * @param {String} project_id Id of project
     * @param {String} fields Requested fields
     *
     * POST /projects/{project_id}/manifest/lock_all -> ByteArray
     */
    @JvmOverloads fun lock_all(
        project_id: String,
        fields: String? = null
    ) : SDKResponse {
        val path_project_id = encodeParam(project_id)
            return this.post<ByteArray>("/projects/${path_project_id}/manifest/lock_all", 
                mapOf("fields" to fields))
    }


    /**
     * ### Get All Git Branches
     *
     * Returns a list of git branches in the project repository
     *
     * @param {String} project_id Project Id
     *
     * GET /projects/{project_id}/git_branches -> ByteArray
     */
    fun all_git_branches(
        project_id: String
    ) : SDKResponse {
        val path_project_id = encodeParam(project_id)
            return this.get<ByteArray>("/projects/${path_project_id}/git_branches", mapOf())
    }


    /**
     * ### Get the Current Git Branch
     *
     * Returns the git branch currently checked out in the given project repository
     *
     * @param {String} project_id Project Id
     *
     * GET /projects/{project_id}/git_branch -> ByteArray
     */
    fun git_branch(
        project_id: String
    ) : SDKResponse {
        val path_project_id = encodeParam(project_id)
            return this.get<ByteArray>("/projects/${path_project_id}/git_branch", mapOf())
    }


    /**
     * ### 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.
     *
     * @param {String} project_id Project Id
     * @param {WriteGitBranch} body
     *
     * PUT /projects/{project_id}/git_branch -> ByteArray
     */
    fun update_git_branch(
        project_id: String,
        body: WriteGitBranch
    ) : SDKResponse {
        val path_project_id = encodeParam(project_id)
            return this.put<ByteArray>("/projects/${path_project_id}/git_branch", mapOf(), body)
    }


    /**
     * ### 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.
     *
     * @param {String} project_id Project Id
     * @param {WriteGitBranch} body
     *
     * POST /projects/{project_id}/git_branch -> ByteArray
     */
    fun create_git_branch(
        project_id: String,
        body: WriteGitBranch
    ) : SDKResponse {
        val path_project_id = encodeParam(project_id)
            return this.post<ByteArray>("/projects/${path_project_id}/git_branch", mapOf(), body)
    }


    /**
     * ### Get the specified Git Branch
     *
     * Returns the git branch specified in branch_name path param if it exists in the given project repository
     *
     * @param {String} project_id Project Id
     * @param {String} branch_name Branch Name
     *
     * GET /projects/{project_id}/git_branch/{branch_name} -> ByteArray
     */
    fun find_git_branch(
        project_id: String,
        branch_name: String
    ) : SDKResponse {
        val path_project_id = encodeParam(project_id)
        val path_branch_name = encodeParam(branch_name)
            return this.get<ByteArray>("/projects/${path_project_id}/git_branch/${path_branch_name}", mapOf())
    }


    /**
     * ### Delete the specified Git Branch
     *
     * Delete git branch specified in branch_name path param from local and remote of specified project repository
     *
     * @param {String} project_id Project Id
     * @param {String} branch_name Branch Name
     *
     * DELETE /projects/{project_id}/git_branch/{branch_name} -> ByteArray
     */
    fun delete_git_branch(
        project_id: String,
        branch_name: String
    ) : SDKResponse {
        val path_project_id = encodeParam(project_id)
        val path_branch_name = encodeParam(branch_name)
            return this.delete<ByteArray>("/projects/${path_project_id}/git_branch/${path_branch_name}", mapOf())
    }


    /**
     * ### 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.
     *
     * @param {String} project_id Id of project
     * @param {String} branch Branch to deploy to production
     * @param {String} ref Ref to deploy to production
     *
     * POST /projects/{project_id}/deploy_ref_to_production -> ByteArray
     */
    @JvmOverloads fun deploy_ref_to_production(
        project_id: String,
        branch: String? = null,
        ref: String? = null
    ) : SDKResponse {
        val path_project_id = encodeParam(project_id)
            return this.post<ByteArray>("/projects/${path_project_id}/deploy_ref_to_production", 
                mapOf("branch" to branch,
                     "ref" to ref))
    }


    /**
     * ### 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.
     *
     * @param {String} project_id Id of project
     *
     * POST /projects/{project_id}/deploy_to_production -> ByteArray
     */
    fun deploy_to_production(
        project_id: String
    ) : SDKResponse {
        val path_project_id = encodeParam(project_id)
            return this.post<ByteArray>("/projects/${path_project_id}/deploy_to_production", mapOf())
    }


    /**
     * ### 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.
     *
     * @param {String} project_id Id of project
     *
     * POST /projects/{project_id}/reset_to_production -> ByteArray
     */
    fun reset_project_to_production(
        project_id: String
    ) : SDKResponse {
        val path_project_id = encodeParam(project_id)
            return this.post<ByteArray>("/projects/${path_project_id}/reset_to_production", mapOf())
    }


    /**
     * ### 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.
     *
     * @param {String} project_id Id of project
     *
     * POST /projects/{project_id}/reset_to_remote -> ByteArray
     */
    fun reset_project_to_remote(
        project_id: String
    ) : SDKResponse {
        val path_project_id = encodeParam(project_id)
            return this.post<ByteArray>("/projects/${path_project_id}/reset_to_remote", mapOf())
    }


    /**
     * ### Get All Projects
     *
     * Returns all projects visible to the current user
     *
     * @param {String} fields Requested fields
     *
     * GET /projects -> ByteArray
     */
    @JvmOverloads fun all_projects(
        fields: String? = null
    ) : SDKResponse {
            return this.get<ByteArray>("/projects", 
                mapOf("fields" to fields))
    }


    /**
     * ### 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`.
     *
     * @param {WriteProject} body
     *
     * POST /projects -> ByteArray
     */
    fun create_project(
        body: WriteProject
    ) : SDKResponse {
            return this.post<ByteArray>("/projects", mapOf(), body)
    }


    /**
     * ### Get A Project
     *
     * Returns the project with the given project id
     *
     * @param {String} project_id Project Id
     * @param {String} fields Requested fields
     *
     * GET /projects/{project_id} -> ByteArray
     */
    @JvmOverloads fun project(
        project_id: String,
        fields: String? = null
    ) : SDKResponse {
        val path_project_id = encodeParam(project_id)
            return this.get<ByteArray>("/projects/${path_project_id}", 
                mapOf("fields" to fields))
    }


    /**
     * ### 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".
     *
     * @param {String} project_id Project Id
     * @param {WriteProject} body
     * @param {String} fields Requested fields
     *
     * PATCH /projects/{project_id} -> ByteArray
     */
    @JvmOverloads fun update_project(
        project_id: String,
        body: WriteProject,
        fields: String? = null
    ) : SDKResponse {
        val path_project_id = encodeParam(project_id)
            return this.patch<ByteArray>("/projects/${path_project_id}", 
                mapOf("fields" to fields), body)
    }


    /**
     * ### Get A Projects Manifest object
     *
     * Returns the project with the given project id
     *
     * @param {String} project_id Project Id
     *
     * GET /projects/{project_id}/manifest -> ByteArray
     */
    fun manifest(
        project_id: String
    ) : SDKResponse {
        val path_project_id = encodeParam(project_id)
            return this.get<ByteArray>("/projects/${path_project_id}/manifest", mapOf())
    }


    /**
     * ### Git Deploy Key
     *
     * Returns the ssh public key previously created for a project's git repository.
     *
     * @param {String} project_id Project Id
     *
     * GET /projects/{project_id}/git/deploy_key -> ByteArray
     */
    fun git_deploy_key(
        project_id: String
    ) : SDKResponse {
        val path_project_id = encodeParam(project_id)
            return this.get<ByteArray>("/projects/${path_project_id}/git/deploy_key", mapOf())
    }


    /**
     * ### 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.
     *
     * @param {String} project_id Project Id
     *
     * POST /projects/{project_id}/git/deploy_key -> ByteArray
     */
    fun create_git_deploy_key(
        project_id: String
    ) : SDKResponse {
        val path_project_id = encodeParam(project_id)
            return this.post<ByteArray>("/projects/${path_project_id}/git/deploy_key", mapOf())
    }


    /**
     * ### 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.
     *
     * @param {String} project_id Project Id
     * @param {String} fields Requested fields
     *
     * GET /projects/{project_id}/validate -> ByteArray
     */
    @JvmOverloads fun project_validation_results(
        project_id: String,
        fields: String? = null
    ) : SDKResponse {
        val path_project_id = encodeParam(project_id)
            return this.get<ByteArray>("/projects/${path_project_id}/validate", 
                mapOf("fields" to fields))
    }


    /**
     * ### 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)`
     *
     * @param {String} project_id Project Id
     * @param {String} fields Requested fields
     *
     * POST /projects/{project_id}/validate -> ByteArray
     */
    @JvmOverloads fun validate_project(
        project_id: String,
        fields: String? = null
    ) : SDKResponse {
        val path_project_id = encodeParam(project_id)
            return this.post<ByteArray>("/projects/${path_project_id}/validate", 
                mapOf("fields" to fields))
    }


    /**
     * ### Get Project Workspace
     *
     * Returns information about the state of the project files in the currently selected workspace
     *
     * @param {String} project_id Project Id
     * @param {String} fields Requested fields
     *
     * GET /projects/{project_id}/current_workspace -> ByteArray
     */
    @JvmOverloads fun project_workspace(
        project_id: String,
        fields: String? = null
    ) : SDKResponse {
        val path_project_id = encodeParam(project_id)
            return this.get<ByteArray>("/projects/${path_project_id}/current_workspace", 
                mapOf("fields" to fields))
    }


    /**
     * ### Get All Project Files
     *
     * Returns a list of the files in the project
     *
     * @param {String} project_id Project Id
     * @param {String} fields Requested fields
     *
     * GET /projects/{project_id}/files -> ByteArray
     */
    @JvmOverloads fun all_project_files(
        project_id: String,
        fields: String? = null
    ) : SDKResponse {
        val path_project_id = encodeParam(project_id)
            return this.get<ByteArray>("/projects/${path_project_id}/files", 
                mapOf("fields" to fields))
    }


    /**
     * ### Get Project File Info
     *
     * Returns information about a file in the project
     *
     * @param {String} project_id Project Id
     * @param {String} file_id File Id
     * @param {String} fields Requested fields
     *
     * GET /projects/{project_id}/files/file -> ByteArray
     */
    @JvmOverloads fun project_file(
        project_id: String,
        file_id: String,
        fields: String? = null
    ) : SDKResponse {
        val path_project_id = encodeParam(project_id)
            return this.get<ByteArray>("/projects/${path_project_id}/files/file", 
                mapOf("file_id" to file_id,
                     "fields" to fields))
    }


    /**
     * ### 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.
     *
     * @param {String} project_id Project Id
     * @param {String} remote_url (Optional: leave blank for root project) The remote url for remote dependency to test.
     *
     * GET /projects/{project_id}/git_connection_tests -> ByteArray
     */
    @JvmOverloads fun all_git_connection_tests(
        project_id: String,
        remote_url: String? = null
    ) : SDKResponse {
        val path_project_id = encodeParam(project_id)
            return this.get<ByteArray>("/projects/${path_project_id}/git_connection_tests", 
                mapOf("remote_url" to remote_url))
    }


    /**
     * ### 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).
     *
     * @param {String} project_id Project Id
     * @param {String} test_id Test Id
     * @param {String} remote_url (Optional: leave blank for root project) The remote url for remote dependency to test.
     * @param {String} use_production (Optional: leave blank for dev credentials) Whether to use git production credentials.
     *
     * GET /projects/{project_id}/git_connection_tests/{test_id} -> ByteArray
     */
    @JvmOverloads fun run_git_connection_test(
        project_id: String,
        test_id: String,
        remote_url: String? = null,
        use_production: String? = null
    ) : SDKResponse {
        val path_project_id = encodeParam(project_id)
        val path_test_id = encodeParam(test_id)
            return this.get<ByteArray>("/projects/${path_project_id}/git_connection_tests/${path_test_id}", 
                mapOf("remote_url" to remote_url,
                     "use_production" to use_production))
    }


    /**
     * ### 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.
     *
     * @param {String} project_id Project Id
     * @param {String} file_id File Id
     *
     * GET /projects/{project_id}/lookml_tests -> ByteArray
     */
    @JvmOverloads fun all_lookml_tests(
        project_id: String,
        file_id: String? = null
    ) : SDKResponse {
        val path_project_id = encodeParam(project_id)
            return this.get<ByteArray>("/projects/${path_project_id}/lookml_tests", 
                mapOf("file_id" to file_id))
    }


    /**
     * ### Run LookML Tests
     *
     * Runs all tests in the project, optionally filtered by file, test, and/or model.
     *
     * @param {String} project_id Project Id
     * @param {String} file_id File Name
     * @param {String} test Test Name
     * @param {String} model Model Name
     *
     * GET /projects/{project_id}/lookml_tests/run -> ByteArray
     */
    @JvmOverloads fun run_lookml_test(
        project_id: String,
        file_id: String? = null,
        test: String? = null,
        model: String? = null
    ) : SDKResponse {
        val path_project_id = encodeParam(project_id)
            return this.get<ByteArray>("/projects/${path_project_id}/lookml_tests/run", 
                mapOf("file_id" to file_id,
                     "test" to test,
                     "model" to model))
    }


    /**
     * ### Creates a tag for the most recent commit, or a specific ref is a SHA is provided
     *
     * This is an internal-only, undocumented route.
     *
     * @param {String} project_id Project Id
     * @param {WriteProject} body
     * @param {String} commit_sha (Optional): Commit Sha to Tag
     * @param {String} tag_name Tag Name
     * @param {String} tag_message (Optional): Tag Message
     *
     * POST /projects/{project_id}/tag -> ByteArray
     */
    @JvmOverloads fun tag_ref(
        project_id: String,
        body: WriteProject,
        commit_sha: String? = null,
        tag_name: String? = null,
        tag_message: String? = null
    ) : SDKResponse {
        val path_project_id = encodeParam(project_id)
            return this.post<ByteArray>("/projects/${path_project_id}/tag", 
                mapOf("commit_sha" to commit_sha,
                     "tag_name" to tag_name,
                     "tag_message" to tag_message), body)
    }


    /**
     * ### Configure Repository Credential for a remote dependency
     *
     * Admin required.
     *
     * `root_project_id` is required.
     * `credential_id` is required.
     *
     * @param {String} root_project_id Root Project Id
     * @param {String} credential_id Credential Id
     * @param {WriteRepositoryCredential} body
     *
     * PUT /projects/{root_project_id}/credential/{credential_id} -> ByteArray
     */
    fun update_repository_credential(
        root_project_id: String,
        credential_id: String,
        body: WriteRepositoryCredential
    ) : SDKResponse {
        val path_root_project_id = encodeParam(root_project_id)
        val path_credential_id = encodeParam(credential_id)
            return this.put<ByteArray>("/projects/${path_root_project_id}/credential/${path_credential_id}", mapOf(), body)
    }


    /**
     * ### Repository Credential for a remote dependency
     *
     * Admin required.
     *
     * `root_project_id` is required.
     * `credential_id` is required.
     *
     * @param {String} root_project_id Root Project Id
     * @param {String} credential_id Credential Id
     *
     * DELETE /projects/{root_project_id}/credential/{credential_id} -> ByteArray
     */
    fun delete_repository_credential(
        root_project_id: String,
        credential_id: String
    ) : SDKResponse {
        val path_root_project_id = encodeParam(root_project_id)
        val path_credential_id = encodeParam(credential_id)
            return this.delete<ByteArray>("/projects/${path_root_project_id}/credential/${path_credential_id}", mapOf())
    }


    /**
     * ### Get all Repository Credentials for a project
     *
     * `root_project_id` is required.
     *
     * @param {String} root_project_id Root Project Id
     *
     * GET /projects/{root_project_id}/credentials -> ByteArray
     */
    fun get_all_repository_credentials(
        root_project_id: String
    ) : SDKResponse {
        val path_root_project_id = encodeParam(root_project_id)
            return this.get<ByteArray>("/projects/${path_root_project_id}/credentials", mapOf())
    }

    //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.
     *
     * @param {WriteCreateQueryTask} body
     * @param {Long} limit Row limit (may override the limit in the saved query).
     * @param {Boolean} apply_formatting Apply model-specified formatting to each result.
     * @param {Boolean} apply_vis Apply visualization options to results.
     * @param {Boolean} cache Get results from cache if available.
     * @param {Boolean} generate_drill_links Generate drill links (only applicable to 'json_detail' format.
     * @param {Boolean} force_production Force use of production models even if the user is in development mode. Note that this flag being false does not guarantee development models will be used.
     * @param {Boolean} cache_only Retrieve any results from cache even if the results have expired.
     * @param {String} path_prefix Prefix to use for drill links (url encoded).
     * @param {Boolean} rebuild_pdts Rebuild PDTS used in query.
     * @param {Boolean} server_table_calcs Perform table calculations on query results
     * @param {Long} image_width DEPRECATED. Render width for image formats. Note that this parameter is always ignored by this method.
     * @param {Long} image_height DEPRECATED. Render height for image formats. Note that this parameter is always ignored by this method.
     * @param {String} fields Requested fields
     *
     * POST /query_tasks -> ByteArray
     */
    @JvmOverloads fun create_query_task(
        body: WriteCreateQueryTask,
        limit: Long? = null,
        apply_formatting: Boolean? = null,
        apply_vis: Boolean? = null,
        cache: Boolean? = null,
        generate_drill_links: Boolean? = null,
        force_production: Boolean? = null,
        cache_only: Boolean? = null,
        path_prefix: String? = null,
        rebuild_pdts: Boolean? = null,
        server_table_calcs: Boolean? = null,
        image_width: Long? = null,
        image_height: Long? = null,
        fields: String? = null
    ) : SDKResponse {
            return this.post<ByteArray>("/query_tasks", 
                mapOf("limit" to limit,
                     "apply_formatting" to apply_formatting,
                     "apply_vis" to apply_vis,
                     "cache" to cache,
                     "generate_drill_links" to generate_drill_links,
                     "force_production" to force_production,
                     "cache_only" to cache_only,
                     "path_prefix" to path_prefix,
                     "rebuild_pdts" to rebuild_pdts,
                     "server_table_calcs" to server_table_calcs,
                     "image_width" to image_width,
                     "image_height" to image_height,
                     "fields" to fields), body)
    }


    /**
     * ### 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'
     *
     * @param {DelimArray<String>} query_task_ids List of Query Task IDs
     *
     * GET /query_tasks/multi_results -> ByteArray
     */
    fun query_task_multi_results(
        query_task_ids: DelimArray<String>
    ) : SDKResponse {
            return this.get<ByteArray>("/query_tasks/multi_results", 
                mapOf("query_task_ids" to query_task_ids))
    }


    /**
     * ### 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.
     *
     * @param {String} query_task_id ID of the Query Task
     * @param {String} fields Requested fields.
     *
     * GET /query_tasks/{query_task_id} -> ByteArray
     */
    @JvmOverloads fun query_task(
        query_task_id: String,
        fields: String? = null
    ) : SDKResponse {
        val path_query_task_id = encodeParam(query_task_id)
            return this.get<ByteArray>("/query_tasks/${path_query_task_id}", 
                mapOf("fields" to fields))
    }


    /**
     * ### 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.
     *
     * @param {String} query_task_id ID of the Query Task
     *
     * GET /query_tasks/{query_task_id}/results -> ByteArray
     */
    fun query_task_results(
        query_task_id: String
    ) : SDKResponse {
        val path_query_task_id = encodeParam(query_task_id)
            return this.get<ByteArray>("/query_tasks/${path_query_task_id}/results", mapOf())
    }


    /**
     * ### 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.
     *
     * @param {String} query_id Id of query
     * @param {String} fields Requested fields.
     *
     * GET /queries/{query_id} -> ByteArray
     */
    @JvmOverloads fun query(
        query_id: String,
        fields: String? = null
    ) : SDKResponse {
        val path_query_id = encodeParam(query_id)
            return this.get<ByteArray>("/queries/${path_query_id}", 
                mapOf("fields" to fields))
    }


    /**
     * ### 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.
     *
     * @param {String} slug Slug of query
     * @param {String} fields Requested fields.
     *
     * GET /queries/slug/{slug} -> ByteArray
     */
    @JvmOverloads fun query_for_slug(
        slug: String,
        fields: String? = null
    ) : SDKResponse {
        val path_slug = encodeParam(slug)
            return this.get<ByteArray>("/queries/slug/${path_slug}", 
                mapOf("fields" to fields))
    }


    /**
     * ### 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.
     *
     * @param {WriteQuery} body
     * @param {String} fields Requested fields.
     *
     * POST /queries -> ByteArray
     */
    @JvmOverloads fun create_query(
        body: WriteQuery,
        fields: String? = null
    ) : SDKResponse {
            return this.post<ByteArray>("/queries", 
                mapOf("fields" to fields), body)
    }


    /**
     * ### 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_detail | 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
     *
     * @param {String} query_id Id of query
     * @param {String} result_format Format of result
     * @param {Long} limit Row limit (may override the limit in the saved query).
     * @param {Boolean} apply_formatting Apply model-specified formatting to each result.
     * @param {Boolean} apply_vis Apply visualization options to results.
     * @param {Boolean} cache Get results from cache if available.
     * @param {Long} image_width Render width for image formats.
     * @param {Long} image_height Render height for image formats.
     * @param {Boolean} generate_drill_links Generate drill links (only applicable to 'json_detail' format.
     * @param {Boolean} force_production Force use of production models even if the user is in development mode. Note that this flag being false does not guarantee development models will be used.
     * @param {Boolean} cache_only Retrieve any results from cache even if the results have expired.
     * @param {String} path_prefix Prefix to use for drill links (url encoded).
     * @param {Boolean} rebuild_pdts Rebuild PDTS used in query.
     * @param {Boolean} server_table_calcs Perform table calculations on query results
     * @param {String} source Specifies the source of this call.
     *
     * GET /queries/{query_id}/run/{result_format} -> ByteArray
     *
     * **Note**: Binary content may be returned by this method.
     */
    @JvmOverloads fun run_query(
        query_id: String,
        result_format: String,
        limit: Long? = null,
        apply_formatting: Boolean? = null,
        apply_vis: Boolean? = null,
        cache: Boolean? = null,
        image_width: Long? = null,
        image_height: Long? = null,
        generate_drill_links: Boolean? = null,
        force_production: Boolean? = null,
        cache_only: Boolean? = null,
        path_prefix: String? = null,
        rebuild_pdts: Boolean? = null,
        server_table_calcs: Boolean? = null,
        source: String? = null
    ) : SDKResponse {
        val path_query_id = encodeParam(query_id)
        val path_result_format = encodeParam(result_format)
            return this.get<ByteArray>("/queries/${path_query_id}/run/${path_result_format}", 
                mapOf("limit" to limit,
                     "apply_formatting" to apply_formatting,
                     "apply_vis" to apply_vis,
                     "cache" to cache,
                     "image_width" to image_width,
                     "image_height" to image_height,
                     "generate_drill_links" to generate_drill_links,
                     "force_production" to force_production,
                     "cache_only" to cache_only,
                     "path_prefix" to path_prefix,
                     "rebuild_pdts" to rebuild_pdts,
                     "server_table_calcs" to server_table_calcs,
                     "source" to source))
    }


    /**
     * ### 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_detail | 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
     *
     * @param {String} result_format Format of result
     * @param {WriteQuery} body
     * @param {Long} limit Row limit (may override the limit in the saved query).
     * @param {Boolean} apply_formatting Apply model-specified formatting to each result.
     * @param {Boolean} apply_vis Apply visualization options to results.
     * @param {Boolean} cache Get results from cache if available.
     * @param {Long} image_width Render width for image formats.
     * @param {Long} image_height Render height for image formats.
     * @param {Boolean} generate_drill_links Generate drill links (only applicable to 'json_detail' format.
     * @param {Boolean} force_production Force use of production models even if the user is in development mode. Note that this flag being false does not guarantee development models will be used.
     * @param {Boolean} cache_only Retrieve any results from cache even if the results have expired.
     * @param {String} path_prefix Prefix to use for drill links (url encoded).
     * @param {Boolean} rebuild_pdts Rebuild PDTS used in query.
     * @param {Boolean} server_table_calcs Perform table calculations on query results
     *
     * POST /queries/run/{result_format} -> ByteArray
     *
     * **Note**: Binary content may be returned by this method.
     */
    @JvmOverloads fun run_inline_query(
        result_format: String,
        body: WriteQuery,
        limit: Long? = null,
        apply_formatting: Boolean? = null,
        apply_vis: Boolean? = null,
        cache: Boolean? = null,
        image_width: Long? = null,
        image_height: Long? = null,
        generate_drill_links: Boolean? = null,
        force_production: Boolean? = null,
        cache_only: Boolean? = null,
        path_prefix: String? = null,
        rebuild_pdts: Boolean? = null,
        server_table_calcs: Boolean? = null
    ) : SDKResponse {
        val path_result_format = encodeParam(result_format)
            return this.post<ByteArray>("/queries/run/${path_result_format}", 
                mapOf("limit" to limit,
                     "apply_formatting" to apply_formatting,
                     "apply_vis" to apply_vis,
                     "cache" to cache,
                     "image_width" to image_width,
                     "image_height" to image_height,
                     "generate_drill_links" to generate_drill_links,
                     "force_production" to force_production,
                     "cache_only" to cache_only,
                     "path_prefix" to path_prefix,
                     "rebuild_pdts" to rebuild_pdts,
                     "server_table_calcs" to server_table_calcs), body)
    }


    /**
     * ### 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/3.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_detail | 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
     *
     * @param {String} model_name Model name
     * @param {String} view_name View name
     * @param {String} result_format Format of result
     *
     * GET /queries/models/{model_name}/views/{view_name}/run/{result_format} -> ByteArray
     *
     * **Note**: Binary content may be returned by this method.
     */
    fun run_url_encoded_query(
        model_name: String,
        view_name: String,
        result_format: String
    ) : SDKResponse {
        val path_model_name = encodeParam(model_name)
        val path_view_name = encodeParam(view_name)
        val path_result_format = encodeParam(result_format)
            return this.get<ByteArray>("/queries/models/${path_model_name}/views/${path_view_name}/run/${path_result_format}", mapOf())
    }


    /**
     * ### Get Merge Query
     *
     * Returns a merge query object given its id.
     *
     * @param {String} merge_query_id Merge Query Id
     * @param {String} fields Requested fields
     *
     * GET /merge_queries/{merge_query_id} -> ByteArray
     */
    @JvmOverloads fun merge_query(
        merge_query_id: String,
        fields: String? = null
    ) : SDKResponse {
        val path_merge_query_id = encodeParam(merge_query_id)
            return this.get<ByteArray>("/merge_queries/${path_merge_query_id}", 
                mapOf("fields" to fields))
    }


    /**
     * ### 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.
     *
     * @param {WriteMergeQuery} body
     * @param {String} fields Requested fields
     *
     * POST /merge_queries -> ByteArray
     */
    @JvmOverloads fun create_merge_query(
        body: WriteMergeQuery? = null,
        fields: String? = null
    ) : SDKResponse {
            return this.post<ByteArray>("/merge_queries", 
                mapOf("fields" to fields), body)
    }


    /**
     * Get information about all running queries.
     *
     * GET /running_queries -> ByteArray
     */
    fun all_running_queries(

    ) : SDKResponse {
            return this.get<ByteArray>("/running_queries", mapOf())
    }


    /**
     * Kill a query with a specific query_task_id.
     *
     * @param {String} query_task_id Query task id.
     *
     * DELETE /running_queries/{query_task_id} -> ByteArray
     */
    fun kill_query(
        query_task_id: String
    ) : SDKResponse {
        val path_query_task_id = encodeParam(query_task_id)
            return this.delete<ByteArray>("/running_queries/${path_query_task_id}", mapOf())
    }


    /**
     * Get a SQL Runner query.
     *
     * @param {String} slug slug of query
     *
     * GET /sql_queries/{slug} -> ByteArray
     */
    fun sql_query(
        slug: String
    ) : SDKResponse {
        val path_slug = encodeParam(slug)
            return this.get<ByteArray>("/sql_queries/${path_slug}", mapOf())
    }


    /**
     * ### Create a SQL Runner Query
     *
     * Either the `connection_name` or `model_name` parameter MUST be provided.
     *
     * @param {SqlQueryCreate} body
     *
     * POST /sql_queries -> ByteArray
     */
    fun create_sql_query(
        body: SqlQueryCreate
    ) : SDKResponse {
            return this.post<ByteArray>("/sql_queries", mapOf(), body)
    }


    /**
     * Execute a SQL Runner query in a given result_format.
     *
     * @param {String} slug slug of query
     * @param {String} result_format Format of result, options are: ["inline_json", "json", "json_detail", "json_fe", "csv", "html", "md", "txt", "xlsx", "gsxml", "json_label"]
     * @param {String} download Defaults to false. If set to true, the HTTP response will have content-disposition and other headers set to make the HTTP response behave as a downloadable attachment instead of as inline content.
     *
     * POST /sql_queries/{slug}/run/{result_format} -> ByteArray
     *
     * **Note**: Binary content may be returned by this method.
     */
    @JvmOverloads fun run_sql_query(
        slug: String,
        result_format: String,
        download: String? = null
    ) : SDKResponse {
        val path_slug = encodeParam(slug)
        val path_result_format = encodeParam(result_format)
            return this.post<ByteArray>("/sql_queries/${path_slug}/run/${path_result_format}", 
                mapOf("download" to download))
    }

    //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).
     *
     * @param {String} look_id Id of look to render
     * @param {String} result_format Output type: png, or jpg
     * @param {Long} width Output width in pixels
     * @param {Long} height Output height in pixels
     * @param {String} fields Requested fields.
     *
     * POST /render_tasks/looks/{look_id}/{result_format} -> ByteArray
     */
    @JvmOverloads fun create_look_render_task(
        look_id: String,
        result_format: String,
        width: Long,
        height: Long,
        fields: String? = null
    ) : SDKResponse {
        val path_look_id = encodeParam(look_id)
        val path_result_format = encodeParam(result_format)
            return this.post<ByteArray>("/render_tasks/looks/${path_look_id}/${path_result_format}", 
                mapOf("width" to width,
                     "height" to height,
                     "fields" to fields))
    }


    /**
     * ### 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).
     *
     * @param {String} query_id Id of the query to render
     * @param {String} result_format Output type: png or jpg
     * @param {Long} width Output width in pixels
     * @param {Long} height Output height in pixels
     * @param {String} fields Requested fields.
     *
     * POST /render_tasks/queries/{query_id}/{result_format} -> ByteArray
     */
    @JvmOverloads fun create_query_render_task(
        query_id: String,
        result_format: String,
        width: Long,
        height: Long,
        fields: String? = null
    ) : SDKResponse {
        val path_query_id = encodeParam(query_id)
        val path_result_format = encodeParam(result_format)
            return this.post<ByteArray>("/render_tasks/queries/${path_query_id}/${path_result_format}", 
                mapOf("width" to width,
                     "height" to height,
                     "fields" to fields))
    }


    /**
     * ### 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).
     *
     * @param {String} dashboard_id Id of dashboard to render. The ID can be a LookML dashboard also.
     * @param {String} result_format Output type: pdf, png, or jpg
     * @param {CreateDashboardRenderTask} body
     * @param {Long} width Output width in pixels
     * @param {Long} height Output height in pixels
     * @param {String} fields Requested fields.
     * @param {String} pdf_paper_size Paper size for pdf. Value can be one of: ["letter","legal","tabloid","a0","a1","a2","a3","a4","a5"]
     * @param {Boolean} pdf_landscape Whether to render pdf in landscape paper orientation
     * @param {Boolean} long_tables Whether or not to expand table vis to full length
     *
     * POST /render_tasks/dashboards/{dashboard_id}/{result_format} -> ByteArray
     */
    @JvmOverloads fun create_dashboard_render_task(
        dashboard_id: String,
        result_format: String,
        body: CreateDashboardRenderTask,
        width: Long,
        height: Long,
        fields: String? = null,
        pdf_paper_size: String? = null,
        pdf_landscape: Boolean? = null,
        long_tables: Boolean? = null
    ) : SDKResponse {
        val path_dashboard_id = encodeParam(dashboard_id)
        val path_result_format = encodeParam(result_format)
            return this.post<ByteArray>("/render_tasks/dashboards/${path_dashboard_id}/${path_result_format}", 
                mapOf("width" to width,
                     "height" to height,
                     "fields" to fields,
                     "pdf_paper_size" to pdf_paper_size,
                     "pdf_landscape" to pdf_landscape,
                     "long_tables" to long_tables), body)
    }


    /**
     * ### 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).
     *
     * @param {String} render_task_id Id of render task
     * @param {String} fields Requested fields.
     *
     * GET /render_tasks/{render_task_id} -> ByteArray
     */
    @JvmOverloads fun render_task(
        render_task_id: String,
        fields: String? = null
    ) : SDKResponse {
        val path_render_task_id = encodeParam(render_task_id)
            return this.get<ByteArray>("/render_tasks/${path_render_task_id}", 
                mapOf("fields" to fields))
    }


    /**
     * ### 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.
     *
     * @param {String} render_task_id Id of render task
     *
     * GET /render_tasks/{render_task_id}/results -> ByteArray
     *
     * **Note**: Binary content is returned by this method.
     */
    fun render_task_results(
        render_task_id: String
    ) : SDKResponse {
        val path_render_task_id = encodeParam(render_task_id)
            return this.get<ByteArray>("/render_tasks/${path_render_task_id}/results", mapOf())
    }


    /**
     * ### 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).
     *
     * @param {String} dashboard_element_id Id of dashboard element to render: UDD dashboard element would be numeric and LookML dashboard element would be model_name::dashboard_title::lookml_link_id
     * @param {String} result_format Output type: png or jpg
     * @param {Long} width Output width in pixels
     * @param {Long} height Output height in pixels
     * @param {String} fields Requested fields.
     *
     * POST /render_tasks/dashboard_elements/{dashboard_element_id}/{result_format} -> ByteArray
     */
    @JvmOverloads fun create_dashboard_element_render_task(
        dashboard_element_id: String,
        result_format: String,
        width: Long,
        height: Long,
        fields: String? = null
    ) : SDKResponse {
        val path_dashboard_element_id = encodeParam(dashboard_element_id)
        val path_result_format = encodeParam(result_format)
            return this.post<ByteArray>("/render_tasks/dashboard_elements/${path_dashboard_element_id}/${path_result_format}", 
                mapOf("width" to width,
                     "height" to height,
                     "fields" to fields))
    }

    //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.
     *
     * @param {String} fields Requested fields.
     * @param {Long} limit Number of results to return (used with `offset`).
     * @param {Long} offset Number of results to skip before returning any (used with `limit`).
     * @param {String} sorts Fields to sort by.
     * @param {String} id Match model set id.
     * @param {String} name Match model set name.
     * @param {Boolean} all_access Match model sets by all_access status.
     * @param {Boolean} built_in Match model sets by built_in status.
     * @param {Boolean} filter_or Combine given search criteria in a boolean OR expression.
     *
     * GET /model_sets/search -> ByteArray
     */
    @JvmOverloads fun search_model_sets(
        fields: String? = null,
        limit: Long? = null,
        offset: Long? = null,
        sorts: String? = null,
        id: String? = null,
        name: String? = null,
        all_access: Boolean? = null,
        built_in: Boolean? = null,
        filter_or: Boolean? = null
    ) : SDKResponse {
            return this.get<ByteArray>("/model_sets/search", 
                mapOf("fields" to fields,
                     "limit" to limit,
                     "offset" to offset,
                     "sorts" to sorts,
                     "id" to id,
                     "name" to name,
                     "all_access" to all_access,
                     "built_in" to built_in,
                     "filter_or" to filter_or))
    }


    /**
     * ### Get information about the model set with a specific id.
     *
     * @param {String} model_set_id Id of model set
     * @param {String} fields Requested fields.
     *
     * GET /model_sets/{model_set_id} -> ByteArray
     */
    @JvmOverloads fun model_set(
        model_set_id: String,
        fields: String? = null
    ) : SDKResponse {
        val path_model_set_id = encodeParam(model_set_id)
            return this.get<ByteArray>("/model_sets/${path_model_set_id}", 
                mapOf("fields" to fields))
    }


    /**
     * ### Update information about the model set with a specific id.
     *
     * @param {String} model_set_id id of model set
     * @param {WriteModelSet} body
     *
     * PATCH /model_sets/{model_set_id} -> ByteArray
     */
    fun update_model_set(
        model_set_id: String,
        body: WriteModelSet
    ) : SDKResponse {
        val path_model_set_id = encodeParam(model_set_id)
            return this.patch<ByteArray>("/model_sets/${path_model_set_id}", mapOf(), body)
    }


    /**
     * ### Delete the model set with a specific id.
     *
     * @param {String} model_set_id id of model set
     *
     * DELETE /model_sets/{model_set_id} -> ByteArray
     */
    fun delete_model_set(
        model_set_id: String
    ) : SDKResponse {
        val path_model_set_id = encodeParam(model_set_id)
            return this.delete<ByteArray>("/model_sets/${path_model_set_id}", mapOf())
    }


    /**
     * ### Get information about all model sets.
     *
     * @param {String} fields Requested fields.
     *
     * GET /model_sets -> ByteArray
     */
    @JvmOverloads fun all_model_sets(
        fields: String? = null
    ) : SDKResponse {
            return this.get<ByteArray>("/model_sets", 
                mapOf("fields" to fields))
    }


    /**
     * ### Create a model set with the specified information. Model sets are used by Roles.
     *
     * @param {WriteModelSet} body
     *
     * POST /model_sets -> ByteArray
     */
    fun create_model_set(
        body: WriteModelSet
    ) : SDKResponse {
            return this.post<ByteArray>("/model_sets", mapOf(), body)
    }


    /**
     * ### Get all supported permissions.
     *
     * GET /permissions -> ByteArray
     */
    fun all_permissions(

    ) : SDKResponse {
            return this.get<ByteArray>("/permissions", mapOf())
    }


    /**
     * ### 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.
     *
     * @param {String} fields Requested fields.
     * @param {Long} limit Number of results to return (used with `offset`).
     * @param {Long} offset Number of results to skip before returning any (used with `limit`).
     * @param {String} sorts Fields to sort by.
     * @param {String} id Match permission set id.
     * @param {String} name Match permission set name.
     * @param {Boolean} all_access Match permission sets by all_access status.
     * @param {Boolean} built_in Match permission sets by built_in status.
     * @param {Boolean} filter_or Combine given search criteria in a boolean OR expression.
     *
     * GET /permission_sets/search -> ByteArray
     */
    @JvmOverloads fun search_permission_sets(
        fields: String? = null,
        limit: Long? = null,
        offset: Long? = null,
        sorts: String? = null,
        id: String? = null,
        name: String? = null,
        all_access: Boolean? = null,
        built_in: Boolean? = null,
        filter_or: Boolean? = null
    ) : SDKResponse {
            return this.get<ByteArray>("/permission_sets/search", 
                mapOf("fields" to fields,
                     "limit" to limit,
                     "offset" to offset,
                     "sorts" to sorts,
                     "id" to id,
                     "name" to name,
                     "all_access" to all_access,
                     "built_in" to built_in,
                     "filter_or" to filter_or))
    }


    /**
     * ### Get information about the permission set with a specific id.
     *
     * @param {String} permission_set_id Id of permission set
     * @param {String} fields Requested fields.
     *
     * GET /permission_sets/{permission_set_id} -> ByteArray
     */
    @JvmOverloads fun permission_set(
        permission_set_id: String,
        fields: String? = null
    ) : SDKResponse {
        val path_permission_set_id = encodeParam(permission_set_id)
            return this.get<ByteArray>("/permission_sets/${path_permission_set_id}", 
                mapOf("fields" to fields))
    }


    /**
     * ### Update information about the permission set with a specific id.
     *
     * @param {String} permission_set_id Id of permission set
     * @param {WritePermissionSet} body
     *
     * PATCH /permission_sets/{permission_set_id} -> ByteArray
     */
    fun update_permission_set(
        permission_set_id: String,
        body: WritePermissionSet
    ) : SDKResponse {
        val path_permission_set_id = encodeParam(permission_set_id)
            return this.patch<ByteArray>("/permission_sets/${path_permission_set_id}", mapOf(), body)
    }


    /**
     * ### Delete the permission set with a specific id.
     *
     * @param {String} permission_set_id Id of permission set
     *
     * DELETE /permission_sets/{permission_set_id} -> ByteArray
     */
    fun delete_permission_set(
        permission_set_id: String
    ) : SDKResponse {
        val path_permission_set_id = encodeParam(permission_set_id)
            return this.delete<ByteArray>("/permission_sets/${path_permission_set_id}", mapOf())
    }


    /**
     * ### Get information about all permission sets.
     *
     * @param {String} fields Requested fields.
     *
     * GET /permission_sets -> ByteArray
     */
    @JvmOverloads fun all_permission_sets(
        fields: String? = null
    ) : SDKResponse {
            return this.get<ByteArray>("/permission_sets", 
                mapOf("fields" to fields))
    }


    /**
     * ### Create a permission set with the specified information. Permission sets are used by Roles.
     *
     * @param {WritePermissionSet} body
     *
     * POST /permission_sets -> ByteArray
     */
    fun create_permission_set(
        body: WritePermissionSet
    ) : SDKResponse {
            return this.post<ByteArray>("/permission_sets", mapOf(), body)
    }


    /**
     * ### Get information about all roles.
     *
     * @param {String} fields Requested fields.
     * @param {DelimArray<String>} ids Optional list of ids to get specific roles.
     *
     * GET /roles -> ByteArray
     */
    @JvmOverloads fun all_roles(
        fields: String? = null,
        ids: DelimArray<String>? = null
    ) : SDKResponse {
            return this.get<ByteArray>("/roles", 
                mapOf("fields" to fields,
                     "ids" to ids))
    }


    /**
     * ### Create a role with the specified information.
     *
     * @param {WriteRole} body
     *
     * POST /roles -> ByteArray
     */
    fun create_role(
        body: WriteRole
    ) : SDKResponse {
            return this.post<ByteArray>("/roles", mapOf(), body)
    }


    /**
     * ### 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.
     *
     * @param {String} fields Requested fields.
     * @param {Long} limit Number of results to return (used with `offset`).
     * @param {Long} offset Number of results to skip before returning any (used with `limit`).
     * @param {String} sorts Fields to sort by.
     * @param {String} id Match role id.
     * @param {String} name Match role name.
     * @param {Boolean} built_in Match roles by built_in status.
     * @param {Boolean} filter_or Combine given search criteria in a boolean OR expression.
     *
     * GET /roles/search -> ByteArray
     */
    @JvmOverloads fun search_roles(
        fields: String? = null,
        limit: Long? = null,
        offset: Long? = null,
        sorts: String? = null,
        id: String? = null,
        name: String? = null,
        built_in: Boolean? = null,
        filter_or: Boolean? = null
    ) : SDKResponse {
            return this.get<ByteArray>("/roles/search", 
                mapOf("fields" to fields,
                     "limit" to limit,
                     "offset" to offset,
                     "sorts" to sorts,
                     "id" to id,
                     "name" to name,
                     "built_in" to built_in,
                     "filter_or" to filter_or))
    }


    /**
     * ### 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.
     *
     * @param {String} fields Requested fields.
     * @param {Long} limit Number of results to return (used with `offset`).
     * @param {Long} offset Number of results to skip before returning any (used with `limit`).
     * @param {String} sorts Fields to sort by.
     * @param {String} id Match role id.
     * @param {String} name Match role name.
     * @param {Boolean} built_in Match roles by built_in status.
     * @param {Boolean} filter_or Combine given search criteria in a boolean OR expression.
     *
     * GET /roles/search/with_user_count -> ByteArray
     */
    @JvmOverloads fun search_roles_with_user_count(
        fields: String? = null,
        limit: Long? = null,
        offset: Long? = null,
        sorts: String? = null,
        id: String? = null,
        name: String? = null,
        built_in: Boolean? = null,
        filter_or: Boolean? = null
    ) : SDKResponse {
            return this.get<ByteArray>("/roles/search/with_user_count", 
                mapOf("fields" to fields,
                     "limit" to limit,
                     "offset" to offset,
                     "sorts" to sorts,
                     "id" to id,
                     "name" to name,
                     "built_in" to built_in,
                     "filter_or" to filter_or))
    }


    /**
     * ### Get information about the role with a specific id.
     *
     * @param {String} role_id id of role
     *
     * GET /roles/{role_id} -> ByteArray
     */
    fun role(
        role_id: String
    ) : SDKResponse {
        val path_role_id = encodeParam(role_id)
            return this.get<ByteArray>("/roles/${path_role_id}", mapOf())
    }


    /**
     * ### Update information about the role with a specific id.
     *
     * @param {String} role_id id of role
     * @param {WriteRole} body
     *
     * PATCH /roles/{role_id} -> ByteArray
     */
    fun update_role(
        role_id: String,
        body: WriteRole
    ) : SDKResponse {
        val path_role_id = encodeParam(role_id)
            return this.patch<ByteArray>("/roles/${path_role_id}", mapOf(), body)
    }


    /**
     * ### Delete the role with a specific id.
     *
     * @param {String} role_id id of role
     *
     * DELETE /roles/{role_id} -> ByteArray
     */
    fun delete_role(
        role_id: String
    ) : SDKResponse {
        val path_role_id = encodeParam(role_id)
            return this.delete<ByteArray>("/roles/${path_role_id}", mapOf())
    }


    /**
     * ### Get information about all the groups with the role that has a specific id.
     *
     * @param {String} role_id id of role
     * @param {String} fields Requested fields.
     *
     * GET /roles/{role_id}/groups -> ByteArray
     */
    @JvmOverloads fun role_groups(
        role_id: String,
        fields: String? = null
    ) : SDKResponse {
        val path_role_id = encodeParam(role_id)
            return this.get<ByteArray>("/roles/${path_role_id}/groups", 
                mapOf("fields" to fields))
    }


    /**
     * ### Set all groups for a role, removing all existing group associations from that role.
     *
     * @param {String} role_id id of role
     * @param {Array<String>} body
     *
     * PUT /roles/{role_id}/groups -> ByteArray
     */
    fun set_role_groups(
        role_id: String,
        body: Array<String>
    ) : SDKResponse {
        val path_role_id = encodeParam(role_id)
            return this.put<ByteArray>("/roles/${path_role_id}/groups", mapOf(), body)
    }


    /**
     * ### Get information about all the users with the role that has a specific id.
     *
     * @param {String} role_id id of role
     * @param {String} fields Requested fields.
     * @param {Boolean} direct_association_only Get only users associated directly with the role: exclude those only associated through groups.
     *
     * GET /roles/{role_id}/users -> ByteArray
     */
    @JvmOverloads fun role_users(
        role_id: String,
        fields: String? = null,
        direct_association_only: Boolean? = null
    ) : SDKResponse {
        val path_role_id = encodeParam(role_id)
            return this.get<ByteArray>("/roles/${path_role_id}/users", 
                mapOf("fields" to fields,
                     "direct_association_only" to direct_association_only))
    }


    /**
     * ### Set all the users of the role with a specific id.
     *
     * @param {String} role_id id of role
     * @param {Array<String>} body
     *
     * PUT /roles/{role_id}/users -> ByteArray
     */
    fun set_role_users(
        role_id: String,
        body: Array<String>
    ) : SDKResponse {
        val path_role_id = encodeParam(role_id)
            return this.put<ByteArray>("/roles/${path_role_id}/users", mapOf(), body)
    }

    //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.
     *
     * @param {String} space_id Space Id
     * @param {String} fields Requested fields.
     *
     * GET /scheduled_plans/space/{space_id} -> ByteArray
     */
    @JvmOverloads fun scheduled_plans_for_space(
        space_id: String,
        fields: String? = null
    ) : SDKResponse {
        val path_space_id = encodeParam(space_id)
            return this.get<ByteArray>("/scheduled_plans/space/${path_space_id}", 
                mapOf("fields" to fields))
    }


    /**
     * ### Get Information About a Scheduled Plan
     *
     * Admins can fetch information about other users' Scheduled Plans.
     *
     * @param {String} scheduled_plan_id Scheduled Plan Id
     * @param {String} fields Requested fields.
     *
     * GET /scheduled_plans/{scheduled_plan_id} -> ByteArray
     */
    @JvmOverloads fun scheduled_plan(
        scheduled_plan_id: String,
        fields: String? = null
    ) : SDKResponse {
        val path_scheduled_plan_id = encodeParam(scheduled_plan_id)
            return this.get<ByteArray>("/scheduled_plans/${path_scheduled_plan_id}", 
                mapOf("fields" to fields))
    }


    /**
     * ### 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 Whitelist for Scheduled Looks](https://docs.looker.com/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.
     *
     * @param {String} scheduled_plan_id Scheduled Plan Id
     * @param {WriteScheduledPlan} body
     *
     * PATCH /scheduled_plans/{scheduled_plan_id} -> ByteArray
     */
    fun update_scheduled_plan(
        scheduled_plan_id: String,
        body: WriteScheduledPlan
    ) : SDKResponse {
        val path_scheduled_plan_id = encodeParam(scheduled_plan_id)
            return this.patch<ByteArray>("/scheduled_plans/${path_scheduled_plan_id}", mapOf(), body)
    }


    /**
     * ### 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.
     *
     * @param {String} scheduled_plan_id Scheduled Plan Id
     *
     * DELETE /scheduled_plans/{scheduled_plan_id} -> ByteArray
     */
    fun delete_scheduled_plan(
        scheduled_plan_id: String
    ) : SDKResponse {
        val path_scheduled_plan_id = encodeParam(scheduled_plan_id)
            return this.delete<ByteArray>("/scheduled_plans/${path_scheduled_plan_id}", mapOf())
    }


    /**
     * ### 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.
     *
     * @param {String} user_id Return scheduled plans belonging to this user_id. If not provided, returns scheduled plans owned by the caller.
     * @param {String} fields Comma delimited list of field names. If provided, only the fields specified will be included in the response
     * @param {Boolean} all_users Return scheduled plans belonging to all users (caller needs see_schedules permission)
     *
     * GET /scheduled_plans -> ByteArray
     */
    @JvmOverloads fun all_scheduled_plans(
        user_id: String? = null,
        fields: String? = null,
        all_users: Boolean? = null
    ) : SDKResponse {
            return this.get<ByteArray>("/scheduled_plans", 
                mapOf("user_id" to user_id,
                     "fields" to fields,
                     "all_users" to all_users))
    }


    /**
     * ### 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://docs.looker.com/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 Whitelist for Scheduled Looks](https://docs.looker.com/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.
     *
     * @param {WriteScheduledPlan} body
     *
     * POST /scheduled_plans -> ByteArray
     */
    fun create_scheduled_plan(
        body: WriteScheduledPlan
    ) : SDKResponse {
            return this.post<ByteArray>("/scheduled_plans", mapOf(), body)
    }


    /**
     * ### 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 Whitelist for Scheduled Looks](https://docs.looker.com/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.
     *
     * @param {WriteScheduledPlan} body
     *
     * POST /scheduled_plans/run_once -> ByteArray
     */
    fun scheduled_plan_run_once(
        body: WriteScheduledPlan
    ) : SDKResponse {
            return this.post<ByteArray>("/scheduled_plans/run_once", mapOf(), body)
    }


    /**
     * ### 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.
     *
     * @param {String} look_id Look Id
     * @param {String} user_id User Id (default is requesting user if not specified)
     * @param {String} fields Requested fields.
     * @param {Boolean} all_users Return scheduled plans belonging to all users for the look
     *
     * GET /scheduled_plans/look/{look_id} -> ByteArray
     */
    @JvmOverloads fun scheduled_plans_for_look(
        look_id: String,
        user_id: String? = null,
        fields: String? = null,
        all_users: Boolean? = null
    ) : SDKResponse {
        val path_look_id = encodeParam(look_id)
            return this.get<ByteArray>("/scheduled_plans/look/${path_look_id}", 
                mapOf("user_id" to user_id,
                     "fields" to fields,
                     "all_users" to all_users))
    }


    /**
     * ### 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.
     *
     * @param {String} dashboard_id Dashboard Id
     * @param {String} user_id User Id (default is requesting user if not specified)
     * @param {Boolean} all_users Return scheduled plans belonging to all users for the dashboard
     * @param {String} fields Requested fields.
     *
     * GET /scheduled_plans/dashboard/{dashboard_id} -> ByteArray
     */
    @JvmOverloads fun scheduled_plans_for_dashboard(
        dashboard_id: String,
        user_id: String? = null,
        all_users: Boolean? = null,
        fields: String? = null
    ) : SDKResponse {
        val path_dashboard_id = encodeParam(dashboard_id)
            return this.get<ByteArray>("/scheduled_plans/dashboard/${path_dashboard_id}", 
                mapOf("user_id" to user_id,
                     "all_users" to all_users,
                     "fields" to fields))
    }


    /**
     * ### 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.
     *
     * @param {String} lookml_dashboard_id LookML Dashboard Id
     * @param {String} user_id User Id (default is requesting user if not specified)
     * @param {String} fields Requested fields.
     * @param {Boolean} all_users Return scheduled plans belonging to all users for the dashboard
     *
     * GET /scheduled_plans/lookml_dashboard/{lookml_dashboard_id} -> ByteArray
     */
    @JvmOverloads fun scheduled_plans_for_lookml_dashboard(
        lookml_dashboard_id: String,
        user_id: String? = null,
        fields: String? = null,
        all_users: Boolean? = null
    ) : SDKResponse {
        val path_lookml_dashboard_id = encodeParam(lookml_dashboard_id)
            return this.get<ByteArray>("/scheduled_plans/lookml_dashboard/${path_lookml_dashboard_id}", 
                mapOf("user_id" to user_id,
                     "fields" to fields,
                     "all_users" to all_users))
    }


    /**
     * ### 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 Whitelist for Scheduled Looks](https://docs.looker.com/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
     *
     * @param {String} scheduled_plan_id Id of schedule plan to copy and run
     * @param {WriteScheduledPlan} body
     *
     * POST /scheduled_plans/{scheduled_plan_id}/run_once -> ByteArray
     */
    @JvmOverloads fun scheduled_plan_run_once_by_id(
        scheduled_plan_id: String,
        body: WriteScheduledPlan? = null
    ) : SDKResponse {
        val path_scheduled_plan_id = encodeParam(scheduled_plan_id)
            return this.post<ByteArray>("/scheduled_plans/${path_scheduled_plan_id}/run_once", mapOf(), body)
    }

    //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 -> ByteArray
     */
    fun session(

    ) : SDKResponse {
            return this.get<ByteArray>("/session", mapOf())
    }


    /**
     * ### 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.
     *
     * @param {WriteApiSession} body
     *
     * PATCH /session -> ByteArray
     */
    fun update_session(
        body: WriteApiSession
    ) : SDKResponse {
            return this.patch<ByteArray>("/session", mapOf(), body)
    }

    //endregion Session: Session Information

    //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 help.looker.com to update your license for this feature.
     *
     * @param {String} fields Requested fields.
     *
     * GET /themes -> ByteArray
     */
    @JvmOverloads fun all_themes(
        fields: String? = null
    ) : SDKResponse {
            return this.get<ByteArray>("/themes", 
                mapOf("fields" to fields))
    }


    /**
     * ### 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://docs.looker.com/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 help.looker.com to update your license for this feature.
     *
     * @param {WriteTheme} body
     *
     * POST /themes -> ByteArray
     */
    fun create_theme(
        body: WriteTheme
    ) : SDKResponse {
            return this.post<ByteArray>("/themes", mapOf(), body)
    }


    /**
     * ### 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 help.looker.com to update your license for this feature.
     *
     * @param {String} id Match theme id.
     * @param {String} name Match theme name.
     * @param {Date} begin_at Timestamp for activation.
     * @param {Date} end_at Timestamp for expiration.
     * @param {Long} limit Number of results to return (used with `offset`).
     * @param {Long} offset Number of results to skip before returning any (used with `limit`).
     * @param {String} sorts Fields to sort by.
     * @param {String} fields Requested fields.
     * @param {Boolean} filter_or Combine given search criteria in a boolean OR expression
     *
     * GET /themes/search -> ByteArray
     */
    @JvmOverloads fun search_themes(
        id: String? = null,
        name: String? = null,
        begin_at: Date? = null,
        end_at: Date? = null,
        limit: Long? = null,
        offset: Long? = null,
        sorts: String? = null,
        fields: String? = null,
        filter_or: Boolean? = null
    ) : SDKResponse {
            return this.get<ByteArray>("/themes/search", 
                mapOf("id" to id,
                     "name" to name,
                     "begin_at" to begin_at,
                     "end_at" to end_at,
                     "limit" to limit,
                     "offset" to offset,
                     "sorts" to sorts,
                     "fields" to fields,
                     "filter_or" to filter_or))
    }


    /**
     * ### 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.
     *
     * @param {Date} ts Timestamp representing the target datetime for the active period. Defaults to 'now'
     *
     * GET /themes/default -> ByteArray
     */
    @JvmOverloads fun default_theme(
        ts: Date? = null
    ) : SDKResponse {
            return this.get<ByteArray>("/themes/default", 
                mapOf("ts" to ts))
    }


    /**
     * ### 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 help.looker.com to update your license for this feature.
     *
     * @param {String} name Name of theme to set as default
     *
     * PUT /themes/default -> ByteArray
     */
    fun set_default_theme(
        name: String
    ) : SDKResponse {
            return this.put<ByteArray>("/themes/default", 
                mapOf("name" to name))
    }


    /**
     * ### 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 help.looker.com to update your license for this feature.
     *
     * @param {String} name Name of theme
     * @param {Date} ts Timestamp representing the target datetime for the active period. Defaults to 'now'
     * @param {String} fields Requested fields.
     *
     * GET /themes/active -> ByteArray
     */
    @JvmOverloads fun active_themes(
        name: String? = null,
        ts: Date? = null,
        fields: String? = null
    ) : SDKResponse {
            return this.get<ByteArray>("/themes/active", 
                mapOf("name" to name,
                     "ts" to ts,
                     "fields" to fields))
    }


    /**
     * ### 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 help.looker.com to update your license for this feature.
     *
     * @param {String} name Name of theme
     * @param {Date} ts Timestamp representing the target datetime for the active period. Defaults to 'now'
     *
     * GET /themes/theme_or_default -> ByteArray
     */
    @JvmOverloads fun theme_or_default(
        name: String,
        ts: Date? = null
    ) : SDKResponse {
            return this.get<ByteArray>("/themes/theme_or_default", 
                mapOf("name" to name,
                     "ts" to ts))
    }


    /**
     * ### 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 help.looker.com to update your license for this feature.
     *
     * @param {WriteTheme} body
     *
     * POST /themes/validate -> ByteArray
     */
    fun validate_theme(
        body: WriteTheme
    ) : SDKResponse {
            return this.post<ByteArray>("/themes/validate", mapOf(), body)
    }


    /**
     * ### 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 help.looker.com to update your license for this feature.
     *
     * @param {String} theme_id Id of theme
     * @param {String} fields Requested fields.
     *
     * GET /themes/{theme_id} -> ByteArray
     */
    @JvmOverloads fun theme(
        theme_id: String,
        fields: String? = null
    ) : SDKResponse {
        val path_theme_id = encodeParam(theme_id)
            return this.get<ByteArray>("/themes/${path_theme_id}", 
                mapOf("fields" to fields))
    }


    /**
     * ### 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 help.looker.com to update your license for this feature.
     *
     * @param {String} theme_id Id of theme
     * @param {WriteTheme} body
     *
     * PATCH /themes/{theme_id} -> ByteArray
     */
    fun update_theme(
        theme_id: String,
        body: WriteTheme
    ) : SDKResponse {
        val path_theme_id = encodeParam(theme_id)
            return this.patch<ByteArray>("/themes/${path_theme_id}", mapOf(), body)
    }


    /**
     * ### 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 help.looker.com to update your license for this feature.
     *
     * @param {String} theme_id Id of theme
     *
     * DELETE /themes/{theme_id} -> ByteArray
     */
    fun delete_theme(
        theme_id: String
    ) : SDKResponse {
        val path_theme_id = encodeParam(theme_id)
            return this.delete<ByteArray>("/themes/${path_theme_id}", mapOf())
    }

    //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.
     *
     * @param {String} fields Requested fields.
     * @param {Long} limit Number of results to return (used with `offset`).
     * @param {Long} offset Number of results to skip before returning any (used with `limit`).
     * @param {String} sorts Fields to sort by.
     * @param {String} id Match credentials_email id.
     * @param {String} email Match credentials_email email.
     * @param {String} emails Find credentials_email that match given emails.
     * @param {Boolean} filter_or Combine given search criteria in a boolean OR expression.
     *
     * GET /credentials_email/search -> ByteArray
     */
    @JvmOverloads fun search_credentials_email(
        fields: String? = null,
        limit: Long? = null,
        offset: Long? = null,
        sorts: String? = null,
        id: String? = null,
        email: String? = null,
        emails: String? = null,
        filter_or: Boolean? = null
    ) : SDKResponse {
            return this.get<ByteArray>("/credentials_email/search", 
                mapOf("fields" to fields,
                     "limit" to limit,
                     "offset" to offset,
                     "sorts" to sorts,
                     "id" to id,
                     "email" to email,
                     "emails" to emails,
                     "filter_or" to filter_or))
    }


    /**
     * ### Get information about the current user; i.e. the user account currently calling the API.
     *
     * @param {String} fields Requested fields.
     *
     * GET /user -> ByteArray
     */
    @JvmOverloads fun me(
        fields: String? = null
    ) : SDKResponse {
            return this.get<ByteArray>("/user", 
                mapOf("fields" to fields))
    }


    /**
     * ### Get information about all users.
     *
     * @param {String} fields Requested fields.
     * @param {Long} page DEPRECATED. Use limit and offset instead. Return only page N of paginated results
     * @param {Long} per_page DEPRECATED. Use limit and offset instead. Return N rows of data per page
     * @param {Long} limit Number of results to return. (used with offset and takes priority over page and per_page)
     * @param {Long} offset Number of results to skip before returning any. (used with limit and takes priority over page and per_page)
     * @param {String} sorts Fields to sort by.
     * @param {DelimArray<String>} ids Optional list of ids to get specific users.
     *
     * GET /users -> ByteArray
     */
    @JvmOverloads fun all_users(
        fields: String? = null,
        page: Long? = null,
        per_page: Long? = null,
        limit: Long? = null,
        offset: Long? = null,
        sorts: String? = null,
        ids: DelimArray<String>? = null
    ) : SDKResponse {
            return this.get<ByteArray>("/users", 
                mapOf("fields" to fields,
                     "page" to page,
                     "per_page" to per_page,
                     "limit" to limit,
                     "offset" to offset,
                     "sorts" to sorts,
                     "ids" to ids))
    }


    /**
     * ### Create a user with the specified information.
     *
     * @param {WriteUser} body
     * @param {String} fields Requested fields.
     *
     * POST /users -> ByteArray
     */
    @JvmOverloads fun create_user(
        body: WriteUser? = null,
        fields: String? = null
    ) : SDKResponse {
            return this.post<ByteArray>("/users", 
                mapOf("fields" to fields), body)
    }


    /**
     * ### 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.
     *
     * @param {String} fields Include only these fields in the response
     * @param {Long} page DEPRECATED. Use limit and offset instead. Return only page N of paginated results
     * @param {Long} per_page DEPRECATED. Use limit and offset instead. Return N rows of data per page
     * @param {Long} limit Number of results to return. (used with offset and takes priority over page and per_page)
     * @param {Long} offset Number of results to skip before returning any. (used with limit and takes priority over page and per_page)
     * @param {String} sorts Fields to sort by.
     * @param {String} id Match User Id.
     * @param {String} first_name Match First name.
     * @param {String} last_name Match Last name.
     * @param {Boolean} verified_looker_employee Search for user accounts associated with Looker employees
     * @param {Boolean} embed_user Search for only embed users
     * @param {String} email Search for the user with this email address
     * @param {Boolean} is_disabled Search for disabled user accounts
     * @param {Boolean} filter_or Combine given search criteria in a boolean OR expression
     * @param {String} content_metadata_id Search for users who have access to this content_metadata item
     * @param {String} group_id Search for users who are direct members of this group
     *
     * GET /users/search -> ByteArray
     */
    @JvmOverloads fun search_users(
        fields: String? = null,
        page: Long? = null,
        per_page: Long? = null,
        limit: Long? = null,
        offset: Long? = null,
        sorts: String? = null,
        id: String? = null,
        first_name: String? = null,
        last_name: String? = null,
        verified_looker_employee: Boolean? = null,
        embed_user: Boolean? = null,
        email: String? = null,
        is_disabled: Boolean? = null,
        filter_or: Boolean? = null,
        content_metadata_id: String? = null,
        group_id: String? = null
    ) : SDKResponse {
            return this.get<ByteArray>("/users/search", 
                mapOf("fields" to fields,
                     "page" to page,
                     "per_page" to per_page,
                     "limit" to limit,
                     "offset" to offset,
                     "sorts" to sorts,
                     "id" to id,
                     "first_name" to first_name,
                     "last_name" to last_name,
                     "verified_looker_employee" to verified_looker_employee,
                     "embed_user" to embed_user,
                     "email" to email,
                     "is_disabled" to is_disabled,
                     "filter_or" to filter_or,
                     "content_metadata_id" to content_metadata_id,
                     "group_id" to group_id))
    }


    /**
     * ### 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.
     *
     * @param {String} pattern Pattern to match
     * @param {String} fields Include only these fields in the response
     * @param {Long} page DEPRECATED. Use limit and offset instead. Return only page N of paginated results
     * @param {Long} per_page DEPRECATED. Use limit and offset instead. Return N rows of data per page
     * @param {Long} limit Number of results to return. (used with offset and takes priority over page and per_page)
     * @param {Long} offset Number of results to skip before returning any. (used with limit and takes priority over page and per_page)
     * @param {String} sorts Fields to sort by
     * @param {String} id Match User Id
     * @param {String} first_name Match First name
     * @param {String} last_name Match Last name
     * @param {Boolean} verified_looker_employee Match Verified Looker employee
     * @param {String} email Match Email Address
     * @param {Boolean} is_disabled Include or exclude disabled accounts in the results
     *
     * GET /users/search/names/{pattern} -> ByteArray
     */
    @JvmOverloads fun search_users_names(
        pattern: String,
        fields: String? = null,
        page: Long? = null,
        per_page: Long? = null,
        limit: Long? = null,
        offset: Long? = null,
        sorts: String? = null,
        id: String? = null,
        first_name: String? = null,
        last_name: String? = null,
        verified_looker_employee: Boolean? = null,
        email: String? = null,
        is_disabled: Boolean? = null
    ) : SDKResponse {
        val path_pattern = encodeParam(pattern)
            return this.get<ByteArray>("/users/search/names/${path_pattern}", 
                mapOf("fields" to fields,
                     "page" to page,
                     "per_page" to per_page,
                     "limit" to limit,
                     "offset" to offset,
                     "sorts" to sorts,
                     "id" to id,
                     "first_name" to first_name,
                     "last_name" to last_name,
                     "verified_looker_employee" to verified_looker_employee,
                     "email" to email,
                     "is_disabled" to is_disabled))
    }


    /**
     * ### 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.
     *
     * @param {String} user_id Id of user
     * @param {String} fields Requested fields.
     *
     * GET /users/{user_id} -> ByteArray
     */
    @JvmOverloads fun user(
        user_id: String,
        fields: String? = null
    ) : SDKResponse {
        val path_user_id = encodeParam(user_id)
            return this.get<ByteArray>("/users/${path_user_id}", 
                mapOf("fields" to fields))
    }


    /**
     * ### Update information about the user with a specific id.
     *
     * @param {String} user_id Id of user
     * @param {WriteUser} body
     * @param {String} fields Requested fields.
     *
     * PATCH /users/{user_id} -> ByteArray
     */
    @JvmOverloads fun update_user(
        user_id: String,
        body: WriteUser,
        fields: String? = null
    ) : SDKResponse {
        val path_user_id = encodeParam(user_id)
            return this.patch<ByteArray>("/users/${path_user_id}", 
                mapOf("fields" to fields), body)
    }


    /**
     * ### Delete the user with a specific id.
     *
     * **DANGER** this will delete the user and all looks and other information owned by the user.
     *
     * @param {String} user_id Id of user
     *
     * DELETE /users/{user_id} -> ByteArray
     */
    fun delete_user(
        user_id: String
    ) : SDKResponse {
        val path_user_id = encodeParam(user_id)
            return this.delete<ByteArray>("/users/${path_user_id}", mapOf())
    }


    /**
     * ### 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'.
     *
     * @param {String} credential_type Type name of credential
     * @param {String} credential_id Id of credential
     * @param {String} fields Requested fields.
     *
     * GET /users/credential/{credential_type}/{credential_id} -> ByteArray
     */
    @JvmOverloads fun user_for_credential(
        credential_type: String,
        credential_id: String,
        fields: String? = null
    ) : SDKResponse {
        val path_credential_type = encodeParam(credential_type)
        val path_credential_id = encodeParam(credential_id)
            return this.get<ByteArray>("/users/credential/${path_credential_type}/${path_credential_id}", 
                mapOf("fields" to fields))
    }


    /**
     * ### Email/password login information for the specified user.
     *
     * @param {String} user_id Id of user
     * @param {String} fields Requested fields.
     *
     * GET /users/{user_id}/credentials_email -> ByteArray
     */
    @JvmOverloads fun user_credentials_email(
        user_id: String,
        fields: String? = null
    ) : SDKResponse {
        val path_user_id = encodeParam(user_id)
            return this.get<ByteArray>("/users/${path_user_id}/credentials_email", 
                mapOf("fields" to fields))
    }


    /**
     * ### Email/password login information for the specified user.
     *
     * @param {String} user_id Id of user
     * @param {WriteCredentialsEmail} body
     * @param {String} fields Requested fields.
     *
     * POST /users/{user_id}/credentials_email -> ByteArray
     */
    @JvmOverloads fun create_user_credentials_email(
        user_id: String,
        body: WriteCredentialsEmail,
        fields: String? = null
    ) : SDKResponse {
        val path_user_id = encodeParam(user_id)
            return this.post<ByteArray>("/users/${path_user_id}/credentials_email", 
                mapOf("fields" to fields), body)
    }


    /**
     * ### Email/password login information for the specified user.
     *
     * @param {String} user_id Id of user
     * @param {WriteCredentialsEmail} body
     * @param {String} fields Requested fields.
     *
     * PATCH /users/{user_id}/credentials_email -> ByteArray
     */
    @JvmOverloads fun update_user_credentials_email(
        user_id: String,
        body: WriteCredentialsEmail,
        fields: String? = null
    ) : SDKResponse {
        val path_user_id = encodeParam(user_id)
            return this.patch<ByteArray>("/users/${path_user_id}/credentials_email", 
                mapOf("fields" to fields), body)
    }


    /**
     * ### Email/password login information for the specified user.
     *
     * @param {String} user_id Id of user
     *
     * DELETE /users/{user_id}/credentials_email -> ByteArray
     */
    fun delete_user_credentials_email(
        user_id: String
    ) : SDKResponse {
        val path_user_id = encodeParam(user_id)
            return this.delete<ByteArray>("/users/${path_user_id}/credentials_email", mapOf())
    }


    /**
     * ### Two-factor login information for the specified user.
     *
     * @param {String} user_id Id of user
     * @param {String} fields Requested fields.
     *
     * GET /users/{user_id}/credentials_totp -> ByteArray
     */
    @JvmOverloads fun user_credentials_totp(
        user_id: String,
        fields: String? = null
    ) : SDKResponse {
        val path_user_id = encodeParam(user_id)
            return this.get<ByteArray>("/users/${path_user_id}/credentials_totp", 
                mapOf("fields" to fields))
    }


    /**
     * ### Two-factor login information for the specified user.
     *
     * @param {String} user_id Id of user
     * @param {CredentialsTotp} body WARNING: no writeable properties found for POST, PUT, or PATCH
     * @param {String} fields Requested fields.
     *
     * POST /users/{user_id}/credentials_totp -> ByteArray
     */
    @JvmOverloads fun create_user_credentials_totp(
        user_id: String,
        body: CredentialsTotp? = null,
        fields: String? = null
    ) : SDKResponse {
        val path_user_id = encodeParam(user_id)
            return this.post<ByteArray>("/users/${path_user_id}/credentials_totp", 
                mapOf("fields" to fields), body)
    }


    /**
     * ### Two-factor login information for the specified user.
     *
     * @param {String} user_id Id of user
     *
     * DELETE /users/{user_id}/credentials_totp -> ByteArray
     */
    fun delete_user_credentials_totp(
        user_id: String
    ) : SDKResponse {
        val path_user_id = encodeParam(user_id)
            return this.delete<ByteArray>("/users/${path_user_id}/credentials_totp", mapOf())
    }


    /**
     * ### LDAP login information for the specified user.
     *
     * @param {String} user_id Id of user
     * @param {String} fields Requested fields.
     *
     * GET /users/{user_id}/credentials_ldap -> ByteArray
     */
    @JvmOverloads fun user_credentials_ldap(
        user_id: String,
        fields: String? = null
    ) : SDKResponse {
        val path_user_id = encodeParam(user_id)
            return this.get<ByteArray>("/users/${path_user_id}/credentials_ldap", 
                mapOf("fields" to fields))
    }


    /**
     * ### LDAP login information for the specified user.
     *
     * @param {String} user_id Id of user
     *
     * DELETE /users/{user_id}/credentials_ldap -> ByteArray
     */
    fun delete_user_credentials_ldap(
        user_id: String
    ) : SDKResponse {
        val path_user_id = encodeParam(user_id)
            return this.delete<ByteArray>("/users/${path_user_id}/credentials_ldap", mapOf())
    }


    /**
     * ### Google authentication login information for the specified user.
     *
     * @param {String} user_id Id of user
     * @param {String} fields Requested fields.
     *
     * GET /users/{user_id}/credentials_google -> ByteArray
     */
    @JvmOverloads fun user_credentials_google(
        user_id: String,
        fields: String? = null
    ) : SDKResponse {
        val path_user_id = encodeParam(user_id)
            return this.get<ByteArray>("/users/${path_user_id}/credentials_google", 
                mapOf("fields" to fields))
    }


    /**
     * ### Google authentication login information for the specified user.
     *
     * @param {String} user_id Id of user
     *
     * DELETE /users/{user_id}/credentials_google -> ByteArray
     */
    fun delete_user_credentials_google(
        user_id: String
    ) : SDKResponse {
        val path_user_id = encodeParam(user_id)
            return this.delete<ByteArray>("/users/${path_user_id}/credentials_google", mapOf())
    }


    /**
     * ### Saml authentication login information for the specified user.
     *
     * @param {String} user_id Id of user
     * @param {String} fields Requested fields.
     *
     * GET /users/{user_id}/credentials_saml -> ByteArray
     */
    @JvmOverloads fun user_credentials_saml(
        user_id: String,
        fields: String? = null
    ) : SDKResponse {
        val path_user_id = encodeParam(user_id)
            return this.get<ByteArray>("/users/${path_user_id}/credentials_saml", 
                mapOf("fields" to fields))
    }


    /**
     * ### Saml authentication login information for the specified user.
     *
     * @param {String} user_id Id of user
     *
     * DELETE /users/{user_id}/credentials_saml -> ByteArray
     */
    fun delete_user_credentials_saml(
        user_id: String
    ) : SDKResponse {
        val path_user_id = encodeParam(user_id)
            return this.delete<ByteArray>("/users/${path_user_id}/credentials_saml", mapOf())
    }


    /**
     * ### OpenID Connect (OIDC) authentication login information for the specified user.
     *
     * @param {String} user_id Id of user
     * @param {String} fields Requested fields.
     *
     * GET /users/{user_id}/credentials_oidc -> ByteArray
     */
    @JvmOverloads fun user_credentials_oidc(
        user_id: String,
        fields: String? = null
    ) : SDKResponse {
        val path_user_id = encodeParam(user_id)
            return this.get<ByteArray>("/users/${path_user_id}/credentials_oidc", 
                mapOf("fields" to fields))
    }


    /**
     * ### OpenID Connect (OIDC) authentication login information for the specified user.
     *
     * @param {String} user_id Id of user
     *
     * DELETE /users/{user_id}/credentials_oidc -> ByteArray
     */
    fun delete_user_credentials_oidc(
        user_id: String
    ) : SDKResponse {
        val path_user_id = encodeParam(user_id)
            return this.delete<ByteArray>("/users/${path_user_id}/credentials_oidc", mapOf())
    }


    /**
     * ### API 3 login information for the specified user. This is for the newer API keys that can be added for any user.
     *
     * @param {String} user_id Id of user
     * @param {String} credentials_api3_id Id of API 3 Credential
     * @param {String} fields Requested fields.
     *
     * GET /users/{user_id}/credentials_api3/{credentials_api3_id} -> ByteArray
     */
    @JvmOverloads fun user_credentials_api3(
        user_id: String,
        credentials_api3_id: String,
        fields: String? = null
    ) : SDKResponse {
        val path_user_id = encodeParam(user_id)
        val path_credentials_api3_id = encodeParam(credentials_api3_id)
            return this.get<ByteArray>("/users/${path_user_id}/credentials_api3/${path_credentials_api3_id}", 
                mapOf("fields" to fields))
    }


    /**
     * ### API 3 login information for the specified user. This is for the newer API keys that can be added for any user.
     *
     * @param {String} user_id Id of user
     * @param {String} credentials_api3_id Id of API 3 Credential
     *
     * DELETE /users/{user_id}/credentials_api3/{credentials_api3_id} -> ByteArray
     */
    fun delete_user_credentials_api3(
        user_id: String,
        credentials_api3_id: String
    ) : SDKResponse {
        val path_user_id = encodeParam(user_id)
        val path_credentials_api3_id = encodeParam(credentials_api3_id)
            return this.delete<ByteArray>("/users/${path_user_id}/credentials_api3/${path_credentials_api3_id}", mapOf())
    }


    /**
     * ### API 3 login information for the specified user. This is for the newer API keys that can be added for any user.
     *
     * @param {String} user_id Id of user
     * @param {String} fields Requested fields.
     *
     * GET /users/{user_id}/credentials_api3 -> ByteArray
     */
    @JvmOverloads fun all_user_credentials_api3s(
        user_id: String,
        fields: String? = null
    ) : SDKResponse {
        val path_user_id = encodeParam(user_id)
            return this.get<ByteArray>("/users/${path_user_id}/credentials_api3", 
                mapOf("fields" to fields))
    }


    /**
     * ### API 3 login information for the specified user. This is for the newer API keys that can be added for any user.
     *
     * @param {String} user_id Id of user
     * @param {String} fields Requested fields.
     *
     * POST /users/{user_id}/credentials_api3 -> ByteArray
     */
    @JvmOverloads fun create_user_credentials_api3(
        user_id: String,
        fields: String? = null
    ) : SDKResponse {
        val path_user_id = encodeParam(user_id)
            return this.post<ByteArray>("/users/${path_user_id}/credentials_api3", 
                mapOf("fields" to fields))
    }


    /**
     * ### Embed login information for the specified user.
     *
     * @param {String} user_id Id of user
     * @param {String} credentials_embed_id Id of Embedding Credential
     * @param {String} fields Requested fields.
     *
     * GET /users/{user_id}/credentials_embed/{credentials_embed_id} -> ByteArray
     */
    @JvmOverloads fun user_credentials_embed(
        user_id: String,
        credentials_embed_id: String,
        fields: String? = null
    ) : SDKResponse {
        val path_user_id = encodeParam(user_id)
        val path_credentials_embed_id = encodeParam(credentials_embed_id)
            return this.get<ByteArray>("/users/${path_user_id}/credentials_embed/${path_credentials_embed_id}", 
                mapOf("fields" to fields))
    }


    /**
     * ### Embed login information for the specified user.
     *
     * @param {String} user_id Id of user
     * @param {String} credentials_embed_id Id of Embedding Credential
     *
     * DELETE /users/{user_id}/credentials_embed/{credentials_embed_id} -> ByteArray
     */
    fun delete_user_credentials_embed(
        user_id: String,
        credentials_embed_id: String
    ) : SDKResponse {
        val path_user_id = encodeParam(user_id)
        val path_credentials_embed_id = encodeParam(credentials_embed_id)
            return this.delete<ByteArray>("/users/${path_user_id}/credentials_embed/${path_credentials_embed_id}", mapOf())
    }


    /**
     * ### Embed login information for the specified user.
     *
     * @param {String} user_id Id of user
     * @param {String} fields Requested fields.
     *
     * GET /users/{user_id}/credentials_embed -> ByteArray
     */
    @JvmOverloads fun all_user_credentials_embeds(
        user_id: String,
        fields: String? = null
    ) : SDKResponse {
        val path_user_id = encodeParam(user_id)
            return this.get<ByteArray>("/users/${path_user_id}/credentials_embed", 
                mapOf("fields" to fields))
    }


    /**
     * ### Looker Openid login information for the specified user. Used by Looker Analysts.
     *
     * @param {String} user_id Id of user
     * @param {String} fields Requested fields.
     *
     * GET /users/{user_id}/credentials_looker_openid -> ByteArray
     */
    @JvmOverloads fun user_credentials_looker_openid(
        user_id: String,
        fields: String? = null
    ) : SDKResponse {
        val path_user_id = encodeParam(user_id)
            return this.get<ByteArray>("/users/${path_user_id}/credentials_looker_openid", 
                mapOf("fields" to fields))
    }


    /**
     * ### Looker Openid login information for the specified user. Used by Looker Analysts.
     *
     * @param {String} user_id Id of user
     *
     * DELETE /users/{user_id}/credentials_looker_openid -> ByteArray
     */
    fun delete_user_credentials_looker_openid(
        user_id: String
    ) : SDKResponse {
        val path_user_id = encodeParam(user_id)
            return this.delete<ByteArray>("/users/${path_user_id}/credentials_looker_openid", mapOf())
    }


    /**
     * ### Web login session for the specified user.
     *
     * @param {String} user_id Id of user
     * @param {String} session_id Id of Web Login Session
     * @param {String} fields Requested fields.
     *
     * GET /users/{user_id}/sessions/{session_id} -> ByteArray
     */
    @JvmOverloads fun user_session(
        user_id: String,
        session_id: String,
        fields: String? = null
    ) : SDKResponse {
        val path_user_id = encodeParam(user_id)
        val path_session_id = encodeParam(session_id)
            return this.get<ByteArray>("/users/${path_user_id}/sessions/${path_session_id}", 
                mapOf("fields" to fields))
    }


    /**
     * ### Web login session for the specified user.
     *
     * @param {String} user_id Id of user
     * @param {String} session_id Id of Web Login Session
     *
     * DELETE /users/{user_id}/sessions/{session_id} -> ByteArray
     */
    fun delete_user_session(
        user_id: String,
        session_id: String
    ) : SDKResponse {
        val path_user_id = encodeParam(user_id)
        val path_session_id = encodeParam(session_id)
            return this.delete<ByteArray>("/users/${path_user_id}/sessions/${path_session_id}", mapOf())
    }


    /**
     * ### Web login session for the specified user.
     *
     * @param {String} user_id Id of user
     * @param {String} fields Requested fields.
     *
     * GET /users/{user_id}/sessions -> ByteArray
     */
    @JvmOverloads fun all_user_sessions(
        user_id: String,
        fields: String? = null
    ) : SDKResponse {
        val path_user_id = encodeParam(user_id)
            return this.get<ByteArray>("/users/${path_user_id}/sessions", 
                mapOf("fields" to fields))
    }


    /**
     * ### 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.
     *
     * @param {String} user_id Id of user
     * @param {Boolean} expires Expiring token.
     * @param {String} fields Requested fields.
     *
     * POST /users/{user_id}/credentials_email/password_reset -> ByteArray
     */
    @JvmOverloads fun create_user_credentials_email_password_reset(
        user_id: String,
        expires: Boolean? = null,
        fields: String? = null
    ) : SDKResponse {
        val path_user_id = encodeParam(user_id)
            return this.post<ByteArray>("/users/${path_user_id}/credentials_email/password_reset", 
                mapOf("expires" to expires,
                     "fields" to fields))
    }


    /**
     * ### Get information about roles of a given user
     *
     * @param {String} user_id Id of user
     * @param {String} fields Requested fields.
     * @param {Boolean} direct_association_only Get only roles associated directly with the user: exclude those only associated through groups.
     *
     * GET /users/{user_id}/roles -> ByteArray
     */
    @JvmOverloads fun user_roles(
        user_id: String,
        fields: String? = null,
        direct_association_only: Boolean? = null
    ) : SDKResponse {
        val path_user_id = encodeParam(user_id)
            return this.get<ByteArray>("/users/${path_user_id}/roles", 
                mapOf("fields" to fields,
                     "direct_association_only" to direct_association_only))
    }


    /**
     * ### Set roles of the user with a specific id.
     *
     * @param {String} user_id Id of user
     * @param {Array<String>} body
     * @param {String} fields Requested fields.
     *
     * PUT /users/{user_id}/roles -> ByteArray
     */
    @JvmOverloads fun set_user_roles(
        user_id: String,
        body: Array<String>,
        fields: String? = null
    ) : SDKResponse {
        val path_user_id = encodeParam(user_id)
            return this.put<ByteArray>("/users/${path_user_id}/roles", 
                mapOf("fields" to fields), body)
    }


    /**
     * ### 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.
     *
     * @param {String} user_id Id of user
     * @param {String} fields Requested fields.
     * @param {DelimArray<String>} user_attribute_ids Specific user attributes to request. Omit or leave blank to request all user attributes.
     * @param {Boolean} all_values If true, returns all values in the search path instead of just the first value found. Useful for debugging group precedence.
     * @param {Boolean} include_unset If true, returns an empty record for each requested attribute that has no user, group, or default value.
     *
     * GET /users/{user_id}/attribute_values -> ByteArray
     */
    @JvmOverloads fun user_attribute_user_values(
        user_id: String,
        fields: String? = null,
        user_attribute_ids: DelimArray<String>? = null,
        all_values: Boolean? = null,
        include_unset: Boolean? = null
    ) : SDKResponse {
        val path_user_id = encodeParam(user_id)
            return this.get<ByteArray>("/users/${path_user_id}/attribute_values", 
                mapOf("fields" to fields,
                     "user_attribute_ids" to user_attribute_ids,
                     "all_values" to all_values,
                     "include_unset" to include_unset))
    }


    /**
     * ### 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.
     *
     * @param {String} user_id Id of user
     * @param {String} user_attribute_id Id of user attribute
     * @param {WriteUserAttributeWithValue} body
     *
     * PATCH /users/{user_id}/attribute_values/{user_attribute_id} -> ByteArray
     */
    fun set_user_attribute_user_value(
        user_id: String,
        user_attribute_id: String,
        body: WriteUserAttributeWithValue
    ) : SDKResponse {
        val path_user_id = encodeParam(user_id)
        val path_user_attribute_id = encodeParam(user_attribute_id)
            return this.patch<ByteArray>("/users/${path_user_id}/attribute_values/${path_user_attribute_id}", mapOf(), body)
    }


    /**
     * ### 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.
     *
     * @param {String} user_id Id of user
     * @param {String} user_attribute_id Id of user attribute
     *
     * DELETE /users/{user_id}/attribute_values/{user_attribute_id} -> ByteArray
     */
    fun delete_user_attribute_user_value(
        user_id: String,
        user_attribute_id: String
    ) : SDKResponse {
        val path_user_id = encodeParam(user_id)
        val path_user_attribute_id = encodeParam(user_attribute_id)
            return this.delete<ByteArray>("/users/${path_user_id}/attribute_values/${path_user_attribute_id}", mapOf())
    }


    /**
     * ### 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.
     *
     * @param {String} user_id Id of user
     * @param {String} fields Requested fields.
     *
     * POST /users/{user_id}/credentials_email/send_password_reset -> ByteArray
     */
    @JvmOverloads fun send_user_credentials_email_password_reset(
        user_id: String,
        fields: String? = null
    ) : SDKResponse {
        val path_user_id = encodeParam(user_id)
            return this.post<ByteArray>("/users/${path_user_id}/credentials_email/send_password_reset", 
                mapOf("fields" to fields))
    }


    /**
     * ### 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.
     *
     * @param {String} user_id Id of user
     * @param {UserEmailOnly} body
     * @param {String} fields Requested fields.
     *
     * POST /users/{user_id}/update_emails -> ByteArray
     */
    @JvmOverloads fun wipeout_user_emails(
        user_id: String,
        body: UserEmailOnly,
        fields: String? = null
    ) : SDKResponse {
        val path_user_id = encodeParam(user_id)
            return this.post<ByteArray>("/users/${path_user_id}/update_emails", 
                mapOf("fields" to fields), body)
    }


    /**
     * Create an embed user from an external user ID
     *
     * @param {CreateEmbedUserRequest} body
     *
     * POST /users/embed_user -> ByteArray
     */
    fun create_embed_user(
        body: CreateEmbedUserRequest
    ) : SDKResponse {
            return this.post<ByteArray>("/users/embed_user", mapOf(), body)
    }

    //endregion User: Manage Users

    //region UserAttribute: Manage User Attributes


    /**
     * ### Get information about all user attributes.
     *
     * @param {String} fields Requested fields.
     * @param {String} sorts Fields to order the results by. Sortable fields include: name, label
     *
     * GET /user_attributes -> ByteArray
     */
    @JvmOverloads fun all_user_attributes(
        fields: String? = null,
        sorts: String? = null
    ) : SDKResponse {
            return this.get<ByteArray>("/user_attributes", 
                mapOf("fields" to fields,
                     "sorts" to sorts))
    }


    /**
     * ### 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.
     *
     * @param {WriteUserAttribute} body
     * @param {String} fields Requested fields.
     *
     * POST /user_attributes -> ByteArray
     */
    @JvmOverloads fun create_user_attribute(
        body: WriteUserAttribute,
        fields: String? = null
    ) : SDKResponse {
            return this.post<ByteArray>("/user_attributes", 
                mapOf("fields" to fields), body)
    }


    /**
     * ### Get information about a user attribute.
     *
     * @param {String} user_attribute_id Id of user attribute
     * @param {String} fields Requested fields.
     *
     * GET /user_attributes/{user_attribute_id} -> ByteArray
     */
    @JvmOverloads fun user_attribute(
        user_attribute_id: String,
        fields: String? = null
    ) : SDKResponse {
        val path_user_attribute_id = encodeParam(user_attribute_id)
            return this.get<ByteArray>("/user_attributes/${path_user_attribute_id}", 
                mapOf("fields" to fields))
    }


    /**
     * ### Update a user attribute definition.
     *
     * @param {String} user_attribute_id Id of user attribute
     * @param {WriteUserAttribute} body
     * @param {String} fields Requested fields.
     *
     * PATCH /user_attributes/{user_attribute_id} -> ByteArray
     */
    @JvmOverloads fun update_user_attribute(
        user_attribute_id: String,
        body: WriteUserAttribute,
        fields: String? = null
    ) : SDKResponse {
        val path_user_attribute_id = encodeParam(user_attribute_id)
            return this.patch<ByteArray>("/user_attributes/${path_user_attribute_id}", 
                mapOf("fields" to fields), body)
    }


    /**
     * ### Delete a user attribute (admin only).
     *
     * @param {String} user_attribute_id Id of user attribute
     *
     * DELETE /user_attributes/{user_attribute_id} -> ByteArray
     */
    fun delete_user_attribute(
        user_attribute_id: String
    ) : SDKResponse {
        val path_user_attribute_id = encodeParam(user_attribute_id)
            return this.delete<ByteArray>("/user_attributes/${path_user_attribute_id}", mapOf())
    }


    /**
     * ### 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.
     *
     * @param {String} user_attribute_id Id of user attribute
     * @param {String} fields Requested fields.
     *
     * GET /user_attributes/{user_attribute_id}/group_values -> ByteArray
     */
    @JvmOverloads fun all_user_attribute_group_values(
        user_attribute_id: String,
        fields: String? = null
    ) : SDKResponse {
        val path_user_attribute_id = encodeParam(user_attribute_id)
            return this.get<ByteArray>("/user_attributes/${path_user_attribute_id}/group_values", 
                mapOf("fields" to fields))
    }


    /**
     * ### 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).
     *
     * @param {String} user_attribute_id Id of user attribute
     * @param {Array<UserAttributeGroupValue>} body
     *
     * POST /user_attributes/{user_attribute_id}/group_values -> ByteArray
     */
    fun set_user_attribute_group_values(
        user_attribute_id: String,
        body: Array<UserAttributeGroupValue>
    ) : SDKResponse {
        val path_user_attribute_id = encodeParam(user_attribute_id)
            return this.post<ByteArray>("/user_attributes/${path_user_attribute_id}/group_values", mapOf(), body)
    }

    //endregion UserAttribute: Manage User Attributes

    //region Workspace: Manage Workspaces


    /**
     * ### Get All Workspaces
     *
     * Returns all workspaces available to the calling user.
     *
     * GET /workspaces -> ByteArray
     */
    fun all_workspaces(

    ) : SDKResponse {
            return this.get<ByteArray>("/workspaces", mapOf())
    }


    /**
     * ### 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 API3 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.
     *
     * @param {String} workspace_id Id of the workspace
     *
     * GET /workspaces/{workspace_id} -> ByteArray
     */
    fun workspace(
        workspace_id: String
    ) : SDKResponse {
        val path_workspace_id = encodeParam(workspace_id)
            return this.get<ByteArray>("/workspaces/${path_workspace_id}", mapOf())
    }

    //endregion Workspace: Manage Workspaces

}