paths.go

// Code generated by `generate`. DO NOT EDIT.

package kittycad

import (
	"bytes"
	"encoding/json"
	"errors"
	"fmt"
	"net/http"
	"net/url"
	"strconv"
	"strings"

	"github.com/gorilla/schema"
	"github.com/gorilla/websocket"
)

// GetSchema: Get OpenAPI schema.
func (s *MetaService) GetSchema() error {
	// Create the url.
	path := "/"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return fmt.Errorf("error creating request: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return err
	}

	// Return.
	return nil

}

// Getdata: Get the metadata about our currently running server.
// This includes information on any of our other distributed systems it is connected to.
//
// You must be a Zoo employee to perform this request.
func (s *MetaService) Getdata() (*Metadata, error) {
	// Create the url.
	path := "/_meta/info"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded Metadata
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// GetIpinfo: Get ip address information.
func (s *MetaService) GetIpinfo() (*IpAddrInfo, error) {
	// Create the url.
	path := "/_meta/ipinfo"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded IpAddrInfo
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// CreateTextToCad: Generate a CAD model from text.
// Because our source of truth for the resulting model is a STEP file, you will always have STEP file contents when you list your generated models. Any other formats you request here will also be returned when you list your generated models.
//
// This operation is performed asynchronously, the `id` of the operation will be returned. You can use the `id` returned from the request to get status information about the async operation from the `/async/operations/{id}` endpoint.
//
// One thing to note, if you hit the cache, this endpoint will return right away. So you only have to wait if the status is not `Completed` or `Failed`.
//
// Parameters
//
//   - `outputFormat`: The valid types of output file formats.
//   - `kcl`
//   - `body`: Body for generating models from text.
func (s *MlService) CreateTextToCad(outputFormat FileExportFormat, kcl bool, body TextToCadCreateBody) (*TextToCad, error) {
	// Create the url.
	path := "/ai/text-to-cad/{{.output_format}}"
	uri := resolveRelative(s.client.server, path)

	// Encode the request body as json.
	b := new(bytes.Buffer)
	if err := json.NewEncoder(b).Encode(body); err != nil {
		return nil, fmt.Errorf("encoding json body request failed: %v", err)
	}

	// Create the request.
	req, err := http.NewRequest("POST", uri, b)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add our headers.
	req.Header.Add("Content-Type", "application/json")

	// Add the parameters to the url.
	if err := expandURL(req.URL, map[string]string{
		"output_format": string(outputFormat),
		"kcl":           strconv.FormatBool(kcl),
	}); err != nil {
		return nil, fmt.Errorf("expanding URL with parameters failed: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded TextToCad
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// GetMetrics: Get API call metrics.
// This endpoint requires authentication by a Zoo employee. The API calls are grouped by the parameter passed.
//
// Parameters
//
//   - `groupBy`: The field of an API call to group by.
func (s *APICallService) GetMetrics(groupBy APICallQueryGroupBy) (*[]APICallQueryGroup, error) {
	// Create the url.
	path := "/api-call-metrics"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add the parameters to the url.
	if err := expandURL(req.URL, map[string]string{
		"group_by": string(groupBy),
	}); err != nil {
		return nil, fmt.Errorf("expanding URL with parameters failed: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded []APICallQueryGroup
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// List: List API calls.
// This endpoint requires authentication by a Zoo employee. The API calls are returned in order of creation, with the most recently created API calls first.
//
// Parameters
//
//   - `limit`
//
//   - `pageToken`
//
//   - `sortBy`: Supported set of sort modes for scanning by created_at only.
//
//     Currently, we only support scanning in ascending order.
func (s *APICallService) List(limit int, pageToken string, sortBy CreatedAtSortMode) (*APICallWithPriceResultsPage, error) {
	// Create the url.
	path := "/api-calls"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add the parameters to the url.
	if err := expandURL(req.URL, map[string]string{
		"limit":      strconv.Itoa(limit),
		"page_token": pageToken,
		"sort_by":    string(sortBy),
	}); err != nil {
		return nil, fmt.Errorf("expanding URL with parameters failed: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded APICallWithPriceResultsPage
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// Get: Get details of an API call.
// This endpoint requires authentication by any Zoo user. It returns details of the requested API call for the user.
//
// If the user is not authenticated to view the specified API call, then it is not returned.
//
// Only Zoo employees can view API calls for other users.
//
// Parameters
//
//   - `id`
func (s *APICallService) Get(id UUID) (*APICallWithPrice, error) {
	// Create the url.
	path := "/api-calls/{{.id}}"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add the parameters to the url.
	if err := expandURL(req.URL, map[string]string{
		"id": id.String(),
	}); err != nil {
		return nil, fmt.Errorf("expanding URL with parameters failed: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded APICallWithPrice
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// GithubCallback: Listen for callbacks to GitHub app authentication.
// This is different than OAuth 2.0 authentication for users. This endpoint grants access for Zoo to access user's repos.
//
// The user doesn't need Zoo OAuth authorization for this endpoint, this is purely for the GitHub permissions to access repos.
//
// Parameters
//
//   - `body`
func (s *AppService) GithubCallback(body any) error {
	// Create the url.
	path := "/apps/github/callback"
	uri := resolveRelative(s.client.server, path)

	// Encode the request body as json.
	b := new(bytes.Buffer)
	if err := json.NewEncoder(b).Encode(body); err != nil {
		return fmt.Errorf("encoding json body request failed: %v", err)
	}

	// Create the request.
	req, err := http.NewRequest("GET", uri, b)
	if err != nil {
		return fmt.Errorf("error creating request: %v", err)
	}

	// Add our headers.
	req.Header.Add("Content-Type", "application/json")

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return err
	}

	// Return.
	return nil

}

// GithubConsent: Get the consent URL for GitHub app authentication.
// This is different than OAuth 2.0 authentication for users. This endpoint grants access for Zoo to access user's repos.
//
// The user doesn't need Zoo OAuth authorization for this endpoint, this is purely for the GitHub permissions to access repos.
func (s *AppService) GithubConsent() (*AppClientInfo, error) {
	// Create the url.
	path := "/apps/github/consent"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded AppClientInfo
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// GithubWebhook: Listen for GitHub webhooks.
// These come from the GitHub app.
//
// Parameters
//
//   - `body`
func (s *AppService) GithubWebhook(body []byte) error {
	// Create the url.
	path := "/apps/github/webhook"
	uri := resolveRelative(s.client.server, path)

	b := bytes.NewReader(body)

	// Create the request.
	req, err := http.NewRequest("POST", uri, b)
	if err != nil {
		return fmt.Errorf("error creating request: %v", err)
	}

	// Add our headers.
	req.Header.Add("Content-Type", "application/octet-stream")

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return err
	}

	// Return.
	return nil

}

// ListAsyncOperations: List async operations.
// For async file conversion operations, this endpoint does not return the contents of converted files (`output`). To get the contents use the `/async/operations/{id}` endpoint.
//
// This endpoint requires authentication by a Zoo employee.
//
// Parameters
//
//   - `limit`
//
//   - `pageToken`
//
//   - `sortBy`: Supported set of sort modes for scanning by created_at only.
//
//     Currently, we only support scanning in ascending order.
//
//   - `status`: The status of an async API call.
func (s *APICallService) ListAsyncOperations(limit int, pageToken string, sortBy CreatedAtSortMode, status APICallStatus) (*AsyncAPICallResultsPage, error) {
	// Create the url.
	path := "/async/operations"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add the parameters to the url.
	if err := expandURL(req.URL, map[string]string{
		"limit":      strconv.Itoa(limit),
		"page_token": pageToken,
		"sort_by":    string(sortBy),
		"status":     string(status),
	}); err != nil {
		return nil, fmt.Errorf("expanding URL with parameters failed: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded AsyncAPICallResultsPage
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// GetAsyncOperation: Get an async operation.
// Get the status and output of an async operation.
//
// This endpoint requires authentication by any Zoo user. It returns details of the requested async operation for the user.
//
// If the user is not authenticated to view the specified async operation, then it is not returned.
//
// Only Zoo employees with the proper access can view async operations for other users.
//
// Parameters
//
//   - `id`
func (s *APICallService) GetAsyncOperation(id UUID) (*any, error) {
	// Create the url.
	path := "/async/operations/{{.id}}"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add the parameters to the url.
	if err := expandURL(req.URL, map[string]string{
		"id": id.String(),
	}); err != nil {
		return nil, fmt.Errorf("expanding URL with parameters failed: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded any
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// AuthEmail: Create an email verification request for a user.
// Parameters
//
//   - `body`: The body of the form for email authentication.
func (s *HiddenService) AuthEmail(body EmailAuthenticationForm) (*VerificationTokenResponse, error) {
	// Create the url.
	path := "/auth/email"
	uri := resolveRelative(s.client.server, path)

	// Encode the request body as json.
	b := new(bytes.Buffer)
	if err := json.NewEncoder(b).Encode(body); err != nil {
		return nil, fmt.Errorf("encoding json body request failed: %v", err)
	}

	// Create the request.
	req, err := http.NewRequest("POST", uri, b)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add our headers.
	req.Header.Add("Content-Type", "application/json")

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded VerificationTokenResponse
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// AuthEmailCallback: Listen for callbacks for email authentication for users.
// Parameters
//
//   - `callbackUrl`
//   - `email`
//   - `token`
func (s *HiddenService) AuthEmailCallback(callbackUrl URL, email string, token string) error {
	// Create the url.
	path := "/auth/email/callback"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return fmt.Errorf("error creating request: %v", err)
	}

	// Add the parameters to the url.
	if err := expandURL(req.URL, map[string]string{
		"callback_url": callbackUrl.String(),
		"email":        email,
		"token":        token,
	}); err != nil {
		return fmt.Errorf("expanding URL with parameters failed: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return err
	}

	// Return.
	return nil

}

// GetAuthSaml: Get a redirect straight to the SAML IdP.
// The UI uses this to avoid having to ask the API anything about the IdP. It already knows the SAML IdP ID from the path, so it can just link to this path and rely on the API to redirect to the actual IdP.
//
// Parameters
//
//   - `providerId`: A UUID usually v4 or v7
//   - `callbackUrl`
func (s *HiddenService) GetAuthSaml(providerId UUID, callbackUrl URL) error {
	// Create the url.
	path := "/auth/saml/provider/{{.provider_id}}/login"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return fmt.Errorf("error creating request: %v", err)
	}

	// Add the parameters to the url.
	if err := expandURL(req.URL, map[string]string{
		"provider_id":  providerId.String(),
		"callback_url": callbackUrl.String(),
	}); err != nil {
		return fmt.Errorf("expanding URL with parameters failed: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return err
	}

	// Return.
	return nil

}

// PostAuthSaml: Authenticate a user via SAML
// Parameters
//
//   - `providerId`: A UUID usually v4 or v7
//   - `body`
func (s *HiddenService) PostAuthSaml(providerId UUID, body []byte) error {
	// Create the url.
	path := "/auth/saml/provider/{{.provider_id}}/login"
	uri := resolveRelative(s.client.server, path)

	b := bytes.NewReader(body)

	// Create the request.
	req, err := http.NewRequest("POST", uri, b)
	if err != nil {
		return fmt.Errorf("error creating request: %v", err)
	}

	// Add our headers.
	req.Header.Add("Content-Type", "application/octet-stream")

	// Add the parameters to the url.
	if err := expandURL(req.URL, map[string]string{
		"provider_id": providerId.String(),
	}); err != nil {
		return fmt.Errorf("expanding URL with parameters failed: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return err
	}

	// Return.
	return nil

}

// CommunitySso: Authorize an inbound auth request from our Community page.
// Parameters
//
//   - `sig`
//   - `sso`
func (s *MetaService) CommunitySso(sig string, sso string) error {
	// Create the url.
	path := "/community/sso"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return fmt.Errorf("error creating request: %v", err)
	}

	// Add the parameters to the url.
	if err := expandURL(req.URL, map[string]string{
		"sig": sig,
		"sso": sso,
	}); err != nil {
		return fmt.Errorf("expanding URL with parameters failed: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return err
	}

	// Return.
	return nil

}

// CreateDebugUploads: Uploads files to public blob storage for debugging purposes.
// Do NOT send files here that you don't want to be public.
//
// Parameters
//
//   - `body`
func (s *MetaService) CreateDebugUploads(body *bytes.Buffer) (*[]URL, error) {
	// Create the url.
	path := "/debug/uploads"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("POST", uri, body)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add our headers.
	req.Header.Add("Content-Type", "multipart/form-data")

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded []URL
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// CreateEvent: Creates an internal telemetry event.
// We collect anonymous telemetry data for improving our product.
//
// Parameters
//
//   - `body`: Telemetry data we are collecting
func (s *MetaService) CreateEvent(body *bytes.Buffer) error {
	// Create the url.
	path := "/events"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("POST", uri, body)
	if err != nil {
		return fmt.Errorf("error creating request: %v", err)
	}

	// Add our headers.
	req.Header.Add("Content-Type", "multipart/form-data")

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return err
	}

	// Return.
	return nil

}

// CreateCenterOfMass: Get CAD file center of mass.
// We assume any file given to us has one consistent unit throughout. We also assume the file is at the proper scale.
//
// This endpoint returns the cartesian coordinate in world space measure units.
//
// In the future, we will use the units inside the file if they are given and do any conversions if necessary for the calculation. But currently, that is not supported.
//
// Get the center of mass of an object in a CAD file. If the file is larger than 25MB, it will be performed asynchronously.
//
// If the operation is performed asynchronously, the `id` of the operation will be returned. You can use the `id` returned from the request to get status information about the async operation from the `/async/operations/{id}` endpoint.
//
// Parameters
//
//   - `outputUnit`: The valid types of length units.
//   - `srcFormat`: The valid types of source file formats.
//   - `body`
func (s *FileService) CreateCenterOfMass(outputUnit UnitLength, srcFormat FileImportFormat, body []byte) (*FileCenterOfMass, error) {
	// Create the url.
	path := "/file/center-of-mass"
	uri := resolveRelative(s.client.server, path)

	b := bytes.NewReader(body)

	// Create the request.
	req, err := http.NewRequest("POST", uri, b)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add our headers.
	req.Header.Add("Content-Type", "application/octet-stream")

	// Add the parameters to the url.
	if err := expandURL(req.URL, map[string]string{
		"output_unit": string(outputUnit),
		"src_format":  string(srcFormat),
	}); err != nil {
		return nil, fmt.Errorf("expanding URL with parameters failed: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded FileCenterOfMass
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// CreateConversion: Convert CAD file with defaults.
// If you wish to specify the conversion options, use the `/file/conversion` endpoint instead.
//
// Convert a CAD file from one format to another. If the file being converted is larger than 25MB, it will be performed asynchronously.
//
// If the conversion is performed synchronously, the contents of the converted file (`output`) will be returned as a base64 encoded string.
//
// If the operation is performed asynchronously, the `id` of the operation will be returned. You can use the `id` returned from the request to get status information about the async operation from the `/async/operations/{id}` endpoint.
//
// Parameters
//
//   - `outputFormat`: The valid types of output file formats.
//   - `srcFormat`: The valid types of source file formats.
//   - `body`
func (s *FileService) CreateConversion(outputFormat FileExportFormat, srcFormat FileImportFormat, body []byte) (*FileConversion, error) {
	// Create the url.
	path := "/file/conversion/{{.src_format}}/{{.output_format}}"
	uri := resolveRelative(s.client.server, path)

	b := bytes.NewReader(body)

	// Create the request.
	req, err := http.NewRequest("POST", uri, b)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add our headers.
	req.Header.Add("Content-Type", "application/octet-stream")

	// Add the parameters to the url.
	if err := expandURL(req.URL, map[string]string{
		"output_format": string(outputFormat),
		"src_format":    string(srcFormat),
	}); err != nil {
		return nil, fmt.Errorf("expanding URL with parameters failed: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded FileConversion
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// CreateDensity: Get CAD file density.
// We assume any file given to us has one consistent unit throughout. We also assume the file is at the proper scale.
//
// This endpoint assumes if you are giving a material mass in a specific mass units, we return a density in mass unit per cubic measure unit.
//
// In the future, we will use the units inside the file if they are given and do any conversions if necessary for the calculation. But currently, that is not supported.
//
// Get the density of an object in a CAD file. If the file is larger than 25MB, it will be performed asynchronously.
//
// If the operation is performed asynchronously, the `id` of the operation will be returned. You can use the `id` returned from the request to get status information about the async operation from the `/async/operations/{id}` endpoint.
//
// Parameters
//
//   - `materialMass`
//   - `materialMassUnit`: The valid types of mass units.
//   - `outputUnit`: The valid types for density units.
//   - `srcFormat`: The valid types of source file formats.
//   - `body`
func (s *FileService) CreateDensity(materialMass float64, materialMassUnit UnitMas, outputUnit UnitDensity, srcFormat FileImportFormat, body []byte) (*FileDensity, error) {
	// Create the url.
	path := "/file/density"
	uri := resolveRelative(s.client.server, path)

	b := bytes.NewReader(body)

	// Create the request.
	req, err := http.NewRequest("POST", uri, b)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add our headers.
	req.Header.Add("Content-Type", "application/octet-stream")

	// Add the parameters to the url.
	if err := expandURL(req.URL, map[string]string{
		"material_mass":      fmt.Sprintf("%f", materialMass),
		"material_mass_unit": string(materialMassUnit),
		"output_unit":        string(outputUnit),
		"src_format":         string(srcFormat),
	}); err != nil {
		return nil, fmt.Errorf("expanding URL with parameters failed: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded FileDensity
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// CreateFileExecution: Execute a Zoo program in a specific language.
// Parameters
//
//   - `lang`: The language code is written in.
//
//     <details><summary>JSON schema</summary>
//
//     ```json { "description": "The language code is written in.", "oneOf": [ { "description": "The `go` programming language.", "type": "string", "enum": [ "go" ] }, { "description": "The `python` programming language.", "type": "string", "enum": [ "python" ] }, { "description": "The `node` programming language.", "type": "string", "enum": [ "node" ] } ] } ``` </details>
//
//   - `output`
//
//   - `body`
func (s *ExecutorService) CreateFileExecution(lang CodeLanguage, output string, body []byte) (*CodeOutput, error) {
	// Create the url.
	path := "/file/execute/{{.lang}}"
	uri := resolveRelative(s.client.server, path)

	b := bytes.NewReader(body)

	// Create the request.
	req, err := http.NewRequest("POST", uri, b)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add our headers.
	req.Header.Add("Content-Type", "application/octet-stream")

	// Add the parameters to the url.
	if err := expandURL(req.URL, map[string]string{
		"lang":   string(lang),
		"output": output,
	}); err != nil {
		return nil, fmt.Errorf("expanding URL with parameters failed: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded CodeOutput
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// CreateMass: Get CAD file mass.
// We assume any file given to us has one consistent unit throughout. We also assume the file is at the proper scale.
//
// This endpoint assumes if you are giving a material density in a specific mass unit per cubic measure unit, we return a mass in mass units. The same mass units as passed in the material density.
//
// In the future, we will use the units inside the file if they are given and do any conversions if necessary for the calculation. But currently, that is not supported.
//
// Get the mass of an object in a CAD file. If the file is larger than 25MB, it will be performed asynchronously.
//
// If the operation is performed asynchronously, the `id` of the operation will be returned. You can use the `id` returned from the request to get status information about the async operation from the `/async/operations/{id}` endpoint.
//
// Parameters
//
//   - `materialDensity`
//   - `materialDensityUnit`: The valid types for density units.
//   - `outputUnit`: The valid types of mass units.
//   - `srcFormat`: The valid types of source file formats.
//   - `body`
func (s *FileService) CreateMass(materialDensity float64, materialDensityUnit UnitDensity, outputUnit UnitMas, srcFormat FileImportFormat, body []byte) (*FileMass, error) {
	// Create the url.
	path := "/file/mass"
	uri := resolveRelative(s.client.server, path)

	b := bytes.NewReader(body)

	// Create the request.
	req, err := http.NewRequest("POST", uri, b)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add our headers.
	req.Header.Add("Content-Type", "application/octet-stream")

	// Add the parameters to the url.
	if err := expandURL(req.URL, map[string]string{
		"material_density":      fmt.Sprintf("%f", materialDensity),
		"material_density_unit": string(materialDensityUnit),
		"output_unit":           string(outputUnit),
		"src_format":            string(srcFormat),
	}); err != nil {
		return nil, fmt.Errorf("expanding URL with parameters failed: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded FileMass
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// CreateSurfaceArea: Get CAD file surface area.
// We assume any file given to us has one consistent unit throughout. We also assume the file is at the proper scale.
//
// This endpoint returns the square measure units.
//
// In the future, we will use the units inside the file if they are given and do any conversions if necessary for the calculation. But currently, that is not supported.
//
// Get the surface area of an object in a CAD file. If the file is larger than 25MB, it will be performed asynchronously.
//
// If the operation is performed asynchronously, the `id` of the operation will be returned. You can use the `id` returned from the request to get status information about the async operation from the `/async/operations/{id}` endpoint.
//
// Parameters
//
//   - `outputUnit`: The valid types of area units.
//   - `srcFormat`: The valid types of source file formats.
//   - `body`
func (s *FileService) CreateSurfaceArea(outputUnit UnitArea, srcFormat FileImportFormat, body []byte) (*FileSurfaceArea, error) {
	// Create the url.
	path := "/file/surface-area"
	uri := resolveRelative(s.client.server, path)

	b := bytes.NewReader(body)

	// Create the request.
	req, err := http.NewRequest("POST", uri, b)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add our headers.
	req.Header.Add("Content-Type", "application/octet-stream")

	// Add the parameters to the url.
	if err := expandURL(req.URL, map[string]string{
		"output_unit": string(outputUnit),
		"src_format":  string(srcFormat),
	}); err != nil {
		return nil, fmt.Errorf("expanding URL with parameters failed: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded FileSurfaceArea
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// CreateVolume: Get CAD file volume.
// We assume any file given to us has one consistent unit throughout. We also assume the file is at the proper scale.
//
// This endpoint returns the cubic measure units.
//
// In the future, we will use the units inside the file if they are given and do any conversions if necessary for the calculation. But currently, that is not supported.
//
// Get the volume of an object in a CAD file. If the file is larger than 25MB, it will be performed asynchronously.
//
// If the operation is performed asynchronously, the `id` of the operation will be returned. You can use the `id` returned from the request to get status information about the async operation from the `/async/operations/{id}` endpoint.
//
// Parameters
//
//   - `outputUnit`: The valid types of volume units.
//   - `srcFormat`: The valid types of source file formats.
//   - `body`
func (s *FileService) CreateVolume(outputUnit UnitVolume, srcFormat FileImportFormat, body []byte) (*FileVolume, error) {
	// Create the url.
	path := "/file/volume"
	uri := resolveRelative(s.client.server, path)

	b := bytes.NewReader(body)

	// Create the request.
	req, err := http.NewRequest("POST", uri, b)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add our headers.
	req.Header.Add("Content-Type", "application/octet-stream")

	// Add the parameters to the url.
	if err := expandURL(req.URL, map[string]string{
		"output_unit": string(outputUnit),
		"src_format":  string(srcFormat),
	}); err != nil {
		return nil, fmt.Errorf("expanding URL with parameters failed: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded FileVolume
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// InternalGetAPITokenForDiscordUser: Get an API token for a user by their discord id.
// This endpoint allows us to run API calls from our discord bot on behalf of a user. The user must have a discord account linked to their Zoo Account via oauth2 for this to work.
//
// You must be a Zoo employee to use this endpoint.
//
// Parameters
//
//   - `discordId`
func (s *MetaService) InternalGetAPITokenForDiscordUser(discordId string) (*APIToken, error) {
	// Create the url.
	path := "/internal/discord/api-token/{{.discord_id}}"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add the parameters to the url.
	if err := expandURL(req.URL, map[string]string{
		"discord_id": discordId,
	}); err != nil {
		return nil, fmt.Errorf("expanding URL with parameters failed: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded APIToken
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// Logout: This endpoint removes the session cookie for a user.
// This is used in logout scenarios.
func (s *HiddenService) Logout() error {
	// Create the url.
	path := "/logout"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("POST", uri, nil)
	if err != nil {
		return fmt.Errorf("error creating request: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return err
	}

	// Return.
	return nil

}

// ListPrompts: List all ML prompts.
// For text-to-cad prompts, this will always return the STEP file contents as well as the format the user originally requested.
//
// This endpoint requires authentication by a Zoo employee.
//
// The ML prompts are returned in order of creation, with the most recently created ML prompts first.
//
// Parameters
//
//   - `limit`
//
//   - `pageToken`
//
//   - `sortBy`: Supported set of sort modes for scanning by created_at only.
//
//     Currently, we only support scanning in ascending order.
func (s *MlService) ListPrompts(limit int, pageToken string, sortBy CreatedAtSortMode) (*MlPromptResultsPage, error) {
	// Create the url.
	path := "/ml-prompts"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add the parameters to the url.
	if err := expandURL(req.URL, map[string]string{
		"limit":      strconv.Itoa(limit),
		"page_token": pageToken,
		"sort_by":    string(sortBy),
	}); err != nil {
		return nil, fmt.Errorf("expanding URL with parameters failed: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded MlPromptResultsPage
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// GetPrompt: Get a ML prompt.
// This endpoint requires authentication by a Zoo employee.
//
// Parameters
//
//   - `id`
func (s *MlService) GetPrompt(id UUID) (*MlPrompt, error) {
	// Create the url.
	path := "/ml-prompts/{{.id}}"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add the parameters to the url.
	if err := expandURL(req.URL, map[string]string{
		"id": id.String(),
	}); err != nil {
		return nil, fmt.Errorf("expanding URL with parameters failed: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded MlPrompt
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// CreateKclCodeCompletions: Generate code completions for KCL.
// Parameters
//
//   - `body`: A request to generate KCL code completions.
func (s *MlService) CreateKclCodeCompletions(body KclCodeCompletionRequest) (*KclCodeCompletionResponse, error) {
	// Create the url.
	path := "/ml/kcl/completions"
	uri := resolveRelative(s.client.server, path)

	// Encode the request body as json.
	b := new(bytes.Buffer)
	if err := json.NewEncoder(b).Encode(body); err != nil {
		return nil, fmt.Errorf("encoding json body request failed: %v", err)
	}

	// Create the request.
	req, err := http.NewRequest("POST", uri, b)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add our headers.
	req.Header.Add("Content-Type", "application/json")

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded KclCodeCompletionResponse
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// CreateTextToCadIteration: Iterate on a CAD model with a prompt.
// Even if you give specific ranges to edit, the model might change more than just those in order to make the changes you requested without breaking the code.
//
// You always get the whole code back, even if you only changed a small part of it.
//
// This operation is performed asynchronously, the `id` of the operation will be returned. You can use the `id` returned from the request to get status information about the async operation from the `/async/operations/{id}` endpoint.
//
// This endpoint will soon be deprecated in favor of the `/ml/text-to-cad/multi-file/iteration` endpoint. In that the endpoint path will remain but it will have the same behavior as `ml/text-to-cad/multi-file/iteration`.
//
// Parameters
//
//   - `body`: Body for generating models from text.
func (s *MlService) CreateTextToCadIteration(body TextToCadIterationBody) (*TextToCadIteration, error) {
	// Create the url.
	path := "/ml/text-to-cad/iteration"
	uri := resolveRelative(s.client.server, path)

	// Encode the request body as json.
	b := new(bytes.Buffer)
	if err := json.NewEncoder(b).Encode(body); err != nil {
		return nil, fmt.Errorf("encoding json body request failed: %v", err)
	}

	// Create the request.
	req, err := http.NewRequest("POST", uri, b)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add our headers.
	req.Header.Add("Content-Type", "application/json")

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded TextToCadIteration
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// CreateTextToCadMultiFileIteration: Iterate on a multi-file CAD model with a prompt.
// This endpoint can iterate on multi-file models.
//
// Even if you give specific ranges to edit, the model might change more than just those in order to make the changes you requested without breaking the code.
//
// You always get the whole code back, even if you only changed a small part of it. This endpoint will always return all the code back, including files that were not changed. If your original source code imported a stl/gltf/step/etc file, the output will not include that file since the model will never change non-kcl files. The endpoint will only return the kcl files that were changed.
//
// This operation is performed asynchronously, the `id` of the operation will be returned. You can use the `id` returned from the request to get status information about the async operation from the `/async/operations/{id}` endpoint.
//
// Parameters
//
//   - `body`: Body for generating models from text.
func (s *MlService) CreateTextToCadMultiFileIteration(body *bytes.Buffer) (*TextToCadMultiFileIteration, error) {
	// Create the url.
	path := "/ml/text-to-cad/multi-file/iteration"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("POST", uri, body)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add our headers.
	req.Header.Add("Content-Type", "multipart/form-data")

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded TextToCadMultiFileIteration
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// DeviceAuthRequest: Start an OAuth 2.0 Device Authorization Grant.
// This endpoint is designed to be accessed from an *unauthenticated* API client. It generates and records a `device_code` and `user_code` which must be verified and confirmed prior to a token being granted.
//
// Parameters
//
//   - `body`: The request parameters for the OAuth 2.0 Device Authorization Grant flow.
func (s *Oauth2Service) DeviceAuthRequest(body DeviceAuthRequestForm) error {
	// Create the url.
	path := "/oauth2/device/auth"
	uri := resolveRelative(s.client.server, path)

	// Encode the request body as a form.
	form := url.Values{}
	encoder := schema.NewEncoder()
	err := encoder.Encode(body, form)
	if err != nil {
		return fmt.Errorf("encoding form body request failed: %v", err)
	}
	b := strings.NewReader(form.Encode())

	// Create the request.
	req, err := http.NewRequest("POST", uri, b)
	if err != nil {
		return fmt.Errorf("error creating request: %v", err)
	}

	// Add our headers.
	req.Header.Add("Content-Type", "application/x-www-form-urlencoded")

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return err
	}

	// Return.
	return nil

}

// DeviceAuthConfirm: Confirm an OAuth 2.0 Device Authorization Grant.
// This endpoint is designed to be accessed by the user agent (browser), not the client requesting the token. So we do not actually return the token here; it will be returned in response to the poll on `/oauth2/device/token`.
//
// Parameters
//
//   - `body`: The request parameters to verify the `user_code` for the OAuth 2.0 Device Authorization Grant.
func (s *Oauth2Service) DeviceAuthConfirm(body DeviceAuthVerifyParams) error {
	// Create the url.
	path := "/oauth2/device/confirm"
	uri := resolveRelative(s.client.server, path)

	// Encode the request body as json.
	b := new(bytes.Buffer)
	if err := json.NewEncoder(b).Encode(body); err != nil {
		return fmt.Errorf("encoding json body request failed: %v", err)
	}

	// Create the request.
	req, err := http.NewRequest("POST", uri, b)
	if err != nil {
		return fmt.Errorf("error creating request: %v", err)
	}

	// Add our headers.
	req.Header.Add("Content-Type", "application/json")

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return err
	}

	// Return.
	return nil

}

// DeviceAccessToken: Request a device access token.
// This endpoint should be polled by the client until the user code is verified and the grant is confirmed.
//
// Parameters
//
//   - `body`: The form for a device access token request.
func (s *Oauth2Service) DeviceAccessToken(body DeviceAccessTokenRequestForm) error {
	// Create the url.
	path := "/oauth2/device/token"
	uri := resolveRelative(s.client.server, path)

	// Encode the request body as a form.
	form := url.Values{}
	encoder := schema.NewEncoder()
	err := encoder.Encode(body, form)
	if err != nil {
		return fmt.Errorf("encoding form body request failed: %v", err)
	}
	b := strings.NewReader(form.Encode())

	// Create the request.
	req, err := http.NewRequest("POST", uri, b)
	if err != nil {
		return fmt.Errorf("error creating request: %v", err)
	}

	// Add our headers.
	req.Header.Add("Content-Type", "application/x-www-form-urlencoded")

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return err
	}

	// Return.
	return nil

}

// DeviceAuthVerify: Verify an OAuth 2.0 Device Authorization Grant.
// This endpoint should be accessed in a full user agent (e.g., a browser). If the user is not logged in, we redirect them to the login page and use the `callback_url` parameter to get them to the UI verification form upon logging in. If they are logged in, we redirect them to the UI verification form on the website.
//
// Parameters
//
//   - `userCode`
func (s *Oauth2Service) DeviceAuthVerify(userCode string) error {
	// Create the url.
	path := "/oauth2/device/verify"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return fmt.Errorf("error creating request: %v", err)
	}

	// Add the parameters to the url.
	if err := expandURL(req.URL, map[string]string{
		"user_code": userCode,
	}); err != nil {
		return fmt.Errorf("expanding URL with parameters failed: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return err
	}

	// Return.
	return nil

}

// ProviderCallback: Listen for callbacks for the OAuth 2.0 provider.
// Parameters
//
//   - `provider`: An account provider.
//   - `code`
//   - `idToken`
//   - `state`
//   - `user`
func (s *Oauth2Service) ProviderCallback(provider AccountProvider, code string, idToken string, state string, user string) error {
	// Create the url.
	path := "/oauth2/provider/{{.provider}}/callback"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return fmt.Errorf("error creating request: %v", err)
	}

	// Add the parameters to the url.
	if err := expandURL(req.URL, map[string]string{
		"provider": string(provider),
		"code":     code,
		"id_token": idToken,
		"state":    state,
		"user":     user,
	}); err != nil {
		return fmt.Errorf("expanding URL with parameters failed: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return err
	}

	// Return.
	return nil

}

// ProviderCallbackCreate: Listen for callbacks for the OAuth 2.0 provider.
// This specific endpoint listens for posts of form data.
//
// Parameters
//
//   - `provider`: An account provider.
//   - `body`: The authentication callback from the OAuth 2.0 client. This is typically posted to the redirect URL as query params after authenticating.
func (s *Oauth2Service) ProviderCallbackCreate(provider AccountProvider, body AuthCallback) error {
	// Create the url.
	path := "/oauth2/provider/{{.provider}}/callback"
	uri := resolveRelative(s.client.server, path)

	// Encode the request body as a form.
	form := url.Values{}
	encoder := schema.NewEncoder()
	err := encoder.Encode(body, form)
	if err != nil {
		return fmt.Errorf("encoding form body request failed: %v", err)
	}
	b := strings.NewReader(form.Encode())

	// Create the request.
	req, err := http.NewRequest("POST", uri, b)
	if err != nil {
		return fmt.Errorf("error creating request: %v", err)
	}

	// Add our headers.
	req.Header.Add("Content-Type", "application/x-www-form-urlencoded")

	// Add the parameters to the url.
	if err := expandURL(req.URL, map[string]string{
		"provider": string(provider),
	}); err != nil {
		return fmt.Errorf("expanding URL with parameters failed: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return err
	}

	// Return.
	return nil

}

// ProviderConsent: Get the consent URL and other information for the OAuth 2.0 provider.
// Parameters
//
//   - `provider`: An account provider.
//   - `callbackUrl`
func (s *Oauth2Service) ProviderConsent(provider AccountProvider, callbackUrl string) (*Oauth2ClientInfo, error) {
	// Create the url.
	path := "/oauth2/provider/{{.provider}}/consent"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add the parameters to the url.
	if err := expandURL(req.URL, map[string]string{
		"provider":     string(provider),
		"callback_url": callbackUrl,
	}); err != nil {
		return nil, fmt.Errorf("expanding URL with parameters failed: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded Oauth2ClientInfo
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// TokenRevoke: Revoke an OAuth2 token.
// This endpoint is designed to be accessed from an *unauthenticated* API client.
//
// Parameters
//
//   - `body`: The request parameters for the OAuth 2.0 token revocation flow.
func (s *Oauth2Service) TokenRevoke(body TokenRevokeRequestForm) error {
	// Create the url.
	path := "/oauth2/token/revoke"
	uri := resolveRelative(s.client.server, path)

	// Encode the request body as a form.
	form := url.Values{}
	encoder := schema.NewEncoder()
	err := encoder.Encode(body, form)
	if err != nil {
		return fmt.Errorf("encoding form body request failed: %v", err)
	}
	b := strings.NewReader(form.Encode())

	// Create the request.
	req, err := http.NewRequest("POST", uri, b)
	if err != nil {
		return fmt.Errorf("error creating request: %v", err)
	}

	// Add our headers.
	req.Header.Add("Content-Type", "application/x-www-form-urlencoded")

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return err
	}

	// Return.
	return nil

}

// Get: Get an org.
// This endpoint requires authentication by an org admin. It gets the authenticated user's org.
func (s *OrgService) Get() (*Org, error) {
	// Create the url.
	path := "/org"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded Org
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// Create: Create an org.
// This endpoint requires authentication by a Zoo user that is not already in an org. It creates a new org for the authenticated user and makes them an admin.
//
// Parameters
//
//   - `body`: The user-modifiable parts of an organization.
func (s *OrgService) Create(body OrgDetails) (*Org, error) {
	// Create the url.
	path := "/org"
	uri := resolveRelative(s.client.server, path)

	// Encode the request body as json.
	b := new(bytes.Buffer)
	if err := json.NewEncoder(b).Encode(body); err != nil {
		return nil, fmt.Errorf("encoding json body request failed: %v", err)
	}

	// Create the request.
	req, err := http.NewRequest("POST", uri, b)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add our headers.
	req.Header.Add("Content-Type", "application/json")

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded Org
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// Update: Update an org.
// This endpoint requires authentication by an org admin. It updates the authenticated user's org.
//
// Parameters
//
//   - `body`: The user-modifiable parts of an organization.
func (s *OrgService) Update(body OrgDetails) (*Org, error) {
	// Create the url.
	path := "/org"
	uri := resolveRelative(s.client.server, path)

	// Encode the request body as json.
	b := new(bytes.Buffer)
	if err := json.NewEncoder(b).Encode(body); err != nil {
		return nil, fmt.Errorf("encoding json body request failed: %v", err)
	}

	// Create the request.
	req, err := http.NewRequest("PUT", uri, b)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add our headers.
	req.Header.Add("Content-Type", "application/json")

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded Org
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// Delete: Delete an org.
// In order to delete an org, you must first delete all of its members, except yourself.
//
// You must also have no outstanding invoices or unpaid balances.
//
// This endpoint requires authentication by an org admin. It deletes the authenticated user's org.
func (s *OrgService) Delete() error {
	// Create the url.
	path := "/org"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("DELETE", uri, nil)
	if err != nil {
		return fmt.Errorf("error creating request: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return err
	}

	// Return.
	return nil

}

// OrgList: List API calls for your org.
// This includes all API calls that were made by users in the org.
//
// This endpoint requires authentication by an org admin. It returns the API calls for the authenticated user's org.
//
// The API calls are returned in order of creation, with the most recently created API calls first.
//
// Parameters
//
//   - `limit`
//
//   - `pageToken`
//
//   - `sortBy`: Supported set of sort modes for scanning by created_at only.
//
//     Currently, we only support scanning in ascending order.
func (s *APICallService) OrgList(limit int, pageToken string, sortBy CreatedAtSortMode) (*APICallWithPriceResultsPage, error) {
	// Create the url.
	path := "/org/api-calls"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add the parameters to the url.
	if err := expandURL(req.URL, map[string]string{
		"limit":      strconv.Itoa(limit),
		"page_token": pageToken,
		"sort_by":    string(sortBy),
	}); err != nil {
		return nil, fmt.Errorf("expanding URL with parameters failed: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded APICallWithPriceResultsPage
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// GetForOrg: Get an API call for an org.
// This endpoint requires authentication by an org admin. It returns details of the requested API call for the user's org.
//
// Parameters
//
//   - `id`
func (s *APICallService) GetForOrg(id UUID) (*APICallWithPrice, error) {
	// Create the url.
	path := "/org/api-calls/{{.id}}"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add the parameters to the url.
	if err := expandURL(req.URL, map[string]string{
		"id": id.String(),
	}); err != nil {
		return nil, fmt.Errorf("expanding URL with parameters failed: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded APICallWithPrice
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// ListMembers: List members of your org.
// This endpoint requires authentication by an org admin. It lists the members of the authenticated user's org.
//
// Parameters
//
//   - `limit`
//
//   - `pageToken`
//
//   - `sortBy`: Supported set of sort modes for scanning by created_at only.
//
//     Currently, we only support scanning in ascending order.
//
//   - `role`: The roles for users in an organization.
func (s *OrgService) ListMembers(limit int, pageToken string, sortBy CreatedAtSortMode, role UserOrgRole) (*OrgMemberResultsPage, error) {
	// Create the url.
	path := "/org/members"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add the parameters to the url.
	if err := expandURL(req.URL, map[string]string{
		"limit":      strconv.Itoa(limit),
		"page_token": pageToken,
		"sort_by":    string(sortBy),
		"role":       string(role),
	}); err != nil {
		return nil, fmt.Errorf("expanding URL with parameters failed: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded OrgMemberResultsPage
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// CreateMember: Add a member to your org.
// If the user exists, this will add them to your org. If they do not exist, this will create a new user and add them to your org.
//
// In both cases the user gets an email that they have been added to the org.
//
// If the user is already in your org, this will return a 400 and a message.
//
// If the user is already in a different org, this will return a 400 and a message.
//
// This endpoint requires authentication by an org admin. It adds the specified member to the authenticated user's org.
//
// Parameters
//
//   - `body`: Data for adding a member to an org.
func (s *OrgService) CreateMember(body AddOrgMember) (*OrgMember, error) {
	// Create the url.
	path := "/org/members"
	uri := resolveRelative(s.client.server, path)

	// Encode the request body as json.
	b := new(bytes.Buffer)
	if err := json.NewEncoder(b).Encode(body); err != nil {
		return nil, fmt.Errorf("encoding json body request failed: %v", err)
	}

	// Create the request.
	req, err := http.NewRequest("POST", uri, b)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add our headers.
	req.Header.Add("Content-Type", "application/json")

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded OrgMember
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// GetMember: Get a member of your org.
// This endpoint requires authentication by an org admin. It gets the specified member of the authenticated user's org.
//
// Parameters
//
//   - `userId`: A UUID usually v4 or v7
func (s *OrgService) GetMember(userId UUID) (*OrgMember, error) {
	// Create the url.
	path := "/org/members/{{.user_id}}"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add the parameters to the url.
	if err := expandURL(req.URL, map[string]string{
		"user_id": userId.String(),
	}); err != nil {
		return nil, fmt.Errorf("expanding URL with parameters failed: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded OrgMember
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// UpdateMember: Update a member of your org.
// This endpoint requires authentication by an org admin. It updates the specified member of the authenticated user's org.
//
// Parameters
//
//   - `userId`: A UUID usually v4 or v7
//   - `body`: Data for updating a member of an org.
func (s *OrgService) UpdateMember(userId UUID, body UpdateMemberToOrgBody) (*OrgMember, error) {
	// Create the url.
	path := "/org/members/{{.user_id}}"
	uri := resolveRelative(s.client.server, path)

	// Encode the request body as json.
	b := new(bytes.Buffer)
	if err := json.NewEncoder(b).Encode(body); err != nil {
		return nil, fmt.Errorf("encoding json body request failed: %v", err)
	}

	// Create the request.
	req, err := http.NewRequest("PUT", uri, b)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add our headers.
	req.Header.Add("Content-Type", "application/json")

	// Add the parameters to the url.
	if err := expandURL(req.URL, map[string]string{
		"user_id": userId.String(),
	}); err != nil {
		return nil, fmt.Errorf("expanding URL with parameters failed: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded OrgMember
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// DeleteMember: Remove a member from your org.
// This endpoint requires authentication by an org admin. It removes the specified member from the authenticated user's org.
//
// Parameters
//
//   - `userId`: A UUID usually v4 or v7
func (s *OrgService) DeleteMember(userId UUID) error {
	// Create the url.
	path := "/org/members/{{.user_id}}"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("DELETE", uri, nil)
	if err != nil {
		return fmt.Errorf("error creating request: %v", err)
	}

	// Add the parameters to the url.
	if err := expandURL(req.URL, map[string]string{
		"user_id": userId.String(),
	}); err != nil {
		return fmt.Errorf("expanding URL with parameters failed: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return err
	}

	// Return.
	return nil

}

// GetInformationForOrg: Get payment info about your org.
// This includes billing address, phone, and name.
//
// This endpoint requires authentication by an org admin. It gets the payment information for the authenticated user's org.
func (s *PaymentService) GetInformationForOrg() (*Customer, error) {
	// Create the url.
	path := "/org/payment"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded Customer
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// CreateInformationForOrg: Create payment info for your org.
// This includes billing address, phone, and name.
//
// This endpoint requires authentication by the org admin. It creates the payment information for the authenticated user's org.
//
// Parameters
//
//   - `body`: The billing information for payments.
func (s *PaymentService) CreateInformationForOrg(body BillingInfo) (*Customer, error) {
	// Create the url.
	path := "/org/payment"
	uri := resolveRelative(s.client.server, path)

	// Encode the request body as json.
	b := new(bytes.Buffer)
	if err := json.NewEncoder(b).Encode(body); err != nil {
		return nil, fmt.Errorf("encoding json body request failed: %v", err)
	}

	// Create the request.
	req, err := http.NewRequest("POST", uri, b)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add our headers.
	req.Header.Add("Content-Type", "application/json")

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded Customer
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// UpdateInformationForOrg: Update payment info for your org.
// This includes billing address, phone, and name.
//
// This endpoint requires authentication by an org admin. It updates the payment information for the authenticated user's org.
//
// Parameters
//
//   - `body`: The billing information for payments.
func (s *PaymentService) UpdateInformationForOrg(body BillingInfo) (*Customer, error) {
	// Create the url.
	path := "/org/payment"
	uri := resolveRelative(s.client.server, path)

	// Encode the request body as json.
	b := new(bytes.Buffer)
	if err := json.NewEncoder(b).Encode(body); err != nil {
		return nil, fmt.Errorf("encoding json body request failed: %v", err)
	}

	// Create the request.
	req, err := http.NewRequest("PUT", uri, b)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add our headers.
	req.Header.Add("Content-Type", "application/json")

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded Customer
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// DeleteInformationForOrg: Delete payment info for your org.
// This includes billing address, phone, and name.
//
// This endpoint requires authentication by an org admin. It deletes the payment information for the authenticated user's org.
func (s *PaymentService) DeleteInformationForOrg() error {
	// Create the url.
	path := "/org/payment"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("DELETE", uri, nil)
	if err != nil {
		return fmt.Errorf("error creating request: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return err
	}

	// Return.
	return nil

}

// GetBalanceForOrg: Get balance for your org.
// This endpoint requires authentication by an org admin. It gets the balance information for the authenticated user's org.
func (s *PaymentService) GetBalanceForOrg() (*CustomerBalance, error) {
	// Create the url.
	path := "/org/payment/balance"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded CustomerBalance
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// CreateIntentForOrg: Create a payment intent for your org.
// This endpoint requires authentication by the org admin. It creates a new payment intent for the authenticated user's org's org.
func (s *PaymentService) CreateIntentForOrg() (*PaymentIntent, error) {
	// Create the url.
	path := "/org/payment/intent"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("POST", uri, nil)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded PaymentIntent
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// ListInvoicesForOrg: List invoices for your org.
// This endpoint requires authentication by an org admin. It lists invoices for the authenticated user's org.
func (s *PaymentService) ListInvoicesForOrg() (*[]Invoice, error) {
	// Create the url.
	path := "/org/payment/invoices"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded []Invoice
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// ListMethodsForOrg: List payment methods for your org.
// This endpoint requires authentication by an org admin. It lists payment methods for the authenticated user's org.
func (s *PaymentService) ListMethodsForOrg() (*[]PaymentMethod, error) {
	// Create the url.
	path := "/org/payment/methods"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded []PaymentMethod
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// DeleteMethodForOrg: Delete a payment method for your org.
// This endpoint requires authentication by an org admin. It deletes the specified payment method for the authenticated user's org.
//
// Parameters
//
//   - `id`
func (s *PaymentService) DeleteMethodForOrg(id string) error {
	// Create the url.
	path := "/org/payment/methods/{{.id}}"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("DELETE", uri, nil)
	if err != nil {
		return fmt.Errorf("error creating request: %v", err)
	}

	// Add the parameters to the url.
	if err := expandURL(req.URL, map[string]string{
		"id": id,
	}); err != nil {
		return fmt.Errorf("expanding URL with parameters failed: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return err
	}

	// Return.
	return nil

}

// GetOrgSubscription: Get the subscription for an org.
// This endpoint requires authentication by an org admin. It gets the subscription for the authenticated user's org.
func (s *PaymentService) GetOrgSubscription() (*ZooProductSubscriptions, error) {
	// Create the url.
	path := "/org/payment/subscriptions"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded ZooProductSubscriptions
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// CreateOrgSubscription: Create the subscription for an org.
// This endpoint requires authentication by an org admin. It creates the subscription for the authenticated user's org.
//
// Parameters
//
//   - `body`: A struct of Zoo product subscriptions an organization can request.
func (s *PaymentService) CreateOrgSubscription(body ZooProductSubscriptionsOrgRequest) (*ZooProductSubscriptions, error) {
	// Create the url.
	path := "/org/payment/subscriptions"
	uri := resolveRelative(s.client.server, path)

	// Encode the request body as json.
	b := new(bytes.Buffer)
	if err := json.NewEncoder(b).Encode(body); err != nil {
		return nil, fmt.Errorf("encoding json body request failed: %v", err)
	}

	// Create the request.
	req, err := http.NewRequest("POST", uri, b)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add our headers.
	req.Header.Add("Content-Type", "application/json")

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded ZooProductSubscriptions
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// UpdateOrgSubscription: Update the subscription for an org.
// This endpoint requires authentication by an org admin. It updates the subscription for the authenticated user's org.
//
// Parameters
//
//   - `body`: A struct of Zoo product subscriptions an organization can request.
func (s *PaymentService) UpdateOrgSubscription(body ZooProductSubscriptionsOrgRequest) (*ZooProductSubscriptions, error) {
	// Create the url.
	path := "/org/payment/subscriptions"
	uri := resolveRelative(s.client.server, path)

	// Encode the request body as json.
	b := new(bytes.Buffer)
	if err := json.NewEncoder(b).Encode(body); err != nil {
		return nil, fmt.Errorf("encoding json body request failed: %v", err)
	}

	// Create the request.
	req, err := http.NewRequest("PUT", uri, b)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add our headers.
	req.Header.Add("Content-Type", "application/json")

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded ZooProductSubscriptions
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// ValidateCustomerTaxInformationForOrg: Validate an orgs's information is correct and valid for automatic tax.
// This endpoint requires authentication by an org admin. It will return an error if the org's information is not valid for automatic tax. Otherwise, it will return an empty successful response.
func (s *PaymentService) ValidateCustomerTaxInformationForOrg() error {
	// Create the url.
	path := "/org/payment/tax"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return fmt.Errorf("error creating request: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return err
	}

	// Return.
	return nil

}

// GetPrivacySettings: Get the privacy settings for an org.
// This endpoint requires authentication by an org admin. It gets the privacy settings for the authenticated user's org.
func (s *OrgService) GetPrivacySettings() (*PrivacySettings, error) {
	// Create the url.
	path := "/org/privacy"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded PrivacySettings
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// UpdatePrivacySettings: Update the privacy settings for an org.
// This endpoint requires authentication by an org admin. It updates the privacy settings for the authenticated user's org.
//
// Parameters
//
//   - `body`: Privacy settings for an org or user.
func (s *OrgService) UpdatePrivacySettings(body PrivacySettings) (*PrivacySettings, error) {
	// Create the url.
	path := "/org/privacy"
	uri := resolveRelative(s.client.server, path)

	// Encode the request body as json.
	b := new(bytes.Buffer)
	if err := json.NewEncoder(b).Encode(body); err != nil {
		return nil, fmt.Errorf("encoding json body request failed: %v", err)
	}

	// Create the request.
	req, err := http.NewRequest("PUT", uri, b)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add our headers.
	req.Header.Add("Content-Type", "application/json")

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded PrivacySettings
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// GetSamlIdp: Get the SAML identity provider.
// This endpoint requires authentication by an org admin.
func (s *OrgService) GetSamlIdp() (*SamlIdentityProvider, error) {
	// Create the url.
	path := "/org/saml/idp"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded SamlIdentityProvider
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// CreateSamlIdp: Create a SAML identity provider.
// This endpoint requires authentication by an org admin.
//
// Parameters
//
//   - `body`: Parameters for creating a SAML identity provider.
func (s *OrgService) CreateSamlIdp(body SamlIdentityProviderCreate) (*SamlIdentityProvider, error) {
	// Create the url.
	path := "/org/saml/idp"
	uri := resolveRelative(s.client.server, path)

	// Encode the request body as json.
	b := new(bytes.Buffer)
	if err := json.NewEncoder(b).Encode(body); err != nil {
		return nil, fmt.Errorf("encoding json body request failed: %v", err)
	}

	// Create the request.
	req, err := http.NewRequest("POST", uri, b)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add our headers.
	req.Header.Add("Content-Type", "application/json")

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded SamlIdentityProvider
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// UpdateSamlIdp: Update the SAML identity provider.
// This endpoint requires authentication by an org admin.
//
// Parameters
//
//   - `body`: Parameters for creating a SAML identity provider.
func (s *OrgService) UpdateSamlIdp(body SamlIdentityProviderCreate) (*SamlIdentityProvider, error) {
	// Create the url.
	path := "/org/saml/idp"
	uri := resolveRelative(s.client.server, path)

	// Encode the request body as json.
	b := new(bytes.Buffer)
	if err := json.NewEncoder(b).Encode(body); err != nil {
		return nil, fmt.Errorf("encoding json body request failed: %v", err)
	}

	// Create the request.
	req, err := http.NewRequest("PUT", uri, b)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add our headers.
	req.Header.Add("Content-Type", "application/json")

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded SamlIdentityProvider
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// DeleteSamlIdp: Delete an SAML identity provider.
// This endpoint requires authentication by an org admin.
func (s *OrgService) DeleteSamlIdp() error {
	// Create the url.
	path := "/org/saml/idp"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("DELETE", uri, nil)
	if err != nil {
		return fmt.Errorf("error creating request: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return err
	}

	// Return.
	return nil

}

// ListForOrg: List service accounts for your org.
// This endpoint requires authentication by an org admin. It returns the service accounts for the organization.
//
// The service accounts are returned in order of creation, with the most recently created service accounts first.
//
// Parameters
//
//   - `limit`
//
//   - `pageToken`
//
//   - `sortBy`: Supported set of sort modes for scanning by created_at only.
//
//     Currently, we only support scanning in ascending order.
func (s *ServiceAccountService) ListForOrg(limit int, pageToken string, sortBy CreatedAtSortMode) (*ServiceAccountResultsPage, error) {
	// Create the url.
	path := "/org/service-accounts"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add the parameters to the url.
	if err := expandURL(req.URL, map[string]string{
		"limit":      strconv.Itoa(limit),
		"page_token": pageToken,
		"sort_by":    string(sortBy),
	}); err != nil {
		return nil, fmt.Errorf("expanding URL with parameters failed: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded ServiceAccountResultsPage
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// CreateForOrg: Create a new service account for your org.
// This endpoint requires authentication by an org admin. It creates a new service account for the organization.
//
// Parameters
//
//   - `label`
func (s *ServiceAccountService) CreateForOrg(label string) (*ServiceAccount, error) {
	// Create the url.
	path := "/org/service-accounts"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("POST", uri, nil)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add the parameters to the url.
	if err := expandURL(req.URL, map[string]string{
		"label": label,
	}); err != nil {
		return nil, fmt.Errorf("expanding URL with parameters failed: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded ServiceAccount
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// GetForOrg: Get an service account for your org.
// This endpoint requires authentication by an org admin. It returns details of the requested service account for the organization.
//
// Parameters
//
//   - `token`: An auth token. A uuid with a prefix of svc-
func (s *ServiceAccountService) GetForOrg(token string) (*ServiceAccount, error) {
	// Create the url.
	path := "/org/service-accounts/{{.token}}"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add the parameters to the url.
	if err := expandURL(req.URL, map[string]string{
		"token": token,
	}); err != nil {
		return nil, fmt.Errorf("expanding URL with parameters failed: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded ServiceAccount
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// DeleteForOrg: Delete an service account for your org.
// This endpoint requires authentication by an org admin. It deletes the requested service account for the organization.
//
// This endpoint does not actually delete the service account from the database. It merely marks the token as invalid. We still want to keep the service account in the database for historical purposes.
//
// Parameters
//
//   - `token`: An auth token. A uuid with a prefix of svc-
func (s *ServiceAccountService) DeleteForOrg(token string) error {
	// Create the url.
	path := "/org/service-accounts/{{.token}}"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("DELETE", uri, nil)
	if err != nil {
		return fmt.Errorf("error creating request: %v", err)
	}

	// Add the parameters to the url.
	if err := expandURL(req.URL, map[string]string{
		"token": token,
	}); err != nil {
		return fmt.Errorf("expanding URL with parameters failed: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return err
	}

	// Return.
	return nil

}

// GetShortlinks: Get the shortlinks for an org.
// This endpoint requires authentication by an org admin. It gets the shortlinks for the authenticated user's org.
//
// Parameters
//
//   - `limit`
//
//   - `pageToken`
//
//   - `sortBy`: Supported set of sort modes for scanning by created_at only.
//
//     Currently, we only support scanning in ascending order.
func (s *OrgService) GetShortlinks(limit int, pageToken string, sortBy CreatedAtSortMode) (*ShortlinkResultsPage, error) {
	// Create the url.
	path := "/org/shortlinks"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add the parameters to the url.
	if err := expandURL(req.URL, map[string]string{
		"limit":      strconv.Itoa(limit),
		"page_token": pageToken,
		"sort_by":    string(sortBy),
	}); err != nil {
		return nil, fmt.Errorf("expanding URL with parameters failed: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded ShortlinkResultsPage
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// List: List orgs.
// This endpoint requires authentication by a Zoo employee. The orgs are returned in order of creation, with the most recently created orgs first.
//
// Parameters
//
//   - `limit`
//
//   - `pageToken`
//
//   - `sortBy`: Supported set of sort modes for scanning by created_at only.
//
//     Currently, we only support scanning in ascending order.
func (s *OrgService) List(limit int, pageToken string, sortBy CreatedAtSortMode) (*OrgResultsPage, error) {
	// Create the url.
	path := "/orgs"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add the parameters to the url.
	if err := expandURL(req.URL, map[string]string{
		"limit":      strconv.Itoa(limit),
		"page_token": pageToken,
		"sort_by":    string(sortBy),
	}); err != nil {
		return nil, fmt.Errorf("expanding URL with parameters failed: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded OrgResultsPage
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// GetAny: Get an org.
// This endpoint requires authentication by a Zoo employee. It gets the information for the specified org.
//
// Parameters
//
//   - `id`: A UUID usually v4 or v7
func (s *OrgService) GetAny(id UUID) (*Org, error) {
	// Create the url.
	path := "/orgs/{{.id}}"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add the parameters to the url.
	if err := expandURL(req.URL, map[string]string{
		"id": id.String(),
	}); err != nil {
		return nil, fmt.Errorf("expanding URL with parameters failed: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded Org
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// UpdateEnterprisePricingFor: Set the enterprise price for an organization.
// You must be a Zoo employee to perform this request.
//
// Parameters
//
//   - `id`: A UUID usually v4 or v7
//   - `body`: The price for an enterprise subscription.
func (s *OrgService) UpdateEnterprisePricingFor(id UUID, body any) (*ZooProductSubscriptions, error) {
	// Create the url.
	path := "/orgs/{{.id}}/enterprise/pricing"
	uri := resolveRelative(s.client.server, path)

	// Encode the request body as json.
	b := new(bytes.Buffer)
	if err := json.NewEncoder(b).Encode(body); err != nil {
		return nil, fmt.Errorf("encoding json body request failed: %v", err)
	}

	// Create the request.
	req, err := http.NewRequest("PUT", uri, b)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add our headers.
	req.Header.Add("Content-Type", "application/json")

	// Add the parameters to the url.
	if err := expandURL(req.URL, map[string]string{
		"id": id.String(),
	}); err != nil {
		return nil, fmt.Errorf("expanding URL with parameters failed: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded ZooProductSubscriptions
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// GetBalanceForAnyOrg: Get balance for an org.
// This endpoint requires authentication by a Zoo employee. It gets the balance information for the specified org.
//
// Parameters
//
//   - `id`: A UUID usually v4 or v7
func (s *PaymentService) GetBalanceForAnyOrg(id UUID) (*CustomerBalance, error) {
	// Create the url.
	path := "/orgs/{{.id}}/payment/balance"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add the parameters to the url.
	if err := expandURL(req.URL, map[string]string{
		"id": id.String(),
	}); err != nil {
		return nil, fmt.Errorf("expanding URL with parameters failed: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded CustomerBalance
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// UpdateBalanceForAnyOrg: Update balance for an org.
// This endpoint requires authentication by a Zoo employee. It updates the balance information for the specified org.
//
// Parameters
//
//   - `id`: A UUID usually v4 or v7
//   - `body`: The data for updating a balance.
func (s *PaymentService) UpdateBalanceForAnyOrg(id UUID, body UpdatePaymentBalance) (*CustomerBalance, error) {
	// Create the url.
	path := "/orgs/{{.id}}/payment/balance"
	uri := resolveRelative(s.client.server, path)

	// Encode the request body as json.
	b := new(bytes.Buffer)
	if err := json.NewEncoder(b).Encode(body); err != nil {
		return nil, fmt.Errorf("encoding json body request failed: %v", err)
	}

	// Create the request.
	req, err := http.NewRequest("PUT", uri, b)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add our headers.
	req.Header.Add("Content-Type", "application/json")

	// Add the parameters to the url.
	if err := expandURL(req.URL, map[string]string{
		"id": id.String(),
	}); err != nil {
		return nil, fmt.Errorf("expanding URL with parameters failed: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded CustomerBalance
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// Ping: Return pong.
func (s *MetaService) Ping() (*Pong, error) {
	// Create the url.
	path := "/ping"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded Pong
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// GetPricingSubscriptions: Get the pricing for our subscriptions.
// This is the ultimate source of truth for the pricing of our subscriptions.
func (s *MetaService) GetPricingSubscriptions() (*map[string][]ZooProductSubscription, error) {
	// Create the url.
	path := "/pricing/subscriptions"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded map[string][]ZooProductSubscription
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// CreateCoupon: Create a new store coupon.
// This endpoint requires authentication by a Zoo employee. It creates a new store coupon.
//
// Parameters
//
//   - `body`: The parameters for a new store coupon.
func (s *StoreService) CreateCoupon(body StoreCouponParams) (*DiscountCode, error) {
	// Create the url.
	path := "/store/coupon"
	uri := resolveRelative(s.client.server, path)

	// Encode the request body as json.
	b := new(bytes.Buffer)
	if err := json.NewEncoder(b).Encode(body); err != nil {
		return nil, fmt.Errorf("encoding json body request failed: %v", err)
	}

	// Create the request.
	req, err := http.NewRequest("POST", uri, b)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add our headers.
	req.Header.Add("Content-Type", "application/json")

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded DiscountCode
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// GetAngleConversion: Convert angle units.
// Convert an angle unit value to another angle unit value. This is a nice endpoint to use for helper functions.
//
// Parameters
//
//   - `inputUnit`: The valid types of angle formats.
//   - `outputUnit`: The valid types of angle formats.
//   - `value`
func (s *UnitService) GetAngleConversion(inputUnit UnitAngle, outputUnit UnitAngle, value float64) (*UnitAngleConversion, error) {
	// Create the url.
	path := "/unit/conversion/angle/{{.input_unit}}/{{.output_unit}}"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add the parameters to the url.
	if err := expandURL(req.URL, map[string]string{
		"input_unit":  string(inputUnit),
		"output_unit": string(outputUnit),
		"value":       fmt.Sprintf("%f", value),
	}); err != nil {
		return nil, fmt.Errorf("expanding URL with parameters failed: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded UnitAngleConversion
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// GetAreaConversion: Convert area units.
// Convert an area unit value to another area unit value. This is a nice endpoint to use for helper functions.
//
// Parameters
//
//   - `inputUnit`: The valid types of area units.
//   - `outputUnit`: The valid types of area units.
//   - `value`
func (s *UnitService) GetAreaConversion(inputUnit UnitArea, outputUnit UnitArea, value float64) (*UnitAreaConversion, error) {
	// Create the url.
	path := "/unit/conversion/area/{{.input_unit}}/{{.output_unit}}"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add the parameters to the url.
	if err := expandURL(req.URL, map[string]string{
		"input_unit":  string(inputUnit),
		"output_unit": string(outputUnit),
		"value":       fmt.Sprintf("%f", value),
	}); err != nil {
		return nil, fmt.Errorf("expanding URL with parameters failed: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded UnitAreaConversion
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// GetCurrentConversion: Convert current units.
// Convert a current unit value to another current unit value. This is a nice endpoint to use for helper functions.
//
// Parameters
//
//   - `inputUnit`: The valid types of current units.
//   - `outputUnit`: The valid types of current units.
//   - `value`
func (s *UnitService) GetCurrentConversion(inputUnit UnitCurrent, outputUnit UnitCurrent, value float64) (*UnitCurrentConversion, error) {
	// Create the url.
	path := "/unit/conversion/current/{{.input_unit}}/{{.output_unit}}"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add the parameters to the url.
	if err := expandURL(req.URL, map[string]string{
		"input_unit":  string(inputUnit),
		"output_unit": string(outputUnit),
		"value":       fmt.Sprintf("%f", value),
	}); err != nil {
		return nil, fmt.Errorf("expanding URL with parameters failed: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded UnitCurrentConversion
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// GetEnergyConversion: Convert energy units.
// Convert a energy unit value to another energy unit value. This is a nice endpoint to use for helper functions.
//
// Parameters
//
//   - `inputUnit`: The valid types of energy units.
//   - `outputUnit`: The valid types of energy units.
//   - `value`
func (s *UnitService) GetEnergyConversion(inputUnit UnitEnergy, outputUnit UnitEnergy, value float64) (*UnitEnergyConversion, error) {
	// Create the url.
	path := "/unit/conversion/energy/{{.input_unit}}/{{.output_unit}}"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add the parameters to the url.
	if err := expandURL(req.URL, map[string]string{
		"input_unit":  string(inputUnit),
		"output_unit": string(outputUnit),
		"value":       fmt.Sprintf("%f", value),
	}); err != nil {
		return nil, fmt.Errorf("expanding URL with parameters failed: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded UnitEnergyConversion
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// GetForceConversion: Convert force units.
// Convert a force unit value to another force unit value. This is a nice endpoint to use for helper functions.
//
// Parameters
//
//   - `inputUnit`: The valid types of force units.
//   - `outputUnit`: The valid types of force units.
//   - `value`
func (s *UnitService) GetForceConversion(inputUnit UnitForce, outputUnit UnitForce, value float64) (*UnitForceConversion, error) {
	// Create the url.
	path := "/unit/conversion/force/{{.input_unit}}/{{.output_unit}}"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add the parameters to the url.
	if err := expandURL(req.URL, map[string]string{
		"input_unit":  string(inputUnit),
		"output_unit": string(outputUnit),
		"value":       fmt.Sprintf("%f", value),
	}); err != nil {
		return nil, fmt.Errorf("expanding URL with parameters failed: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded UnitForceConversion
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// GetFrequencyConversion: Convert frequency units.
// Convert a frequency unit value to another frequency unit value. This is a nice endpoint to use for helper functions.
//
// Parameters
//
//   - `inputUnit`: The valid types of frequency units.
//   - `outputUnit`: The valid types of frequency units.
//   - `value`
func (s *UnitService) GetFrequencyConversion(inputUnit UnitFrequency, outputUnit UnitFrequency, value float64) (*UnitFrequencyConversion, error) {
	// Create the url.
	path := "/unit/conversion/frequency/{{.input_unit}}/{{.output_unit}}"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add the parameters to the url.
	if err := expandURL(req.URL, map[string]string{
		"input_unit":  string(inputUnit),
		"output_unit": string(outputUnit),
		"value":       fmt.Sprintf("%f", value),
	}); err != nil {
		return nil, fmt.Errorf("expanding URL with parameters failed: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded UnitFrequencyConversion
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// GetLengthConversion: Convert length units.
// Convert a length unit value to another length unit value. This is a nice endpoint to use for helper functions.
//
// Parameters
//
//   - `inputUnit`: The valid types of length units.
//   - `outputUnit`: The valid types of length units.
//   - `value`
func (s *UnitService) GetLengthConversion(inputUnit UnitLength, outputUnit UnitLength, value float64) (*UnitLengthConversion, error) {
	// Create the url.
	path := "/unit/conversion/length/{{.input_unit}}/{{.output_unit}}"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add the parameters to the url.
	if err := expandURL(req.URL, map[string]string{
		"input_unit":  string(inputUnit),
		"output_unit": string(outputUnit),
		"value":       fmt.Sprintf("%f", value),
	}); err != nil {
		return nil, fmt.Errorf("expanding URL with parameters failed: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded UnitLengthConversion
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// GetMassConversion: Convert mass units.
// Convert a mass unit value to another mass unit value. This is a nice endpoint to use for helper functions.
//
// Parameters
//
//   - `inputUnit`: The valid types of mass units.
//   - `outputUnit`: The valid types of mass units.
//   - `value`
func (s *UnitService) GetMassConversion(inputUnit UnitMas, outputUnit UnitMas, value float64) (*UnitMassConversion, error) {
	// Create the url.
	path := "/unit/conversion/mass/{{.input_unit}}/{{.output_unit}}"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add the parameters to the url.
	if err := expandURL(req.URL, map[string]string{
		"input_unit":  string(inputUnit),
		"output_unit": string(outputUnit),
		"value":       fmt.Sprintf("%f", value),
	}); err != nil {
		return nil, fmt.Errorf("expanding URL with parameters failed: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded UnitMassConversion
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// GetPowerConversion: Convert power units.
// Convert a power unit value to another power unit value. This is a nice endpoint to use for helper functions.
//
// Parameters
//
//   - `inputUnit`: The valid types of power units.
//   - `outputUnit`: The valid types of power units.
//   - `value`
func (s *UnitService) GetPowerConversion(inputUnit UnitPower, outputUnit UnitPower, value float64) (*UnitPowerConversion, error) {
	// Create the url.
	path := "/unit/conversion/power/{{.input_unit}}/{{.output_unit}}"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add the parameters to the url.
	if err := expandURL(req.URL, map[string]string{
		"input_unit":  string(inputUnit),
		"output_unit": string(outputUnit),
		"value":       fmt.Sprintf("%f", value),
	}); err != nil {
		return nil, fmt.Errorf("expanding URL with parameters failed: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded UnitPowerConversion
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// GetPressureConversion: Convert pressure units.
// Convert a pressure unit value to another pressure unit value. This is a nice endpoint to use for helper functions.
//
// Parameters
//
//   - `inputUnit`: The valid types of pressure units.
//   - `outputUnit`: The valid types of pressure units.
//   - `value`
func (s *UnitService) GetPressureConversion(inputUnit UnitPressure, outputUnit UnitPressure, value float64) (*UnitPressureConversion, error) {
	// Create the url.
	path := "/unit/conversion/pressure/{{.input_unit}}/{{.output_unit}}"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add the parameters to the url.
	if err := expandURL(req.URL, map[string]string{
		"input_unit":  string(inputUnit),
		"output_unit": string(outputUnit),
		"value":       fmt.Sprintf("%f", value),
	}); err != nil {
		return nil, fmt.Errorf("expanding URL with parameters failed: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded UnitPressureConversion
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// GetTemperatureConversion: Convert temperature units.
// Convert a temperature unit value to another temperature unit value. This is a nice endpoint to use for helper functions.
//
// Parameters
//
//   - `inputUnit`: The valid types of temperature units.
//   - `outputUnit`: The valid types of temperature units.
//   - `value`
func (s *UnitService) GetTemperatureConversion(inputUnit UnitTemperature, outputUnit UnitTemperature, value float64) (*UnitTemperatureConversion, error) {
	// Create the url.
	path := "/unit/conversion/temperature/{{.input_unit}}/{{.output_unit}}"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add the parameters to the url.
	if err := expandURL(req.URL, map[string]string{
		"input_unit":  string(inputUnit),
		"output_unit": string(outputUnit),
		"value":       fmt.Sprintf("%f", value),
	}); err != nil {
		return nil, fmt.Errorf("expanding URL with parameters failed: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded UnitTemperatureConversion
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// GetTorqueConversion: Convert torque units.
// Convert a torque unit value to another torque unit value. This is a nice endpoint to use for helper functions.
//
// Parameters
//
//   - `inputUnit`: The valid types of torque units.
//   - `outputUnit`: The valid types of torque units.
//   - `value`
func (s *UnitService) GetTorqueConversion(inputUnit UnitTorque, outputUnit UnitTorque, value float64) (*UnitTorqueConversion, error) {
	// Create the url.
	path := "/unit/conversion/torque/{{.input_unit}}/{{.output_unit}}"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add the parameters to the url.
	if err := expandURL(req.URL, map[string]string{
		"input_unit":  string(inputUnit),
		"output_unit": string(outputUnit),
		"value":       fmt.Sprintf("%f", value),
	}); err != nil {
		return nil, fmt.Errorf("expanding URL with parameters failed: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded UnitTorqueConversion
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// GetVolumeConversion: Convert volume units.
// Convert a volume unit value to another volume unit value. This is a nice endpoint to use for helper functions.
//
// Parameters
//
//   - `inputUnit`: The valid types of volume units.
//   - `outputUnit`: The valid types of volume units.
//   - `value`
func (s *UnitService) GetVolumeConversion(inputUnit UnitVolume, outputUnit UnitVolume, value float64) (*UnitVolumeConversion, error) {
	// Create the url.
	path := "/unit/conversion/volume/{{.input_unit}}/{{.output_unit}}"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add the parameters to the url.
	if err := expandURL(req.URL, map[string]string{
		"input_unit":  string(inputUnit),
		"output_unit": string(outputUnit),
		"value":       fmt.Sprintf("%f", value),
	}); err != nil {
		return nil, fmt.Errorf("expanding URL with parameters failed: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded UnitVolumeConversion
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// GetSelf: Get your user.
// Get the user information for the authenticated user.
//
// Alternatively, you can also use the `/users/me` endpoint.
func (s *UserService) GetSelf() (*User, error) {
	// Create the url.
	path := "/user"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded User
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// UpdateSelf: Update your user.
// This endpoint requires authentication by any Zoo user. It updates information about the authenticated user.
//
// Parameters
//
//   - `body`: The user-modifiable parts of a User.
func (s *UserService) UpdateSelf(body UpdateUser) (*User, error) {
	// Create the url.
	path := "/user"
	uri := resolveRelative(s.client.server, path)

	// Encode the request body as json.
	b := new(bytes.Buffer)
	if err := json.NewEncoder(b).Encode(body); err != nil {
		return nil, fmt.Errorf("encoding json body request failed: %v", err)
	}

	// Create the request.
	req, err := http.NewRequest("PUT", uri, b)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add our headers.
	req.Header.Add("Content-Type", "application/json")

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded User
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// DeleteSelf: Delete your user.
// This endpoint requires authentication by any Zoo user. It deletes the authenticated user from Zoo's database.
//
// This call will only succeed if all invoices associated with the user have been paid in full and there is no outstanding balance.
func (s *UserService) DeleteSelf() error {
	// Create the url.
	path := "/user"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("DELETE", uri, nil)
	if err != nil {
		return fmt.Errorf("error creating request: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return err
	}

	// Return.
	return nil

}

// UserList: List API calls for your user.
// This endpoint requires authentication by any Zoo user. It returns the API calls for the authenticated user.
//
// The API calls are returned in order of creation, with the most recently created API calls first.
//
// Parameters
//
//   - `limit`
//
//   - `pageToken`
//
//   - `sortBy`: Supported set of sort modes for scanning by created_at only.
//
//     Currently, we only support scanning in ascending order.
func (s *APICallService) UserList(limit int, pageToken string, sortBy CreatedAtSortMode) (*APICallWithPriceResultsPage, error) {
	// Create the url.
	path := "/user/api-calls"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add the parameters to the url.
	if err := expandURL(req.URL, map[string]string{
		"limit":      strconv.Itoa(limit),
		"page_token": pageToken,
		"sort_by":    string(sortBy),
	}); err != nil {
		return nil, fmt.Errorf("expanding URL with parameters failed: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded APICallWithPriceResultsPage
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// GetForUser: Get an API call for a user.
// This endpoint requires authentication by any Zoo user. It returns details of the requested API call for the user.
//
// Parameters
//
//   - `id`
func (s *APICallService) GetForUser(id UUID) (*APICallWithPrice, error) {
	// Create the url.
	path := "/user/api-calls/{{.id}}"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add the parameters to the url.
	if err := expandURL(req.URL, map[string]string{
		"id": id.String(),
	}); err != nil {
		return nil, fmt.Errorf("expanding URL with parameters failed: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded APICallWithPrice
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// ListForUser: List API tokens for your user.
// This endpoint requires authentication by any Zoo user. It returns the API tokens for the authenticated user.
//
// The API tokens are returned in order of creation, with the most recently created API tokens first.
//
// Parameters
//
//   - `limit`
//
//   - `pageToken`
//
//   - `sortBy`: Supported set of sort modes for scanning by created_at only.
//
//     Currently, we only support scanning in ascending order.
func (s *APITokenService) ListForUser(limit int, pageToken string, sortBy CreatedAtSortMode) (*APITokenResultsPage, error) {
	// Create the url.
	path := "/user/api-tokens"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add the parameters to the url.
	if err := expandURL(req.URL, map[string]string{
		"limit":      strconv.Itoa(limit),
		"page_token": pageToken,
		"sort_by":    string(sortBy),
	}); err != nil {
		return nil, fmt.Errorf("expanding URL with parameters failed: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded APITokenResultsPage
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// CreateForUser: Create a new API token for your user.
// This endpoint requires authentication by any Zoo user. It creates a new API token for the authenticated user.
//
// Parameters
//
//   - `label`
func (s *APITokenService) CreateForUser(label string) (*APIToken, error) {
	// Create the url.
	path := "/user/api-tokens"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("POST", uri, nil)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add the parameters to the url.
	if err := expandURL(req.URL, map[string]string{
		"label": label,
	}); err != nil {
		return nil, fmt.Errorf("expanding URL with parameters failed: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded APIToken
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// GetForUser: Get an API token for your user.
// This endpoint requires authentication by any Zoo user. It returns details of the requested API token for the user.
//
// Parameters
//
//   - `token`: An auth token. A uuid with a prefix of api-
func (s *APITokenService) GetForUser(token string) (*APIToken, error) {
	// Create the url.
	path := "/user/api-tokens/{{.token}}"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add the parameters to the url.
	if err := expandURL(req.URL, map[string]string{
		"token": token,
	}); err != nil {
		return nil, fmt.Errorf("expanding URL with parameters failed: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded APIToken
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// DeleteForUser: Delete an API token for your user.
// This endpoint requires authentication by any Zoo user. It deletes the requested API token for the user.
//
// This endpoint does not actually delete the API token from the database. It merely marks the token as invalid. We still want to keep the token in the database for historical purposes.
//
// Parameters
//
//   - `token`: An auth token. A uuid with a prefix of api-
func (s *APITokenService) DeleteForUser(token string) error {
	// Create the url.
	path := "/user/api-tokens/{{.token}}"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("DELETE", uri, nil)
	if err != nil {
		return fmt.Errorf("error creating request: %v", err)
	}

	// Add the parameters to the url.
	if err := expandURL(req.URL, map[string]string{
		"token": token,
	}); err != nil {
		return fmt.Errorf("expanding URL with parameters failed: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return err
	}

	// Return.
	return nil

}

// GetSelfExtended: Get extended information about your user.
// Get the user information for the authenticated user.
//
// Alternatively, you can also use the `/users-extended/me` endpoint.
func (s *UserService) GetSelfExtended() (*ExtendedUser, error) {
	// Create the url.
	path := "/user/extended"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded ExtendedUser
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// GetOauth2ProvidersFor: Get the OAuth2 providers for your user.
// If this returns an empty array, then the user has not connected any OAuth2 providers and uses raw email authentication.
//
// This endpoint requires authentication by any Zoo user. It gets the providers for the authenticated user.
func (s *UserService) GetOauth2ProvidersFor() (*[]AccountProvider, error) {
	// Create the url.
	path := "/user/oauth2/providers"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded []AccountProvider
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// GetOnboardingSelf: Get your user's onboarding status.
// Checks key part of their api usage to determine their onboarding progress
func (s *UserService) GetOnboardingSelf() (*Onboarding, error) {
	// Create the url.
	path := "/user/onboarding"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded Onboarding
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// GetUser: Get a user's org.
// This endpoint requires authentication by any Zoo user. It gets the authenticated user's org.
//
// If the user is not a member of an org, this endpoint will return a 404.
func (s *OrgService) GetUser() (*UserOrgInfo, error) {
	// Create the url.
	path := "/user/org"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded UserOrgInfo
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// GetInformationForUser: Get payment info about your user.
// This includes billing address, phone, and name.
//
// This endpoint requires authentication by any Zoo user. It gets the payment information for the authenticated user.
func (s *PaymentService) GetInformationForUser() (*Customer, error) {
	// Create the url.
	path := "/user/payment"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded Customer
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// CreateInformationForUser: Create payment info for your user.
// This includes billing address, phone, and name.
//
// This endpoint requires authentication by any Zoo user. It creates the payment information for the authenticated user.
//
// Parameters
//
//   - `body`: The billing information for payments.
func (s *PaymentService) CreateInformationForUser(body BillingInfo) (*Customer, error) {
	// Create the url.
	path := "/user/payment"
	uri := resolveRelative(s.client.server, path)

	// Encode the request body as json.
	b := new(bytes.Buffer)
	if err := json.NewEncoder(b).Encode(body); err != nil {
		return nil, fmt.Errorf("encoding json body request failed: %v", err)
	}

	// Create the request.
	req, err := http.NewRequest("POST", uri, b)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add our headers.
	req.Header.Add("Content-Type", "application/json")

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded Customer
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// UpdateInformationForUser: Update payment info for your user.
// This includes billing address, phone, and name.
//
// This endpoint requires authentication by any Zoo user. It updates the payment information for the authenticated user.
//
// Parameters
//
//   - `body`: The billing information for payments.
func (s *PaymentService) UpdateInformationForUser(body BillingInfo) (*Customer, error) {
	// Create the url.
	path := "/user/payment"
	uri := resolveRelative(s.client.server, path)

	// Encode the request body as json.
	b := new(bytes.Buffer)
	if err := json.NewEncoder(b).Encode(body); err != nil {
		return nil, fmt.Errorf("encoding json body request failed: %v", err)
	}

	// Create the request.
	req, err := http.NewRequest("PUT", uri, b)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add our headers.
	req.Header.Add("Content-Type", "application/json")

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded Customer
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// DeleteInformationForUser: Delete payment info for your user.
// This includes billing address, phone, and name.
//
// This endpoint requires authentication by any Zoo user. It deletes the payment information for the authenticated user.
func (s *PaymentService) DeleteInformationForUser() error {
	// Create the url.
	path := "/user/payment"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("DELETE", uri, nil)
	if err != nil {
		return fmt.Errorf("error creating request: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return err
	}

	// Return.
	return nil

}

// GetBalanceForUser: Get balance for your user.
// This endpoint requires authentication by any Zoo user. It gets the balance information for the authenticated user.
func (s *PaymentService) GetBalanceForUser() (*CustomerBalance, error) {
	// Create the url.
	path := "/user/payment/balance"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded CustomerBalance
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// CreateIntentForUser: Create a payment intent for your user.
// This endpoint requires authentication by any Zoo user. It creates a new payment intent for the authenticated user.
func (s *PaymentService) CreateIntentForUser() (*PaymentIntent, error) {
	// Create the url.
	path := "/user/payment/intent"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("POST", uri, nil)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded PaymentIntent
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// ListInvoicesForUser: List invoices for your user.
// This endpoint requires authentication by any Zoo user. It lists invoices for the authenticated user.
func (s *PaymentService) ListInvoicesForUser() (*[]Invoice, error) {
	// Create the url.
	path := "/user/payment/invoices"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded []Invoice
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// ListMethodsForUser: List payment methods for your user.
// This endpoint requires authentication by any Zoo user. It lists payment methods for the authenticated user.
func (s *PaymentService) ListMethodsForUser() (*[]PaymentMethod, error) {
	// Create the url.
	path := "/user/payment/methods"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded []PaymentMethod
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// DeleteMethodForUser: Delete a payment method for your user.
// This endpoint requires authentication by any Zoo user. It deletes the specified payment method for the authenticated user.
//
// Parameters
//
//   - `id`
func (s *PaymentService) DeleteMethodForUser(id string) error {
	// Create the url.
	path := "/user/payment/methods/{{.id}}"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("DELETE", uri, nil)
	if err != nil {
		return fmt.Errorf("error creating request: %v", err)
	}

	// Add the parameters to the url.
	if err := expandURL(req.URL, map[string]string{
		"id": id,
	}); err != nil {
		return fmt.Errorf("expanding URL with parameters failed: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return err
	}

	// Return.
	return nil

}

// GetUserSubscription: Get the subscription for a user.
// This endpoint requires authentication by any Zoo user. It gets the subscription for the user.
func (s *PaymentService) GetUserSubscription() (*ZooProductSubscriptions, error) {
	// Create the url.
	path := "/user/payment/subscriptions"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded ZooProductSubscriptions
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// CreateUserSubscription: Create the subscription for a user.
// This endpoint requires authentication by any Zoo user. It creates the subscription for the user.
//
// Parameters
//
//   - `body`: A struct of Zoo product subscriptions a user can request.
func (s *PaymentService) CreateUserSubscription(body ZooProductSubscriptionsUserRequest) (*ZooProductSubscriptions, error) {
	// Create the url.
	path := "/user/payment/subscriptions"
	uri := resolveRelative(s.client.server, path)

	// Encode the request body as json.
	b := new(bytes.Buffer)
	if err := json.NewEncoder(b).Encode(body); err != nil {
		return nil, fmt.Errorf("encoding json body request failed: %v", err)
	}

	// Create the request.
	req, err := http.NewRequest("POST", uri, b)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add our headers.
	req.Header.Add("Content-Type", "application/json")

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded ZooProductSubscriptions
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// UpdateUserSubscription: Update the user's subscription.
// This endpoint requires authentication by any Zoo user. It updates the subscription for the user.
//
// Parameters
//
//   - `body`: A struct of Zoo product subscriptions a user can request.
func (s *PaymentService) UpdateUserSubscription(body ZooProductSubscriptionsUserRequest) (*ZooProductSubscriptions, error) {
	// Create the url.
	path := "/user/payment/subscriptions"
	uri := resolveRelative(s.client.server, path)

	// Encode the request body as json.
	b := new(bytes.Buffer)
	if err := json.NewEncoder(b).Encode(body); err != nil {
		return nil, fmt.Errorf("encoding json body request failed: %v", err)
	}

	// Create the request.
	req, err := http.NewRequest("PUT", uri, b)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add our headers.
	req.Header.Add("Content-Type", "application/json")

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded ZooProductSubscriptions
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// ValidateCustomerTaxInformationForUser: Validate a user's information is correct and valid for automatic tax.
// This endpoint requires authentication by any Zoo user. It will return an error if the user's information is not valid for automatic tax. Otherwise, it will return an empty successful response.
func (s *PaymentService) ValidateCustomerTaxInformationForUser() error {
	// Create the url.
	path := "/user/payment/tax"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return fmt.Errorf("error creating request: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return err
	}

	// Return.
	return nil

}

// GetPrivacySettings: Get the privacy settings for a user.
// This endpoint requires authentication by any Zoo user. It gets the privacy settings for the user.
func (s *UserService) GetPrivacySettings() (*PrivacySettings, error) {
	// Create the url.
	path := "/user/privacy"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded PrivacySettings
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// UpdatePrivacySettings: Update the user's privacy settings.
// This endpoint requires authentication by any Zoo user. It updates the privacy settings for the user.
//
// Parameters
//
//   - `body`: Privacy settings for an org or user.
func (s *UserService) UpdatePrivacySettings(body PrivacySettings) (*PrivacySettings, error) {
	// Create the url.
	path := "/user/privacy"
	uri := resolveRelative(s.client.server, path)

	// Encode the request body as json.
	b := new(bytes.Buffer)
	if err := json.NewEncoder(b).Encode(body); err != nil {
		return nil, fmt.Errorf("encoding json body request failed: %v", err)
	}

	// Create the request.
	req, err := http.NewRequest("PUT", uri, b)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add our headers.
	req.Header.Add("Content-Type", "application/json")

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded PrivacySettings
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// GetSessionFor: Get a session for your user.
// This endpoint requires authentication by any Zoo user. It returns details of the requested API token for the user.
//
// Parameters
//
//   - `token`: An auth token. A uuid with a prefix of ses-
func (s *UserService) GetSessionFor(token string) (*Session, error) {
	// Create the url.
	path := "/user/session/{{.token}}"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add the parameters to the url.
	if err := expandURL(req.URL, map[string]string{
		"token": token,
	}); err != nil {
		return nil, fmt.Errorf("expanding URL with parameters failed: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded Session
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// GetShortlinks: Get the shortlinks for a user.
// This endpoint requires authentication by any Zoo user. It gets the shortlinks for the user.
//
// Parameters
//
//   - `limit`
//
//   - `pageToken`
//
//   - `sortBy`: Supported set of sort modes for scanning by created_at only.
//
//     Currently, we only support scanning in ascending order.
func (s *UserService) GetShortlinks(limit int, pageToken string, sortBy CreatedAtSortMode) (*ShortlinkResultsPage, error) {
	// Create the url.
	path := "/user/shortlinks"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add the parameters to the url.
	if err := expandURL(req.URL, map[string]string{
		"limit":      strconv.Itoa(limit),
		"page_token": pageToken,
		"sort_by":    string(sortBy),
	}); err != nil {
		return nil, fmt.Errorf("expanding URL with parameters failed: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded ShortlinkResultsPage
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// CreateShortlink: Create a shortlink for a user.
// This endpoint requires authentication by any Zoo user. It creates a shortlink for the user.
//
// Parameters
//
//   - `body`: Request to create a shortlink.
func (s *UserService) CreateShortlink(body CreateShortlinkRequest) (*CreateShortlinkResponse, error) {
	// Create the url.
	path := "/user/shortlinks"
	uri := resolveRelative(s.client.server, path)

	// Encode the request body as json.
	b := new(bytes.Buffer)
	if err := json.NewEncoder(b).Encode(body); err != nil {
		return nil, fmt.Errorf("encoding json body request failed: %v", err)
	}

	// Create the request.
	req, err := http.NewRequest("POST", uri, b)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add our headers.
	req.Header.Add("Content-Type", "application/json")

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded CreateShortlinkResponse
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// RedirectUserShortlink: Redirect the user to the URL for the shortlink.
// This endpoint might require authentication by a Zoo user. It gets the shortlink for the user and redirects them to the URL. If the shortlink is owned by an org, the user must be a member of the org.
//
// Parameters
//
//   - `key`
func (s *HiddenService) RedirectUserShortlink(key string) error {
	// Create the url.
	path := "/user/shortlinks/{{.key}}"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return fmt.Errorf("error creating request: %v", err)
	}

	// Add the parameters to the url.
	if err := expandURL(req.URL, map[string]string{
		"key": key,
	}); err != nil {
		return fmt.Errorf("expanding URL with parameters failed: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return err
	}

	// Return.
	return nil

}

// UpdateShortlink: Update a shortlink for a user.
// This endpoint requires authentication by any Zoo user. It updates a shortlink for the user.
//
// This endpoint really only allows you to change the `restrict_to_org` setting of a shortlink. Thus it is only useful for folks who are part of an org. If you are not part of an org, you will not be able to change the `restrict_to_org` status.
//
// Parameters
//
//   - `key`
//   - `body`: Request to update a shortlink.
func (s *UserService) UpdateShortlink(key string, body UpdateShortlinkRequest) error {
	// Create the url.
	path := "/user/shortlinks/{{.key}}"
	uri := resolveRelative(s.client.server, path)

	// Encode the request body as json.
	b := new(bytes.Buffer)
	if err := json.NewEncoder(b).Encode(body); err != nil {
		return fmt.Errorf("encoding json body request failed: %v", err)
	}

	// Create the request.
	req, err := http.NewRequest("PUT", uri, b)
	if err != nil {
		return fmt.Errorf("error creating request: %v", err)
	}

	// Add our headers.
	req.Header.Add("Content-Type", "application/json")

	// Add the parameters to the url.
	if err := expandURL(req.URL, map[string]string{
		"key": key,
	}); err != nil {
		return fmt.Errorf("expanding URL with parameters failed: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return err
	}

	// Return.
	return nil

}

// DeleteShortlink: Delete a shortlink for a user.
// This endpoint requires authentication by any Zoo user. It deletes a shortlink for the user.
//
// Parameters
//
//   - `key`
func (s *UserService) DeleteShortlink(key string) error {
	// Create the url.
	path := "/user/shortlinks/{{.key}}"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("DELETE", uri, nil)
	if err != nil {
		return fmt.Errorf("error creating request: %v", err)
	}

	// Add the parameters to the url.
	if err := expandURL(req.URL, map[string]string{
		"key": key,
	}); err != nil {
		return fmt.Errorf("expanding URL with parameters failed: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return err
	}

	// Return.
	return nil

}

// ListTextToCadModelsForUser: List text-to-CAD models you've generated.
// This will always return the STEP file contents as well as the format the user originally requested.
//
// This endpoint requires authentication by any Zoo user. It returns the text-to-CAD models for the authenticated user.
//
// The text-to-CAD models are returned in order of creation, with the most recently created text-to-CAD models first.
//
// Parameters
//
//   - `limit`
//
//   - `pageToken`
//
//   - `sortBy`: Supported set of sort modes for scanning by created_at only.
//
//     Currently, we only support scanning in ascending order.
//
//   - `noModels`
func (s *MlService) ListTextToCadModelsForUser(limit int, pageToken string, sortBy CreatedAtSortMode, noModels bool) (*TextToCadResultsPage, error) {
	// Create the url.
	path := "/user/text-to-cad"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add the parameters to the url.
	if err := expandURL(req.URL, map[string]string{
		"limit":      strconv.Itoa(limit),
		"page_token": pageToken,
		"sort_by":    string(sortBy),
		"no_models":  strconv.FormatBool(noModels),
	}); err != nil {
		return nil, fmt.Errorf("expanding URL with parameters failed: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded TextToCadResultsPage
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// GetTextToCadModelForUser: Get a text-to-CAD response.
// This endpoint requires authentication by any Zoo user. The user must be the owner of the text-to-CAD model.
//
// Parameters
//
//   - `id`
func (s *MlService) GetTextToCadModelForUser(id UUID) (*TextToCad, error) {
	// Create the url.
	path := "/user/text-to-cad/{{.id}}"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add the parameters to the url.
	if err := expandURL(req.URL, map[string]string{
		"id": id.String(),
	}); err != nil {
		return nil, fmt.Errorf("expanding URL with parameters failed: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded TextToCad
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// CreateTextToCadModelFeedback: Give feedback to a specific ML response.
// This can be a text-to-CAD creation or iteration.
//
// This endpoint requires authentication by any Zoo user. The user must be the owner of the ML response, in order to give feedback.
//
// Parameters
//
//   - `id`
//   - `feedback`: Human feedback on an ML response.
func (s *MlService) CreateTextToCadModelFeedback(id UUID, feedback MlFeedback) error {
	// Create the url.
	path := "/user/text-to-cad/{{.id}}"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("POST", uri, nil)
	if err != nil {
		return fmt.Errorf("error creating request: %v", err)
	}

	// Add the parameters to the url.
	if err := expandURL(req.URL, map[string]string{
		"id":       id.String(),
		"feedback": string(feedback),
	}); err != nil {
		return fmt.Errorf("expanding URL with parameters failed: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return err
	}

	// Return.
	return nil

}

// List: List users.
// This endpoint requires authentication by a Zoo employee. The users are returned in order of creation, with the most recently created users first.
//
// Parameters
//
//   - `limit`
//
//   - `pageToken`
//
//   - `sortBy`: Supported set of sort modes for scanning by created_at only.
//
//     Currently, we only support scanning in ascending order.
func (s *UserService) List(limit int, pageToken string, sortBy CreatedAtSortMode) (*UserResultsPage, error) {
	// Create the url.
	path := "/users"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add the parameters to the url.
	if err := expandURL(req.URL, map[string]string{
		"limit":      strconv.Itoa(limit),
		"page_token": pageToken,
		"sort_by":    string(sortBy),
	}); err != nil {
		return nil, fmt.Errorf("expanding URL with parameters failed: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded UserResultsPage
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// ListExtended: List users with extended information.
// This endpoint requires authentication by a Zoo employee. The users are returned in order of creation, with the most recently created users first.
//
// Parameters
//
//   - `limit`
//
//   - `pageToken`
//
//   - `sortBy`: Supported set of sort modes for scanning by created_at only.
//
//     Currently, we only support scanning in ascending order.
func (s *UserService) ListExtended(limit int, pageToken string, sortBy CreatedAtSortMode) (*ExtendedUserResultsPage, error) {
	// Create the url.
	path := "/users-extended"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add the parameters to the url.
	if err := expandURL(req.URL, map[string]string{
		"limit":      strconv.Itoa(limit),
		"page_token": pageToken,
		"sort_by":    string(sortBy),
	}); err != nil {
		return nil, fmt.Errorf("expanding URL with parameters failed: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded ExtendedUserResultsPage
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// GetExtended: Get extended information about a user.
// To get information about yourself, use `/users-extended/me` as the endpoint. By doing so you will get the user information for the authenticated user.
//
// Alternatively, to get information about the authenticated user, use `/user/extended` endpoint.
//
// To get information about any Zoo user, you must be a Zoo employee.
//
// Parameters
//
//   - `id`
func (s *UserService) GetExtended(id string) (*ExtendedUser, error) {
	// Create the url.
	path := "/users-extended/{{.id}}"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add the parameters to the url.
	if err := expandURL(req.URL, map[string]string{
		"id": id,
	}); err != nil {
		return nil, fmt.Errorf("expanding URL with parameters failed: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded ExtendedUser
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// Get: Get a user.
// To get information about yourself, use `/users/me` as the endpoint. By doing so you will get the user information for the authenticated user.
//
// Alternatively, to get information about the authenticated user, use `/user` endpoint.
//
// To get information about any Zoo user, you must be a Zoo employee.
//
// Parameters
//
//   - `id`
func (s *UserService) Get(id string) (*User, error) {
	// Create the url.
	path := "/users/{{.id}}"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add the parameters to the url.
	if err := expandURL(req.URL, map[string]string{
		"id": id,
	}); err != nil {
		return nil, fmt.Errorf("expanding URL with parameters failed: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded User
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// ListForUser: List API calls for a user.
// This endpoint requires authentication by any Zoo user. It returns the API calls for the authenticated user if "me" is passed as the user id.
//
// Alternatively, you can use the `/user/api-calls` endpoint to get the API calls for your user.
//
// If the authenticated user is a Zoo employee, then the API calls are returned for the user specified by the user id.
//
// The API calls are returned in order of creation, with the most recently created API calls first.
//
// Parameters
//
//   - `id`
//
//   - `limit`
//
//   - `pageToken`
//
//   - `sortBy`: Supported set of sort modes for scanning by created_at only.
//
//     Currently, we only support scanning in ascending order.
func (s *APICallService) ListForUser(id string, limit int, pageToken string, sortBy CreatedAtSortMode) (*APICallWithPriceResultsPage, error) {
	// Create the url.
	path := "/users/{{.id}}/api-calls"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add the parameters to the url.
	if err := expandURL(req.URL, map[string]string{
		"id":         id,
		"limit":      strconv.Itoa(limit),
		"page_token": pageToken,
		"sort_by":    string(sortBy),
	}); err != nil {
		return nil, fmt.Errorf("expanding URL with parameters failed: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded APICallWithPriceResultsPage
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// GetBalanceForAnyUser: Get balance for an user.
// This endpoint requires authentication by a Zoo employee. It gets the balance information for the specified user.
//
// Parameters
//
//   - `id`
func (s *PaymentService) GetBalanceForAnyUser(id string) (*CustomerBalance, error) {
	// Create the url.
	path := "/users/{{.id}}/payment/balance"
	uri := resolveRelative(s.client.server, path)

	// Create the request.
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add the parameters to the url.
	if err := expandURL(req.URL, map[string]string{
		"id": id,
	}); err != nil {
		return nil, fmt.Errorf("expanding URL with parameters failed: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded CustomerBalance
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// UpdateBalanceForAnyUser: Update balance for an user.
// This endpoint requires authentication by a Zoo employee. It updates the balance information for the specified user.
//
// Parameters
//
//   - `id`
//   - `body`: The data for updating a balance.
func (s *PaymentService) UpdateBalanceForAnyUser(id string, body UpdatePaymentBalance) (*CustomerBalance, error) {
	// Create the url.
	path := "/users/{{.id}}/payment/balance"
	uri := resolveRelative(s.client.server, path)

	// Encode the request body as json.
	b := new(bytes.Buffer)
	if err := json.NewEncoder(b).Encode(body); err != nil {
		return nil, fmt.Errorf("encoding json body request failed: %v", err)
	}

	// Create the request.
	req, err := http.NewRequest("PUT", uri, b)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %v", err)
	}

	// Add our headers.
	req.Header.Add("Content-Type", "application/json")

	// Add the parameters to the url.
	if err := expandURL(req.URL, map[string]string{
		"id": id,
	}); err != nil {
		return nil, fmt.Errorf("expanding URL with parameters failed: %v", err)
	}

	// Send the request.
	resp, err := s.client.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error sending request: %v", err)
	}
	defer resp.Body.Close()

	// Check the response.
	if err := checkResponse(resp); err != nil {
		return nil, err
	}

	// Decode the body from the response.
	if resp.Body == nil {
		return nil, errors.New("request returned an empty body in the response")
	}
	var decoded CustomerBalance
	if err := json.NewDecoder(resp.Body).Decode(&decoded); err != nil {
		return nil, fmt.Errorf("error decoding response body: %v", err)
	}

	// Return the response.
	return &decoded, nil

}

// CreateTerm: Create a terminal.
// Attach to a docker container to create an interactive terminal.
func (s *ExecutorService) CreateTerm() (*websocket.Conn, error) {
	// Create the url.
	path := "/ws/executor/term"
	uri := resolveRelative(s.client.server, path)

	headers := http.Header{}
	headers["Authorization"] = []string{fmt.Sprintf("Bearer %s", s.client.token)}

	conn, _, err := websocket.DefaultDialer.Dial(strings.ReplaceAll(uri, "https://", "wss://"), headers)
	if err != nil {
		return nil, err
	}

	return conn, nil
}

// CommandsWs: Open a websocket which accepts modeling commands.
// Pass those commands to the engine via websocket, and pass responses back to the client. Basically, this is a websocket proxy between the frontend/client and the engine.
//
// Parameters
//
//   - `fps`
//   - `pool`
//   - `postEffect`: Post effect type
//   - `replay`
//   - `showGrid`
//   - `unlockedFramerate`
//   - `videoResHeight`
//   - `videoResWidth`
//   - `webrtc`
//   - `body`: The websocket messages the server receives.
func (s *ModelingService) CommandsWs(fps int, pool string, postEffect PostEffectType, replay string, showGrid bool, unlockedFramerate bool, videoResHeight int, videoResWidth int, webrtc bool, body any) (*websocket.Conn, error) {
	// Create the url.
	path := "/ws/modeling/commands"
	uri := resolveRelative(s.client.server, path)

	headers := http.Header{}
	headers["Authorization"] = []string{fmt.Sprintf("Bearer %s", s.client.token)}

	conn, _, err := websocket.DefaultDialer.Dial(strings.ReplaceAll(uri, "https://", "wss://"), headers)
	if err != nil {
		return nil, err
	}

	return conn, nil
}