client.gen.go

// Package rest provides primitives to interact with the openapi HTTP API.
//
// Code generated by github.com/deepmap/oapi-codegen DO NOT EDIT.
package rest

import (
	"bytes"
	"context"
	"encoding/json"
	"encoding/xml"
	"fmt"
	"io"
	"io/ioutil"
	"net/http"
	"net/url"
	"strings"

	"gopkg.in/yaml.v2"

	"github.com/deepmap/oapi-codegen/pkg/runtime"
)

// RequestEditorFn  is the function signature for the RequestEditor callback function
type RequestEditorFn func(ctx context.Context, req *http.Request) error

// Doer performs HTTP requests.
//
// The standard http.Client implements this interface.
type HttpRequestDoer interface {
	Do(req *http.Request) (*http.Response, error)
}

// Client which conforms to the OpenAPI3 specification for this service.
type Client struct {
	// The endpoint of the server conforming to this interface, with scheme,
	// https://api.deepmap.com for example. This can contain a path relative
	// to the server, such as https://api.deepmap.com/dev-test, and all the
	// paths in the swagger spec will be appended to the server.
	Server string

	// Doer for performing requests, typically a *http.Client with any
	// customized settings, such as certificate chains.
	Client HttpRequestDoer

	// A list of callbacks for modifying requests which are generated before sending over
	// the network.
	RequestEditors []RequestEditorFn
}

// ClientOption allows setting custom parameters during construction
type ClientOption func(*Client) error

// Creates a new Client, with reasonable defaults
func NewClient(server string, opts ...ClientOption) (*Client, error) {
	// create a client with sane default values
	client := Client{
		Server: server,
	}
	// mutate client and add all optional params
	for _, o := range opts {
		if err := o(&client); err != nil {
			return nil, err
		}
	}
	// ensure the server URL always has a trailing slash
	if !strings.HasSuffix(client.Server, "/") {
		client.Server += "/"
	}
	// create httpClient, if not already present
	if client.Client == nil {
		client.Client = &http.Client{}
	}
	return &client, nil
}

// WithHTTPClient allows overriding the default Doer, which is
// automatically created using http.Client. This is useful for tests.
func WithHTTPClient(doer HttpRequestDoer) ClientOption {
	return func(c *Client) error {
		c.Client = doer
		return nil
	}
}

// WithRequestEditorFn allows setting up a callback function, which will be
// called right before sending the request. This can be used to mutate the request.
func WithRequestEditorFn(fn RequestEditorFn) ClientOption {
	return func(c *Client) error {
		c.RequestEditors = append(c.RequestEditors, fn)
		return nil
	}
}

// The interface specification for the client above.
type ClientInterface interface {
	// FindAlerts request
	FindAlerts(ctx context.Context, params *FindAlertsParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// CreateAlert request  with any body
	CreateAlertWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	CreateAlert(ctx context.Context, body CreateAlertJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DeleteAlertByUuid request
	DeleteAlertByUuid(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*http.Response, error)

	// FindAlertByUuid request
	FindAlertByUuid(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*http.Response, error)

	// UpdateAlertByUuid request  with any body
	UpdateAlertByUuidWithBody(ctx context.Context, uuid UuidParam, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	UpdateAlertByUuid(ctx context.Context, uuid UuidParam, body UpdateAlertByUuidJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// FindDatasets request
	FindDatasets(ctx context.Context, params *FindDatasetsParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// AddDatasets request  with any body
	AddDatasetsWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	AddDatasets(ctx context.Context, body AddDatasetsJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DeleteDatasetByUuid request
	DeleteDatasetByUuid(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*http.Response, error)

	// FindDatasetByUuid request
	FindDatasetByUuid(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*http.Response, error)

	// UpdateDatasetByUuid request  with any body
	UpdateDatasetByUuidWithBody(ctx context.Context, uuid UuidParam, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	UpdateDatasetByUuid(ctx context.Context, uuid UuidParam, body UpdateDatasetByUuidJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// AssembleDatasetPartsByKey request
	AssembleDatasetPartsByKey(ctx context.Context, uuid UuidParam, params *AssembleDatasetPartsByKeyParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ListDatasetPartsByKey request
	ListDatasetPartsByKey(ctx context.Context, uuid UuidParam, params *ListDatasetPartsByKeyParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// UploadDatasetContentByKey request
	UploadDatasetContentByKey(ctx context.Context, uuid UuidParam, params *UploadDatasetContentByKeyParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetRawDatasetByUuid request
	GetRawDatasetByUuid(ctx context.Context, uuid UuidParam, params *GetRawDatasetByUuidParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DeleteDatasetUploadByKey request
	DeleteDatasetUploadByKey(ctx context.Context, uuid UuidParam, params *DeleteDatasetUploadByKeyParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// InitializeDatasetUploadByUuid request
	InitializeDatasetUploadByUuid(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*http.Response, error)

	// FindGroups request
	FindGroups(ctx context.Context, params *FindGroupsParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// AddGroup request  with any body
	AddGroupWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	AddGroup(ctx context.Context, body AddGroupJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DeleteGroupByUuid request
	DeleteGroupByUuid(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*http.Response, error)

	// FindGroupByUuid request
	FindGroupByUuid(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*http.Response, error)

	// UpdateGroupByUuid request  with any body
	UpdateGroupByUuidWithBody(ctx context.Context, uuid UuidParam, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	UpdateGroupByUuid(ctx context.Context, uuid UuidParam, body UpdateGroupByUuidJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// FindPoliciesForGroup request
	FindPoliciesForGroup(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*http.Response, error)

	// FindPolicies request
	FindPolicies(ctx context.Context, params *FindPoliciesParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// AddPolicy request  with any body
	AddPolicyWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	AddPolicy(ctx context.Context, body AddPolicyJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DeletePolicyByUuid request
	DeletePolicyByUuid(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*http.Response, error)

	// FindPolicyByUuid request
	FindPolicyByUuid(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*http.Response, error)

	// UpdatePolicyByUuid request  with any body
	UpdatePolicyByUuidWithBody(ctx context.Context, uuid UuidParam, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	UpdatePolicyByUuid(ctx context.Context, uuid UuidParam, body UpdatePolicyByUuidJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// FindPrograms request
	FindPrograms(ctx context.Context, params *FindProgramsParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// AddProgram request  with any body
	AddProgramWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	AddProgram(ctx context.Context, body AddProgramJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DeleteProgramByUuid request
	DeleteProgramByUuid(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*http.Response, error)

	// FindProgramByUuid request
	FindProgramByUuid(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*http.Response, error)

	// UpdateProgramByUuid request  with any body
	UpdateProgramByUuidWithBody(ctx context.Context, uuid UuidParam, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	UpdateProgramByUuid(ctx context.Context, uuid UuidParam, body UpdateProgramByUuidJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetCodeFromProgram request
	GetCodeFromProgram(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*http.Response, error)

	// AddProgramCodeRevision request  with any body
	AddProgramCodeRevisionWithBody(ctx context.Context, uuid UuidParam, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetProgramCodeRevisionsDiff request
	GetProgramCodeRevisionsDiff(ctx context.Context, uuid UuidParam, params *GetProgramCodeRevisionsDiffParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetProgramCodeRevisions request
	GetProgramCodeRevisions(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DeleteProgramCodeRevisions request
	DeleteProgramCodeRevisions(ctx context.Context, uuid UuidParam, revisionId int, reqEditors ...RequestEditorFn) (*http.Response, error)

	// SignProgramCodeRevisions request
	SignProgramCodeRevisions(ctx context.Context, uuid UuidParam, revisionId int, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ExecuteProgramWebhook request
	ExecuteProgramWebhook(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*http.Response, error)

	// FindThings request
	FindThings(ctx context.Context, params *FindThingsParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// AddThing request  with any body
	AddThingWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	AddThing(ctx context.Context, body AddThingJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DeleteThingByUuid request
	DeleteThingByUuid(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*http.Response, error)

	// FindThingByUuid request
	FindThingByUuid(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*http.Response, error)

	// UpdateThingByUuid request  with any body
	UpdateThingByUuidWithBody(ctx context.Context, uuid UuidParam, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	UpdateThingByUuid(ctx context.Context, uuid UuidParam, body UpdateThingByUuidJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// FindDatasetsForThing request
	FindDatasetsForThing(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*http.Response, error)

	// FindTimeSeriesForThing request
	FindTimeSeriesForThing(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*http.Response, error)

	// FindTimeSeries request
	FindTimeSeries(ctx context.Context, params *FindTimeSeriesParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// AddTimeSeries request  with any body
	AddTimeSeriesWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	AddTimeSeries(ctx context.Context, body AddTimeSeriesJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DeleteTimeSeriesByUuid request
	DeleteTimeSeriesByUuid(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*http.Response, error)

	// FindTimeSeriesByUuid request
	FindTimeSeriesByUuid(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*http.Response, error)

	// UpdateTimeseriesByUuid request  with any body
	UpdateTimeseriesByUuidWithBody(ctx context.Context, uuid UuidParam, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	UpdateTimeseriesByUuid(ctx context.Context, uuid UuidParam, body UpdateTimeseriesByUuidJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DeleteDataFromTimeSeries request
	DeleteDataFromTimeSeries(ctx context.Context, uuid UuidParam, params *DeleteDataFromTimeSeriesParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// QueryTimeseriesForData request
	QueryTimeseriesForData(ctx context.Context, uuid UuidParam, params *QueryTimeseriesForDataParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// AddDataToTimeseries request  with any body
	AddDataToTimeseriesWithBody(ctx context.Context, uuid UuidParam, params *AddDataToTimeseriesParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	AddDataToTimeseries(ctx context.Context, uuid UuidParam, params *AddDataToTimeseriesParams, body AddDataToTimeseriesJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// FindTsdataByQuery request
	FindTsdataByQuery(ctx context.Context, params *FindTsdataByQueryParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// FindUsers request
	FindUsers(ctx context.Context, params *FindUsersParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// AddUser request  with any body
	AddUserWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	AddUser(ctx context.Context, body AddUserJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// Whoami request
	Whoami(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DeleteUserByUuid request
	DeleteUserByUuid(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*http.Response, error)

	// FindUserByUuid request
	FindUserByUuid(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*http.Response, error)

	// UpdateUserByUuid request  with any body
	UpdateUserByUuidWithBody(ctx context.Context, uuid UuidParam, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	UpdateUserByUuid(ctx context.Context, uuid UuidParam, body UpdateUserByUuidJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// FindPoliciesForUser request
	FindPoliciesForUser(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*http.Response, error)

	// SetRequestRateForUser request  with any body
	SetRequestRateForUserWithBody(ctx context.Context, uuid UuidParam, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	SetRequestRateForUser(ctx context.Context, uuid UuidParam, body SetRequestRateForUserJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// FindTokensForUser request
	FindTokensForUser(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*http.Response, error)

	// AddNewTokenToUser request  with any body
	AddNewTokenToUserWithBody(ctx context.Context, uuid UuidParam, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	AddNewTokenToUser(ctx context.Context, uuid UuidParam, body AddNewTokenToUserJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DeleteTokenForUser request
	DeleteTokenForUser(ctx context.Context, uuid UuidParam, tokenUuid string, reqEditors ...RequestEditorFn) (*http.Response, error)
}

func (c *Client) FindAlerts(ctx context.Context, params *FindAlertsParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewFindAlertsRequest(c.Server, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) CreateAlertWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewCreateAlertRequestWithBody(c.Server, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) CreateAlert(ctx context.Context, body CreateAlertJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewCreateAlertRequest(c.Server, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) DeleteAlertByUuid(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDeleteAlertByUuidRequest(c.Server, uuid)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) FindAlertByUuid(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewFindAlertByUuidRequest(c.Server, uuid)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) UpdateAlertByUuidWithBody(ctx context.Context, uuid UuidParam, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewUpdateAlertByUuidRequestWithBody(c.Server, uuid, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) UpdateAlertByUuid(ctx context.Context, uuid UuidParam, body UpdateAlertByUuidJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewUpdateAlertByUuidRequest(c.Server, uuid, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) FindDatasets(ctx context.Context, params *FindDatasetsParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewFindDatasetsRequest(c.Server, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) AddDatasetsWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewAddDatasetsRequestWithBody(c.Server, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) AddDatasets(ctx context.Context, body AddDatasetsJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewAddDatasetsRequest(c.Server, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) DeleteDatasetByUuid(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDeleteDatasetByUuidRequest(c.Server, uuid)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) FindDatasetByUuid(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewFindDatasetByUuidRequest(c.Server, uuid)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) UpdateDatasetByUuidWithBody(ctx context.Context, uuid UuidParam, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewUpdateDatasetByUuidRequestWithBody(c.Server, uuid, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) UpdateDatasetByUuid(ctx context.Context, uuid UuidParam, body UpdateDatasetByUuidJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewUpdateDatasetByUuidRequest(c.Server, uuid, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) AssembleDatasetPartsByKey(ctx context.Context, uuid UuidParam, params *AssembleDatasetPartsByKeyParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewAssembleDatasetPartsByKeyRequest(c.Server, uuid, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) ListDatasetPartsByKey(ctx context.Context, uuid UuidParam, params *ListDatasetPartsByKeyParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewListDatasetPartsByKeyRequest(c.Server, uuid, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) UploadDatasetContentByKey(ctx context.Context, uuid UuidParam, params *UploadDatasetContentByKeyParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewUploadDatasetContentByKeyRequest(c.Server, uuid, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) GetRawDatasetByUuid(ctx context.Context, uuid UuidParam, params *GetRawDatasetByUuidParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetRawDatasetByUuidRequest(c.Server, uuid, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) DeleteDatasetUploadByKey(ctx context.Context, uuid UuidParam, params *DeleteDatasetUploadByKeyParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDeleteDatasetUploadByKeyRequest(c.Server, uuid, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) InitializeDatasetUploadByUuid(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewInitializeDatasetUploadByUuidRequest(c.Server, uuid)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) FindGroups(ctx context.Context, params *FindGroupsParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewFindGroupsRequest(c.Server, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) AddGroupWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewAddGroupRequestWithBody(c.Server, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) AddGroup(ctx context.Context, body AddGroupJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewAddGroupRequest(c.Server, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) DeleteGroupByUuid(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDeleteGroupByUuidRequest(c.Server, uuid)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) FindGroupByUuid(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewFindGroupByUuidRequest(c.Server, uuid)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) UpdateGroupByUuidWithBody(ctx context.Context, uuid UuidParam, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewUpdateGroupByUuidRequestWithBody(c.Server, uuid, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) UpdateGroupByUuid(ctx context.Context, uuid UuidParam, body UpdateGroupByUuidJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewUpdateGroupByUuidRequest(c.Server, uuid, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) FindPoliciesForGroup(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewFindPoliciesForGroupRequest(c.Server, uuid)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) FindPolicies(ctx context.Context, params *FindPoliciesParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewFindPoliciesRequest(c.Server, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) AddPolicyWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewAddPolicyRequestWithBody(c.Server, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) AddPolicy(ctx context.Context, body AddPolicyJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewAddPolicyRequest(c.Server, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) DeletePolicyByUuid(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDeletePolicyByUuidRequest(c.Server, uuid)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) FindPolicyByUuid(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewFindPolicyByUuidRequest(c.Server, uuid)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) UpdatePolicyByUuidWithBody(ctx context.Context, uuid UuidParam, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewUpdatePolicyByUuidRequestWithBody(c.Server, uuid, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) UpdatePolicyByUuid(ctx context.Context, uuid UuidParam, body UpdatePolicyByUuidJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewUpdatePolicyByUuidRequest(c.Server, uuid, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) FindPrograms(ctx context.Context, params *FindProgramsParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewFindProgramsRequest(c.Server, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) AddProgramWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewAddProgramRequestWithBody(c.Server, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) AddProgram(ctx context.Context, body AddProgramJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewAddProgramRequest(c.Server, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) DeleteProgramByUuid(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDeleteProgramByUuidRequest(c.Server, uuid)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) FindProgramByUuid(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewFindProgramByUuidRequest(c.Server, uuid)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) UpdateProgramByUuidWithBody(ctx context.Context, uuid UuidParam, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewUpdateProgramByUuidRequestWithBody(c.Server, uuid, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) UpdateProgramByUuid(ctx context.Context, uuid UuidParam, body UpdateProgramByUuidJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewUpdateProgramByUuidRequest(c.Server, uuid, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) GetCodeFromProgram(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetCodeFromProgramRequest(c.Server, uuid)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) AddProgramCodeRevisionWithBody(ctx context.Context, uuid UuidParam, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewAddProgramCodeRevisionRequestWithBody(c.Server, uuid, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) GetProgramCodeRevisionsDiff(ctx context.Context, uuid UuidParam, params *GetProgramCodeRevisionsDiffParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetProgramCodeRevisionsDiffRequest(c.Server, uuid, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) GetProgramCodeRevisions(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetProgramCodeRevisionsRequest(c.Server, uuid)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) DeleteProgramCodeRevisions(ctx context.Context, uuid UuidParam, revisionId int, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDeleteProgramCodeRevisionsRequest(c.Server, uuid, revisionId)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) SignProgramCodeRevisions(ctx context.Context, uuid UuidParam, revisionId int, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewSignProgramCodeRevisionsRequest(c.Server, uuid, revisionId)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) ExecuteProgramWebhook(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewExecuteProgramWebhookRequest(c.Server, uuid)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) FindThings(ctx context.Context, params *FindThingsParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewFindThingsRequest(c.Server, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) AddThingWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewAddThingRequestWithBody(c.Server, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) AddThing(ctx context.Context, body AddThingJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewAddThingRequest(c.Server, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) DeleteThingByUuid(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDeleteThingByUuidRequest(c.Server, uuid)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) FindThingByUuid(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewFindThingByUuidRequest(c.Server, uuid)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) UpdateThingByUuidWithBody(ctx context.Context, uuid UuidParam, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewUpdateThingByUuidRequestWithBody(c.Server, uuid, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) UpdateThingByUuid(ctx context.Context, uuid UuidParam, body UpdateThingByUuidJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewUpdateThingByUuidRequest(c.Server, uuid, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) FindDatasetsForThing(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewFindDatasetsForThingRequest(c.Server, uuid)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) FindTimeSeriesForThing(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewFindTimeSeriesForThingRequest(c.Server, uuid)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) FindTimeSeries(ctx context.Context, params *FindTimeSeriesParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewFindTimeSeriesRequest(c.Server, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) AddTimeSeriesWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewAddTimeSeriesRequestWithBody(c.Server, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) AddTimeSeries(ctx context.Context, body AddTimeSeriesJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewAddTimeSeriesRequest(c.Server, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) DeleteTimeSeriesByUuid(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDeleteTimeSeriesByUuidRequest(c.Server, uuid)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) FindTimeSeriesByUuid(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewFindTimeSeriesByUuidRequest(c.Server, uuid)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) UpdateTimeseriesByUuidWithBody(ctx context.Context, uuid UuidParam, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewUpdateTimeseriesByUuidRequestWithBody(c.Server, uuid, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) UpdateTimeseriesByUuid(ctx context.Context, uuid UuidParam, body UpdateTimeseriesByUuidJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewUpdateTimeseriesByUuidRequest(c.Server, uuid, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) DeleteDataFromTimeSeries(ctx context.Context, uuid UuidParam, params *DeleteDataFromTimeSeriesParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDeleteDataFromTimeSeriesRequest(c.Server, uuid, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) QueryTimeseriesForData(ctx context.Context, uuid UuidParam, params *QueryTimeseriesForDataParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewQueryTimeseriesForDataRequest(c.Server, uuid, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) AddDataToTimeseriesWithBody(ctx context.Context, uuid UuidParam, params *AddDataToTimeseriesParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewAddDataToTimeseriesRequestWithBody(c.Server, uuid, params, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) AddDataToTimeseries(ctx context.Context, uuid UuidParam, params *AddDataToTimeseriesParams, body AddDataToTimeseriesJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewAddDataToTimeseriesRequest(c.Server, uuid, params, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) FindTsdataByQuery(ctx context.Context, params *FindTsdataByQueryParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewFindTsdataByQueryRequest(c.Server, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) FindUsers(ctx context.Context, params *FindUsersParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewFindUsersRequest(c.Server, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) AddUserWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewAddUserRequestWithBody(c.Server, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) AddUser(ctx context.Context, body AddUserJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewAddUserRequest(c.Server, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) Whoami(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewWhoamiRequest(c.Server)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) DeleteUserByUuid(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDeleteUserByUuidRequest(c.Server, uuid)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) FindUserByUuid(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewFindUserByUuidRequest(c.Server, uuid)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) UpdateUserByUuidWithBody(ctx context.Context, uuid UuidParam, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewUpdateUserByUuidRequestWithBody(c.Server, uuid, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) UpdateUserByUuid(ctx context.Context, uuid UuidParam, body UpdateUserByUuidJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewUpdateUserByUuidRequest(c.Server, uuid, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) FindPoliciesForUser(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewFindPoliciesForUserRequest(c.Server, uuid)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) SetRequestRateForUserWithBody(ctx context.Context, uuid UuidParam, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewSetRequestRateForUserRequestWithBody(c.Server, uuid, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) SetRequestRateForUser(ctx context.Context, uuid UuidParam, body SetRequestRateForUserJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewSetRequestRateForUserRequest(c.Server, uuid, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) FindTokensForUser(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewFindTokensForUserRequest(c.Server, uuid)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) AddNewTokenToUserWithBody(ctx context.Context, uuid UuidParam, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewAddNewTokenToUserRequestWithBody(c.Server, uuid, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) AddNewTokenToUser(ctx context.Context, uuid UuidParam, body AddNewTokenToUserJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewAddNewTokenToUserRequest(c.Server, uuid, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) DeleteTokenForUser(ctx context.Context, uuid UuidParam, tokenUuid string, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDeleteTokenForUserRequest(c.Server, uuid, tokenUuid)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

// NewFindAlertsRequest generates requests for FindAlerts
func NewFindAlertsRequest(server string, params *FindAlertsParams) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/v2/alerts")
	if operationPath[0] == '/' {
		operationPath = operationPath[1:]
	}
	operationURL := url.URL{
		Path: operationPath,
	}

	queryURL := serverURL.ResolveReference(&operationURL)

	queryValues := queryURL.Query()

	if params.Offset != nil {

		if queryFrag, err := runtime.StyleParamWithLocation("form", true, "offset", runtime.ParamLocationQuery, *params.Offset); err != nil {
			return nil, err
		} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
			return nil, err
		} else {
			for k, v := range parsed {
				for _, v2 := range v {
					queryValues.Add(k, v2)
				}
			}
		}

	}

	if params.Limit != nil {

		if queryFrag, err := runtime.StyleParamWithLocation("form", true, "limit", runtime.ParamLocationQuery, *params.Limit); err != nil {
			return nil, err
		} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
			return nil, err
		} else {
			for k, v := range parsed {
				for _, v2 := range v {
					queryValues.Add(k, v2)
				}
			}
		}

	}

	if params.Resource != nil {

		if queryFrag, err := runtime.StyleParamWithLocation("form", true, "resource", runtime.ParamLocationQuery, *params.Resource); err != nil {
			return nil, err
		} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
			return nil, err
		} else {
			for k, v := range parsed {
				for _, v2 := range v {
					queryValues.Add(k, v2)
				}
			}
		}

	}

	if params.Environment != nil {

		if queryFrag, err := runtime.StyleParamWithLocation("form", true, "environment", runtime.ParamLocationQuery, *params.Environment); err != nil {
			return nil, err
		} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
			return nil, err
		} else {
			for k, v := range parsed {
				for _, v2 := range v {
					queryValues.Add(k, v2)
				}
			}
		}

	}

	if params.Event != nil {

		if queryFrag, err := runtime.StyleParamWithLocation("form", true, "event", runtime.ParamLocationQuery, *params.Event); err != nil {
			return nil, err
		} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
			return nil, err
		} else {
			for k, v := range parsed {
				for _, v2 := range v {
					queryValues.Add(k, v2)
				}
			}
		}

	}

	if params.Origin != nil {

		if queryFrag, err := runtime.StyleParamWithLocation("form", true, "origin", runtime.ParamLocationQuery, *params.Origin); err != nil {
			return nil, err
		} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
			return nil, err
		} else {
			for k, v := range parsed {
				for _, v2 := range v {
					queryValues.Add(k, v2)
				}
			}
		}

	}

	if params.Status != nil {

		if queryFrag, err := runtime.StyleParamWithLocation("form", true, "status", runtime.ParamLocationQuery, *params.Status); err != nil {
			return nil, err
		} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
			return nil, err
		} else {
			for k, v := range parsed {
				for _, v2 := range v {
					queryValues.Add(k, v2)
				}
			}
		}

	}

	if params.SeverityLe != nil {

		if queryFrag, err := runtime.StyleParamWithLocation("form", true, "severity_le", runtime.ParamLocationQuery, *params.SeverityLe); err != nil {
			return nil, err
		} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
			return nil, err
		} else {
			for k, v := range parsed {
				for _, v2 := range v {
					queryValues.Add(k, v2)
				}
			}
		}

	}

	if params.SeverityGe != nil {

		if queryFrag, err := runtime.StyleParamWithLocation("form", true, "severity_ge", runtime.ParamLocationQuery, *params.SeverityGe); err != nil {
			return nil, err
		} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
			return nil, err
		} else {
			for k, v := range parsed {
				for _, v2 := range v {
					queryValues.Add(k, v2)
				}
			}
		}

	}

	if params.Severity != nil {

		if queryFrag, err := runtime.StyleParamWithLocation("form", true, "severity", runtime.ParamLocationQuery, *params.Severity); err != nil {
			return nil, err
		} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
			return nil, err
		} else {
			for k, v := range parsed {
				for _, v2 := range v {
					queryValues.Add(k, v2)
				}
			}
		}

	}

	if params.Tags != nil {

		if queryFrag, err := runtime.StyleParamWithLocation("form", true, "tags", runtime.ParamLocationQuery, *params.Tags); err != nil {
			return nil, err
		} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
			return nil, err
		} else {
			for k, v := range parsed {
				for _, v2 := range v {
					queryValues.Add(k, v2)
				}
			}
		}

	}

	if params.Service != nil {

		if queryFrag, err := runtime.StyleParamWithLocation("form", true, "service", runtime.ParamLocationQuery, *params.Service); err != nil {
			return nil, err
		} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
			return nil, err
		} else {
			for k, v := range parsed {
				for _, v2 := range v {
					queryValues.Add(k, v2)
				}
			}
		}

	}

	queryURL.RawQuery = queryValues.Encode()

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewCreateAlertRequest calls the generic CreateAlert builder with application/json body
func NewCreateAlertRequest(server string, body CreateAlertJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewCreateAlertRequestWithBody(server, "application/json", bodyReader)
}

// NewCreateAlertRequestWithBody generates requests for CreateAlert with any type of body
func NewCreateAlertRequestWithBody(server string, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/v2/alerts")
	if operationPath[0] == '/' {
		operationPath = operationPath[1:]
	}
	operationURL := url.URL{
		Path: operationPath,
	}

	queryURL := serverURL.ResolveReference(&operationURL)

	req, err := http.NewRequest("POST", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewDeleteAlertByUuidRequest generates requests for DeleteAlertByUuid
func NewDeleteAlertByUuidRequest(server string, uuid UuidParam) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "uuid", runtime.ParamLocationPath, uuid)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/v2/alerts/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = operationPath[1:]
	}
	operationURL := url.URL{
		Path: operationPath,
	}

	queryURL := serverURL.ResolveReference(&operationURL)

	req, err := http.NewRequest("DELETE", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewFindAlertByUuidRequest generates requests for FindAlertByUuid
func NewFindAlertByUuidRequest(server string, uuid UuidParam) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "uuid", runtime.ParamLocationPath, uuid)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/v2/alerts/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = operationPath[1:]
	}
	operationURL := url.URL{
		Path: operationPath,
	}

	queryURL := serverURL.ResolveReference(&operationURL)

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewUpdateAlertByUuidRequest calls the generic UpdateAlertByUuid builder with application/json body
func NewUpdateAlertByUuidRequest(server string, uuid UuidParam, body UpdateAlertByUuidJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewUpdateAlertByUuidRequestWithBody(server, uuid, "application/json", bodyReader)
}

// NewUpdateAlertByUuidRequestWithBody generates requests for UpdateAlertByUuid with any type of body
func NewUpdateAlertByUuidRequestWithBody(server string, uuid UuidParam, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "uuid", runtime.ParamLocationPath, uuid)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/v2/alerts/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = operationPath[1:]
	}
	operationURL := url.URL{
		Path: operationPath,
	}

	queryURL := serverURL.ResolveReference(&operationURL)

	req, err := http.NewRequest("PUT", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewFindDatasetsRequest generates requests for FindDatasets
func NewFindDatasetsRequest(server string, params *FindDatasetsParams) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/v2/datasets")
	if operationPath[0] == '/' {
		operationPath = operationPath[1:]
	}
	operationURL := url.URL{
		Path: operationPath,
	}

	queryURL := serverURL.ResolveReference(&operationURL)

	queryValues := queryURL.Query()

	if params.Offset != nil {

		if queryFrag, err := runtime.StyleParamWithLocation("form", true, "offset", runtime.ParamLocationQuery, *params.Offset); err != nil {
			return nil, err
		} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
			return nil, err
		} else {
			for k, v := range parsed {
				for _, v2 := range v {
					queryValues.Add(k, v2)
				}
			}
		}

	}

	if params.Limit != nil {

		if queryFrag, err := runtime.StyleParamWithLocation("form", true, "limit", runtime.ParamLocationQuery, *params.Limit); err != nil {
			return nil, err
		} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
			return nil, err
		} else {
			for k, v := range parsed {
				for _, v2 := range v {
					queryValues.Add(k, v2)
				}
			}
		}

	}

	if params.Tags != nil {

		if queryFrag, err := runtime.StyleParamWithLocation("form", true, "tags", runtime.ParamLocationQuery, *params.Tags); err != nil {
			return nil, err
		} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
			return nil, err
		} else {
			for k, v := range parsed {
				for _, v2 := range v {
					queryValues.Add(k, v2)
				}
			}
		}

	}

	queryURL.RawQuery = queryValues.Encode()

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewAddDatasetsRequest calls the generic AddDatasets builder with application/json body
func NewAddDatasetsRequest(server string, body AddDatasetsJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewAddDatasetsRequestWithBody(server, "application/json", bodyReader)
}

// NewAddDatasetsRequestWithBody generates requests for AddDatasets with any type of body
func NewAddDatasetsRequestWithBody(server string, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/v2/datasets")
	if operationPath[0] == '/' {
		operationPath = operationPath[1:]
	}
	operationURL := url.URL{
		Path: operationPath,
	}

	queryURL := serverURL.ResolveReference(&operationURL)

	req, err := http.NewRequest("POST", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewDeleteDatasetByUuidRequest generates requests for DeleteDatasetByUuid
func NewDeleteDatasetByUuidRequest(server string, uuid UuidParam) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "uuid", runtime.ParamLocationPath, uuid)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/v2/datasets/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = operationPath[1:]
	}
	operationURL := url.URL{
		Path: operationPath,
	}

	queryURL := serverURL.ResolveReference(&operationURL)

	req, err := http.NewRequest("DELETE", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewFindDatasetByUuidRequest generates requests for FindDatasetByUuid
func NewFindDatasetByUuidRequest(server string, uuid UuidParam) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "uuid", runtime.ParamLocationPath, uuid)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/v2/datasets/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = operationPath[1:]
	}
	operationURL := url.URL{
		Path: operationPath,
	}

	queryURL := serverURL.ResolveReference(&operationURL)

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewUpdateDatasetByUuidRequest calls the generic UpdateDatasetByUuid builder with application/json body
func NewUpdateDatasetByUuidRequest(server string, uuid UuidParam, body UpdateDatasetByUuidJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewUpdateDatasetByUuidRequestWithBody(server, uuid, "application/json", bodyReader)
}

// NewUpdateDatasetByUuidRequestWithBody generates requests for UpdateDatasetByUuid with any type of body
func NewUpdateDatasetByUuidRequestWithBody(server string, uuid UuidParam, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "uuid", runtime.ParamLocationPath, uuid)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/v2/datasets/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = operationPath[1:]
	}
	operationURL := url.URL{
		Path: operationPath,
	}

	queryURL := serverURL.ResolveReference(&operationURL)

	req, err := http.NewRequest("PUT", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewAssembleDatasetPartsByKeyRequest generates requests for AssembleDatasetPartsByKey
func NewAssembleDatasetPartsByKeyRequest(server string, uuid UuidParam, params *AssembleDatasetPartsByKeyParams) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "uuid", runtime.ParamLocationPath, uuid)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/v2/datasets/%s/assemble", pathParam0)
	if operationPath[0] == '/' {
		operationPath = operationPath[1:]
	}
	operationURL := url.URL{
		Path: operationPath,
	}

	queryURL := serverURL.ResolveReference(&operationURL)

	queryValues := queryURL.Query()

	if queryFrag, err := runtime.StyleParamWithLocation("form", true, "partNumber", runtime.ParamLocationQuery, params.PartNumber); err != nil {
		return nil, err
	} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
		return nil, err
	} else {
		for k, v := range parsed {
			for _, v2 := range v {
				queryValues.Add(k, v2)
			}
		}
	}

	if queryFrag, err := runtime.StyleParamWithLocation("form", true, "uploadId", runtime.ParamLocationQuery, params.UploadId); err != nil {
		return nil, err
	} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
		return nil, err
	} else {
		for k, v := range parsed {
			for _, v2 := range v {
				queryValues.Add(k, v2)
			}
		}
	}

	queryURL.RawQuery = queryValues.Encode()

	req, err := http.NewRequest("POST", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	var headerParam0 string

	headerParam0, err = runtime.StyleParamWithLocation("simple", false, "Content-MD5", runtime.ParamLocationHeader, params.ContentMD5)
	if err != nil {
		return nil, err
	}

	req.Header.Set("Content-MD5", headerParam0)

	return req, nil
}

// NewListDatasetPartsByKeyRequest generates requests for ListDatasetPartsByKey
func NewListDatasetPartsByKeyRequest(server string, uuid UuidParam, params *ListDatasetPartsByKeyParams) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "uuid", runtime.ParamLocationPath, uuid)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/v2/datasets/%s/parts", pathParam0)
	if operationPath[0] == '/' {
		operationPath = operationPath[1:]
	}
	operationURL := url.URL{
		Path: operationPath,
	}

	queryURL := serverURL.ResolveReference(&operationURL)

	queryValues := queryURL.Query()

	if queryFrag, err := runtime.StyleParamWithLocation("form", true, "key", runtime.ParamLocationQuery, params.Key); err != nil {
		return nil, err
	} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
		return nil, err
	} else {
		for k, v := range parsed {
			for _, v2 := range v {
				queryValues.Add(k, v2)
			}
		}
	}

	queryURL.RawQuery = queryValues.Encode()

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewUploadDatasetContentByKeyRequest generates requests for UploadDatasetContentByKey
func NewUploadDatasetContentByKeyRequest(server string, uuid UuidParam, params *UploadDatasetContentByKeyParams) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "uuid", runtime.ParamLocationPath, uuid)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/v2/datasets/%s/parts", pathParam0)
	if operationPath[0] == '/' {
		operationPath = operationPath[1:]
	}
	operationURL := url.URL{
		Path: operationPath,
	}

	queryURL := serverURL.ResolveReference(&operationURL)

	queryValues := queryURL.Query()

	if queryFrag, err := runtime.StyleParamWithLocation("form", true, "partNumber", runtime.ParamLocationQuery, params.PartNumber); err != nil {
		return nil, err
	} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
		return nil, err
	} else {
		for k, v := range parsed {
			for _, v2 := range v {
				queryValues.Add(k, v2)
			}
		}
	}

	if queryFrag, err := runtime.StyleParamWithLocation("form", true, "uploadId", runtime.ParamLocationQuery, params.UploadId); err != nil {
		return nil, err
	} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
		return nil, err
	} else {
		for k, v := range parsed {
			for _, v2 := range v {
				queryValues.Add(k, v2)
			}
		}
	}

	queryURL.RawQuery = queryValues.Encode()

	req, err := http.NewRequest("PUT", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	var headerParam0 string

	headerParam0, err = runtime.StyleParamWithLocation("simple", false, "Content-MD5", runtime.ParamLocationHeader, params.ContentMD5)
	if err != nil {
		return nil, err
	}

	req.Header.Set("Content-MD5", headerParam0)

	return req, nil
}

// NewGetRawDatasetByUuidRequest generates requests for GetRawDatasetByUuid
func NewGetRawDatasetByUuidRequest(server string, uuid UuidParam, params *GetRawDatasetByUuidParams) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "uuid", runtime.ParamLocationPath, uuid)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/v2/datasets/%s/raw", pathParam0)
	if operationPath[0] == '/' {
		operationPath = operationPath[1:]
	}
	operationURL := url.URL{
		Path: operationPath,
	}

	queryURL := serverURL.ResolveReference(&operationURL)

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	if params.IfNoneMatch != nil {
		var headerParam0 string

		headerParam0, err = runtime.StyleParamWithLocation("simple", false, "If-None-Match", runtime.ParamLocationHeader, *params.IfNoneMatch)
		if err != nil {
			return nil, err
		}

		req.Header.Set("If-None-Match", headerParam0)
	}

	return req, nil
}

// NewDeleteDatasetUploadByKeyRequest generates requests for DeleteDatasetUploadByKey
func NewDeleteDatasetUploadByKeyRequest(server string, uuid UuidParam, params *DeleteDatasetUploadByKeyParams) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "uuid", runtime.ParamLocationPath, uuid)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/v2/datasets/%s/uploads", pathParam0)
	if operationPath[0] == '/' {
		operationPath = operationPath[1:]
	}
	operationURL := url.URL{
		Path: operationPath,
	}

	queryURL := serverURL.ResolveReference(&operationURL)

	queryValues := queryURL.Query()

	if queryFrag, err := runtime.StyleParamWithLocation("form", true, "key", runtime.ParamLocationQuery, params.Key); err != nil {
		return nil, err
	} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
		return nil, err
	} else {
		for k, v := range parsed {
			for _, v2 := range v {
				queryValues.Add(k, v2)
			}
		}
	}

	queryURL.RawQuery = queryValues.Encode()

	req, err := http.NewRequest("DELETE", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewInitializeDatasetUploadByUuidRequest generates requests for InitializeDatasetUploadByUuid
func NewInitializeDatasetUploadByUuidRequest(server string, uuid UuidParam) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "uuid", runtime.ParamLocationPath, uuid)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/v2/datasets/%s/uploads", pathParam0)
	if operationPath[0] == '/' {
		operationPath = operationPath[1:]
	}
	operationURL := url.URL{
		Path: operationPath,
	}

	queryURL := serverURL.ResolveReference(&operationURL)

	req, err := http.NewRequest("POST", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewFindGroupsRequest generates requests for FindGroups
func NewFindGroupsRequest(server string, params *FindGroupsParams) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/v2/groups")
	if operationPath[0] == '/' {
		operationPath = operationPath[1:]
	}
	operationURL := url.URL{
		Path: operationPath,
	}

	queryURL := serverURL.ResolveReference(&operationURL)

	queryValues := queryURL.Query()

	if params.Limit != nil {

		if queryFrag, err := runtime.StyleParamWithLocation("form", true, "limit", runtime.ParamLocationQuery, *params.Limit); err != nil {
			return nil, err
		} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
			return nil, err
		} else {
			for k, v := range parsed {
				for _, v2 := range v {
					queryValues.Add(k, v2)
				}
			}
		}

	}

	if params.Offset != nil {

		if queryFrag, err := runtime.StyleParamWithLocation("form", true, "offset", runtime.ParamLocationQuery, *params.Offset); err != nil {
			return nil, err
		} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
			return nil, err
		} else {
			for k, v := range parsed {
				for _, v2 := range v {
					queryValues.Add(k, v2)
				}
			}
		}

	}

	queryURL.RawQuery = queryValues.Encode()

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewAddGroupRequest calls the generic AddGroup builder with application/json body
func NewAddGroupRequest(server string, body AddGroupJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewAddGroupRequestWithBody(server, "application/json", bodyReader)
}

// NewAddGroupRequestWithBody generates requests for AddGroup with any type of body
func NewAddGroupRequestWithBody(server string, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/v2/groups")
	if operationPath[0] == '/' {
		operationPath = operationPath[1:]
	}
	operationURL := url.URL{
		Path: operationPath,
	}

	queryURL := serverURL.ResolveReference(&operationURL)

	req, err := http.NewRequest("POST", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewDeleteGroupByUuidRequest generates requests for DeleteGroupByUuid
func NewDeleteGroupByUuidRequest(server string, uuid UuidParam) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "uuid", runtime.ParamLocationPath, uuid)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/v2/groups/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = operationPath[1:]
	}
	operationURL := url.URL{
		Path: operationPath,
	}

	queryURL := serverURL.ResolveReference(&operationURL)

	req, err := http.NewRequest("DELETE", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewFindGroupByUuidRequest generates requests for FindGroupByUuid
func NewFindGroupByUuidRequest(server string, uuid UuidParam) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "uuid", runtime.ParamLocationPath, uuid)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/v2/groups/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = operationPath[1:]
	}
	operationURL := url.URL{
		Path: operationPath,
	}

	queryURL := serverURL.ResolveReference(&operationURL)

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewUpdateGroupByUuidRequest calls the generic UpdateGroupByUuid builder with application/json body
func NewUpdateGroupByUuidRequest(server string, uuid UuidParam, body UpdateGroupByUuidJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewUpdateGroupByUuidRequestWithBody(server, uuid, "application/json", bodyReader)
}

// NewUpdateGroupByUuidRequestWithBody generates requests for UpdateGroupByUuid with any type of body
func NewUpdateGroupByUuidRequestWithBody(server string, uuid UuidParam, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "uuid", runtime.ParamLocationPath, uuid)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/v2/groups/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = operationPath[1:]
	}
	operationURL := url.URL{
		Path: operationPath,
	}

	queryURL := serverURL.ResolveReference(&operationURL)

	req, err := http.NewRequest("PUT", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewFindPoliciesForGroupRequest generates requests for FindPoliciesForGroup
func NewFindPoliciesForGroupRequest(server string, uuid UuidParam) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "uuid", runtime.ParamLocationPath, uuid)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/v2/groups/%s/policies", pathParam0)
	if operationPath[0] == '/' {
		operationPath = operationPath[1:]
	}
	operationURL := url.URL{
		Path: operationPath,
	}

	queryURL := serverURL.ResolveReference(&operationURL)

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewFindPoliciesRequest generates requests for FindPolicies
func NewFindPoliciesRequest(server string, params *FindPoliciesParams) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/v2/policies")
	if operationPath[0] == '/' {
		operationPath = operationPath[1:]
	}
	operationURL := url.URL{
		Path: operationPath,
	}

	queryURL := serverURL.ResolveReference(&operationURL)

	queryValues := queryURL.Query()

	if params.Offset != nil {

		if queryFrag, err := runtime.StyleParamWithLocation("form", true, "offset", runtime.ParamLocationQuery, *params.Offset); err != nil {
			return nil, err
		} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
			return nil, err
		} else {
			for k, v := range parsed {
				for _, v2 := range v {
					queryValues.Add(k, v2)
				}
			}
		}

	}

	if params.Limit != nil {

		if queryFrag, err := runtime.StyleParamWithLocation("form", true, "limit", runtime.ParamLocationQuery, *params.Limit); err != nil {
			return nil, err
		} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
			return nil, err
		} else {
			for k, v := range parsed {
				for _, v2 := range v {
					queryValues.Add(k, v2)
				}
			}
		}

	}

	if params.GroupUuids != nil {

		if queryFrag, err := runtime.StyleParamWithLocation("form", true, "group_uuids", runtime.ParamLocationQuery, *params.GroupUuids); err != nil {
			return nil, err
		} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
			return nil, err
		} else {
			for k, v := range parsed {
				for _, v2 := range v {
					queryValues.Add(k, v2)
				}
			}
		}

	}

	queryURL.RawQuery = queryValues.Encode()

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewAddPolicyRequest calls the generic AddPolicy builder with application/json body
func NewAddPolicyRequest(server string, body AddPolicyJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewAddPolicyRequestWithBody(server, "application/json", bodyReader)
}

// NewAddPolicyRequestWithBody generates requests for AddPolicy with any type of body
func NewAddPolicyRequestWithBody(server string, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/v2/policies")
	if operationPath[0] == '/' {
		operationPath = operationPath[1:]
	}
	operationURL := url.URL{
		Path: operationPath,
	}

	queryURL := serverURL.ResolveReference(&operationURL)

	req, err := http.NewRequest("POST", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewDeletePolicyByUuidRequest generates requests for DeletePolicyByUuid
func NewDeletePolicyByUuidRequest(server string, uuid UuidParam) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "uuid", runtime.ParamLocationPath, uuid)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/v2/policies/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = operationPath[1:]
	}
	operationURL := url.URL{
		Path: operationPath,
	}

	queryURL := serverURL.ResolveReference(&operationURL)

	req, err := http.NewRequest("DELETE", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewFindPolicyByUuidRequest generates requests for FindPolicyByUuid
func NewFindPolicyByUuidRequest(server string, uuid UuidParam) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "uuid", runtime.ParamLocationPath, uuid)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/v2/policies/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = operationPath[1:]
	}
	operationURL := url.URL{
		Path: operationPath,
	}

	queryURL := serverURL.ResolveReference(&operationURL)

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewUpdatePolicyByUuidRequest calls the generic UpdatePolicyByUuid builder with application/json body
func NewUpdatePolicyByUuidRequest(server string, uuid UuidParam, body UpdatePolicyByUuidJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewUpdatePolicyByUuidRequestWithBody(server, uuid, "application/json", bodyReader)
}

// NewUpdatePolicyByUuidRequestWithBody generates requests for UpdatePolicyByUuid with any type of body
func NewUpdatePolicyByUuidRequestWithBody(server string, uuid UuidParam, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "uuid", runtime.ParamLocationPath, uuid)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/v2/policies/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = operationPath[1:]
	}
	operationURL := url.URL{
		Path: operationPath,
	}

	queryURL := serverURL.ResolveReference(&operationURL)

	req, err := http.NewRequest("PUT", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewFindProgramsRequest generates requests for FindPrograms
func NewFindProgramsRequest(server string, params *FindProgramsParams) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/v2/programs")
	if operationPath[0] == '/' {
		operationPath = operationPath[1:]
	}
	operationURL := url.URL{
		Path: operationPath,
	}

	queryURL := serverURL.ResolveReference(&operationURL)

	queryValues := queryURL.Query()

	if params.Offset != nil {

		if queryFrag, err := runtime.StyleParamWithLocation("form", true, "offset", runtime.ParamLocationQuery, *params.Offset); err != nil {
			return nil, err
		} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
			return nil, err
		} else {
			for k, v := range parsed {
				for _, v2 := range v {
					queryValues.Add(k, v2)
				}
			}
		}

	}

	if params.Limit != nil {

		if queryFrag, err := runtime.StyleParamWithLocation("form", true, "limit", runtime.ParamLocationQuery, *params.Limit); err != nil {
			return nil, err
		} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
			return nil, err
		} else {
			for k, v := range parsed {
				for _, v2 := range v {
					queryValues.Add(k, v2)
				}
			}
		}

	}

	if params.Tags != nil {

		if queryFrag, err := runtime.StyleParamWithLocation("form", true, "tags", runtime.ParamLocationQuery, *params.Tags); err != nil {
			return nil, err
		} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
			return nil, err
		} else {
			for k, v := range parsed {
				for _, v2 := range v {
					queryValues.Add(k, v2)
				}
			}
		}

	}

	queryURL.RawQuery = queryValues.Encode()

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewAddProgramRequest calls the generic AddProgram builder with application/json body
func NewAddProgramRequest(server string, body AddProgramJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewAddProgramRequestWithBody(server, "application/json", bodyReader)
}

// NewAddProgramRequestWithBody generates requests for AddProgram with any type of body
func NewAddProgramRequestWithBody(server string, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/v2/programs")
	if operationPath[0] == '/' {
		operationPath = operationPath[1:]
	}
	operationURL := url.URL{
		Path: operationPath,
	}

	queryURL := serverURL.ResolveReference(&operationURL)

	req, err := http.NewRequest("POST", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewDeleteProgramByUuidRequest generates requests for DeleteProgramByUuid
func NewDeleteProgramByUuidRequest(server string, uuid UuidParam) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "uuid", runtime.ParamLocationPath, uuid)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/v2/programs/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = operationPath[1:]
	}
	operationURL := url.URL{
		Path: operationPath,
	}

	queryURL := serverURL.ResolveReference(&operationURL)

	req, err := http.NewRequest("DELETE", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewFindProgramByUuidRequest generates requests for FindProgramByUuid
func NewFindProgramByUuidRequest(server string, uuid UuidParam) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "uuid", runtime.ParamLocationPath, uuid)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/v2/programs/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = operationPath[1:]
	}
	operationURL := url.URL{
		Path: operationPath,
	}

	queryURL := serverURL.ResolveReference(&operationURL)

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewUpdateProgramByUuidRequest calls the generic UpdateProgramByUuid builder with application/json body
func NewUpdateProgramByUuidRequest(server string, uuid UuidParam, body UpdateProgramByUuidJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewUpdateProgramByUuidRequestWithBody(server, uuid, "application/json", bodyReader)
}

// NewUpdateProgramByUuidRequestWithBody generates requests for UpdateProgramByUuid with any type of body
func NewUpdateProgramByUuidRequestWithBody(server string, uuid UuidParam, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "uuid", runtime.ParamLocationPath, uuid)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/v2/programs/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = operationPath[1:]
	}
	operationURL := url.URL{
		Path: operationPath,
	}

	queryURL := serverURL.ResolveReference(&operationURL)

	req, err := http.NewRequest("PUT", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewGetCodeFromProgramRequest generates requests for GetCodeFromProgram
func NewGetCodeFromProgramRequest(server string, uuid UuidParam) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "uuid", runtime.ParamLocationPath, uuid)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/v2/programs/%s/code", pathParam0)
	if operationPath[0] == '/' {
		operationPath = operationPath[1:]
	}
	operationURL := url.URL{
		Path: operationPath,
	}

	queryURL := serverURL.ResolveReference(&operationURL)

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewAddProgramCodeRevisionRequestWithBody generates requests for AddProgramCodeRevision with any type of body
func NewAddProgramCodeRevisionRequestWithBody(server string, uuid UuidParam, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "uuid", runtime.ParamLocationPath, uuid)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/v2/programs/%s/code", pathParam0)
	if operationPath[0] == '/' {
		operationPath = operationPath[1:]
	}
	operationURL := url.URL{
		Path: operationPath,
	}

	queryURL := serverURL.ResolveReference(&operationURL)

	req, err := http.NewRequest("POST", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewGetProgramCodeRevisionsDiffRequest generates requests for GetProgramCodeRevisionsDiff
func NewGetProgramCodeRevisionsDiffRequest(server string, uuid UuidParam, params *GetProgramCodeRevisionsDiffParams) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "uuid", runtime.ParamLocationPath, uuid)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/v2/programs/%s/diff", pathParam0)
	if operationPath[0] == '/' {
		operationPath = operationPath[1:]
	}
	operationURL := url.URL{
		Path: operationPath,
	}

	queryURL := serverURL.ResolveReference(&operationURL)

	queryValues := queryURL.Query()

	if queryFrag, err := runtime.StyleParamWithLocation("form", true, "rev_a", runtime.ParamLocationQuery, params.RevA); err != nil {
		return nil, err
	} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
		return nil, err
	} else {
		for k, v := range parsed {
			for _, v2 := range v {
				queryValues.Add(k, v2)
			}
		}
	}

	if queryFrag, err := runtime.StyleParamWithLocation("form", true, "rev_b", runtime.ParamLocationQuery, params.RevB); err != nil {
		return nil, err
	} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
		return nil, err
	} else {
		for k, v := range parsed {
			for _, v2 := range v {
				queryValues.Add(k, v2)
			}
		}
	}

	queryURL.RawQuery = queryValues.Encode()

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewGetProgramCodeRevisionsRequest generates requests for GetProgramCodeRevisions
func NewGetProgramCodeRevisionsRequest(server string, uuid UuidParam) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "uuid", runtime.ParamLocationPath, uuid)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/v2/programs/%s/revisions", pathParam0)
	if operationPath[0] == '/' {
		operationPath = operationPath[1:]
	}
	operationURL := url.URL{
		Path: operationPath,
	}

	queryURL := serverURL.ResolveReference(&operationURL)

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewDeleteProgramCodeRevisionsRequest generates requests for DeleteProgramCodeRevisions
func NewDeleteProgramCodeRevisionsRequest(server string, uuid UuidParam, revisionId int) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "uuid", runtime.ParamLocationPath, uuid)
	if err != nil {
		return nil, err
	}

	var pathParam1 string

	pathParam1, err = runtime.StyleParamWithLocation("simple", false, "revision_id", runtime.ParamLocationPath, revisionId)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/v2/programs/%s/revisions/%s", pathParam0, pathParam1)
	if operationPath[0] == '/' {
		operationPath = operationPath[1:]
	}
	operationURL := url.URL{
		Path: operationPath,
	}

	queryURL := serverURL.ResolveReference(&operationURL)

	req, err := http.NewRequest("DELETE", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewSignProgramCodeRevisionsRequest generates requests for SignProgramCodeRevisions
func NewSignProgramCodeRevisionsRequest(server string, uuid UuidParam, revisionId int) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "uuid", runtime.ParamLocationPath, uuid)
	if err != nil {
		return nil, err
	}

	var pathParam1 string

	pathParam1, err = runtime.StyleParamWithLocation("simple", false, "revision_id", runtime.ParamLocationPath, revisionId)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/v2/programs/%s/revisions/%s/sign", pathParam0, pathParam1)
	if operationPath[0] == '/' {
		operationPath = operationPath[1:]
	}
	operationURL := url.URL{
		Path: operationPath,
	}

	queryURL := serverURL.ResolveReference(&operationURL)

	req, err := http.NewRequest("PUT", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewExecuteProgramWebhookRequest generates requests for ExecuteProgramWebhook
func NewExecuteProgramWebhookRequest(server string, uuid UuidParam) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "uuid", runtime.ParamLocationPath, uuid)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/v2/programs/%s/webhook", pathParam0)
	if operationPath[0] == '/' {
		operationPath = operationPath[1:]
	}
	operationURL := url.URL{
		Path: operationPath,
	}

	queryURL := serverURL.ResolveReference(&operationURL)

	req, err := http.NewRequest("POST", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewFindThingsRequest generates requests for FindThings
func NewFindThingsRequest(server string, params *FindThingsParams) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/v2/things")
	if operationPath[0] == '/' {
		operationPath = operationPath[1:]
	}
	operationURL := url.URL{
		Path: operationPath,
	}

	queryURL := serverURL.ResolveReference(&operationURL)

	queryValues := queryURL.Query()

	if params.Limit != nil {

		if queryFrag, err := runtime.StyleParamWithLocation("form", true, "limit", runtime.ParamLocationQuery, *params.Limit); err != nil {
			return nil, err
		} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
			return nil, err
		} else {
			for k, v := range parsed {
				for _, v2 := range v {
					queryValues.Add(k, v2)
				}
			}
		}

	}

	if params.Offset != nil {

		if queryFrag, err := runtime.StyleParamWithLocation("form", true, "offset", runtime.ParamLocationQuery, *params.Offset); err != nil {
			return nil, err
		} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
			return nil, err
		} else {
			for k, v := range parsed {
				for _, v2 := range v {
					queryValues.Add(k, v2)
				}
			}
		}

	}

	if params.Tags != nil {

		if queryFrag, err := runtime.StyleParamWithLocation("form", true, "tags", runtime.ParamLocationQuery, *params.Tags); err != nil {
			return nil, err
		} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
			return nil, err
		} else {
			for k, v := range parsed {
				for _, v2 := range v {
					queryValues.Add(k, v2)
				}
			}
		}

	}

	queryURL.RawQuery = queryValues.Encode()

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewAddThingRequest calls the generic AddThing builder with application/json body
func NewAddThingRequest(server string, body AddThingJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewAddThingRequestWithBody(server, "application/json", bodyReader)
}

// NewAddThingRequestWithBody generates requests for AddThing with any type of body
func NewAddThingRequestWithBody(server string, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/v2/things")
	if operationPath[0] == '/' {
		operationPath = operationPath[1:]
	}
	operationURL := url.URL{
		Path: operationPath,
	}

	queryURL := serverURL.ResolveReference(&operationURL)

	req, err := http.NewRequest("POST", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewDeleteThingByUuidRequest generates requests for DeleteThingByUuid
func NewDeleteThingByUuidRequest(server string, uuid UuidParam) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "uuid", runtime.ParamLocationPath, uuid)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/v2/things/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = operationPath[1:]
	}
	operationURL := url.URL{
		Path: operationPath,
	}

	queryURL := serverURL.ResolveReference(&operationURL)

	req, err := http.NewRequest("DELETE", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewFindThingByUuidRequest generates requests for FindThingByUuid
func NewFindThingByUuidRequest(server string, uuid UuidParam) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "uuid", runtime.ParamLocationPath, uuid)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/v2/things/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = operationPath[1:]
	}
	operationURL := url.URL{
		Path: operationPath,
	}

	queryURL := serverURL.ResolveReference(&operationURL)

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewUpdateThingByUuidRequest calls the generic UpdateThingByUuid builder with application/json body
func NewUpdateThingByUuidRequest(server string, uuid UuidParam, body UpdateThingByUuidJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewUpdateThingByUuidRequestWithBody(server, uuid, "application/json", bodyReader)
}

// NewUpdateThingByUuidRequestWithBody generates requests for UpdateThingByUuid with any type of body
func NewUpdateThingByUuidRequestWithBody(server string, uuid UuidParam, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "uuid", runtime.ParamLocationPath, uuid)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/v2/things/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = operationPath[1:]
	}
	operationURL := url.URL{
		Path: operationPath,
	}

	queryURL := serverURL.ResolveReference(&operationURL)

	req, err := http.NewRequest("PUT", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewFindDatasetsForThingRequest generates requests for FindDatasetsForThing
func NewFindDatasetsForThingRequest(server string, uuid UuidParam) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "uuid", runtime.ParamLocationPath, uuid)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/v2/things/%s/datasets", pathParam0)
	if operationPath[0] == '/' {
		operationPath = operationPath[1:]
	}
	operationURL := url.URL{
		Path: operationPath,
	}

	queryURL := serverURL.ResolveReference(&operationURL)

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewFindTimeSeriesForThingRequest generates requests for FindTimeSeriesForThing
func NewFindTimeSeriesForThingRequest(server string, uuid UuidParam) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "uuid", runtime.ParamLocationPath, uuid)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/v2/things/%s/timeseries", pathParam0)
	if operationPath[0] == '/' {
		operationPath = operationPath[1:]
	}
	operationURL := url.URL{
		Path: operationPath,
	}

	queryURL := serverURL.ResolveReference(&operationURL)

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewFindTimeSeriesRequest generates requests for FindTimeSeries
func NewFindTimeSeriesRequest(server string, params *FindTimeSeriesParams) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/v2/timeseries")
	if operationPath[0] == '/' {
		operationPath = operationPath[1:]
	}
	operationURL := url.URL{
		Path: operationPath,
	}

	queryURL := serverURL.ResolveReference(&operationURL)

	queryValues := queryURL.Query()

	if params.Limit != nil {

		if queryFrag, err := runtime.StyleParamWithLocation("form", true, "limit", runtime.ParamLocationQuery, *params.Limit); err != nil {
			return nil, err
		} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
			return nil, err
		} else {
			for k, v := range parsed {
				for _, v2 := range v {
					queryValues.Add(k, v2)
				}
			}
		}

	}

	if params.Offset != nil {

		if queryFrag, err := runtime.StyleParamWithLocation("form", true, "offset", runtime.ParamLocationQuery, *params.Offset); err != nil {
			return nil, err
		} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
			return nil, err
		} else {
			for k, v := range parsed {
				for _, v2 := range v {
					queryValues.Add(k, v2)
				}
			}
		}

	}

	if params.Tags != nil {

		if queryFrag, err := runtime.StyleParamWithLocation("form", true, "tags", runtime.ParamLocationQuery, *params.Tags); err != nil {
			return nil, err
		} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
			return nil, err
		} else {
			for k, v := range parsed {
				for _, v2 := range v {
					queryValues.Add(k, v2)
				}
			}
		}

	}

	queryURL.RawQuery = queryValues.Encode()

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewAddTimeSeriesRequest calls the generic AddTimeSeries builder with application/json body
func NewAddTimeSeriesRequest(server string, body AddTimeSeriesJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewAddTimeSeriesRequestWithBody(server, "application/json", bodyReader)
}

// NewAddTimeSeriesRequestWithBody generates requests for AddTimeSeries with any type of body
func NewAddTimeSeriesRequestWithBody(server string, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/v2/timeseries")
	if operationPath[0] == '/' {
		operationPath = operationPath[1:]
	}
	operationURL := url.URL{
		Path: operationPath,
	}

	queryURL := serverURL.ResolveReference(&operationURL)

	req, err := http.NewRequest("POST", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewDeleteTimeSeriesByUuidRequest generates requests for DeleteTimeSeriesByUuid
func NewDeleteTimeSeriesByUuidRequest(server string, uuid UuidParam) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "uuid", runtime.ParamLocationPath, uuid)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/v2/timeseries/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = operationPath[1:]
	}
	operationURL := url.URL{
		Path: operationPath,
	}

	queryURL := serverURL.ResolveReference(&operationURL)

	req, err := http.NewRequest("DELETE", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewFindTimeSeriesByUuidRequest generates requests for FindTimeSeriesByUuid
func NewFindTimeSeriesByUuidRequest(server string, uuid UuidParam) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "uuid", runtime.ParamLocationPath, uuid)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/v2/timeseries/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = operationPath[1:]
	}
	operationURL := url.URL{
		Path: operationPath,
	}

	queryURL := serverURL.ResolveReference(&operationURL)

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewUpdateTimeseriesByUuidRequest calls the generic UpdateTimeseriesByUuid builder with application/json body
func NewUpdateTimeseriesByUuidRequest(server string, uuid UuidParam, body UpdateTimeseriesByUuidJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewUpdateTimeseriesByUuidRequestWithBody(server, uuid, "application/json", bodyReader)
}

// NewUpdateTimeseriesByUuidRequestWithBody generates requests for UpdateTimeseriesByUuid with any type of body
func NewUpdateTimeseriesByUuidRequestWithBody(server string, uuid UuidParam, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "uuid", runtime.ParamLocationPath, uuid)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/v2/timeseries/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = operationPath[1:]
	}
	operationURL := url.URL{
		Path: operationPath,
	}

	queryURL := serverURL.ResolveReference(&operationURL)

	req, err := http.NewRequest("PUT", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewDeleteDataFromTimeSeriesRequest generates requests for DeleteDataFromTimeSeries
func NewDeleteDataFromTimeSeriesRequest(server string, uuid UuidParam, params *DeleteDataFromTimeSeriesParams) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "uuid", runtime.ParamLocationPath, uuid)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/v2/timeseries/%s/data", pathParam0)
	if operationPath[0] == '/' {
		operationPath = operationPath[1:]
	}
	operationURL := url.URL{
		Path: operationPath,
	}

	queryURL := serverURL.ResolveReference(&operationURL)

	queryValues := queryURL.Query()

	if queryFrag, err := runtime.StyleParamWithLocation("form", true, "start", runtime.ParamLocationQuery, params.Start); err != nil {
		return nil, err
	} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
		return nil, err
	} else {
		for k, v := range parsed {
			for _, v2 := range v {
				queryValues.Add(k, v2)
			}
		}
	}

	if queryFrag, err := runtime.StyleParamWithLocation("form", true, "end", runtime.ParamLocationQuery, params.End); err != nil {
		return nil, err
	} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
		return nil, err
	} else {
		for k, v := range parsed {
			for _, v2 := range v {
				queryValues.Add(k, v2)
			}
		}
	}

	if params.Ge != nil {

		if queryFrag, err := runtime.StyleParamWithLocation("form", true, "ge", runtime.ParamLocationQuery, *params.Ge); err != nil {
			return nil, err
		} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
			return nil, err
		} else {
			for k, v := range parsed {
				for _, v2 := range v {
					queryValues.Add(k, v2)
				}
			}
		}

	}

	if params.Le != nil {

		if queryFrag, err := runtime.StyleParamWithLocation("form", true, "le", runtime.ParamLocationQuery, *params.Le); err != nil {
			return nil, err
		} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
			return nil, err
		} else {
			for k, v := range parsed {
				for _, v2 := range v {
					queryValues.Add(k, v2)
				}
			}
		}

	}

	queryURL.RawQuery = queryValues.Encode()

	req, err := http.NewRequest("DELETE", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewQueryTimeseriesForDataRequest generates requests for QueryTimeseriesForData
func NewQueryTimeseriesForDataRequest(server string, uuid UuidParam, params *QueryTimeseriesForDataParams) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "uuid", runtime.ParamLocationPath, uuid)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/v2/timeseries/%s/data", pathParam0)
	if operationPath[0] == '/' {
		operationPath = operationPath[1:]
	}
	operationURL := url.URL{
		Path: operationPath,
	}

	queryURL := serverURL.ResolveReference(&operationURL)

	queryValues := queryURL.Query()

	if queryFrag, err := runtime.StyleParamWithLocation("form", true, "start", runtime.ParamLocationQuery, params.Start); err != nil {
		return nil, err
	} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
		return nil, err
	} else {
		for k, v := range parsed {
			for _, v2 := range v {
				queryValues.Add(k, v2)
			}
		}
	}

	if queryFrag, err := runtime.StyleParamWithLocation("form", true, "end", runtime.ParamLocationQuery, params.End); err != nil {
		return nil, err
	} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
		return nil, err
	} else {
		for k, v := range parsed {
			for _, v2 := range v {
				queryValues.Add(k, v2)
			}
		}
	}

	if params.Unit != nil {

		if queryFrag, err := runtime.StyleParamWithLocation("form", true, "unit", runtime.ParamLocationQuery, *params.Unit); err != nil {
			return nil, err
		} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
			return nil, err
		} else {
			for k, v := range parsed {
				for _, v2 := range v {
					queryValues.Add(k, v2)
				}
			}
		}

	}

	if params.Ge != nil {

		if queryFrag, err := runtime.StyleParamWithLocation("form", true, "ge", runtime.ParamLocationQuery, *params.Ge); err != nil {
			return nil, err
		} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
			return nil, err
		} else {
			for k, v := range parsed {
				for _, v2 := range v {
					queryValues.Add(k, v2)
				}
			}
		}

	}

	if params.Le != nil {

		if queryFrag, err := runtime.StyleParamWithLocation("form", true, "le", runtime.ParamLocationQuery, *params.Le); err != nil {
			return nil, err
		} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
			return nil, err
		} else {
			for k, v := range parsed {
				for _, v2 := range v {
					queryValues.Add(k, v2)
				}
			}
		}

	}

	if params.Precision != nil {

		if queryFrag, err := runtime.StyleParamWithLocation("form", true, "precision", runtime.ParamLocationQuery, *params.Precision); err != nil {
			return nil, err
		} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
			return nil, err
		} else {
			for k, v := range parsed {
				for _, v2 := range v {
					queryValues.Add(k, v2)
				}
			}
		}

	}

	if params.Aggregate != nil {

		if queryFrag, err := runtime.StyleParamWithLocation("form", true, "aggregate", runtime.ParamLocationQuery, *params.Aggregate); err != nil {
			return nil, err
		} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
			return nil, err
		} else {
			for k, v := range parsed {
				for _, v2 := range v {
					queryValues.Add(k, v2)
				}
			}
		}

	}

	if params.Timezone != nil {

		if queryFrag, err := runtime.StyleParamWithLocation("form", true, "timezone", runtime.ParamLocationQuery, *params.Timezone); err != nil {
			return nil, err
		} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
			return nil, err
		} else {
			for k, v := range parsed {
				for _, v2 := range v {
					queryValues.Add(k, v2)
				}
			}
		}

	}

	queryURL.RawQuery = queryValues.Encode()

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewAddDataToTimeseriesRequest calls the generic AddDataToTimeseries builder with application/json body
func NewAddDataToTimeseriesRequest(server string, uuid UuidParam, params *AddDataToTimeseriesParams, body AddDataToTimeseriesJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewAddDataToTimeseriesRequestWithBody(server, uuid, params, "application/json", bodyReader)
}

// NewAddDataToTimeseriesRequestWithBody generates requests for AddDataToTimeseries with any type of body
func NewAddDataToTimeseriesRequestWithBody(server string, uuid UuidParam, params *AddDataToTimeseriesParams, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "uuid", runtime.ParamLocationPath, uuid)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/v2/timeseries/%s/data", pathParam0)
	if operationPath[0] == '/' {
		operationPath = operationPath[1:]
	}
	operationURL := url.URL{
		Path: operationPath,
	}

	queryURL := serverURL.ResolveReference(&operationURL)

	queryValues := queryURL.Query()

	if params.Unit != nil {

		if queryFrag, err := runtime.StyleParamWithLocation("form", true, "unit", runtime.ParamLocationQuery, *params.Unit); err != nil {
			return nil, err
		} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
			return nil, err
		} else {
			for k, v := range parsed {
				for _, v2 := range v {
					queryValues.Add(k, v2)
				}
			}
		}

	}

	queryURL.RawQuery = queryValues.Encode()

	req, err := http.NewRequest("POST", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewFindTsdataByQueryRequest generates requests for FindTsdataByQuery
func NewFindTsdataByQueryRequest(server string, params *FindTsdataByQueryParams) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/v2/tsquery")
	if operationPath[0] == '/' {
		operationPath = operationPath[1:]
	}
	operationURL := url.URL{
		Path: operationPath,
	}

	queryURL := serverURL.ResolveReference(&operationURL)

	queryValues := queryURL.Query()

	if queryFrag, err := runtime.StyleParamWithLocation("form", true, "uuids", runtime.ParamLocationQuery, params.Uuids); err != nil {
		return nil, err
	} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
		return nil, err
	} else {
		for k, v := range parsed {
			for _, v2 := range v {
				queryValues.Add(k, v2)
			}
		}
	}

	if queryFrag, err := runtime.StyleParamWithLocation("form", true, "start", runtime.ParamLocationQuery, params.Start); err != nil {
		return nil, err
	} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
		return nil, err
	} else {
		for k, v := range parsed {
			for _, v2 := range v {
				queryValues.Add(k, v2)
			}
		}
	}

	if queryFrag, err := runtime.StyleParamWithLocation("form", true, "end", runtime.ParamLocationQuery, params.End); err != nil {
		return nil, err
	} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
		return nil, err
	} else {
		for k, v := range parsed {
			for _, v2 := range v {
				queryValues.Add(k, v2)
			}
		}
	}

	if params.Ge != nil {

		if queryFrag, err := runtime.StyleParamWithLocation("form", true, "ge", runtime.ParamLocationQuery, *params.Ge); err != nil {
			return nil, err
		} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
			return nil, err
		} else {
			for k, v := range parsed {
				for _, v2 := range v {
					queryValues.Add(k, v2)
				}
			}
		}

	}

	if params.Le != nil {

		if queryFrag, err := runtime.StyleParamWithLocation("form", true, "le", runtime.ParamLocationQuery, *params.Le); err != nil {
			return nil, err
		} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
			return nil, err
		} else {
			for k, v := range parsed {
				for _, v2 := range v {
					queryValues.Add(k, v2)
				}
			}
		}

	}

	if params.Precision != nil {

		if queryFrag, err := runtime.StyleParamWithLocation("form", true, "precision", runtime.ParamLocationQuery, *params.Precision); err != nil {
			return nil, err
		} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
			return nil, err
		} else {
			for k, v := range parsed {
				for _, v2 := range v {
					queryValues.Add(k, v2)
				}
			}
		}

	}

	if params.Aggregate != nil {

		if queryFrag, err := runtime.StyleParamWithLocation("form", true, "aggregate", runtime.ParamLocationQuery, *params.Aggregate); err != nil {
			return nil, err
		} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
			return nil, err
		} else {
			for k, v := range parsed {
				for _, v2 := range v {
					queryValues.Add(k, v2)
				}
			}
		}

	}

	if params.Timezone != nil {

		if queryFrag, err := runtime.StyleParamWithLocation("form", true, "timezone", runtime.ParamLocationQuery, *params.Timezone); err != nil {
			return nil, err
		} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
			return nil, err
		} else {
			for k, v := range parsed {
				for _, v2 := range v {
					queryValues.Add(k, v2)
				}
			}
		}

	}

	queryURL.RawQuery = queryValues.Encode()

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewFindUsersRequest generates requests for FindUsers
func NewFindUsersRequest(server string, params *FindUsersParams) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/v2/users")
	if operationPath[0] == '/' {
		operationPath = operationPath[1:]
	}
	operationURL := url.URL{
		Path: operationPath,
	}

	queryURL := serverURL.ResolveReference(&operationURL)

	queryValues := queryURL.Query()

	if params.Limit != nil {

		if queryFrag, err := runtime.StyleParamWithLocation("form", true, "limit", runtime.ParamLocationQuery, *params.Limit); err != nil {
			return nil, err
		} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
			return nil, err
		} else {
			for k, v := range parsed {
				for _, v2 := range v {
					queryValues.Add(k, v2)
				}
			}
		}

	}

	if params.Offset != nil {

		if queryFrag, err := runtime.StyleParamWithLocation("form", true, "offset", runtime.ParamLocationQuery, *params.Offset); err != nil {
			return nil, err
		} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
			return nil, err
		} else {
			for k, v := range parsed {
				for _, v2 := range v {
					queryValues.Add(k, v2)
				}
			}
		}

	}

	queryURL.RawQuery = queryValues.Encode()

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewAddUserRequest calls the generic AddUser builder with application/json body
func NewAddUserRequest(server string, body AddUserJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewAddUserRequestWithBody(server, "application/json", bodyReader)
}

// NewAddUserRequestWithBody generates requests for AddUser with any type of body
func NewAddUserRequestWithBody(server string, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/v2/users")
	if operationPath[0] == '/' {
		operationPath = operationPath[1:]
	}
	operationURL := url.URL{
		Path: operationPath,
	}

	queryURL := serverURL.ResolveReference(&operationURL)

	req, err := http.NewRequest("POST", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewWhoamiRequest generates requests for Whoami
func NewWhoamiRequest(server string) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/v2/users/me")
	if operationPath[0] == '/' {
		operationPath = operationPath[1:]
	}
	operationURL := url.URL{
		Path: operationPath,
	}

	queryURL := serverURL.ResolveReference(&operationURL)

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewDeleteUserByUuidRequest generates requests for DeleteUserByUuid
func NewDeleteUserByUuidRequest(server string, uuid UuidParam) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "uuid", runtime.ParamLocationPath, uuid)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/v2/users/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = operationPath[1:]
	}
	operationURL := url.URL{
		Path: operationPath,
	}

	queryURL := serverURL.ResolveReference(&operationURL)

	req, err := http.NewRequest("DELETE", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewFindUserByUuidRequest generates requests for FindUserByUuid
func NewFindUserByUuidRequest(server string, uuid UuidParam) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "uuid", runtime.ParamLocationPath, uuid)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/v2/users/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = operationPath[1:]
	}
	operationURL := url.URL{
		Path: operationPath,
	}

	queryURL := serverURL.ResolveReference(&operationURL)

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewUpdateUserByUuidRequest calls the generic UpdateUserByUuid builder with application/json body
func NewUpdateUserByUuidRequest(server string, uuid UuidParam, body UpdateUserByUuidJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewUpdateUserByUuidRequestWithBody(server, uuid, "application/json", bodyReader)
}

// NewUpdateUserByUuidRequestWithBody generates requests for UpdateUserByUuid with any type of body
func NewUpdateUserByUuidRequestWithBody(server string, uuid UuidParam, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "uuid", runtime.ParamLocationPath, uuid)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/v2/users/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = operationPath[1:]
	}
	operationURL := url.URL{
		Path: operationPath,
	}

	queryURL := serverURL.ResolveReference(&operationURL)

	req, err := http.NewRequest("PUT", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewFindPoliciesForUserRequest generates requests for FindPoliciesForUser
func NewFindPoliciesForUserRequest(server string, uuid UuidParam) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "uuid", runtime.ParamLocationPath, uuid)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/v2/users/%s/policies", pathParam0)
	if operationPath[0] == '/' {
		operationPath = operationPath[1:]
	}
	operationURL := url.URL{
		Path: operationPath,
	}

	queryURL := serverURL.ResolveReference(&operationURL)

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewSetRequestRateForUserRequest calls the generic SetRequestRateForUser builder with application/json body
func NewSetRequestRateForUserRequest(server string, uuid UuidParam, body SetRequestRateForUserJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewSetRequestRateForUserRequestWithBody(server, uuid, "application/json", bodyReader)
}

// NewSetRequestRateForUserRequestWithBody generates requests for SetRequestRateForUser with any type of body
func NewSetRequestRateForUserRequestWithBody(server string, uuid UuidParam, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "uuid", runtime.ParamLocationPath, uuid)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/v2/users/%s/rate", pathParam0)
	if operationPath[0] == '/' {
		operationPath = operationPath[1:]
	}
	operationURL := url.URL{
		Path: operationPath,
	}

	queryURL := serverURL.ResolveReference(&operationURL)

	req, err := http.NewRequest("PUT", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewFindTokensForUserRequest generates requests for FindTokensForUser
func NewFindTokensForUserRequest(server string, uuid UuidParam) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "uuid", runtime.ParamLocationPath, uuid)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/v2/users/%s/tokens", pathParam0)
	if operationPath[0] == '/' {
		operationPath = operationPath[1:]
	}
	operationURL := url.URL{
		Path: operationPath,
	}

	queryURL := serverURL.ResolveReference(&operationURL)

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewAddNewTokenToUserRequest calls the generic AddNewTokenToUser builder with application/json body
func NewAddNewTokenToUserRequest(server string, uuid UuidParam, body AddNewTokenToUserJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewAddNewTokenToUserRequestWithBody(server, uuid, "application/json", bodyReader)
}

// NewAddNewTokenToUserRequestWithBody generates requests for AddNewTokenToUser with any type of body
func NewAddNewTokenToUserRequestWithBody(server string, uuid UuidParam, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "uuid", runtime.ParamLocationPath, uuid)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/v2/users/%s/tokens", pathParam0)
	if operationPath[0] == '/' {
		operationPath = operationPath[1:]
	}
	operationURL := url.URL{
		Path: operationPath,
	}

	queryURL := serverURL.ResolveReference(&operationURL)

	req, err := http.NewRequest("POST", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewDeleteTokenForUserRequest generates requests for DeleteTokenForUser
func NewDeleteTokenForUserRequest(server string, uuid UuidParam, tokenUuid string) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "uuid", runtime.ParamLocationPath, uuid)
	if err != nil {
		return nil, err
	}

	var pathParam1 string

	pathParam1, err = runtime.StyleParamWithLocation("simple", false, "token_uuid", runtime.ParamLocationPath, tokenUuid)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/v2/users/%s/tokens/%s", pathParam0, pathParam1)
	if operationPath[0] == '/' {
		operationPath = operationPath[1:]
	}
	operationURL := url.URL{
		Path: operationPath,
	}

	queryURL := serverURL.ResolveReference(&operationURL)

	req, err := http.NewRequest("DELETE", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

func (c *Client) applyEditors(ctx context.Context, req *http.Request, additionalEditors []RequestEditorFn) error {
	for _, r := range c.RequestEditors {
		if err := r(ctx, req); err != nil {
			return err
		}
	}
	for _, r := range additionalEditors {
		if err := r(ctx, req); err != nil {
			return err
		}
	}
	return nil
}

// ClientWithResponses builds on ClientInterface to offer response payloads
type ClientWithResponses struct {
	ClientInterface
}

// NewClientWithResponses creates a new ClientWithResponses, which wraps
// Client with return type handling
func NewClientWithResponses(server string, opts ...ClientOption) (*ClientWithResponses, error) {
	client, err := NewClient(server, opts...)
	if err != nil {
		return nil, err
	}
	return &ClientWithResponses{client}, nil
}

// WithBaseURL overrides the baseURL.
func WithBaseURL(baseURL string) ClientOption {
	return func(c *Client) error {
		newBaseURL, err := url.Parse(baseURL)
		if err != nil {
			return err
		}
		c.Server = newBaseURL.String()
		return nil
	}
}

// ClientWithResponsesInterface is the interface specification for the client with responses above.
type ClientWithResponsesInterface interface {
	// FindAlerts request
	FindAlertsWithResponse(ctx context.Context, params *FindAlertsParams, reqEditors ...RequestEditorFn) (*FindAlertsResponse, error)

	// CreateAlert request  with any body
	CreateAlertWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*CreateAlertResponse, error)

	CreateAlertWithResponse(ctx context.Context, body CreateAlertJSONRequestBody, reqEditors ...RequestEditorFn) (*CreateAlertResponse, error)

	// DeleteAlertByUuid request
	DeleteAlertByUuidWithResponse(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*DeleteAlertByUuidResponse, error)

	// FindAlertByUuid request
	FindAlertByUuidWithResponse(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*FindAlertByUuidResponse, error)

	// UpdateAlertByUuid request  with any body
	UpdateAlertByUuidWithBodyWithResponse(ctx context.Context, uuid UuidParam, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*UpdateAlertByUuidResponse, error)

	UpdateAlertByUuidWithResponse(ctx context.Context, uuid UuidParam, body UpdateAlertByUuidJSONRequestBody, reqEditors ...RequestEditorFn) (*UpdateAlertByUuidResponse, error)

	// FindDatasets request
	FindDatasetsWithResponse(ctx context.Context, params *FindDatasetsParams, reqEditors ...RequestEditorFn) (*FindDatasetsResponse, error)

	// AddDatasets request  with any body
	AddDatasetsWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*AddDatasetsResponse, error)

	AddDatasetsWithResponse(ctx context.Context, body AddDatasetsJSONRequestBody, reqEditors ...RequestEditorFn) (*AddDatasetsResponse, error)

	// DeleteDatasetByUuid request
	DeleteDatasetByUuidWithResponse(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*DeleteDatasetByUuidResponse, error)

	// FindDatasetByUuid request
	FindDatasetByUuidWithResponse(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*FindDatasetByUuidResponse, error)

	// UpdateDatasetByUuid request  with any body
	UpdateDatasetByUuidWithBodyWithResponse(ctx context.Context, uuid UuidParam, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*UpdateDatasetByUuidResponse, error)

	UpdateDatasetByUuidWithResponse(ctx context.Context, uuid UuidParam, body UpdateDatasetByUuidJSONRequestBody, reqEditors ...RequestEditorFn) (*UpdateDatasetByUuidResponse, error)

	// AssembleDatasetPartsByKey request
	AssembleDatasetPartsByKeyWithResponse(ctx context.Context, uuid UuidParam, params *AssembleDatasetPartsByKeyParams, reqEditors ...RequestEditorFn) (*AssembleDatasetPartsByKeyResponse, error)

	// ListDatasetPartsByKey request
	ListDatasetPartsByKeyWithResponse(ctx context.Context, uuid UuidParam, params *ListDatasetPartsByKeyParams, reqEditors ...RequestEditorFn) (*ListDatasetPartsByKeyResponse, error)

	// UploadDatasetContentByKey request
	UploadDatasetContentByKeyWithResponse(ctx context.Context, uuid UuidParam, params *UploadDatasetContentByKeyParams, reqEditors ...RequestEditorFn) (*UploadDatasetContentByKeyResponse, error)

	// GetRawDatasetByUuid request
	GetRawDatasetByUuidWithResponse(ctx context.Context, uuid UuidParam, params *GetRawDatasetByUuidParams, reqEditors ...RequestEditorFn) (*GetRawDatasetByUuidResponse, error)

	// DeleteDatasetUploadByKey request
	DeleteDatasetUploadByKeyWithResponse(ctx context.Context, uuid UuidParam, params *DeleteDatasetUploadByKeyParams, reqEditors ...RequestEditorFn) (*DeleteDatasetUploadByKeyResponse, error)

	// InitializeDatasetUploadByUuid request
	InitializeDatasetUploadByUuidWithResponse(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*InitializeDatasetUploadByUuidResponse, error)

	// FindGroups request
	FindGroupsWithResponse(ctx context.Context, params *FindGroupsParams, reqEditors ...RequestEditorFn) (*FindGroupsResponse, error)

	// AddGroup request  with any body
	AddGroupWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*AddGroupResponse, error)

	AddGroupWithResponse(ctx context.Context, body AddGroupJSONRequestBody, reqEditors ...RequestEditorFn) (*AddGroupResponse, error)

	// DeleteGroupByUuid request
	DeleteGroupByUuidWithResponse(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*DeleteGroupByUuidResponse, error)

	// FindGroupByUuid request
	FindGroupByUuidWithResponse(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*FindGroupByUuidResponse, error)

	// UpdateGroupByUuid request  with any body
	UpdateGroupByUuidWithBodyWithResponse(ctx context.Context, uuid UuidParam, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*UpdateGroupByUuidResponse, error)

	UpdateGroupByUuidWithResponse(ctx context.Context, uuid UuidParam, body UpdateGroupByUuidJSONRequestBody, reqEditors ...RequestEditorFn) (*UpdateGroupByUuidResponse, error)

	// FindPoliciesForGroup request
	FindPoliciesForGroupWithResponse(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*FindPoliciesForGroupResponse, error)

	// FindPolicies request
	FindPoliciesWithResponse(ctx context.Context, params *FindPoliciesParams, reqEditors ...RequestEditorFn) (*FindPoliciesResponse, error)

	// AddPolicy request  with any body
	AddPolicyWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*AddPolicyResponse, error)

	AddPolicyWithResponse(ctx context.Context, body AddPolicyJSONRequestBody, reqEditors ...RequestEditorFn) (*AddPolicyResponse, error)

	// DeletePolicyByUuid request
	DeletePolicyByUuidWithResponse(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*DeletePolicyByUuidResponse, error)

	// FindPolicyByUuid request
	FindPolicyByUuidWithResponse(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*FindPolicyByUuidResponse, error)

	// UpdatePolicyByUuid request  with any body
	UpdatePolicyByUuidWithBodyWithResponse(ctx context.Context, uuid UuidParam, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*UpdatePolicyByUuidResponse, error)

	UpdatePolicyByUuidWithResponse(ctx context.Context, uuid UuidParam, body UpdatePolicyByUuidJSONRequestBody, reqEditors ...RequestEditorFn) (*UpdatePolicyByUuidResponse, error)

	// FindPrograms request
	FindProgramsWithResponse(ctx context.Context, params *FindProgramsParams, reqEditors ...RequestEditorFn) (*FindProgramsResponse, error)

	// AddProgram request  with any body
	AddProgramWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*AddProgramResponse, error)

	AddProgramWithResponse(ctx context.Context, body AddProgramJSONRequestBody, reqEditors ...RequestEditorFn) (*AddProgramResponse, error)

	// DeleteProgramByUuid request
	DeleteProgramByUuidWithResponse(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*DeleteProgramByUuidResponse, error)

	// FindProgramByUuid request
	FindProgramByUuidWithResponse(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*FindProgramByUuidResponse, error)

	// UpdateProgramByUuid request  with any body
	UpdateProgramByUuidWithBodyWithResponse(ctx context.Context, uuid UuidParam, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*UpdateProgramByUuidResponse, error)

	UpdateProgramByUuidWithResponse(ctx context.Context, uuid UuidParam, body UpdateProgramByUuidJSONRequestBody, reqEditors ...RequestEditorFn) (*UpdateProgramByUuidResponse, error)

	// GetCodeFromProgram request
	GetCodeFromProgramWithResponse(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*GetCodeFromProgramResponse, error)

	// AddProgramCodeRevision request  with any body
	AddProgramCodeRevisionWithBodyWithResponse(ctx context.Context, uuid UuidParam, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*AddProgramCodeRevisionResponse, error)

	// GetProgramCodeRevisionsDiff request
	GetProgramCodeRevisionsDiffWithResponse(ctx context.Context, uuid UuidParam, params *GetProgramCodeRevisionsDiffParams, reqEditors ...RequestEditorFn) (*GetProgramCodeRevisionsDiffResponse, error)

	// GetProgramCodeRevisions request
	GetProgramCodeRevisionsWithResponse(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*GetProgramCodeRevisionsResponse, error)

	// DeleteProgramCodeRevisions request
	DeleteProgramCodeRevisionsWithResponse(ctx context.Context, uuid UuidParam, revisionId int, reqEditors ...RequestEditorFn) (*DeleteProgramCodeRevisionsResponse, error)

	// SignProgramCodeRevisions request
	SignProgramCodeRevisionsWithResponse(ctx context.Context, uuid UuidParam, revisionId int, reqEditors ...RequestEditorFn) (*SignProgramCodeRevisionsResponse, error)

	// ExecuteProgramWebhook request
	ExecuteProgramWebhookWithResponse(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*ExecuteProgramWebhookResponse, error)

	// FindThings request
	FindThingsWithResponse(ctx context.Context, params *FindThingsParams, reqEditors ...RequestEditorFn) (*FindThingsResponse, error)

	// AddThing request  with any body
	AddThingWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*AddThingResponse, error)

	AddThingWithResponse(ctx context.Context, body AddThingJSONRequestBody, reqEditors ...RequestEditorFn) (*AddThingResponse, error)

	// DeleteThingByUuid request
	DeleteThingByUuidWithResponse(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*DeleteThingByUuidResponse, error)

	// FindThingByUuid request
	FindThingByUuidWithResponse(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*FindThingByUuidResponse, error)

	// UpdateThingByUuid request  with any body
	UpdateThingByUuidWithBodyWithResponse(ctx context.Context, uuid UuidParam, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*UpdateThingByUuidResponse, error)

	UpdateThingByUuidWithResponse(ctx context.Context, uuid UuidParam, body UpdateThingByUuidJSONRequestBody, reqEditors ...RequestEditorFn) (*UpdateThingByUuidResponse, error)

	// FindDatasetsForThing request
	FindDatasetsForThingWithResponse(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*FindDatasetsForThingResponse, error)

	// FindTimeSeriesForThing request
	FindTimeSeriesForThingWithResponse(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*FindTimeSeriesForThingResponse, error)

	// FindTimeSeries request
	FindTimeSeriesWithResponse(ctx context.Context, params *FindTimeSeriesParams, reqEditors ...RequestEditorFn) (*FindTimeSeriesResponse, error)

	// AddTimeSeries request  with any body
	AddTimeSeriesWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*AddTimeSeriesResponse, error)

	AddTimeSeriesWithResponse(ctx context.Context, body AddTimeSeriesJSONRequestBody, reqEditors ...RequestEditorFn) (*AddTimeSeriesResponse, error)

	// DeleteTimeSeriesByUuid request
	DeleteTimeSeriesByUuidWithResponse(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*DeleteTimeSeriesByUuidResponse, error)

	// FindTimeSeriesByUuid request
	FindTimeSeriesByUuidWithResponse(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*FindTimeSeriesByUuidResponse, error)

	// UpdateTimeseriesByUuid request  with any body
	UpdateTimeseriesByUuidWithBodyWithResponse(ctx context.Context, uuid UuidParam, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*UpdateTimeseriesByUuidResponse, error)

	UpdateTimeseriesByUuidWithResponse(ctx context.Context, uuid UuidParam, body UpdateTimeseriesByUuidJSONRequestBody, reqEditors ...RequestEditorFn) (*UpdateTimeseriesByUuidResponse, error)

	// DeleteDataFromTimeSeries request
	DeleteDataFromTimeSeriesWithResponse(ctx context.Context, uuid UuidParam, params *DeleteDataFromTimeSeriesParams, reqEditors ...RequestEditorFn) (*DeleteDataFromTimeSeriesResponse, error)

	// QueryTimeseriesForData request
	QueryTimeseriesForDataWithResponse(ctx context.Context, uuid UuidParam, params *QueryTimeseriesForDataParams, reqEditors ...RequestEditorFn) (*QueryTimeseriesForDataResponse, error)

	// AddDataToTimeseries request  with any body
	AddDataToTimeseriesWithBodyWithResponse(ctx context.Context, uuid UuidParam, params *AddDataToTimeseriesParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*AddDataToTimeseriesResponse, error)

	AddDataToTimeseriesWithResponse(ctx context.Context, uuid UuidParam, params *AddDataToTimeseriesParams, body AddDataToTimeseriesJSONRequestBody, reqEditors ...RequestEditorFn) (*AddDataToTimeseriesResponse, error)

	// FindTsdataByQuery request
	FindTsdataByQueryWithResponse(ctx context.Context, params *FindTsdataByQueryParams, reqEditors ...RequestEditorFn) (*FindTsdataByQueryResponse, error)

	// FindUsers request
	FindUsersWithResponse(ctx context.Context, params *FindUsersParams, reqEditors ...RequestEditorFn) (*FindUsersResponse, error)

	// AddUser request  with any body
	AddUserWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*AddUserResponse, error)

	AddUserWithResponse(ctx context.Context, body AddUserJSONRequestBody, reqEditors ...RequestEditorFn) (*AddUserResponse, error)

	// Whoami request
	WhoamiWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*WhoamiResponse, error)

	// DeleteUserByUuid request
	DeleteUserByUuidWithResponse(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*DeleteUserByUuidResponse, error)

	// FindUserByUuid request
	FindUserByUuidWithResponse(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*FindUserByUuidResponse, error)

	// UpdateUserByUuid request  with any body
	UpdateUserByUuidWithBodyWithResponse(ctx context.Context, uuid UuidParam, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*UpdateUserByUuidResponse, error)

	UpdateUserByUuidWithResponse(ctx context.Context, uuid UuidParam, body UpdateUserByUuidJSONRequestBody, reqEditors ...RequestEditorFn) (*UpdateUserByUuidResponse, error)

	// FindPoliciesForUser request
	FindPoliciesForUserWithResponse(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*FindPoliciesForUserResponse, error)

	// SetRequestRateForUser request  with any body
	SetRequestRateForUserWithBodyWithResponse(ctx context.Context, uuid UuidParam, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*SetRequestRateForUserResponse, error)

	SetRequestRateForUserWithResponse(ctx context.Context, uuid UuidParam, body SetRequestRateForUserJSONRequestBody, reqEditors ...RequestEditorFn) (*SetRequestRateForUserResponse, error)

	// FindTokensForUser request
	FindTokensForUserWithResponse(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*FindTokensForUserResponse, error)

	// AddNewTokenToUser request  with any body
	AddNewTokenToUserWithBodyWithResponse(ctx context.Context, uuid UuidParam, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*AddNewTokenToUserResponse, error)

	AddNewTokenToUserWithResponse(ctx context.Context, uuid UuidParam, body AddNewTokenToUserJSONRequestBody, reqEditors ...RequestEditorFn) (*AddNewTokenToUserResponse, error)

	// DeleteTokenForUser request
	DeleteTokenForUserWithResponse(ctx context.Context, uuid UuidParam, tokenUuid string, reqEditors ...RequestEditorFn) (*DeleteTokenForUserResponse, error)
}

type FindAlertsResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *Alert
}

// Status returns HTTPResponse.Status
func (r FindAlertsResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r FindAlertsResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type CreateAlertResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON201      *NewAlertReply
}

// Status returns HTTPResponse.Status
func (r CreateAlertResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r CreateAlertResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type DeleteAlertByUuidResponse struct {
	Body         []byte
	HTTPResponse *http.Response
}

// Status returns HTTPResponse.Status
func (r DeleteAlertByUuidResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r DeleteAlertByUuidResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type FindAlertByUuidResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *Alert
}

// Status returns HTTPResponse.Status
func (r FindAlertByUuidResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r FindAlertByUuidResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type UpdateAlertByUuidResponse struct {
	Body         []byte
	HTTPResponse *http.Response
}

// Status returns HTTPResponse.Status
func (r UpdateAlertByUuidResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r UpdateAlertByUuidResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type FindDatasetsResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *[]Dataset
}

// Status returns HTTPResponse.Status
func (r FindDatasetsResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r FindDatasetsResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type AddDatasetsResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON201      *Dataset
}

// Status returns HTTPResponse.Status
func (r AddDatasetsResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r AddDatasetsResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type DeleteDatasetByUuidResponse struct {
	Body         []byte
	HTTPResponse *http.Response
}

// Status returns HTTPResponse.Status
func (r DeleteDatasetByUuidResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r DeleteDatasetByUuidResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type FindDatasetByUuidResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *Dataset
}

// Status returns HTTPResponse.Status
func (r FindDatasetByUuidResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r FindDatasetByUuidResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type UpdateDatasetByUuidResponse struct {
	Body         []byte
	HTTPResponse *http.Response
}

// Status returns HTTPResponse.Status
func (r UpdateDatasetByUuidResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r UpdateDatasetByUuidResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type AssembleDatasetPartsByKeyResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON400      *struct {
		Message string `json:"message"`
	}
}

// Status returns HTTPResponse.Status
func (r AssembleDatasetPartsByKeyResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r AssembleDatasetPartsByKeyResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type ListDatasetPartsByKeyResponse struct {
	Body         []byte
	HTTPResponse *http.Response
}

// Status returns HTTPResponse.Status
func (r ListDatasetPartsByKeyResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r ListDatasetPartsByKeyResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type UploadDatasetContentByKeyResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *struct {
		Message string `json:"message"`
	}
}

// Status returns HTTPResponse.Status
func (r UploadDatasetContentByKeyResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r UploadDatasetContentByKeyResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type GetRawDatasetByUuidResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *string
	XML200       *string
	YAML200      *string
}

// Status returns HTTPResponse.Status
func (r GetRawDatasetByUuidResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r GetRawDatasetByUuidResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type DeleteDatasetUploadByKeyResponse struct {
	Body         []byte
	HTTPResponse *http.Response
}

// Status returns HTTPResponse.Status
func (r DeleteDatasetUploadByKeyResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r DeleteDatasetUploadByKeyResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type InitializeDatasetUploadByUuidResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *struct {
		UploadId *string `json:"uploadId,omitempty"`
	}
}

// Status returns HTTPResponse.Status
func (r InitializeDatasetUploadByUuidResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r InitializeDatasetUploadByUuidResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type FindGroupsResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *[]Group
}

// Status returns HTTPResponse.Status
func (r FindGroupsResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r FindGroupsResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type AddGroupResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON201      *Group
}

// Status returns HTTPResponse.Status
func (r AddGroupResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r AddGroupResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type DeleteGroupByUuidResponse struct {
	Body         []byte
	HTTPResponse *http.Response
}

// Status returns HTTPResponse.Status
func (r DeleteGroupByUuidResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r DeleteGroupByUuidResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type FindGroupByUuidResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *Group
}

// Status returns HTTPResponse.Status
func (r FindGroupByUuidResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r FindGroupByUuidResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type UpdateGroupByUuidResponse struct {
	Body         []byte
	HTTPResponse *http.Response
}

// Status returns HTTPResponse.Status
func (r UpdateGroupByUuidResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r UpdateGroupByUuidResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type FindPoliciesForGroupResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *[]Policy
}

// Status returns HTTPResponse.Status
func (r FindPoliciesForGroupResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r FindPoliciesForGroupResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type FindPoliciesResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *[]Policy
}

// Status returns HTTPResponse.Status
func (r FindPoliciesResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r FindPoliciesResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type AddPolicyResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON201      *Policy
}

// Status returns HTTPResponse.Status
func (r AddPolicyResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r AddPolicyResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type DeletePolicyByUuidResponse struct {
	Body         []byte
	HTTPResponse *http.Response
}

// Status returns HTTPResponse.Status
func (r DeletePolicyByUuidResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r DeletePolicyByUuidResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type FindPolicyByUuidResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *Policy
}

// Status returns HTTPResponse.Status
func (r FindPolicyByUuidResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r FindPolicyByUuidResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type UpdatePolicyByUuidResponse struct {
	Body         []byte
	HTTPResponse *http.Response
}

// Status returns HTTPResponse.Status
func (r UpdatePolicyByUuidResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r UpdatePolicyByUuidResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type FindProgramsResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *[]Program
}

// Status returns HTTPResponse.Status
func (r FindProgramsResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r FindProgramsResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type AddProgramResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON201      *Program
}

// Status returns HTTPResponse.Status
func (r AddProgramResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r AddProgramResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type DeleteProgramByUuidResponse struct {
	Body         []byte
	HTTPResponse *http.Response
}

// Status returns HTTPResponse.Status
func (r DeleteProgramByUuidResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r DeleteProgramByUuidResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type FindProgramByUuidResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *Program
}

// Status returns HTTPResponse.Status
func (r FindProgramByUuidResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r FindProgramByUuidResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type UpdateProgramByUuidResponse struct {
	Body         []byte
	HTTPResponse *http.Response
}

// Status returns HTTPResponse.Status
func (r UpdateProgramByUuidResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r UpdateProgramByUuidResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type GetCodeFromProgramResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *Program
}

// Status returns HTTPResponse.Status
func (r GetCodeFromProgramResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r GetCodeFromProgramResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type AddProgramCodeRevisionResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON201      *CodeRevision
}

// Status returns HTTPResponse.Status
func (r AddProgramCodeRevisionResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r AddProgramCodeRevisionResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type GetProgramCodeRevisionsDiffResponse struct {
	Body         []byte
	HTTPResponse *http.Response
}

// Status returns HTTPResponse.Status
func (r GetProgramCodeRevisionsDiffResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r GetProgramCodeRevisionsDiffResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type GetProgramCodeRevisionsResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *[]CodeRevision
}

// Status returns HTTPResponse.Status
func (r GetProgramCodeRevisionsResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r GetProgramCodeRevisionsResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type DeleteProgramCodeRevisionsResponse struct {
	Body         []byte
	HTTPResponse *http.Response
}

// Status returns HTTPResponse.Status
func (r DeleteProgramCodeRevisionsResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r DeleteProgramCodeRevisionsResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type SignProgramCodeRevisionsResponse struct {
	Body         []byte
	HTTPResponse *http.Response
}

// Status returns HTTPResponse.Status
func (r SignProgramCodeRevisionsResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r SignProgramCodeRevisionsResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type ExecuteProgramWebhookResponse struct {
	Body         []byte
	HTTPResponse *http.Response
}

// Status returns HTTPResponse.Status
func (r ExecuteProgramWebhookResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r ExecuteProgramWebhookResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type FindThingsResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *[]Thing
}

// Status returns HTTPResponse.Status
func (r FindThingsResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r FindThingsResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type AddThingResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON201      *Thing
}

// Status returns HTTPResponse.Status
func (r AddThingResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r AddThingResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type DeleteThingByUuidResponse struct {
	Body         []byte
	HTTPResponse *http.Response
}

// Status returns HTTPResponse.Status
func (r DeleteThingByUuidResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r DeleteThingByUuidResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type FindThingByUuidResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *Thing
}

// Status returns HTTPResponse.Status
func (r FindThingByUuidResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r FindThingByUuidResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type UpdateThingByUuidResponse struct {
	Body         []byte
	HTTPResponse *http.Response
}

// Status returns HTTPResponse.Status
func (r UpdateThingByUuidResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r UpdateThingByUuidResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type FindDatasetsForThingResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *[]Timeseries
}

// Status returns HTTPResponse.Status
func (r FindDatasetsForThingResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r FindDatasetsForThingResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type FindTimeSeriesForThingResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *[]Timeseries
}

// Status returns HTTPResponse.Status
func (r FindTimeSeriesForThingResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r FindTimeSeriesForThingResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type FindTimeSeriesResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *[]Timeseries
}

// Status returns HTTPResponse.Status
func (r FindTimeSeriesResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r FindTimeSeriesResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type AddTimeSeriesResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON201      *Timeseries
}

// Status returns HTTPResponse.Status
func (r AddTimeSeriesResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r AddTimeSeriesResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type DeleteTimeSeriesByUuidResponse struct {
	Body         []byte
	HTTPResponse *http.Response
}

// Status returns HTTPResponse.Status
func (r DeleteTimeSeriesByUuidResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r DeleteTimeSeriesByUuidResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type FindTimeSeriesByUuidResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *Timeseries
}

// Status returns HTTPResponse.Status
func (r FindTimeSeriesByUuidResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r FindTimeSeriesByUuidResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type UpdateTimeseriesByUuidResponse struct {
	Body         []byte
	HTTPResponse *http.Response
}

// Status returns HTTPResponse.Status
func (r UpdateTimeseriesByUuidResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r UpdateTimeseriesByUuidResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type DeleteDataFromTimeSeriesResponse struct {
	Body         []byte
	HTTPResponse *http.Response
}

// Status returns HTTPResponse.Status
func (r DeleteDataFromTimeSeriesResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r DeleteDataFromTimeSeriesResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type QueryTimeseriesForDataResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *[]TsRow
}

// Status returns HTTPResponse.Status
func (r QueryTimeseriesForDataResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r QueryTimeseriesForDataResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type AddDataToTimeseriesResponse struct {
	Body         []byte
	HTTPResponse *http.Response
}

// Status returns HTTPResponse.Status
func (r AddDataToTimeseriesResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r AddDataToTimeseriesResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type FindTsdataByQueryResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *[]TsResults
}

// Status returns HTTPResponse.Status
func (r FindTsdataByQueryResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r FindTsdataByQueryResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type FindUsersResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *[]User
}

// Status returns HTTPResponse.Status
func (r FindUsersResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r FindUsersResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type AddUserResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON201      *User
}

// Status returns HTTPResponse.Status
func (r AddUserResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r AddUserResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type WhoamiResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *[]User
}

// Status returns HTTPResponse.Status
func (r WhoamiResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r WhoamiResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type DeleteUserByUuidResponse struct {
	Body         []byte
	HTTPResponse *http.Response
}

// Status returns HTTPResponse.Status
func (r DeleteUserByUuidResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r DeleteUserByUuidResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type FindUserByUuidResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *User
}

// Status returns HTTPResponse.Status
func (r FindUserByUuidResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r FindUserByUuidResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type UpdateUserByUuidResponse struct {
	Body         []byte
	HTTPResponse *http.Response
}

// Status returns HTTPResponse.Status
func (r UpdateUserByUuidResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r UpdateUserByUuidResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type FindPoliciesForUserResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *[]Policy
}

// Status returns HTTPResponse.Status
func (r FindPoliciesForUserResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r FindPoliciesForUserResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type SetRequestRateForUserResponse struct {
	Body         []byte
	HTTPResponse *http.Response
}

// Status returns HTTPResponse.Status
func (r SetRequestRateForUserResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r SetRequestRateForUserResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type FindTokensForUserResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *[]Token
}

// Status returns HTTPResponse.Status
func (r FindTokensForUserResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r FindTokensForUserResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type AddNewTokenToUserResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON201      *TokenWithSecret
}

// Status returns HTTPResponse.Status
func (r AddNewTokenToUserResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r AddNewTokenToUserResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type DeleteTokenForUserResponse struct {
	Body         []byte
	HTTPResponse *http.Response
}

// Status returns HTTPResponse.Status
func (r DeleteTokenForUserResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r DeleteTokenForUserResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

// FindAlertsWithResponse request returning *FindAlertsResponse
func (c *ClientWithResponses) FindAlertsWithResponse(ctx context.Context, params *FindAlertsParams, reqEditors ...RequestEditorFn) (*FindAlertsResponse, error) {
	rsp, err := c.FindAlerts(ctx, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseFindAlertsResponse(rsp)
}

// CreateAlertWithBodyWithResponse request with arbitrary body returning *CreateAlertResponse
func (c *ClientWithResponses) CreateAlertWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*CreateAlertResponse, error) {
	rsp, err := c.CreateAlertWithBody(ctx, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseCreateAlertResponse(rsp)
}

func (c *ClientWithResponses) CreateAlertWithResponse(ctx context.Context, body CreateAlertJSONRequestBody, reqEditors ...RequestEditorFn) (*CreateAlertResponse, error) {
	rsp, err := c.CreateAlert(ctx, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseCreateAlertResponse(rsp)
}

// DeleteAlertByUuidWithResponse request returning *DeleteAlertByUuidResponse
func (c *ClientWithResponses) DeleteAlertByUuidWithResponse(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*DeleteAlertByUuidResponse, error) {
	rsp, err := c.DeleteAlertByUuid(ctx, uuid, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDeleteAlertByUuidResponse(rsp)
}

// FindAlertByUuidWithResponse request returning *FindAlertByUuidResponse
func (c *ClientWithResponses) FindAlertByUuidWithResponse(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*FindAlertByUuidResponse, error) {
	rsp, err := c.FindAlertByUuid(ctx, uuid, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseFindAlertByUuidResponse(rsp)
}

// UpdateAlertByUuidWithBodyWithResponse request with arbitrary body returning *UpdateAlertByUuidResponse
func (c *ClientWithResponses) UpdateAlertByUuidWithBodyWithResponse(ctx context.Context, uuid UuidParam, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*UpdateAlertByUuidResponse, error) {
	rsp, err := c.UpdateAlertByUuidWithBody(ctx, uuid, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseUpdateAlertByUuidResponse(rsp)
}

func (c *ClientWithResponses) UpdateAlertByUuidWithResponse(ctx context.Context, uuid UuidParam, body UpdateAlertByUuidJSONRequestBody, reqEditors ...RequestEditorFn) (*UpdateAlertByUuidResponse, error) {
	rsp, err := c.UpdateAlertByUuid(ctx, uuid, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseUpdateAlertByUuidResponse(rsp)
}

// FindDatasetsWithResponse request returning *FindDatasetsResponse
func (c *ClientWithResponses) FindDatasetsWithResponse(ctx context.Context, params *FindDatasetsParams, reqEditors ...RequestEditorFn) (*FindDatasetsResponse, error) {
	rsp, err := c.FindDatasets(ctx, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseFindDatasetsResponse(rsp)
}

// AddDatasetsWithBodyWithResponse request with arbitrary body returning *AddDatasetsResponse
func (c *ClientWithResponses) AddDatasetsWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*AddDatasetsResponse, error) {
	rsp, err := c.AddDatasetsWithBody(ctx, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseAddDatasetsResponse(rsp)
}

func (c *ClientWithResponses) AddDatasetsWithResponse(ctx context.Context, body AddDatasetsJSONRequestBody, reqEditors ...RequestEditorFn) (*AddDatasetsResponse, error) {
	rsp, err := c.AddDatasets(ctx, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseAddDatasetsResponse(rsp)
}

// DeleteDatasetByUuidWithResponse request returning *DeleteDatasetByUuidResponse
func (c *ClientWithResponses) DeleteDatasetByUuidWithResponse(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*DeleteDatasetByUuidResponse, error) {
	rsp, err := c.DeleteDatasetByUuid(ctx, uuid, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDeleteDatasetByUuidResponse(rsp)
}

// FindDatasetByUuidWithResponse request returning *FindDatasetByUuidResponse
func (c *ClientWithResponses) FindDatasetByUuidWithResponse(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*FindDatasetByUuidResponse, error) {
	rsp, err := c.FindDatasetByUuid(ctx, uuid, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseFindDatasetByUuidResponse(rsp)
}

// UpdateDatasetByUuidWithBodyWithResponse request with arbitrary body returning *UpdateDatasetByUuidResponse
func (c *ClientWithResponses) UpdateDatasetByUuidWithBodyWithResponse(ctx context.Context, uuid UuidParam, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*UpdateDatasetByUuidResponse, error) {
	rsp, err := c.UpdateDatasetByUuidWithBody(ctx, uuid, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseUpdateDatasetByUuidResponse(rsp)
}

func (c *ClientWithResponses) UpdateDatasetByUuidWithResponse(ctx context.Context, uuid UuidParam, body UpdateDatasetByUuidJSONRequestBody, reqEditors ...RequestEditorFn) (*UpdateDatasetByUuidResponse, error) {
	rsp, err := c.UpdateDatasetByUuid(ctx, uuid, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseUpdateDatasetByUuidResponse(rsp)
}

// AssembleDatasetPartsByKeyWithResponse request returning *AssembleDatasetPartsByKeyResponse
func (c *ClientWithResponses) AssembleDatasetPartsByKeyWithResponse(ctx context.Context, uuid UuidParam, params *AssembleDatasetPartsByKeyParams, reqEditors ...RequestEditorFn) (*AssembleDatasetPartsByKeyResponse, error) {
	rsp, err := c.AssembleDatasetPartsByKey(ctx, uuid, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseAssembleDatasetPartsByKeyResponse(rsp)
}

// ListDatasetPartsByKeyWithResponse request returning *ListDatasetPartsByKeyResponse
func (c *ClientWithResponses) ListDatasetPartsByKeyWithResponse(ctx context.Context, uuid UuidParam, params *ListDatasetPartsByKeyParams, reqEditors ...RequestEditorFn) (*ListDatasetPartsByKeyResponse, error) {
	rsp, err := c.ListDatasetPartsByKey(ctx, uuid, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseListDatasetPartsByKeyResponse(rsp)
}

// UploadDatasetContentByKeyWithResponse request returning *UploadDatasetContentByKeyResponse
func (c *ClientWithResponses) UploadDatasetContentByKeyWithResponse(ctx context.Context, uuid UuidParam, params *UploadDatasetContentByKeyParams, reqEditors ...RequestEditorFn) (*UploadDatasetContentByKeyResponse, error) {
	rsp, err := c.UploadDatasetContentByKey(ctx, uuid, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseUploadDatasetContentByKeyResponse(rsp)
}

// GetRawDatasetByUuidWithResponse request returning *GetRawDatasetByUuidResponse
func (c *ClientWithResponses) GetRawDatasetByUuidWithResponse(ctx context.Context, uuid UuidParam, params *GetRawDatasetByUuidParams, reqEditors ...RequestEditorFn) (*GetRawDatasetByUuidResponse, error) {
	rsp, err := c.GetRawDatasetByUuid(ctx, uuid, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetRawDatasetByUuidResponse(rsp)
}

// DeleteDatasetUploadByKeyWithResponse request returning *DeleteDatasetUploadByKeyResponse
func (c *ClientWithResponses) DeleteDatasetUploadByKeyWithResponse(ctx context.Context, uuid UuidParam, params *DeleteDatasetUploadByKeyParams, reqEditors ...RequestEditorFn) (*DeleteDatasetUploadByKeyResponse, error) {
	rsp, err := c.DeleteDatasetUploadByKey(ctx, uuid, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDeleteDatasetUploadByKeyResponse(rsp)
}

// InitializeDatasetUploadByUuidWithResponse request returning *InitializeDatasetUploadByUuidResponse
func (c *ClientWithResponses) InitializeDatasetUploadByUuidWithResponse(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*InitializeDatasetUploadByUuidResponse, error) {
	rsp, err := c.InitializeDatasetUploadByUuid(ctx, uuid, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseInitializeDatasetUploadByUuidResponse(rsp)
}

// FindGroupsWithResponse request returning *FindGroupsResponse
func (c *ClientWithResponses) FindGroupsWithResponse(ctx context.Context, params *FindGroupsParams, reqEditors ...RequestEditorFn) (*FindGroupsResponse, error) {
	rsp, err := c.FindGroups(ctx, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseFindGroupsResponse(rsp)
}

// AddGroupWithBodyWithResponse request with arbitrary body returning *AddGroupResponse
func (c *ClientWithResponses) AddGroupWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*AddGroupResponse, error) {
	rsp, err := c.AddGroupWithBody(ctx, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseAddGroupResponse(rsp)
}

func (c *ClientWithResponses) AddGroupWithResponse(ctx context.Context, body AddGroupJSONRequestBody, reqEditors ...RequestEditorFn) (*AddGroupResponse, error) {
	rsp, err := c.AddGroup(ctx, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseAddGroupResponse(rsp)
}

// DeleteGroupByUuidWithResponse request returning *DeleteGroupByUuidResponse
func (c *ClientWithResponses) DeleteGroupByUuidWithResponse(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*DeleteGroupByUuidResponse, error) {
	rsp, err := c.DeleteGroupByUuid(ctx, uuid, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDeleteGroupByUuidResponse(rsp)
}

// FindGroupByUuidWithResponse request returning *FindGroupByUuidResponse
func (c *ClientWithResponses) FindGroupByUuidWithResponse(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*FindGroupByUuidResponse, error) {
	rsp, err := c.FindGroupByUuid(ctx, uuid, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseFindGroupByUuidResponse(rsp)
}

// UpdateGroupByUuidWithBodyWithResponse request with arbitrary body returning *UpdateGroupByUuidResponse
func (c *ClientWithResponses) UpdateGroupByUuidWithBodyWithResponse(ctx context.Context, uuid UuidParam, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*UpdateGroupByUuidResponse, error) {
	rsp, err := c.UpdateGroupByUuidWithBody(ctx, uuid, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseUpdateGroupByUuidResponse(rsp)
}

func (c *ClientWithResponses) UpdateGroupByUuidWithResponse(ctx context.Context, uuid UuidParam, body UpdateGroupByUuidJSONRequestBody, reqEditors ...RequestEditorFn) (*UpdateGroupByUuidResponse, error) {
	rsp, err := c.UpdateGroupByUuid(ctx, uuid, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseUpdateGroupByUuidResponse(rsp)
}

// FindPoliciesForGroupWithResponse request returning *FindPoliciesForGroupResponse
func (c *ClientWithResponses) FindPoliciesForGroupWithResponse(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*FindPoliciesForGroupResponse, error) {
	rsp, err := c.FindPoliciesForGroup(ctx, uuid, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseFindPoliciesForGroupResponse(rsp)
}

// FindPoliciesWithResponse request returning *FindPoliciesResponse
func (c *ClientWithResponses) FindPoliciesWithResponse(ctx context.Context, params *FindPoliciesParams, reqEditors ...RequestEditorFn) (*FindPoliciesResponse, error) {
	rsp, err := c.FindPolicies(ctx, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseFindPoliciesResponse(rsp)
}

// AddPolicyWithBodyWithResponse request with arbitrary body returning *AddPolicyResponse
func (c *ClientWithResponses) AddPolicyWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*AddPolicyResponse, error) {
	rsp, err := c.AddPolicyWithBody(ctx, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseAddPolicyResponse(rsp)
}

func (c *ClientWithResponses) AddPolicyWithResponse(ctx context.Context, body AddPolicyJSONRequestBody, reqEditors ...RequestEditorFn) (*AddPolicyResponse, error) {
	rsp, err := c.AddPolicy(ctx, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseAddPolicyResponse(rsp)
}

// DeletePolicyByUuidWithResponse request returning *DeletePolicyByUuidResponse
func (c *ClientWithResponses) DeletePolicyByUuidWithResponse(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*DeletePolicyByUuidResponse, error) {
	rsp, err := c.DeletePolicyByUuid(ctx, uuid, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDeletePolicyByUuidResponse(rsp)
}

// FindPolicyByUuidWithResponse request returning *FindPolicyByUuidResponse
func (c *ClientWithResponses) FindPolicyByUuidWithResponse(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*FindPolicyByUuidResponse, error) {
	rsp, err := c.FindPolicyByUuid(ctx, uuid, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseFindPolicyByUuidResponse(rsp)
}

// UpdatePolicyByUuidWithBodyWithResponse request with arbitrary body returning *UpdatePolicyByUuidResponse
func (c *ClientWithResponses) UpdatePolicyByUuidWithBodyWithResponse(ctx context.Context, uuid UuidParam, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*UpdatePolicyByUuidResponse, error) {
	rsp, err := c.UpdatePolicyByUuidWithBody(ctx, uuid, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseUpdatePolicyByUuidResponse(rsp)
}

func (c *ClientWithResponses) UpdatePolicyByUuidWithResponse(ctx context.Context, uuid UuidParam, body UpdatePolicyByUuidJSONRequestBody, reqEditors ...RequestEditorFn) (*UpdatePolicyByUuidResponse, error) {
	rsp, err := c.UpdatePolicyByUuid(ctx, uuid, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseUpdatePolicyByUuidResponse(rsp)
}

// FindProgramsWithResponse request returning *FindProgramsResponse
func (c *ClientWithResponses) FindProgramsWithResponse(ctx context.Context, params *FindProgramsParams, reqEditors ...RequestEditorFn) (*FindProgramsResponse, error) {
	rsp, err := c.FindPrograms(ctx, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseFindProgramsResponse(rsp)
}

// AddProgramWithBodyWithResponse request with arbitrary body returning *AddProgramResponse
func (c *ClientWithResponses) AddProgramWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*AddProgramResponse, error) {
	rsp, err := c.AddProgramWithBody(ctx, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseAddProgramResponse(rsp)
}

func (c *ClientWithResponses) AddProgramWithResponse(ctx context.Context, body AddProgramJSONRequestBody, reqEditors ...RequestEditorFn) (*AddProgramResponse, error) {
	rsp, err := c.AddProgram(ctx, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseAddProgramResponse(rsp)
}

// DeleteProgramByUuidWithResponse request returning *DeleteProgramByUuidResponse
func (c *ClientWithResponses) DeleteProgramByUuidWithResponse(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*DeleteProgramByUuidResponse, error) {
	rsp, err := c.DeleteProgramByUuid(ctx, uuid, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDeleteProgramByUuidResponse(rsp)
}

// FindProgramByUuidWithResponse request returning *FindProgramByUuidResponse
func (c *ClientWithResponses) FindProgramByUuidWithResponse(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*FindProgramByUuidResponse, error) {
	rsp, err := c.FindProgramByUuid(ctx, uuid, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseFindProgramByUuidResponse(rsp)
}

// UpdateProgramByUuidWithBodyWithResponse request with arbitrary body returning *UpdateProgramByUuidResponse
func (c *ClientWithResponses) UpdateProgramByUuidWithBodyWithResponse(ctx context.Context, uuid UuidParam, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*UpdateProgramByUuidResponse, error) {
	rsp, err := c.UpdateProgramByUuidWithBody(ctx, uuid, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseUpdateProgramByUuidResponse(rsp)
}

func (c *ClientWithResponses) UpdateProgramByUuidWithResponse(ctx context.Context, uuid UuidParam, body UpdateProgramByUuidJSONRequestBody, reqEditors ...RequestEditorFn) (*UpdateProgramByUuidResponse, error) {
	rsp, err := c.UpdateProgramByUuid(ctx, uuid, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseUpdateProgramByUuidResponse(rsp)
}

// GetCodeFromProgramWithResponse request returning *GetCodeFromProgramResponse
func (c *ClientWithResponses) GetCodeFromProgramWithResponse(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*GetCodeFromProgramResponse, error) {
	rsp, err := c.GetCodeFromProgram(ctx, uuid, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetCodeFromProgramResponse(rsp)
}

// AddProgramCodeRevisionWithBodyWithResponse request with arbitrary body returning *AddProgramCodeRevisionResponse
func (c *ClientWithResponses) AddProgramCodeRevisionWithBodyWithResponse(ctx context.Context, uuid UuidParam, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*AddProgramCodeRevisionResponse, error) {
	rsp, err := c.AddProgramCodeRevisionWithBody(ctx, uuid, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseAddProgramCodeRevisionResponse(rsp)
}

// GetProgramCodeRevisionsDiffWithResponse request returning *GetProgramCodeRevisionsDiffResponse
func (c *ClientWithResponses) GetProgramCodeRevisionsDiffWithResponse(ctx context.Context, uuid UuidParam, params *GetProgramCodeRevisionsDiffParams, reqEditors ...RequestEditorFn) (*GetProgramCodeRevisionsDiffResponse, error) {
	rsp, err := c.GetProgramCodeRevisionsDiff(ctx, uuid, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetProgramCodeRevisionsDiffResponse(rsp)
}

// GetProgramCodeRevisionsWithResponse request returning *GetProgramCodeRevisionsResponse
func (c *ClientWithResponses) GetProgramCodeRevisionsWithResponse(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*GetProgramCodeRevisionsResponse, error) {
	rsp, err := c.GetProgramCodeRevisions(ctx, uuid, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetProgramCodeRevisionsResponse(rsp)
}

// DeleteProgramCodeRevisionsWithResponse request returning *DeleteProgramCodeRevisionsResponse
func (c *ClientWithResponses) DeleteProgramCodeRevisionsWithResponse(ctx context.Context, uuid UuidParam, revisionId int, reqEditors ...RequestEditorFn) (*DeleteProgramCodeRevisionsResponse, error) {
	rsp, err := c.DeleteProgramCodeRevisions(ctx, uuid, revisionId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDeleteProgramCodeRevisionsResponse(rsp)
}

// SignProgramCodeRevisionsWithResponse request returning *SignProgramCodeRevisionsResponse
func (c *ClientWithResponses) SignProgramCodeRevisionsWithResponse(ctx context.Context, uuid UuidParam, revisionId int, reqEditors ...RequestEditorFn) (*SignProgramCodeRevisionsResponse, error) {
	rsp, err := c.SignProgramCodeRevisions(ctx, uuid, revisionId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseSignProgramCodeRevisionsResponse(rsp)
}

// ExecuteProgramWebhookWithResponse request returning *ExecuteProgramWebhookResponse
func (c *ClientWithResponses) ExecuteProgramWebhookWithResponse(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*ExecuteProgramWebhookResponse, error) {
	rsp, err := c.ExecuteProgramWebhook(ctx, uuid, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseExecuteProgramWebhookResponse(rsp)
}

// FindThingsWithResponse request returning *FindThingsResponse
func (c *ClientWithResponses) FindThingsWithResponse(ctx context.Context, params *FindThingsParams, reqEditors ...RequestEditorFn) (*FindThingsResponse, error) {
	rsp, err := c.FindThings(ctx, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseFindThingsResponse(rsp)
}

// AddThingWithBodyWithResponse request with arbitrary body returning *AddThingResponse
func (c *ClientWithResponses) AddThingWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*AddThingResponse, error) {
	rsp, err := c.AddThingWithBody(ctx, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseAddThingResponse(rsp)
}

func (c *ClientWithResponses) AddThingWithResponse(ctx context.Context, body AddThingJSONRequestBody, reqEditors ...RequestEditorFn) (*AddThingResponse, error) {
	rsp, err := c.AddThing(ctx, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseAddThingResponse(rsp)
}

// DeleteThingByUuidWithResponse request returning *DeleteThingByUuidResponse
func (c *ClientWithResponses) DeleteThingByUuidWithResponse(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*DeleteThingByUuidResponse, error) {
	rsp, err := c.DeleteThingByUuid(ctx, uuid, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDeleteThingByUuidResponse(rsp)
}

// FindThingByUuidWithResponse request returning *FindThingByUuidResponse
func (c *ClientWithResponses) FindThingByUuidWithResponse(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*FindThingByUuidResponse, error) {
	rsp, err := c.FindThingByUuid(ctx, uuid, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseFindThingByUuidResponse(rsp)
}

// UpdateThingByUuidWithBodyWithResponse request with arbitrary body returning *UpdateThingByUuidResponse
func (c *ClientWithResponses) UpdateThingByUuidWithBodyWithResponse(ctx context.Context, uuid UuidParam, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*UpdateThingByUuidResponse, error) {
	rsp, err := c.UpdateThingByUuidWithBody(ctx, uuid, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseUpdateThingByUuidResponse(rsp)
}

func (c *ClientWithResponses) UpdateThingByUuidWithResponse(ctx context.Context, uuid UuidParam, body UpdateThingByUuidJSONRequestBody, reqEditors ...RequestEditorFn) (*UpdateThingByUuidResponse, error) {
	rsp, err := c.UpdateThingByUuid(ctx, uuid, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseUpdateThingByUuidResponse(rsp)
}

// FindDatasetsForThingWithResponse request returning *FindDatasetsForThingResponse
func (c *ClientWithResponses) FindDatasetsForThingWithResponse(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*FindDatasetsForThingResponse, error) {
	rsp, err := c.FindDatasetsForThing(ctx, uuid, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseFindDatasetsForThingResponse(rsp)
}

// FindTimeSeriesForThingWithResponse request returning *FindTimeSeriesForThingResponse
func (c *ClientWithResponses) FindTimeSeriesForThingWithResponse(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*FindTimeSeriesForThingResponse, error) {
	rsp, err := c.FindTimeSeriesForThing(ctx, uuid, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseFindTimeSeriesForThingResponse(rsp)
}

// FindTimeSeriesWithResponse request returning *FindTimeSeriesResponse
func (c *ClientWithResponses) FindTimeSeriesWithResponse(ctx context.Context, params *FindTimeSeriesParams, reqEditors ...RequestEditorFn) (*FindTimeSeriesResponse, error) {
	rsp, err := c.FindTimeSeries(ctx, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseFindTimeSeriesResponse(rsp)
}

// AddTimeSeriesWithBodyWithResponse request with arbitrary body returning *AddTimeSeriesResponse
func (c *ClientWithResponses) AddTimeSeriesWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*AddTimeSeriesResponse, error) {
	rsp, err := c.AddTimeSeriesWithBody(ctx, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseAddTimeSeriesResponse(rsp)
}

func (c *ClientWithResponses) AddTimeSeriesWithResponse(ctx context.Context, body AddTimeSeriesJSONRequestBody, reqEditors ...RequestEditorFn) (*AddTimeSeriesResponse, error) {
	rsp, err := c.AddTimeSeries(ctx, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseAddTimeSeriesResponse(rsp)
}

// DeleteTimeSeriesByUuidWithResponse request returning *DeleteTimeSeriesByUuidResponse
func (c *ClientWithResponses) DeleteTimeSeriesByUuidWithResponse(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*DeleteTimeSeriesByUuidResponse, error) {
	rsp, err := c.DeleteTimeSeriesByUuid(ctx, uuid, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDeleteTimeSeriesByUuidResponse(rsp)
}

// FindTimeSeriesByUuidWithResponse request returning *FindTimeSeriesByUuidResponse
func (c *ClientWithResponses) FindTimeSeriesByUuidWithResponse(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*FindTimeSeriesByUuidResponse, error) {
	rsp, err := c.FindTimeSeriesByUuid(ctx, uuid, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseFindTimeSeriesByUuidResponse(rsp)
}

// UpdateTimeseriesByUuidWithBodyWithResponse request with arbitrary body returning *UpdateTimeseriesByUuidResponse
func (c *ClientWithResponses) UpdateTimeseriesByUuidWithBodyWithResponse(ctx context.Context, uuid UuidParam, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*UpdateTimeseriesByUuidResponse, error) {
	rsp, err := c.UpdateTimeseriesByUuidWithBody(ctx, uuid, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseUpdateTimeseriesByUuidResponse(rsp)
}

func (c *ClientWithResponses) UpdateTimeseriesByUuidWithResponse(ctx context.Context, uuid UuidParam, body UpdateTimeseriesByUuidJSONRequestBody, reqEditors ...RequestEditorFn) (*UpdateTimeseriesByUuidResponse, error) {
	rsp, err := c.UpdateTimeseriesByUuid(ctx, uuid, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseUpdateTimeseriesByUuidResponse(rsp)
}

// DeleteDataFromTimeSeriesWithResponse request returning *DeleteDataFromTimeSeriesResponse
func (c *ClientWithResponses) DeleteDataFromTimeSeriesWithResponse(ctx context.Context, uuid UuidParam, params *DeleteDataFromTimeSeriesParams, reqEditors ...RequestEditorFn) (*DeleteDataFromTimeSeriesResponse, error) {
	rsp, err := c.DeleteDataFromTimeSeries(ctx, uuid, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDeleteDataFromTimeSeriesResponse(rsp)
}

// QueryTimeseriesForDataWithResponse request returning *QueryTimeseriesForDataResponse
func (c *ClientWithResponses) QueryTimeseriesForDataWithResponse(ctx context.Context, uuid UuidParam, params *QueryTimeseriesForDataParams, reqEditors ...RequestEditorFn) (*QueryTimeseriesForDataResponse, error) {
	rsp, err := c.QueryTimeseriesForData(ctx, uuid, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseQueryTimeseriesForDataResponse(rsp)
}

// AddDataToTimeseriesWithBodyWithResponse request with arbitrary body returning *AddDataToTimeseriesResponse
func (c *ClientWithResponses) AddDataToTimeseriesWithBodyWithResponse(ctx context.Context, uuid UuidParam, params *AddDataToTimeseriesParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*AddDataToTimeseriesResponse, error) {
	rsp, err := c.AddDataToTimeseriesWithBody(ctx, uuid, params, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseAddDataToTimeseriesResponse(rsp)
}

func (c *ClientWithResponses) AddDataToTimeseriesWithResponse(ctx context.Context, uuid UuidParam, params *AddDataToTimeseriesParams, body AddDataToTimeseriesJSONRequestBody, reqEditors ...RequestEditorFn) (*AddDataToTimeseriesResponse, error) {
	rsp, err := c.AddDataToTimeseries(ctx, uuid, params, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseAddDataToTimeseriesResponse(rsp)
}

// FindTsdataByQueryWithResponse request returning *FindTsdataByQueryResponse
func (c *ClientWithResponses) FindTsdataByQueryWithResponse(ctx context.Context, params *FindTsdataByQueryParams, reqEditors ...RequestEditorFn) (*FindTsdataByQueryResponse, error) {
	rsp, err := c.FindTsdataByQuery(ctx, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseFindTsdataByQueryResponse(rsp)
}

// FindUsersWithResponse request returning *FindUsersResponse
func (c *ClientWithResponses) FindUsersWithResponse(ctx context.Context, params *FindUsersParams, reqEditors ...RequestEditorFn) (*FindUsersResponse, error) {
	rsp, err := c.FindUsers(ctx, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseFindUsersResponse(rsp)
}

// AddUserWithBodyWithResponse request with arbitrary body returning *AddUserResponse
func (c *ClientWithResponses) AddUserWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*AddUserResponse, error) {
	rsp, err := c.AddUserWithBody(ctx, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseAddUserResponse(rsp)
}

func (c *ClientWithResponses) AddUserWithResponse(ctx context.Context, body AddUserJSONRequestBody, reqEditors ...RequestEditorFn) (*AddUserResponse, error) {
	rsp, err := c.AddUser(ctx, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseAddUserResponse(rsp)
}

// WhoamiWithResponse request returning *WhoamiResponse
func (c *ClientWithResponses) WhoamiWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*WhoamiResponse, error) {
	rsp, err := c.Whoami(ctx, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseWhoamiResponse(rsp)
}

// DeleteUserByUuidWithResponse request returning *DeleteUserByUuidResponse
func (c *ClientWithResponses) DeleteUserByUuidWithResponse(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*DeleteUserByUuidResponse, error) {
	rsp, err := c.DeleteUserByUuid(ctx, uuid, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDeleteUserByUuidResponse(rsp)
}

// FindUserByUuidWithResponse request returning *FindUserByUuidResponse
func (c *ClientWithResponses) FindUserByUuidWithResponse(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*FindUserByUuidResponse, error) {
	rsp, err := c.FindUserByUuid(ctx, uuid, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseFindUserByUuidResponse(rsp)
}

// UpdateUserByUuidWithBodyWithResponse request with arbitrary body returning *UpdateUserByUuidResponse
func (c *ClientWithResponses) UpdateUserByUuidWithBodyWithResponse(ctx context.Context, uuid UuidParam, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*UpdateUserByUuidResponse, error) {
	rsp, err := c.UpdateUserByUuidWithBody(ctx, uuid, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseUpdateUserByUuidResponse(rsp)
}

func (c *ClientWithResponses) UpdateUserByUuidWithResponse(ctx context.Context, uuid UuidParam, body UpdateUserByUuidJSONRequestBody, reqEditors ...RequestEditorFn) (*UpdateUserByUuidResponse, error) {
	rsp, err := c.UpdateUserByUuid(ctx, uuid, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseUpdateUserByUuidResponse(rsp)
}

// FindPoliciesForUserWithResponse request returning *FindPoliciesForUserResponse
func (c *ClientWithResponses) FindPoliciesForUserWithResponse(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*FindPoliciesForUserResponse, error) {
	rsp, err := c.FindPoliciesForUser(ctx, uuid, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseFindPoliciesForUserResponse(rsp)
}

// SetRequestRateForUserWithBodyWithResponse request with arbitrary body returning *SetRequestRateForUserResponse
func (c *ClientWithResponses) SetRequestRateForUserWithBodyWithResponse(ctx context.Context, uuid UuidParam, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*SetRequestRateForUserResponse, error) {
	rsp, err := c.SetRequestRateForUserWithBody(ctx, uuid, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseSetRequestRateForUserResponse(rsp)
}

func (c *ClientWithResponses) SetRequestRateForUserWithResponse(ctx context.Context, uuid UuidParam, body SetRequestRateForUserJSONRequestBody, reqEditors ...RequestEditorFn) (*SetRequestRateForUserResponse, error) {
	rsp, err := c.SetRequestRateForUser(ctx, uuid, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseSetRequestRateForUserResponse(rsp)
}

// FindTokensForUserWithResponse request returning *FindTokensForUserResponse
func (c *ClientWithResponses) FindTokensForUserWithResponse(ctx context.Context, uuid UuidParam, reqEditors ...RequestEditorFn) (*FindTokensForUserResponse, error) {
	rsp, err := c.FindTokensForUser(ctx, uuid, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseFindTokensForUserResponse(rsp)
}

// AddNewTokenToUserWithBodyWithResponse request with arbitrary body returning *AddNewTokenToUserResponse
func (c *ClientWithResponses) AddNewTokenToUserWithBodyWithResponse(ctx context.Context, uuid UuidParam, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*AddNewTokenToUserResponse, error) {
	rsp, err := c.AddNewTokenToUserWithBody(ctx, uuid, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseAddNewTokenToUserResponse(rsp)
}

func (c *ClientWithResponses) AddNewTokenToUserWithResponse(ctx context.Context, uuid UuidParam, body AddNewTokenToUserJSONRequestBody, reqEditors ...RequestEditorFn) (*AddNewTokenToUserResponse, error) {
	rsp, err := c.AddNewTokenToUser(ctx, uuid, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseAddNewTokenToUserResponse(rsp)
}

// DeleteTokenForUserWithResponse request returning *DeleteTokenForUserResponse
func (c *ClientWithResponses) DeleteTokenForUserWithResponse(ctx context.Context, uuid UuidParam, tokenUuid string, reqEditors ...RequestEditorFn) (*DeleteTokenForUserResponse, error) {
	rsp, err := c.DeleteTokenForUser(ctx, uuid, tokenUuid, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDeleteTokenForUserResponse(rsp)
}

// ParseFindAlertsResponse parses an HTTP response from a FindAlertsWithResponse call
func ParseFindAlertsResponse(rsp *http.Response) (*FindAlertsResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer rsp.Body.Close()
	if err != nil {
		return nil, err
	}

	response := &FindAlertsResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest Alert
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseCreateAlertResponse parses an HTTP response from a CreateAlertWithResponse call
func ParseCreateAlertResponse(rsp *http.Response) (*CreateAlertResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer rsp.Body.Close()
	if err != nil {
		return nil, err
	}

	response := &CreateAlertResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 201:
		var dest NewAlertReply
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON201 = &dest

	}

	return response, nil
}

// ParseDeleteAlertByUuidResponse parses an HTTP response from a DeleteAlertByUuidWithResponse call
func ParseDeleteAlertByUuidResponse(rsp *http.Response) (*DeleteAlertByUuidResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer rsp.Body.Close()
	if err != nil {
		return nil, err
	}

	response := &DeleteAlertByUuidResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	}

	return response, nil
}

// ParseFindAlertByUuidResponse parses an HTTP response from a FindAlertByUuidWithResponse call
func ParseFindAlertByUuidResponse(rsp *http.Response) (*FindAlertByUuidResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer rsp.Body.Close()
	if err != nil {
		return nil, err
	}

	response := &FindAlertByUuidResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest Alert
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseUpdateAlertByUuidResponse parses an HTTP response from a UpdateAlertByUuidWithResponse call
func ParseUpdateAlertByUuidResponse(rsp *http.Response) (*UpdateAlertByUuidResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer rsp.Body.Close()
	if err != nil {
		return nil, err
	}

	response := &UpdateAlertByUuidResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	}

	return response, nil
}

// ParseFindDatasetsResponse parses an HTTP response from a FindDatasetsWithResponse call
func ParseFindDatasetsResponse(rsp *http.Response) (*FindDatasetsResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer rsp.Body.Close()
	if err != nil {
		return nil, err
	}

	response := &FindDatasetsResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest []Dataset
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseAddDatasetsResponse parses an HTTP response from a AddDatasetsWithResponse call
func ParseAddDatasetsResponse(rsp *http.Response) (*AddDatasetsResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer rsp.Body.Close()
	if err != nil {
		return nil, err
	}

	response := &AddDatasetsResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 201:
		var dest Dataset
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON201 = &dest

	}

	return response, nil
}

// ParseDeleteDatasetByUuidResponse parses an HTTP response from a DeleteDatasetByUuidWithResponse call
func ParseDeleteDatasetByUuidResponse(rsp *http.Response) (*DeleteDatasetByUuidResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer rsp.Body.Close()
	if err != nil {
		return nil, err
	}

	response := &DeleteDatasetByUuidResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	}

	return response, nil
}

// ParseFindDatasetByUuidResponse parses an HTTP response from a FindDatasetByUuidWithResponse call
func ParseFindDatasetByUuidResponse(rsp *http.Response) (*FindDatasetByUuidResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer rsp.Body.Close()
	if err != nil {
		return nil, err
	}

	response := &FindDatasetByUuidResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest Dataset
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseUpdateDatasetByUuidResponse parses an HTTP response from a UpdateDatasetByUuidWithResponse call
func ParseUpdateDatasetByUuidResponse(rsp *http.Response) (*UpdateDatasetByUuidResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer rsp.Body.Close()
	if err != nil {
		return nil, err
	}

	response := &UpdateDatasetByUuidResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	}

	return response, nil
}

// ParseAssembleDatasetPartsByKeyResponse parses an HTTP response from a AssembleDatasetPartsByKeyWithResponse call
func ParseAssembleDatasetPartsByKeyResponse(rsp *http.Response) (*AssembleDatasetPartsByKeyResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer rsp.Body.Close()
	if err != nil {
		return nil, err
	}

	response := &AssembleDatasetPartsByKeyResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest struct {
			Message string `json:"message"`
		}
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	}

	return response, nil
}

// ParseListDatasetPartsByKeyResponse parses an HTTP response from a ListDatasetPartsByKeyWithResponse call
func ParseListDatasetPartsByKeyResponse(rsp *http.Response) (*ListDatasetPartsByKeyResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer rsp.Body.Close()
	if err != nil {
		return nil, err
	}

	response := &ListDatasetPartsByKeyResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	}

	return response, nil
}

// ParseUploadDatasetContentByKeyResponse parses an HTTP response from a UploadDatasetContentByKeyWithResponse call
func ParseUploadDatasetContentByKeyResponse(rsp *http.Response) (*UploadDatasetContentByKeyResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer rsp.Body.Close()
	if err != nil {
		return nil, err
	}

	response := &UploadDatasetContentByKeyResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest struct {
			Message string `json:"message"`
		}
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseGetRawDatasetByUuidResponse parses an HTTP response from a GetRawDatasetByUuidWithResponse call
func ParseGetRawDatasetByUuidResponse(rsp *http.Response) (*GetRawDatasetByUuidResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer rsp.Body.Close()
	if err != nil {
		return nil, err
	}

	response := &GetRawDatasetByUuidResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest string
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "xml") && rsp.StatusCode == 200:
		var dest string
		if err := xml.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.XML200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "yaml") && rsp.StatusCode == 200:
		var dest string
		if err := yaml.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.YAML200 = &dest

	case rsp.StatusCode == 200:
		// Content-type (text/plain; charset=utf-8) unsupported

	}

	return response, nil
}

// ParseDeleteDatasetUploadByKeyResponse parses an HTTP response from a DeleteDatasetUploadByKeyWithResponse call
func ParseDeleteDatasetUploadByKeyResponse(rsp *http.Response) (*DeleteDatasetUploadByKeyResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer rsp.Body.Close()
	if err != nil {
		return nil, err
	}

	response := &DeleteDatasetUploadByKeyResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	}

	return response, nil
}

// ParseInitializeDatasetUploadByUuidResponse parses an HTTP response from a InitializeDatasetUploadByUuidWithResponse call
func ParseInitializeDatasetUploadByUuidResponse(rsp *http.Response) (*InitializeDatasetUploadByUuidResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer rsp.Body.Close()
	if err != nil {
		return nil, err
	}

	response := &InitializeDatasetUploadByUuidResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest struct {
			UploadId *string `json:"uploadId,omitempty"`
		}
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseFindGroupsResponse parses an HTTP response from a FindGroupsWithResponse call
func ParseFindGroupsResponse(rsp *http.Response) (*FindGroupsResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer rsp.Body.Close()
	if err != nil {
		return nil, err
	}

	response := &FindGroupsResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest []Group
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseAddGroupResponse parses an HTTP response from a AddGroupWithResponse call
func ParseAddGroupResponse(rsp *http.Response) (*AddGroupResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer rsp.Body.Close()
	if err != nil {
		return nil, err
	}

	response := &AddGroupResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 201:
		var dest Group
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON201 = &dest

	}

	return response, nil
}

// ParseDeleteGroupByUuidResponse parses an HTTP response from a DeleteGroupByUuidWithResponse call
func ParseDeleteGroupByUuidResponse(rsp *http.Response) (*DeleteGroupByUuidResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer rsp.Body.Close()
	if err != nil {
		return nil, err
	}

	response := &DeleteGroupByUuidResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	}

	return response, nil
}

// ParseFindGroupByUuidResponse parses an HTTP response from a FindGroupByUuidWithResponse call
func ParseFindGroupByUuidResponse(rsp *http.Response) (*FindGroupByUuidResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer rsp.Body.Close()
	if err != nil {
		return nil, err
	}

	response := &FindGroupByUuidResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest Group
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseUpdateGroupByUuidResponse parses an HTTP response from a UpdateGroupByUuidWithResponse call
func ParseUpdateGroupByUuidResponse(rsp *http.Response) (*UpdateGroupByUuidResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer rsp.Body.Close()
	if err != nil {
		return nil, err
	}

	response := &UpdateGroupByUuidResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	}

	return response, nil
}

// ParseFindPoliciesForGroupResponse parses an HTTP response from a FindPoliciesForGroupWithResponse call
func ParseFindPoliciesForGroupResponse(rsp *http.Response) (*FindPoliciesForGroupResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer rsp.Body.Close()
	if err != nil {
		return nil, err
	}

	response := &FindPoliciesForGroupResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest []Policy
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseFindPoliciesResponse parses an HTTP response from a FindPoliciesWithResponse call
func ParseFindPoliciesResponse(rsp *http.Response) (*FindPoliciesResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer rsp.Body.Close()
	if err != nil {
		return nil, err
	}

	response := &FindPoliciesResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest []Policy
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseAddPolicyResponse parses an HTTP response from a AddPolicyWithResponse call
func ParseAddPolicyResponse(rsp *http.Response) (*AddPolicyResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer rsp.Body.Close()
	if err != nil {
		return nil, err
	}

	response := &AddPolicyResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 201:
		var dest Policy
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON201 = &dest

	}

	return response, nil
}

// ParseDeletePolicyByUuidResponse parses an HTTP response from a DeletePolicyByUuidWithResponse call
func ParseDeletePolicyByUuidResponse(rsp *http.Response) (*DeletePolicyByUuidResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer rsp.Body.Close()
	if err != nil {
		return nil, err
	}

	response := &DeletePolicyByUuidResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	}

	return response, nil
}

// ParseFindPolicyByUuidResponse parses an HTTP response from a FindPolicyByUuidWithResponse call
func ParseFindPolicyByUuidResponse(rsp *http.Response) (*FindPolicyByUuidResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer rsp.Body.Close()
	if err != nil {
		return nil, err
	}

	response := &FindPolicyByUuidResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest Policy
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseUpdatePolicyByUuidResponse parses an HTTP response from a UpdatePolicyByUuidWithResponse call
func ParseUpdatePolicyByUuidResponse(rsp *http.Response) (*UpdatePolicyByUuidResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer rsp.Body.Close()
	if err != nil {
		return nil, err
	}

	response := &UpdatePolicyByUuidResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	}

	return response, nil
}

// ParseFindProgramsResponse parses an HTTP response from a FindProgramsWithResponse call
func ParseFindProgramsResponse(rsp *http.Response) (*FindProgramsResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer rsp.Body.Close()
	if err != nil {
		return nil, err
	}

	response := &FindProgramsResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest []Program
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseAddProgramResponse parses an HTTP response from a AddProgramWithResponse call
func ParseAddProgramResponse(rsp *http.Response) (*AddProgramResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer rsp.Body.Close()
	if err != nil {
		return nil, err
	}

	response := &AddProgramResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 201:
		var dest Program
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON201 = &dest

	}

	return response, nil
}

// ParseDeleteProgramByUuidResponse parses an HTTP response from a DeleteProgramByUuidWithResponse call
func ParseDeleteProgramByUuidResponse(rsp *http.Response) (*DeleteProgramByUuidResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer rsp.Body.Close()
	if err != nil {
		return nil, err
	}

	response := &DeleteProgramByUuidResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	}

	return response, nil
}

// ParseFindProgramByUuidResponse parses an HTTP response from a FindProgramByUuidWithResponse call
func ParseFindProgramByUuidResponse(rsp *http.Response) (*FindProgramByUuidResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer rsp.Body.Close()
	if err != nil {
		return nil, err
	}

	response := &FindProgramByUuidResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest Program
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseUpdateProgramByUuidResponse parses an HTTP response from a UpdateProgramByUuidWithResponse call
func ParseUpdateProgramByUuidResponse(rsp *http.Response) (*UpdateProgramByUuidResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer rsp.Body.Close()
	if err != nil {
		return nil, err
	}

	response := &UpdateProgramByUuidResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	}

	return response, nil
}

// ParseGetCodeFromProgramResponse parses an HTTP response from a GetCodeFromProgramWithResponse call
func ParseGetCodeFromProgramResponse(rsp *http.Response) (*GetCodeFromProgramResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer rsp.Body.Close()
	if err != nil {
		return nil, err
	}

	response := &GetCodeFromProgramResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest Program
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseAddProgramCodeRevisionResponse parses an HTTP response from a AddProgramCodeRevisionWithResponse call
func ParseAddProgramCodeRevisionResponse(rsp *http.Response) (*AddProgramCodeRevisionResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer rsp.Body.Close()
	if err != nil {
		return nil, err
	}

	response := &AddProgramCodeRevisionResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 201:
		var dest CodeRevision
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON201 = &dest

	}

	return response, nil
}

// ParseGetProgramCodeRevisionsDiffResponse parses an HTTP response from a GetProgramCodeRevisionsDiffWithResponse call
func ParseGetProgramCodeRevisionsDiffResponse(rsp *http.Response) (*GetProgramCodeRevisionsDiffResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer rsp.Body.Close()
	if err != nil {
		return nil, err
	}

	response := &GetProgramCodeRevisionsDiffResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	}

	return response, nil
}

// ParseGetProgramCodeRevisionsResponse parses an HTTP response from a GetProgramCodeRevisionsWithResponse call
func ParseGetProgramCodeRevisionsResponse(rsp *http.Response) (*GetProgramCodeRevisionsResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer rsp.Body.Close()
	if err != nil {
		return nil, err
	}

	response := &GetProgramCodeRevisionsResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest []CodeRevision
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseDeleteProgramCodeRevisionsResponse parses an HTTP response from a DeleteProgramCodeRevisionsWithResponse call
func ParseDeleteProgramCodeRevisionsResponse(rsp *http.Response) (*DeleteProgramCodeRevisionsResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer rsp.Body.Close()
	if err != nil {
		return nil, err
	}

	response := &DeleteProgramCodeRevisionsResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	}

	return response, nil
}

// ParseSignProgramCodeRevisionsResponse parses an HTTP response from a SignProgramCodeRevisionsWithResponse call
func ParseSignProgramCodeRevisionsResponse(rsp *http.Response) (*SignProgramCodeRevisionsResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer rsp.Body.Close()
	if err != nil {
		return nil, err
	}

	response := &SignProgramCodeRevisionsResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	}

	return response, nil
}

// ParseExecuteProgramWebhookResponse parses an HTTP response from a ExecuteProgramWebhookWithResponse call
func ParseExecuteProgramWebhookResponse(rsp *http.Response) (*ExecuteProgramWebhookResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer rsp.Body.Close()
	if err != nil {
		return nil, err
	}

	response := &ExecuteProgramWebhookResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	}

	return response, nil
}

// ParseFindThingsResponse parses an HTTP response from a FindThingsWithResponse call
func ParseFindThingsResponse(rsp *http.Response) (*FindThingsResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer rsp.Body.Close()
	if err != nil {
		return nil, err
	}

	response := &FindThingsResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest []Thing
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseAddThingResponse parses an HTTP response from a AddThingWithResponse call
func ParseAddThingResponse(rsp *http.Response) (*AddThingResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer rsp.Body.Close()
	if err != nil {
		return nil, err
	}

	response := &AddThingResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 201:
		var dest Thing
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON201 = &dest

	}

	return response, nil
}

// ParseDeleteThingByUuidResponse parses an HTTP response from a DeleteThingByUuidWithResponse call
func ParseDeleteThingByUuidResponse(rsp *http.Response) (*DeleteThingByUuidResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer rsp.Body.Close()
	if err != nil {
		return nil, err
	}

	response := &DeleteThingByUuidResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	}

	return response, nil
}

// ParseFindThingByUuidResponse parses an HTTP response from a FindThingByUuidWithResponse call
func ParseFindThingByUuidResponse(rsp *http.Response) (*FindThingByUuidResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer rsp.Body.Close()
	if err != nil {
		return nil, err
	}

	response := &FindThingByUuidResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest Thing
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseUpdateThingByUuidResponse parses an HTTP response from a UpdateThingByUuidWithResponse call
func ParseUpdateThingByUuidResponse(rsp *http.Response) (*UpdateThingByUuidResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer rsp.Body.Close()
	if err != nil {
		return nil, err
	}

	response := &UpdateThingByUuidResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	}

	return response, nil
}

// ParseFindDatasetsForThingResponse parses an HTTP response from a FindDatasetsForThingWithResponse call
func ParseFindDatasetsForThingResponse(rsp *http.Response) (*FindDatasetsForThingResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer rsp.Body.Close()
	if err != nil {
		return nil, err
	}

	response := &FindDatasetsForThingResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest []Timeseries
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseFindTimeSeriesForThingResponse parses an HTTP response from a FindTimeSeriesForThingWithResponse call
func ParseFindTimeSeriesForThingResponse(rsp *http.Response) (*FindTimeSeriesForThingResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer rsp.Body.Close()
	if err != nil {
		return nil, err
	}

	response := &FindTimeSeriesForThingResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest []Timeseries
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseFindTimeSeriesResponse parses an HTTP response from a FindTimeSeriesWithResponse call
func ParseFindTimeSeriesResponse(rsp *http.Response) (*FindTimeSeriesResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer rsp.Body.Close()
	if err != nil {
		return nil, err
	}

	response := &FindTimeSeriesResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest []Timeseries
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseAddTimeSeriesResponse parses an HTTP response from a AddTimeSeriesWithResponse call
func ParseAddTimeSeriesResponse(rsp *http.Response) (*AddTimeSeriesResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer rsp.Body.Close()
	if err != nil {
		return nil, err
	}

	response := &AddTimeSeriesResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 201:
		var dest Timeseries
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON201 = &dest

	}

	return response, nil
}

// ParseDeleteTimeSeriesByUuidResponse parses an HTTP response from a DeleteTimeSeriesByUuidWithResponse call
func ParseDeleteTimeSeriesByUuidResponse(rsp *http.Response) (*DeleteTimeSeriesByUuidResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer rsp.Body.Close()
	if err != nil {
		return nil, err
	}

	response := &DeleteTimeSeriesByUuidResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	}

	return response, nil
}

// ParseFindTimeSeriesByUuidResponse parses an HTTP response from a FindTimeSeriesByUuidWithResponse call
func ParseFindTimeSeriesByUuidResponse(rsp *http.Response) (*FindTimeSeriesByUuidResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer rsp.Body.Close()
	if err != nil {
		return nil, err
	}

	response := &FindTimeSeriesByUuidResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest Timeseries
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseUpdateTimeseriesByUuidResponse parses an HTTP response from a UpdateTimeseriesByUuidWithResponse call
func ParseUpdateTimeseriesByUuidResponse(rsp *http.Response) (*UpdateTimeseriesByUuidResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer rsp.Body.Close()
	if err != nil {
		return nil, err
	}

	response := &UpdateTimeseriesByUuidResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	}

	return response, nil
}

// ParseDeleteDataFromTimeSeriesResponse parses an HTTP response from a DeleteDataFromTimeSeriesWithResponse call
func ParseDeleteDataFromTimeSeriesResponse(rsp *http.Response) (*DeleteDataFromTimeSeriesResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer rsp.Body.Close()
	if err != nil {
		return nil, err
	}

	response := &DeleteDataFromTimeSeriesResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	}

	return response, nil
}

// ParseQueryTimeseriesForDataResponse parses an HTTP response from a QueryTimeseriesForDataWithResponse call
func ParseQueryTimeseriesForDataResponse(rsp *http.Response) (*QueryTimeseriesForDataResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer rsp.Body.Close()
	if err != nil {
		return nil, err
	}

	response := &QueryTimeseriesForDataResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest []TsRow
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseAddDataToTimeseriesResponse parses an HTTP response from a AddDataToTimeseriesWithResponse call
func ParseAddDataToTimeseriesResponse(rsp *http.Response) (*AddDataToTimeseriesResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer rsp.Body.Close()
	if err != nil {
		return nil, err
	}

	response := &AddDataToTimeseriesResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	}

	return response, nil
}

// ParseFindTsdataByQueryResponse parses an HTTP response from a FindTsdataByQueryWithResponse call
func ParseFindTsdataByQueryResponse(rsp *http.Response) (*FindTsdataByQueryResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer rsp.Body.Close()
	if err != nil {
		return nil, err
	}

	response := &FindTsdataByQueryResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest []TsResults
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseFindUsersResponse parses an HTTP response from a FindUsersWithResponse call
func ParseFindUsersResponse(rsp *http.Response) (*FindUsersResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer rsp.Body.Close()
	if err != nil {
		return nil, err
	}

	response := &FindUsersResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest []User
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseAddUserResponse parses an HTTP response from a AddUserWithResponse call
func ParseAddUserResponse(rsp *http.Response) (*AddUserResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer rsp.Body.Close()
	if err != nil {
		return nil, err
	}

	response := &AddUserResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 201:
		var dest User
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON201 = &dest

	}

	return response, nil
}

// ParseWhoamiResponse parses an HTTP response from a WhoamiWithResponse call
func ParseWhoamiResponse(rsp *http.Response) (*WhoamiResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer rsp.Body.Close()
	if err != nil {
		return nil, err
	}

	response := &WhoamiResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest []User
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseDeleteUserByUuidResponse parses an HTTP response from a DeleteUserByUuidWithResponse call
func ParseDeleteUserByUuidResponse(rsp *http.Response) (*DeleteUserByUuidResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer rsp.Body.Close()
	if err != nil {
		return nil, err
	}

	response := &DeleteUserByUuidResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	}

	return response, nil
}

// ParseFindUserByUuidResponse parses an HTTP response from a FindUserByUuidWithResponse call
func ParseFindUserByUuidResponse(rsp *http.Response) (*FindUserByUuidResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer rsp.Body.Close()
	if err != nil {
		return nil, err
	}

	response := &FindUserByUuidResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest User
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseUpdateUserByUuidResponse parses an HTTP response from a UpdateUserByUuidWithResponse call
func ParseUpdateUserByUuidResponse(rsp *http.Response) (*UpdateUserByUuidResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer rsp.Body.Close()
	if err != nil {
		return nil, err
	}

	response := &UpdateUserByUuidResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	}

	return response, nil
}

// ParseFindPoliciesForUserResponse parses an HTTP response from a FindPoliciesForUserWithResponse call
func ParseFindPoliciesForUserResponse(rsp *http.Response) (*FindPoliciesForUserResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer rsp.Body.Close()
	if err != nil {
		return nil, err
	}

	response := &FindPoliciesForUserResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest []Policy
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseSetRequestRateForUserResponse parses an HTTP response from a SetRequestRateForUserWithResponse call
func ParseSetRequestRateForUserResponse(rsp *http.Response) (*SetRequestRateForUserResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer rsp.Body.Close()
	if err != nil {
		return nil, err
	}

	response := &SetRequestRateForUserResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	}

	return response, nil
}

// ParseFindTokensForUserResponse parses an HTTP response from a FindTokensForUserWithResponse call
func ParseFindTokensForUserResponse(rsp *http.Response) (*FindTokensForUserResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer rsp.Body.Close()
	if err != nil {
		return nil, err
	}

	response := &FindTokensForUserResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest []Token
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseAddNewTokenToUserResponse parses an HTTP response from a AddNewTokenToUserWithResponse call
func ParseAddNewTokenToUserResponse(rsp *http.Response) (*AddNewTokenToUserResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer rsp.Body.Close()
	if err != nil {
		return nil, err
	}

	response := &AddNewTokenToUserResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 201:
		var dest TokenWithSecret
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON201 = &dest

	}

	return response, nil
}

// ParseDeleteTokenForUserResponse parses an HTTP response from a DeleteTokenForUserWithResponse call
func ParseDeleteTokenForUserResponse(rsp *http.Response) (*DeleteTokenForUserResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer rsp.Body.Close()
	if err != nil {
		return nil, err
	}

	response := &DeleteTokenForUserResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	}

	return response, nil
}