client_gen.go

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

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

	"github.com/oapi-codegen/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 {
	// GetAliases request
	GetAliases(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DeleteAlias request
	DeleteAlias(ctx context.Context, aliasName string, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetAlias request
	GetAlias(ctx context.Context, aliasName string, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	UpsertAlias(ctx context.Context, aliasName string, body UpsertAliasJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	CreateAnalyticsEvent(ctx context.Context, body CreateAnalyticsEventJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

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

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

	CreateAnalyticsRule(ctx context.Context, body CreateAnalyticsRuleJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DeleteAnalyticsRule request
	DeleteAnalyticsRule(ctx context.Context, ruleName string, reqEditors ...RequestEditorFn) (*http.Response, error)

	// RetrieveAnalyticsRule request
	RetrieveAnalyticsRule(ctx context.Context, ruleName string, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	UpsertAnalyticsRule(ctx context.Context, ruleName string, body UpsertAnalyticsRuleJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

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

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

	CreateCollection(ctx context.Context, body CreateCollectionJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DeleteCollection request
	DeleteCollection(ctx context.Context, collectionName string, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetCollection request
	GetCollection(ctx context.Context, collectionName string, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	UpdateCollection(ctx context.Context, collectionName string, body UpdateCollectionJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DeleteDocuments request
	DeleteDocuments(ctx context.Context, collectionName string, params *DeleteDocumentsParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// UpdateDocumentsWithBody request with any body
	UpdateDocumentsWithBody(ctx context.Context, collectionName string, params *UpdateDocumentsParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	UpdateDocuments(ctx context.Context, collectionName string, params *UpdateDocumentsParams, body UpdateDocumentsJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// IndexDocumentWithBody request with any body
	IndexDocumentWithBody(ctx context.Context, collectionName string, params *IndexDocumentParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	IndexDocument(ctx context.Context, collectionName string, params *IndexDocumentParams, body IndexDocumentJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ExportDocuments request
	ExportDocuments(ctx context.Context, collectionName string, params *ExportDocumentsParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ImportDocumentsWithBody request with any body
	ImportDocumentsWithBody(ctx context.Context, collectionName string, params *ImportDocumentsParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	// SearchCollection request
	SearchCollection(ctx context.Context, collectionName string, params *SearchCollectionParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DeleteDocument request
	DeleteDocument(ctx context.Context, collectionName string, documentId string, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetDocument request
	GetDocument(ctx context.Context, collectionName string, documentId string, reqEditors ...RequestEditorFn) (*http.Response, error)

	// UpdateDocumentWithBody request with any body
	UpdateDocumentWithBody(ctx context.Context, collectionName string, documentId string, params *UpdateDocumentParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	UpdateDocument(ctx context.Context, collectionName string, documentId string, params *UpdateDocumentParams, body UpdateDocumentJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetSearchOverrides request
	GetSearchOverrides(ctx context.Context, collectionName string, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DeleteSearchOverride request
	DeleteSearchOverride(ctx context.Context, collectionName string, overrideId string, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetSearchOverride request
	GetSearchOverride(ctx context.Context, collectionName string, overrideId string, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	UpsertSearchOverride(ctx context.Context, collectionName string, overrideId string, body UpsertSearchOverrideJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetSearchSynonyms request
	GetSearchSynonyms(ctx context.Context, collectionName string, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DeleteSearchSynonym request
	DeleteSearchSynonym(ctx context.Context, collectionName string, synonymId string, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetSearchSynonym request
	GetSearchSynonym(ctx context.Context, collectionName string, synonymId string, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	UpsertSearchSynonym(ctx context.Context, collectionName string, synonymId string, body UpsertSearchSynonymJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

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

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

	CreateConversationModel(ctx context.Context, body CreateConversationModelJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DeleteConversationModel request
	DeleteConversationModel(ctx context.Context, modelId string, reqEditors ...RequestEditorFn) (*http.Response, error)

	// RetrieveConversationModel request
	RetrieveConversationModel(ctx context.Context, modelId string, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	UpdateConversationModel(ctx context.Context, modelId string, body UpdateConversationModelJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

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

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

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

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

	CreateKey(ctx context.Context, body CreateKeyJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DeleteKey request
	DeleteKey(ctx context.Context, keyId int64, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetKey request
	GetKey(ctx context.Context, keyId int64, reqEditors ...RequestEditorFn) (*http.Response, error)

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

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

	MultiSearch(ctx context.Context, params *MultiSearchParams, body MultiSearchJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

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

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

	CreateNLSearchModel(ctx context.Context, body CreateNLSearchModelJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DeleteNLSearchModel request
	DeleteNLSearchModel(ctx context.Context, modelId string, reqEditors ...RequestEditorFn) (*http.Response, error)

	// RetrieveNLSearchModel request
	RetrieveNLSearchModel(ctx context.Context, modelId string, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	UpdateNLSearchModel(ctx context.Context, modelId string, body UpdateNLSearchModelJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

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

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

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

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

	// DeletePreset request
	DeletePreset(ctx context.Context, presetId string, reqEditors ...RequestEditorFn) (*http.Response, error)

	// RetrievePreset request
	RetrievePreset(ctx context.Context, presetId string, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	UpsertPreset(ctx context.Context, presetId string, body UpsertPresetJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

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

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

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

	ImportStemmingDictionary(ctx context.Context, params *ImportStemmingDictionaryParams, body ImportStemmingDictionaryJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetStemmingDictionary request
	GetStemmingDictionary(ctx context.Context, dictionaryId string, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	// DeleteStopwordsSet request
	DeleteStopwordsSet(ctx context.Context, setId string, reqEditors ...RequestEditorFn) (*http.Response, error)

	// RetrieveStopwordsSet request
	RetrieveStopwordsSet(ctx context.Context, setId string, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	UpsertStopwordsSet(ctx context.Context, setId string, body UpsertStopwordsSetJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)
}

func (c *Client) GetAliases(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetAliasesRequest(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) DeleteAlias(ctx context.Context, aliasName string, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDeleteAliasRequest(c.Server, aliasName)
	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) GetAlias(ctx context.Context, aliasName string, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetAliasRequest(c.Server, aliasName)
	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) UpsertAliasWithBody(ctx context.Context, aliasName string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewUpsertAliasRequestWithBody(c.Server, aliasName, 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) UpsertAlias(ctx context.Context, aliasName string, body UpsertAliasJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewUpsertAliasRequest(c.Server, aliasName, 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) CreateAnalyticsEventWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewCreateAnalyticsEventRequestWithBody(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) CreateAnalyticsEvent(ctx context.Context, body CreateAnalyticsEventJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewCreateAnalyticsEventRequest(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) RetrieveAnalyticsRules(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewRetrieveAnalyticsRulesRequest(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) CreateAnalyticsRuleWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewCreateAnalyticsRuleRequestWithBody(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) CreateAnalyticsRule(ctx context.Context, body CreateAnalyticsRuleJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewCreateAnalyticsRuleRequest(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) DeleteAnalyticsRule(ctx context.Context, ruleName string, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDeleteAnalyticsRuleRequest(c.Server, ruleName)
	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) RetrieveAnalyticsRule(ctx context.Context, ruleName string, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewRetrieveAnalyticsRuleRequest(c.Server, ruleName)
	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) UpsertAnalyticsRuleWithBody(ctx context.Context, ruleName string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewUpsertAnalyticsRuleRequestWithBody(c.Server, ruleName, 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) UpsertAnalyticsRule(ctx context.Context, ruleName string, body UpsertAnalyticsRuleJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewUpsertAnalyticsRuleRequest(c.Server, ruleName, 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) GetCollections(ctx context.Context, params *GetCollectionsParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetCollectionsRequest(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) CreateCollectionWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewCreateCollectionRequestWithBody(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) CreateCollection(ctx context.Context, body CreateCollectionJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewCreateCollectionRequest(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) DeleteCollection(ctx context.Context, collectionName string, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDeleteCollectionRequest(c.Server, collectionName)
	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) GetCollection(ctx context.Context, collectionName string, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetCollectionRequest(c.Server, collectionName)
	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) UpdateCollectionWithBody(ctx context.Context, collectionName string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewUpdateCollectionRequestWithBody(c.Server, collectionName, 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) UpdateCollection(ctx context.Context, collectionName string, body UpdateCollectionJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewUpdateCollectionRequest(c.Server, collectionName, 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) DeleteDocuments(ctx context.Context, collectionName string, params *DeleteDocumentsParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDeleteDocumentsRequest(c.Server, collectionName, 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) UpdateDocumentsWithBody(ctx context.Context, collectionName string, params *UpdateDocumentsParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewUpdateDocumentsRequestWithBody(c.Server, collectionName, 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) UpdateDocuments(ctx context.Context, collectionName string, params *UpdateDocumentsParams, body UpdateDocumentsJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewUpdateDocumentsRequest(c.Server, collectionName, 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) IndexDocumentWithBody(ctx context.Context, collectionName string, params *IndexDocumentParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewIndexDocumentRequestWithBody(c.Server, collectionName, 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) IndexDocument(ctx context.Context, collectionName string, params *IndexDocumentParams, body IndexDocumentJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewIndexDocumentRequest(c.Server, collectionName, 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) ExportDocuments(ctx context.Context, collectionName string, params *ExportDocumentsParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewExportDocumentsRequest(c.Server, collectionName, 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) ImportDocumentsWithBody(ctx context.Context, collectionName string, params *ImportDocumentsParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewImportDocumentsRequestWithBody(c.Server, collectionName, 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) SearchCollection(ctx context.Context, collectionName string, params *SearchCollectionParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewSearchCollectionRequest(c.Server, collectionName, 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) DeleteDocument(ctx context.Context, collectionName string, documentId string, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDeleteDocumentRequest(c.Server, collectionName, documentId)
	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) GetDocument(ctx context.Context, collectionName string, documentId string, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetDocumentRequest(c.Server, collectionName, documentId)
	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) UpdateDocumentWithBody(ctx context.Context, collectionName string, documentId string, params *UpdateDocumentParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewUpdateDocumentRequestWithBody(c.Server, collectionName, documentId, 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) UpdateDocument(ctx context.Context, collectionName string, documentId string, params *UpdateDocumentParams, body UpdateDocumentJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewUpdateDocumentRequest(c.Server, collectionName, documentId, 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) GetSearchOverrides(ctx context.Context, collectionName string, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetSearchOverridesRequest(c.Server, collectionName)
	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) DeleteSearchOverride(ctx context.Context, collectionName string, overrideId string, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDeleteSearchOverrideRequest(c.Server, collectionName, overrideId)
	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) GetSearchOverride(ctx context.Context, collectionName string, overrideId string, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetSearchOverrideRequest(c.Server, collectionName, overrideId)
	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) UpsertSearchOverrideWithBody(ctx context.Context, collectionName string, overrideId string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewUpsertSearchOverrideRequestWithBody(c.Server, collectionName, overrideId, 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) UpsertSearchOverride(ctx context.Context, collectionName string, overrideId string, body UpsertSearchOverrideJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewUpsertSearchOverrideRequest(c.Server, collectionName, overrideId, 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) GetSearchSynonyms(ctx context.Context, collectionName string, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetSearchSynonymsRequest(c.Server, collectionName)
	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) DeleteSearchSynonym(ctx context.Context, collectionName string, synonymId string, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDeleteSearchSynonymRequest(c.Server, collectionName, synonymId)
	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) GetSearchSynonym(ctx context.Context, collectionName string, synonymId string, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetSearchSynonymRequest(c.Server, collectionName, synonymId)
	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) UpsertSearchSynonymWithBody(ctx context.Context, collectionName string, synonymId string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewUpsertSearchSynonymRequestWithBody(c.Server, collectionName, synonymId, 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) UpsertSearchSynonym(ctx context.Context, collectionName string, synonymId string, body UpsertSearchSynonymJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewUpsertSearchSynonymRequest(c.Server, collectionName, synonymId, 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) RetrieveAllConversationModels(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewRetrieveAllConversationModelsRequest(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) CreateConversationModelWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewCreateConversationModelRequestWithBody(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) CreateConversationModel(ctx context.Context, body CreateConversationModelJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewCreateConversationModelRequest(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) DeleteConversationModel(ctx context.Context, modelId string, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDeleteConversationModelRequest(c.Server, modelId)
	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) RetrieveConversationModel(ctx context.Context, modelId string, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewRetrieveConversationModelRequest(c.Server, modelId)
	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) UpdateConversationModelWithBody(ctx context.Context, modelId string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewUpdateConversationModelRequestWithBody(c.Server, modelId, 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) UpdateConversationModel(ctx context.Context, modelId string, body UpdateConversationModelJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewUpdateConversationModelRequest(c.Server, modelId, 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) Debug(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDebugRequest(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) Health(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewHealthRequest(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) GetKeys(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetKeysRequest(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) CreateKeyWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewCreateKeyRequestWithBody(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) CreateKey(ctx context.Context, body CreateKeyJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewCreateKeyRequest(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) DeleteKey(ctx context.Context, keyId int64, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDeleteKeyRequest(c.Server, keyId)
	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) GetKey(ctx context.Context, keyId int64, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetKeyRequest(c.Server, keyId)
	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) RetrieveMetrics(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewRetrieveMetricsRequest(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) MultiSearchWithBody(ctx context.Context, params *MultiSearchParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewMultiSearchRequestWithBody(c.Server, 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) MultiSearch(ctx context.Context, params *MultiSearchParams, body MultiSearchJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewMultiSearchRequest(c.Server, 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) RetrieveAllNLSearchModels(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewRetrieveAllNLSearchModelsRequest(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) CreateNLSearchModelWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewCreateNLSearchModelRequestWithBody(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) CreateNLSearchModel(ctx context.Context, body CreateNLSearchModelJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewCreateNLSearchModelRequest(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) DeleteNLSearchModel(ctx context.Context, modelId string, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDeleteNLSearchModelRequest(c.Server, modelId)
	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) RetrieveNLSearchModel(ctx context.Context, modelId string, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewRetrieveNLSearchModelRequest(c.Server, modelId)
	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) UpdateNLSearchModelWithBody(ctx context.Context, modelId string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewUpdateNLSearchModelRequestWithBody(c.Server, modelId, 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) UpdateNLSearchModel(ctx context.Context, modelId string, body UpdateNLSearchModelJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewUpdateNLSearchModelRequest(c.Server, modelId, 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) GetSchemaChanges(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetSchemaChangesRequest(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) TakeSnapshot(ctx context.Context, params *TakeSnapshotParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewTakeSnapshotRequest(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) Vote(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewVoteRequest(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) RetrieveAllPresets(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewRetrieveAllPresetsRequest(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) DeletePreset(ctx context.Context, presetId string, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDeletePresetRequest(c.Server, presetId)
	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) RetrievePreset(ctx context.Context, presetId string, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewRetrievePresetRequest(c.Server, presetId)
	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) UpsertPresetWithBody(ctx context.Context, presetId string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewUpsertPresetRequestWithBody(c.Server, presetId, 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) UpsertPreset(ctx context.Context, presetId string, body UpsertPresetJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewUpsertPresetRequest(c.Server, presetId, 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) RetrieveAPIStats(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewRetrieveAPIStatsRequest(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) ListStemmingDictionaries(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewListStemmingDictionariesRequest(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) ImportStemmingDictionaryWithBody(ctx context.Context, params *ImportStemmingDictionaryParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewImportStemmingDictionaryRequestWithBody(c.Server, 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) ImportStemmingDictionary(ctx context.Context, params *ImportStemmingDictionaryParams, body ImportStemmingDictionaryJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewImportStemmingDictionaryRequest(c.Server, 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) GetStemmingDictionary(ctx context.Context, dictionaryId string, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetStemmingDictionaryRequest(c.Server, dictionaryId)
	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) RetrieveStopwordsSets(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewRetrieveStopwordsSetsRequest(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) DeleteStopwordsSet(ctx context.Context, setId string, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDeleteStopwordsSetRequest(c.Server, setId)
	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) RetrieveStopwordsSet(ctx context.Context, setId string, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewRetrieveStopwordsSetRequest(c.Server, setId)
	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) UpsertStopwordsSetWithBody(ctx context.Context, setId string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewUpsertStopwordsSetRequestWithBody(c.Server, setId, 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) UpsertStopwordsSet(ctx context.Context, setId string, body UpsertStopwordsSetJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewUpsertStopwordsSetRequest(c.Server, setId, 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)
}

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

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

	operationPath := fmt.Sprintf("/aliases")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

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

	return req, nil
}

// NewDeleteAliasRequest generates requests for DeleteAlias
func NewDeleteAliasRequest(server string, aliasName string) (*http.Request, error) {
	var err error

	var pathParam0 string

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

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

	operationPath := fmt.Sprintf("/aliases/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

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

	return req, nil
}

// NewGetAliasRequest generates requests for GetAlias
func NewGetAliasRequest(server string, aliasName string) (*http.Request, error) {
	var err error

	var pathParam0 string

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

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

	operationPath := fmt.Sprintf("/aliases/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

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

	return req, nil
}

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

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

	var pathParam0 string

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

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

	operationPath := fmt.Sprintf("/aliases/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

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

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

	return req, nil
}

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

// NewCreateAnalyticsEventRequestWithBody generates requests for CreateAnalyticsEvent with any type of body
func NewCreateAnalyticsEventRequestWithBody(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("/analytics/events")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

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

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

	return req, nil
}

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

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

	operationPath := fmt.Sprintf("/analytics/rules")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

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

	return req, nil
}

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

// NewCreateAnalyticsRuleRequestWithBody generates requests for CreateAnalyticsRule with any type of body
func NewCreateAnalyticsRuleRequestWithBody(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("/analytics/rules")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

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

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

	return req, nil
}

// NewDeleteAnalyticsRuleRequest generates requests for DeleteAnalyticsRule
func NewDeleteAnalyticsRuleRequest(server string, ruleName string) (*http.Request, error) {
	var err error

	var pathParam0 string

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

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

	operationPath := fmt.Sprintf("/analytics/rules/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

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

	return req, nil
}

// NewRetrieveAnalyticsRuleRequest generates requests for RetrieveAnalyticsRule
func NewRetrieveAnalyticsRuleRequest(server string, ruleName string) (*http.Request, error) {
	var err error

	var pathParam0 string

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

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

	operationPath := fmt.Sprintf("/analytics/rules/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

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

	return req, nil
}

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

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

	var pathParam0 string

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

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

	operationPath := fmt.Sprintf("/analytics/rules/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

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

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

	return req, nil
}

// NewGetCollectionsRequest generates requests for GetCollections
func NewGetCollectionsRequest(server string, params *GetCollectionsParams) (*http.Request, error) {
	var err error

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

	operationPath := fmt.Sprintf("/collections")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.ExcludeFields != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "exclude_fields", runtime.ParamLocationQuery, *params.ExcludeFields); 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.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
}

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

// NewCreateCollectionRequestWithBody generates requests for CreateCollection with any type of body
func NewCreateCollectionRequestWithBody(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("/collections")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

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

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

	return req, nil
}

// NewDeleteCollectionRequest generates requests for DeleteCollection
func NewDeleteCollectionRequest(server string, collectionName string) (*http.Request, error) {
	var err error

	var pathParam0 string

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

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

	operationPath := fmt.Sprintf("/collections/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

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

	return req, nil
}

// NewGetCollectionRequest generates requests for GetCollection
func NewGetCollectionRequest(server string, collectionName string) (*http.Request, error) {
	var err error

	var pathParam0 string

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

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

	operationPath := fmt.Sprintf("/collections/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

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

	return req, nil
}

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

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

	var pathParam0 string

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

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

	operationPath := fmt.Sprintf("/collections/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

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

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

	return req, nil
}

// NewDeleteDocumentsRequest generates requests for DeleteDocuments
func NewDeleteDocumentsRequest(server string, collectionName string, params *DeleteDocumentsParams) (*http.Request, error) {
	var err error

	var pathParam0 string

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

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

	operationPath := fmt.Sprintf("/collections/%s/documents", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.BatchSize != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "batch_size", runtime.ParamLocationQuery, *params.BatchSize); 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.FilterBy != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "filter_by", runtime.ParamLocationQuery, *params.FilterBy); 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.IgnoreNotFound != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "ignore_not_found", runtime.ParamLocationQuery, *params.IgnoreNotFound); 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.Truncate != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "truncate", runtime.ParamLocationQuery, *params.Truncate); 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
}

// NewUpdateDocumentsRequest calls the generic UpdateDocuments builder with application/json body
func NewUpdateDocumentsRequest(server string, collectionName string, params *UpdateDocumentsParams, body UpdateDocumentsJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewUpdateDocumentsRequestWithBody(server, collectionName, params, "application/json", bodyReader)
}

// NewUpdateDocumentsRequestWithBody generates requests for UpdateDocuments with any type of body
func NewUpdateDocumentsRequestWithBody(server string, collectionName string, params *UpdateDocumentsParams, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	var pathParam0 string

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

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

	operationPath := fmt.Sprintf("/collections/%s/documents", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.FilterBy != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "filter_by", runtime.ParamLocationQuery, *params.FilterBy); 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("PATCH", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

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

	return req, nil
}

// NewIndexDocumentRequest calls the generic IndexDocument builder with application/json body
func NewIndexDocumentRequest(server string, collectionName string, params *IndexDocumentParams, body IndexDocumentJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewIndexDocumentRequestWithBody(server, collectionName, params, "application/json", bodyReader)
}

// NewIndexDocumentRequestWithBody generates requests for IndexDocument with any type of body
func NewIndexDocumentRequestWithBody(server string, collectionName string, params *IndexDocumentParams, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	var pathParam0 string

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

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

	operationPath := fmt.Sprintf("/collections/%s/documents", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Action != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "action", runtime.ParamLocationQuery, *params.Action); 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.DirtyValues != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "dirty_values", runtime.ParamLocationQuery, *params.DirtyValues); 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
}

// NewExportDocumentsRequest generates requests for ExportDocuments
func NewExportDocumentsRequest(server string, collectionName string, params *ExportDocumentsParams) (*http.Request, error) {
	var err error

	var pathParam0 string

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

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

	operationPath := fmt.Sprintf("/collections/%s/documents/export", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.ExcludeFields != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "exclude_fields", runtime.ParamLocationQuery, *params.ExcludeFields); 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.FilterBy != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "filter_by", runtime.ParamLocationQuery, *params.FilterBy); 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.IncludeFields != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "include_fields", runtime.ParamLocationQuery, *params.IncludeFields); 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
}

// NewImportDocumentsRequestWithBody generates requests for ImportDocuments with any type of body
func NewImportDocumentsRequestWithBody(server string, collectionName string, params *ImportDocumentsParams, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	var pathParam0 string

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

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

	operationPath := fmt.Sprintf("/collections/%s/documents/import", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Action != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "action", runtime.ParamLocationQuery, *params.Action); 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.BatchSize != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "batch_size", runtime.ParamLocationQuery, *params.BatchSize); 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.DirtyValues != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "dirty_values", runtime.ParamLocationQuery, *params.DirtyValues); 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.RemoteEmbeddingBatchSize != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "remote_embedding_batch_size", runtime.ParamLocationQuery, *params.RemoteEmbeddingBatchSize); 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.ReturnDoc != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "return_doc", runtime.ParamLocationQuery, *params.ReturnDoc); 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.ReturnId != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "return_id", runtime.ParamLocationQuery, *params.ReturnId); 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
}

// NewSearchCollectionRequest generates requests for SearchCollection
func NewSearchCollectionRequest(server string, collectionName string, params *SearchCollectionParams) (*http.Request, error) {
	var err error

	var pathParam0 string

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

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

	operationPath := fmt.Sprintf("/collections/%s/documents/search", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.CacheTtl != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "cache_ttl", runtime.ParamLocationQuery, *params.CacheTtl); 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.Conversation != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "conversation", runtime.ParamLocationQuery, *params.Conversation); 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.ConversationId != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "conversation_id", runtime.ParamLocationQuery, *params.ConversationId); 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.ConversationModelId != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "conversation_model_id", runtime.ParamLocationQuery, *params.ConversationModelId); 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.DropTokensMode != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "drop_tokens_mode", runtime.ParamLocationQuery, *params.DropTokensMode); 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.DropTokensThreshold != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "drop_tokens_threshold", runtime.ParamLocationQuery, *params.DropTokensThreshold); 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.EnableHighlightV1 != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "enable_highlight_v1", runtime.ParamLocationQuery, *params.EnableHighlightV1); 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.EnableOverrides != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "enable_overrides", runtime.ParamLocationQuery, *params.EnableOverrides); 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.EnableSynonyms != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "enable_synonyms", runtime.ParamLocationQuery, *params.EnableSynonyms); 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.EnableTyposForAlphaNumericalTokens != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "enable_typos_for_alpha_numerical_tokens", runtime.ParamLocationQuery, *params.EnableTyposForAlphaNumericalTokens); 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.EnableTyposForNumericalTokens != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "enable_typos_for_numerical_tokens", runtime.ParamLocationQuery, *params.EnableTyposForNumericalTokens); 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.ExcludeFields != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "exclude_fields", runtime.ParamLocationQuery, *params.ExcludeFields); 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.ExhaustiveSearch != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "exhaustive_search", runtime.ParamLocationQuery, *params.ExhaustiveSearch); 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.FacetBy != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "facet_by", runtime.ParamLocationQuery, *params.FacetBy); 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.FacetQuery != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "facet_query", runtime.ParamLocationQuery, *params.FacetQuery); 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.FacetReturnParent != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "facet_return_parent", runtime.ParamLocationQuery, *params.FacetReturnParent); 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.FacetStrategy != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "facet_strategy", runtime.ParamLocationQuery, *params.FacetStrategy); 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.FilterBy != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "filter_by", runtime.ParamLocationQuery, *params.FilterBy); 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.FilterCuratedHits != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "filter_curated_hits", runtime.ParamLocationQuery, *params.FilterCuratedHits); 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.GroupBy != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "group_by", runtime.ParamLocationQuery, *params.GroupBy); 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.GroupLimit != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "group_limit", runtime.ParamLocationQuery, *params.GroupLimit); 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.GroupMissingValues != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "group_missing_values", runtime.ParamLocationQuery, *params.GroupMissingValues); 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.HiddenHits != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "hidden_hits", runtime.ParamLocationQuery, *params.HiddenHits); 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.HighlightAffixNumTokens != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "highlight_affix_num_tokens", runtime.ParamLocationQuery, *params.HighlightAffixNumTokens); 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.HighlightEndTag != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "highlight_end_tag", runtime.ParamLocationQuery, *params.HighlightEndTag); 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.HighlightFields != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "highlight_fields", runtime.ParamLocationQuery, *params.HighlightFields); 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.HighlightFullFields != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "highlight_full_fields", runtime.ParamLocationQuery, *params.HighlightFullFields); 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.HighlightStartTag != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "highlight_start_tag", runtime.ParamLocationQuery, *params.HighlightStartTag); 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.IncludeFields != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "include_fields", runtime.ParamLocationQuery, *params.IncludeFields); 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.Infix != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "infix", runtime.ParamLocationQuery, *params.Infix); 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.MaxCandidates != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "max_candidates", runtime.ParamLocationQuery, *params.MaxCandidates); 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.MaxExtraPrefix != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "max_extra_prefix", runtime.ParamLocationQuery, *params.MaxExtraPrefix); 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.MaxExtraSuffix != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "max_extra_suffix", runtime.ParamLocationQuery, *params.MaxExtraSuffix); 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.MaxFacetValues != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "max_facet_values", runtime.ParamLocationQuery, *params.MaxFacetValues); 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.MaxFilterByCandidates != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "max_filter_by_candidates", runtime.ParamLocationQuery, *params.MaxFilterByCandidates); 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.MinLen1typo != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "min_len_1typo", runtime.ParamLocationQuery, *params.MinLen1typo); 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.MinLen2typo != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "min_len_2typo", runtime.ParamLocationQuery, *params.MinLen2typo); 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.NlModelId != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "nl_model_id", runtime.ParamLocationQuery, *params.NlModelId); 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.NlQuery != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "nl_query", runtime.ParamLocationQuery, *params.NlQuery); 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.NumTypos != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "num_typos", runtime.ParamLocationQuery, *params.NumTypos); 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.OverrideTags != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "override_tags", runtime.ParamLocationQuery, *params.OverrideTags); 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.Page != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "page", runtime.ParamLocationQuery, *params.Page); 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.PerPage != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "per_page", runtime.ParamLocationQuery, *params.PerPage); 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.PinnedHits != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "pinned_hits", runtime.ParamLocationQuery, *params.PinnedHits); 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.PreSegmentedQuery != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "pre_segmented_query", runtime.ParamLocationQuery, *params.PreSegmentedQuery); 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.Prefix != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "prefix", runtime.ParamLocationQuery, *params.Prefix); 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.Preset != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "preset", runtime.ParamLocationQuery, *params.Preset); 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.PrioritizeExactMatch != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "prioritize_exact_match", runtime.ParamLocationQuery, *params.PrioritizeExactMatch); 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.PrioritizeNumMatchingFields != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "prioritize_num_matching_fields", runtime.ParamLocationQuery, *params.PrioritizeNumMatchingFields); 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.PrioritizeTokenPosition != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "prioritize_token_position", runtime.ParamLocationQuery, *params.PrioritizeTokenPosition); 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.Q != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "q", runtime.ParamLocationQuery, *params.Q); 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.QueryBy != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "query_by", runtime.ParamLocationQuery, *params.QueryBy); 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.QueryByWeights != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "query_by_weights", runtime.ParamLocationQuery, *params.QueryByWeights); 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.RemoteEmbeddingNumTries != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "remote_embedding_num_tries", runtime.ParamLocationQuery, *params.RemoteEmbeddingNumTries); 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.RemoteEmbeddingTimeoutMs != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "remote_embedding_timeout_ms", runtime.ParamLocationQuery, *params.RemoteEmbeddingTimeoutMs); 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.SearchCutoffMs != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "search_cutoff_ms", runtime.ParamLocationQuery, *params.SearchCutoffMs); 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.SnippetThreshold != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "snippet_threshold", runtime.ParamLocationQuery, *params.SnippetThreshold); 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.SortBy != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "sort_by", runtime.ParamLocationQuery, *params.SortBy); 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.SplitJoinTokens != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "split_join_tokens", runtime.ParamLocationQuery, *params.SplitJoinTokens); 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.Stopwords != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "stopwords", runtime.ParamLocationQuery, *params.Stopwords); 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.SynonymNumTypos != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "synonym_num_typos", runtime.ParamLocationQuery, *params.SynonymNumTypos); 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.SynonymPrefix != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "synonym_prefix", runtime.ParamLocationQuery, *params.SynonymPrefix); 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.TextMatchType != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "text_match_type", runtime.ParamLocationQuery, *params.TextMatchType); 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.TypoTokensThreshold != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "typo_tokens_threshold", runtime.ParamLocationQuery, *params.TypoTokensThreshold); 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.UseCache != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "use_cache", runtime.ParamLocationQuery, *params.UseCache); 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.VectorQuery != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "vector_query", runtime.ParamLocationQuery, *params.VectorQuery); 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.VoiceQuery != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "voice_query", runtime.ParamLocationQuery, *params.VoiceQuery); 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
}

// NewDeleteDocumentRequest generates requests for DeleteDocument
func NewDeleteDocumentRequest(server string, collectionName string, documentId string) (*http.Request, error) {
	var err error

	var pathParam0 string

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

	var pathParam1 string

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

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

	operationPath := fmt.Sprintf("/collections/%s/documents/%s", pathParam0, pathParam1)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

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

	return req, nil
}

// NewGetDocumentRequest generates requests for GetDocument
func NewGetDocumentRequest(server string, collectionName string, documentId string) (*http.Request, error) {
	var err error

	var pathParam0 string

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

	var pathParam1 string

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

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

	operationPath := fmt.Sprintf("/collections/%s/documents/%s", pathParam0, pathParam1)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

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

	return req, nil
}

// NewUpdateDocumentRequest calls the generic UpdateDocument builder with application/json body
func NewUpdateDocumentRequest(server string, collectionName string, documentId string, params *UpdateDocumentParams, body UpdateDocumentJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewUpdateDocumentRequestWithBody(server, collectionName, documentId, params, "application/json", bodyReader)
}

// NewUpdateDocumentRequestWithBody generates requests for UpdateDocument with any type of body
func NewUpdateDocumentRequestWithBody(server string, collectionName string, documentId string, params *UpdateDocumentParams, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	var pathParam0 string

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

	var pathParam1 string

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

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

	operationPath := fmt.Sprintf("/collections/%s/documents/%s", pathParam0, pathParam1)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.DirtyValues != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "dirty_values", runtime.ParamLocationQuery, *params.DirtyValues); 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("PATCH", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

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

	return req, nil
}

// NewGetSearchOverridesRequest generates requests for GetSearchOverrides
func NewGetSearchOverridesRequest(server string, collectionName string) (*http.Request, error) {
	var err error

	var pathParam0 string

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

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

	operationPath := fmt.Sprintf("/collections/%s/overrides", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

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

	return req, nil
}

// NewDeleteSearchOverrideRequest generates requests for DeleteSearchOverride
func NewDeleteSearchOverrideRequest(server string, collectionName string, overrideId string) (*http.Request, error) {
	var err error

	var pathParam0 string

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

	var pathParam1 string

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

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

	operationPath := fmt.Sprintf("/collections/%s/overrides/%s", pathParam0, pathParam1)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

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

	return req, nil
}

// NewGetSearchOverrideRequest generates requests for GetSearchOverride
func NewGetSearchOverrideRequest(server string, collectionName string, overrideId string) (*http.Request, error) {
	var err error

	var pathParam0 string

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

	var pathParam1 string

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

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

	operationPath := fmt.Sprintf("/collections/%s/overrides/%s", pathParam0, pathParam1)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

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

	return req, nil
}

// NewUpsertSearchOverrideRequest calls the generic UpsertSearchOverride builder with application/json body
func NewUpsertSearchOverrideRequest(server string, collectionName string, overrideId string, body UpsertSearchOverrideJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewUpsertSearchOverrideRequestWithBody(server, collectionName, overrideId, "application/json", bodyReader)
}

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

	var pathParam0 string

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

	var pathParam1 string

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

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

	operationPath := fmt.Sprintf("/collections/%s/overrides/%s", pathParam0, pathParam1)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

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

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

	return req, nil
}

// NewGetSearchSynonymsRequest generates requests for GetSearchSynonyms
func NewGetSearchSynonymsRequest(server string, collectionName string) (*http.Request, error) {
	var err error

	var pathParam0 string

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

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

	operationPath := fmt.Sprintf("/collections/%s/synonyms", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

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

	return req, nil
}

// NewDeleteSearchSynonymRequest generates requests for DeleteSearchSynonym
func NewDeleteSearchSynonymRequest(server string, collectionName string, synonymId string) (*http.Request, error) {
	var err error

	var pathParam0 string

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

	var pathParam1 string

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

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

	operationPath := fmt.Sprintf("/collections/%s/synonyms/%s", pathParam0, pathParam1)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

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

	return req, nil
}

// NewGetSearchSynonymRequest generates requests for GetSearchSynonym
func NewGetSearchSynonymRequest(server string, collectionName string, synonymId string) (*http.Request, error) {
	var err error

	var pathParam0 string

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

	var pathParam1 string

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

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

	operationPath := fmt.Sprintf("/collections/%s/synonyms/%s", pathParam0, pathParam1)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

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

	return req, nil
}

// NewUpsertSearchSynonymRequest calls the generic UpsertSearchSynonym builder with application/json body
func NewUpsertSearchSynonymRequest(server string, collectionName string, synonymId string, body UpsertSearchSynonymJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewUpsertSearchSynonymRequestWithBody(server, collectionName, synonymId, "application/json", bodyReader)
}

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

	var pathParam0 string

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

	var pathParam1 string

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

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

	operationPath := fmt.Sprintf("/collections/%s/synonyms/%s", pathParam0, pathParam1)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

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

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

	return req, nil
}

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

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

	operationPath := fmt.Sprintf("/conversations/models")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

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

	return req, nil
}

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

// NewCreateConversationModelRequestWithBody generates requests for CreateConversationModel with any type of body
func NewCreateConversationModelRequestWithBody(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("/conversations/models")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

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

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

	return req, nil
}

// NewDeleteConversationModelRequest generates requests for DeleteConversationModel
func NewDeleteConversationModelRequest(server string, modelId string) (*http.Request, error) {
	var err error

	var pathParam0 string

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

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

	operationPath := fmt.Sprintf("/conversations/models/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

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

	return req, nil
}

// NewRetrieveConversationModelRequest generates requests for RetrieveConversationModel
func NewRetrieveConversationModelRequest(server string, modelId string) (*http.Request, error) {
	var err error

	var pathParam0 string

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

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

	operationPath := fmt.Sprintf("/conversations/models/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

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

	return req, nil
}

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

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

	var pathParam0 string

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

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

	operationPath := fmt.Sprintf("/conversations/models/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

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

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

	return req, nil
}

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

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

	operationPath := fmt.Sprintf("/debug")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

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

	return req, nil
}

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

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

	operationPath := fmt.Sprintf("/health")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

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

	return req, nil
}

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

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

	operationPath := fmt.Sprintf("/keys")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

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

	return req, nil
}

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

// NewCreateKeyRequestWithBody generates requests for CreateKey with any type of body
func NewCreateKeyRequestWithBody(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("/keys")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

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

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

	return req, nil
}

// NewDeleteKeyRequest generates requests for DeleteKey
func NewDeleteKeyRequest(server string, keyId int64) (*http.Request, error) {
	var err error

	var pathParam0 string

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

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

	operationPath := fmt.Sprintf("/keys/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

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

	return req, nil
}

// NewGetKeyRequest generates requests for GetKey
func NewGetKeyRequest(server string, keyId int64) (*http.Request, error) {
	var err error

	var pathParam0 string

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

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

	operationPath := fmt.Sprintf("/keys/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

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

	return req, nil
}

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

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

	operationPath := fmt.Sprintf("/metrics.json")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

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

	return req, nil
}

// NewMultiSearchRequest calls the generic MultiSearch builder with application/json body
func NewMultiSearchRequest(server string, params *MultiSearchParams, body MultiSearchJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewMultiSearchRequestWithBody(server, params, "application/json", bodyReader)
}

// NewMultiSearchRequestWithBody generates requests for MultiSearch with any type of body
func NewMultiSearchRequestWithBody(server string, params *MultiSearchParams, 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("/multi_search")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.CacheTtl != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "cache_ttl", runtime.ParamLocationQuery, *params.CacheTtl); 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.Conversation != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "conversation", runtime.ParamLocationQuery, *params.Conversation); 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.ConversationId != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "conversation_id", runtime.ParamLocationQuery, *params.ConversationId); 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.ConversationModelId != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "conversation_model_id", runtime.ParamLocationQuery, *params.ConversationModelId); 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.DropTokensMode != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "drop_tokens_mode", runtime.ParamLocationQuery, *params.DropTokensMode); 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.DropTokensThreshold != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "drop_tokens_threshold", runtime.ParamLocationQuery, *params.DropTokensThreshold); 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.EnableHighlightV1 != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "enable_highlight_v1", runtime.ParamLocationQuery, *params.EnableHighlightV1); 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.EnableOverrides != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "enable_overrides", runtime.ParamLocationQuery, *params.EnableOverrides); 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.EnableSynonyms != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "enable_synonyms", runtime.ParamLocationQuery, *params.EnableSynonyms); 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.EnableTyposForAlphaNumericalTokens != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "enable_typos_for_alpha_numerical_tokens", runtime.ParamLocationQuery, *params.EnableTyposForAlphaNumericalTokens); 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.EnableTyposForNumericalTokens != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "enable_typos_for_numerical_tokens", runtime.ParamLocationQuery, *params.EnableTyposForNumericalTokens); 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.ExcludeFields != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "exclude_fields", runtime.ParamLocationQuery, *params.ExcludeFields); 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.ExhaustiveSearch != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "exhaustive_search", runtime.ParamLocationQuery, *params.ExhaustiveSearch); 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.FacetBy != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "facet_by", runtime.ParamLocationQuery, *params.FacetBy); 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.FacetQuery != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "facet_query", runtime.ParamLocationQuery, *params.FacetQuery); 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.FacetReturnParent != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "facet_return_parent", runtime.ParamLocationQuery, *params.FacetReturnParent); 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.FacetStrategy != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "facet_strategy", runtime.ParamLocationQuery, *params.FacetStrategy); 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.FilterBy != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "filter_by", runtime.ParamLocationQuery, *params.FilterBy); 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.FilterCuratedHits != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "filter_curated_hits", runtime.ParamLocationQuery, *params.FilterCuratedHits); 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.GroupBy != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "group_by", runtime.ParamLocationQuery, *params.GroupBy); 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.GroupLimit != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "group_limit", runtime.ParamLocationQuery, *params.GroupLimit); 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.GroupMissingValues != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "group_missing_values", runtime.ParamLocationQuery, *params.GroupMissingValues); 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.HiddenHits != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "hidden_hits", runtime.ParamLocationQuery, *params.HiddenHits); 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.HighlightAffixNumTokens != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "highlight_affix_num_tokens", runtime.ParamLocationQuery, *params.HighlightAffixNumTokens); 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.HighlightEndTag != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "highlight_end_tag", runtime.ParamLocationQuery, *params.HighlightEndTag); 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.HighlightFields != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "highlight_fields", runtime.ParamLocationQuery, *params.HighlightFields); 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.HighlightFullFields != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "highlight_full_fields", runtime.ParamLocationQuery, *params.HighlightFullFields); 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.HighlightStartTag != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "highlight_start_tag", runtime.ParamLocationQuery, *params.HighlightStartTag); 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.IncludeFields != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "include_fields", runtime.ParamLocationQuery, *params.IncludeFields); 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.Infix != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "infix", runtime.ParamLocationQuery, *params.Infix); 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.MaxCandidates != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "max_candidates", runtime.ParamLocationQuery, *params.MaxCandidates); 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.MaxExtraPrefix != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "max_extra_prefix", runtime.ParamLocationQuery, *params.MaxExtraPrefix); 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.MaxExtraSuffix != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "max_extra_suffix", runtime.ParamLocationQuery, *params.MaxExtraSuffix); 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.MaxFacetValues != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "max_facet_values", runtime.ParamLocationQuery, *params.MaxFacetValues); 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.MaxFilterByCandidates != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "max_filter_by_candidates", runtime.ParamLocationQuery, *params.MaxFilterByCandidates); 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.MinLen1typo != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "min_len_1typo", runtime.ParamLocationQuery, *params.MinLen1typo); 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.MinLen2typo != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "min_len_2typo", runtime.ParamLocationQuery, *params.MinLen2typo); 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.NlModelId != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "nl_model_id", runtime.ParamLocationQuery, *params.NlModelId); 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.NlQuery != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "nl_query", runtime.ParamLocationQuery, *params.NlQuery); 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.NumTypos != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "num_typos", runtime.ParamLocationQuery, *params.NumTypos); 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.OverrideTags != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "override_tags", runtime.ParamLocationQuery, *params.OverrideTags); 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.Page != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "page", runtime.ParamLocationQuery, *params.Page); 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.PerPage != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "per_page", runtime.ParamLocationQuery, *params.PerPage); 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.PinnedHits != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "pinned_hits", runtime.ParamLocationQuery, *params.PinnedHits); 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.PreSegmentedQuery != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "pre_segmented_query", runtime.ParamLocationQuery, *params.PreSegmentedQuery); 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.Prefix != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "prefix", runtime.ParamLocationQuery, *params.Prefix); 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.Preset != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "preset", runtime.ParamLocationQuery, *params.Preset); 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.PrioritizeExactMatch != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "prioritize_exact_match", runtime.ParamLocationQuery, *params.PrioritizeExactMatch); 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.PrioritizeNumMatchingFields != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "prioritize_num_matching_fields", runtime.ParamLocationQuery, *params.PrioritizeNumMatchingFields); 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.PrioritizeTokenPosition != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "prioritize_token_position", runtime.ParamLocationQuery, *params.PrioritizeTokenPosition); 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.Q != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "q", runtime.ParamLocationQuery, *params.Q); 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.QueryBy != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "query_by", runtime.ParamLocationQuery, *params.QueryBy); 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.QueryByWeights != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "query_by_weights", runtime.ParamLocationQuery, *params.QueryByWeights); 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.RemoteEmbeddingNumTries != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "remote_embedding_num_tries", runtime.ParamLocationQuery, *params.RemoteEmbeddingNumTries); 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.RemoteEmbeddingTimeoutMs != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "remote_embedding_timeout_ms", runtime.ParamLocationQuery, *params.RemoteEmbeddingTimeoutMs); 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.SearchCutoffMs != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "search_cutoff_ms", runtime.ParamLocationQuery, *params.SearchCutoffMs); 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.SnippetThreshold != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "snippet_threshold", runtime.ParamLocationQuery, *params.SnippetThreshold); 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.SortBy != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "sort_by", runtime.ParamLocationQuery, *params.SortBy); 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.SplitJoinTokens != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "split_join_tokens", runtime.ParamLocationQuery, *params.SplitJoinTokens); 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.Stopwords != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "stopwords", runtime.ParamLocationQuery, *params.Stopwords); 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.SynonymNumTypos != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "synonym_num_typos", runtime.ParamLocationQuery, *params.SynonymNumTypos); 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.SynonymPrefix != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "synonym_prefix", runtime.ParamLocationQuery, *params.SynonymPrefix); 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.TextMatchType != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "text_match_type", runtime.ParamLocationQuery, *params.TextMatchType); 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.TypoTokensThreshold != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "typo_tokens_threshold", runtime.ParamLocationQuery, *params.TypoTokensThreshold); 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.UseCache != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "use_cache", runtime.ParamLocationQuery, *params.UseCache); 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.VectorQuery != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "vector_query", runtime.ParamLocationQuery, *params.VectorQuery); 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.VoiceQuery != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "voice_query", runtime.ParamLocationQuery, *params.VoiceQuery); 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
}

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

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

	operationPath := fmt.Sprintf("/nl_search_models")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

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

	return req, nil
}

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

// NewCreateNLSearchModelRequestWithBody generates requests for CreateNLSearchModel with any type of body
func NewCreateNLSearchModelRequestWithBody(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("/nl_search_models")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

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

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

	return req, nil
}

// NewDeleteNLSearchModelRequest generates requests for DeleteNLSearchModel
func NewDeleteNLSearchModelRequest(server string, modelId string) (*http.Request, error) {
	var err error

	var pathParam0 string

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

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

	operationPath := fmt.Sprintf("/nl_search_models/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

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

	return req, nil
}

// NewRetrieveNLSearchModelRequest generates requests for RetrieveNLSearchModel
func NewRetrieveNLSearchModelRequest(server string, modelId string) (*http.Request, error) {
	var err error

	var pathParam0 string

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

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

	operationPath := fmt.Sprintf("/nl_search_models/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

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

	return req, nil
}

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

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

	var pathParam0 string

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

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

	operationPath := fmt.Sprintf("/nl_search_models/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

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

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

	return req, nil
}

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

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

	operationPath := fmt.Sprintf("/operations/schema_changes")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

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

	return req, nil
}

// NewTakeSnapshotRequest generates requests for TakeSnapshot
func NewTakeSnapshotRequest(server string, params *TakeSnapshotParams) (*http.Request, error) {
	var err error

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

	operationPath := fmt.Sprintf("/operations/snapshot")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if queryFrag, err := runtime.StyleParamWithLocation("form", true, "snapshot_path", runtime.ParamLocationQuery, params.SnapshotPath); 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
	}

	return req, nil
}

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

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

	operationPath := fmt.Sprintf("/operations/vote")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

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

	return req, nil
}

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

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

	operationPath := fmt.Sprintf("/presets")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

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

	return req, nil
}

// NewDeletePresetRequest generates requests for DeletePreset
func NewDeletePresetRequest(server string, presetId string) (*http.Request, error) {
	var err error

	var pathParam0 string

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

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

	operationPath := fmt.Sprintf("/presets/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

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

	return req, nil
}

// NewRetrievePresetRequest generates requests for RetrievePreset
func NewRetrievePresetRequest(server string, presetId string) (*http.Request, error) {
	var err error

	var pathParam0 string

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

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

	operationPath := fmt.Sprintf("/presets/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

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

	return req, nil
}

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

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

	var pathParam0 string

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

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

	operationPath := fmt.Sprintf("/presets/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

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

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

	return req, nil
}

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

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

	operationPath := fmt.Sprintf("/stats.json")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

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

	return req, nil
}

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

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

	operationPath := fmt.Sprintf("/stemming/dictionaries")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

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

	return req, nil
}

// NewImportStemmingDictionaryRequest calls the generic ImportStemmingDictionary builder with application/json body
func NewImportStemmingDictionaryRequest(server string, params *ImportStemmingDictionaryParams, body ImportStemmingDictionaryJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewImportStemmingDictionaryRequestWithBody(server, params, "application/json", bodyReader)
}

// NewImportStemmingDictionaryRequestWithBody generates requests for ImportStemmingDictionary with any type of body
func NewImportStemmingDictionaryRequestWithBody(server string, params *ImportStemmingDictionaryParams, 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("/stemming/dictionaries/import")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if queryFrag, err := runtime.StyleParamWithLocation("form", true, "id", runtime.ParamLocationQuery, params.Id); 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
}

// NewGetStemmingDictionaryRequest generates requests for GetStemmingDictionary
func NewGetStemmingDictionaryRequest(server string, dictionaryId string) (*http.Request, error) {
	var err error

	var pathParam0 string

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

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

	operationPath := fmt.Sprintf("/stemming/dictionaries/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

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

	return req, nil
}

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

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

	operationPath := fmt.Sprintf("/stopwords")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

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

	return req, nil
}

// NewDeleteStopwordsSetRequest generates requests for DeleteStopwordsSet
func NewDeleteStopwordsSetRequest(server string, setId string) (*http.Request, error) {
	var err error

	var pathParam0 string

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

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

	operationPath := fmt.Sprintf("/stopwords/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

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

	return req, nil
}

// NewRetrieveStopwordsSetRequest generates requests for RetrieveStopwordsSet
func NewRetrieveStopwordsSetRequest(server string, setId string) (*http.Request, error) {
	var err error

	var pathParam0 string

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

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

	operationPath := fmt.Sprintf("/stopwords/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

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

	return req, nil
}

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

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

	var pathParam0 string

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

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

	operationPath := fmt.Sprintf("/stopwords/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

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

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

	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 {
	// GetAliasesWithResponse request
	GetAliasesWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetAliasesResponse, error)

	// DeleteAliasWithResponse request
	DeleteAliasWithResponse(ctx context.Context, aliasName string, reqEditors ...RequestEditorFn) (*DeleteAliasResponse, error)

	// GetAliasWithResponse request
	GetAliasWithResponse(ctx context.Context, aliasName string, reqEditors ...RequestEditorFn) (*GetAliasResponse, error)

	// UpsertAliasWithBodyWithResponse request with any body
	UpsertAliasWithBodyWithResponse(ctx context.Context, aliasName string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*UpsertAliasResponse, error)

	UpsertAliasWithResponse(ctx context.Context, aliasName string, body UpsertAliasJSONRequestBody, reqEditors ...RequestEditorFn) (*UpsertAliasResponse, error)

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

	CreateAnalyticsEventWithResponse(ctx context.Context, body CreateAnalyticsEventJSONRequestBody, reqEditors ...RequestEditorFn) (*CreateAnalyticsEventResponse, error)

	// RetrieveAnalyticsRulesWithResponse request
	RetrieveAnalyticsRulesWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*RetrieveAnalyticsRulesResponse, error)

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

	CreateAnalyticsRuleWithResponse(ctx context.Context, body CreateAnalyticsRuleJSONRequestBody, reqEditors ...RequestEditorFn) (*CreateAnalyticsRuleResponse, error)

	// DeleteAnalyticsRuleWithResponse request
	DeleteAnalyticsRuleWithResponse(ctx context.Context, ruleName string, reqEditors ...RequestEditorFn) (*DeleteAnalyticsRuleResponse, error)

	// RetrieveAnalyticsRuleWithResponse request
	RetrieveAnalyticsRuleWithResponse(ctx context.Context, ruleName string, reqEditors ...RequestEditorFn) (*RetrieveAnalyticsRuleResponse, error)

	// UpsertAnalyticsRuleWithBodyWithResponse request with any body
	UpsertAnalyticsRuleWithBodyWithResponse(ctx context.Context, ruleName string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*UpsertAnalyticsRuleResponse, error)

	UpsertAnalyticsRuleWithResponse(ctx context.Context, ruleName string, body UpsertAnalyticsRuleJSONRequestBody, reqEditors ...RequestEditorFn) (*UpsertAnalyticsRuleResponse, error)

	// GetCollectionsWithResponse request
	GetCollectionsWithResponse(ctx context.Context, params *GetCollectionsParams, reqEditors ...RequestEditorFn) (*GetCollectionsResponse, error)

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

	CreateCollectionWithResponse(ctx context.Context, body CreateCollectionJSONRequestBody, reqEditors ...RequestEditorFn) (*CreateCollectionResponse, error)

	// DeleteCollectionWithResponse request
	DeleteCollectionWithResponse(ctx context.Context, collectionName string, reqEditors ...RequestEditorFn) (*DeleteCollectionResponse, error)

	// GetCollectionWithResponse request
	GetCollectionWithResponse(ctx context.Context, collectionName string, reqEditors ...RequestEditorFn) (*GetCollectionResponse, error)

	// UpdateCollectionWithBodyWithResponse request with any body
	UpdateCollectionWithBodyWithResponse(ctx context.Context, collectionName string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*UpdateCollectionResponse, error)

	UpdateCollectionWithResponse(ctx context.Context, collectionName string, body UpdateCollectionJSONRequestBody, reqEditors ...RequestEditorFn) (*UpdateCollectionResponse, error)

	// DeleteDocumentsWithResponse request
	DeleteDocumentsWithResponse(ctx context.Context, collectionName string, params *DeleteDocumentsParams, reqEditors ...RequestEditorFn) (*DeleteDocumentsResponse, error)

	// UpdateDocumentsWithBodyWithResponse request with any body
	UpdateDocumentsWithBodyWithResponse(ctx context.Context, collectionName string, params *UpdateDocumentsParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*UpdateDocumentsResponse, error)

	UpdateDocumentsWithResponse(ctx context.Context, collectionName string, params *UpdateDocumentsParams, body UpdateDocumentsJSONRequestBody, reqEditors ...RequestEditorFn) (*UpdateDocumentsResponse, error)

	// IndexDocumentWithBodyWithResponse request with any body
	IndexDocumentWithBodyWithResponse(ctx context.Context, collectionName string, params *IndexDocumentParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*IndexDocumentResponse, error)

	IndexDocumentWithResponse(ctx context.Context, collectionName string, params *IndexDocumentParams, body IndexDocumentJSONRequestBody, reqEditors ...RequestEditorFn) (*IndexDocumentResponse, error)

	// ExportDocumentsWithResponse request
	ExportDocumentsWithResponse(ctx context.Context, collectionName string, params *ExportDocumentsParams, reqEditors ...RequestEditorFn) (*ExportDocumentsResponse, error)

	// ImportDocumentsWithBodyWithResponse request with any body
	ImportDocumentsWithBodyWithResponse(ctx context.Context, collectionName string, params *ImportDocumentsParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*ImportDocumentsResponse, error)

	// SearchCollectionWithResponse request
	SearchCollectionWithResponse(ctx context.Context, collectionName string, params *SearchCollectionParams, reqEditors ...RequestEditorFn) (*SearchCollectionResponse, error)

	// DeleteDocumentWithResponse request
	DeleteDocumentWithResponse(ctx context.Context, collectionName string, documentId string, reqEditors ...RequestEditorFn) (*DeleteDocumentResponse, error)

	// GetDocumentWithResponse request
	GetDocumentWithResponse(ctx context.Context, collectionName string, documentId string, reqEditors ...RequestEditorFn) (*GetDocumentResponse, error)

	// UpdateDocumentWithBodyWithResponse request with any body
	UpdateDocumentWithBodyWithResponse(ctx context.Context, collectionName string, documentId string, params *UpdateDocumentParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*UpdateDocumentResponse, error)

	UpdateDocumentWithResponse(ctx context.Context, collectionName string, documentId string, params *UpdateDocumentParams, body UpdateDocumentJSONRequestBody, reqEditors ...RequestEditorFn) (*UpdateDocumentResponse, error)

	// GetSearchOverridesWithResponse request
	GetSearchOverridesWithResponse(ctx context.Context, collectionName string, reqEditors ...RequestEditorFn) (*GetSearchOverridesResponse, error)

	// DeleteSearchOverrideWithResponse request
	DeleteSearchOverrideWithResponse(ctx context.Context, collectionName string, overrideId string, reqEditors ...RequestEditorFn) (*DeleteSearchOverrideResponse, error)

	// GetSearchOverrideWithResponse request
	GetSearchOverrideWithResponse(ctx context.Context, collectionName string, overrideId string, reqEditors ...RequestEditorFn) (*GetSearchOverrideResponse, error)

	// UpsertSearchOverrideWithBodyWithResponse request with any body
	UpsertSearchOverrideWithBodyWithResponse(ctx context.Context, collectionName string, overrideId string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*UpsertSearchOverrideResponse, error)

	UpsertSearchOverrideWithResponse(ctx context.Context, collectionName string, overrideId string, body UpsertSearchOverrideJSONRequestBody, reqEditors ...RequestEditorFn) (*UpsertSearchOverrideResponse, error)

	// GetSearchSynonymsWithResponse request
	GetSearchSynonymsWithResponse(ctx context.Context, collectionName string, reqEditors ...RequestEditorFn) (*GetSearchSynonymsResponse, error)

	// DeleteSearchSynonymWithResponse request
	DeleteSearchSynonymWithResponse(ctx context.Context, collectionName string, synonymId string, reqEditors ...RequestEditorFn) (*DeleteSearchSynonymResponse, error)

	// GetSearchSynonymWithResponse request
	GetSearchSynonymWithResponse(ctx context.Context, collectionName string, synonymId string, reqEditors ...RequestEditorFn) (*GetSearchSynonymResponse, error)

	// UpsertSearchSynonymWithBodyWithResponse request with any body
	UpsertSearchSynonymWithBodyWithResponse(ctx context.Context, collectionName string, synonymId string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*UpsertSearchSynonymResponse, error)

	UpsertSearchSynonymWithResponse(ctx context.Context, collectionName string, synonymId string, body UpsertSearchSynonymJSONRequestBody, reqEditors ...RequestEditorFn) (*UpsertSearchSynonymResponse, error)

	// RetrieveAllConversationModelsWithResponse request
	RetrieveAllConversationModelsWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*RetrieveAllConversationModelsResponse, error)

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

	CreateConversationModelWithResponse(ctx context.Context, body CreateConversationModelJSONRequestBody, reqEditors ...RequestEditorFn) (*CreateConversationModelResponse, error)

	// DeleteConversationModelWithResponse request
	DeleteConversationModelWithResponse(ctx context.Context, modelId string, reqEditors ...RequestEditorFn) (*DeleteConversationModelResponse, error)

	// RetrieveConversationModelWithResponse request
	RetrieveConversationModelWithResponse(ctx context.Context, modelId string, reqEditors ...RequestEditorFn) (*RetrieveConversationModelResponse, error)

	// UpdateConversationModelWithBodyWithResponse request with any body
	UpdateConversationModelWithBodyWithResponse(ctx context.Context, modelId string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*UpdateConversationModelResponse, error)

	UpdateConversationModelWithResponse(ctx context.Context, modelId string, body UpdateConversationModelJSONRequestBody, reqEditors ...RequestEditorFn) (*UpdateConversationModelResponse, error)

	// DebugWithResponse request
	DebugWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*DebugResponse, error)

	// HealthWithResponse request
	HealthWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*HealthResponse, error)

	// GetKeysWithResponse request
	GetKeysWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetKeysResponse, error)

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

	CreateKeyWithResponse(ctx context.Context, body CreateKeyJSONRequestBody, reqEditors ...RequestEditorFn) (*CreateKeyResponse, error)

	// DeleteKeyWithResponse request
	DeleteKeyWithResponse(ctx context.Context, keyId int64, reqEditors ...RequestEditorFn) (*DeleteKeyResponse, error)

	// GetKeyWithResponse request
	GetKeyWithResponse(ctx context.Context, keyId int64, reqEditors ...RequestEditorFn) (*GetKeyResponse, error)

	// RetrieveMetricsWithResponse request
	RetrieveMetricsWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*RetrieveMetricsResponse, error)

	// MultiSearchWithBodyWithResponse request with any body
	MultiSearchWithBodyWithResponse(ctx context.Context, params *MultiSearchParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*MultiSearchResponse, error)

	MultiSearchWithResponse(ctx context.Context, params *MultiSearchParams, body MultiSearchJSONRequestBody, reqEditors ...RequestEditorFn) (*MultiSearchResponse, error)

	// RetrieveAllNLSearchModelsWithResponse request
	RetrieveAllNLSearchModelsWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*RetrieveAllNLSearchModelsResponse, error)

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

	CreateNLSearchModelWithResponse(ctx context.Context, body CreateNLSearchModelJSONRequestBody, reqEditors ...RequestEditorFn) (*CreateNLSearchModelResponse, error)

	// DeleteNLSearchModelWithResponse request
	DeleteNLSearchModelWithResponse(ctx context.Context, modelId string, reqEditors ...RequestEditorFn) (*DeleteNLSearchModelResponse, error)

	// RetrieveNLSearchModelWithResponse request
	RetrieveNLSearchModelWithResponse(ctx context.Context, modelId string, reqEditors ...RequestEditorFn) (*RetrieveNLSearchModelResponse, error)

	// UpdateNLSearchModelWithBodyWithResponse request with any body
	UpdateNLSearchModelWithBodyWithResponse(ctx context.Context, modelId string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*UpdateNLSearchModelResponse, error)

	UpdateNLSearchModelWithResponse(ctx context.Context, modelId string, body UpdateNLSearchModelJSONRequestBody, reqEditors ...RequestEditorFn) (*UpdateNLSearchModelResponse, error)

	// GetSchemaChangesWithResponse request
	GetSchemaChangesWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetSchemaChangesResponse, error)

	// TakeSnapshotWithResponse request
	TakeSnapshotWithResponse(ctx context.Context, params *TakeSnapshotParams, reqEditors ...RequestEditorFn) (*TakeSnapshotResponse, error)

	// VoteWithResponse request
	VoteWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*VoteResponse, error)

	// RetrieveAllPresetsWithResponse request
	RetrieveAllPresetsWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*RetrieveAllPresetsResponse, error)

	// DeletePresetWithResponse request
	DeletePresetWithResponse(ctx context.Context, presetId string, reqEditors ...RequestEditorFn) (*DeletePresetResponse, error)

	// RetrievePresetWithResponse request
	RetrievePresetWithResponse(ctx context.Context, presetId string, reqEditors ...RequestEditorFn) (*RetrievePresetResponse, error)

	// UpsertPresetWithBodyWithResponse request with any body
	UpsertPresetWithBodyWithResponse(ctx context.Context, presetId string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*UpsertPresetResponse, error)

	UpsertPresetWithResponse(ctx context.Context, presetId string, body UpsertPresetJSONRequestBody, reqEditors ...RequestEditorFn) (*UpsertPresetResponse, error)

	// RetrieveAPIStatsWithResponse request
	RetrieveAPIStatsWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*RetrieveAPIStatsResponse, error)

	// ListStemmingDictionariesWithResponse request
	ListStemmingDictionariesWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*ListStemmingDictionariesResponse, error)

	// ImportStemmingDictionaryWithBodyWithResponse request with any body
	ImportStemmingDictionaryWithBodyWithResponse(ctx context.Context, params *ImportStemmingDictionaryParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*ImportStemmingDictionaryResponse, error)

	ImportStemmingDictionaryWithResponse(ctx context.Context, params *ImportStemmingDictionaryParams, body ImportStemmingDictionaryJSONRequestBody, reqEditors ...RequestEditorFn) (*ImportStemmingDictionaryResponse, error)

	// GetStemmingDictionaryWithResponse request
	GetStemmingDictionaryWithResponse(ctx context.Context, dictionaryId string, reqEditors ...RequestEditorFn) (*GetStemmingDictionaryResponse, error)

	// RetrieveStopwordsSetsWithResponse request
	RetrieveStopwordsSetsWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*RetrieveStopwordsSetsResponse, error)

	// DeleteStopwordsSetWithResponse request
	DeleteStopwordsSetWithResponse(ctx context.Context, setId string, reqEditors ...RequestEditorFn) (*DeleteStopwordsSetResponse, error)

	// RetrieveStopwordsSetWithResponse request
	RetrieveStopwordsSetWithResponse(ctx context.Context, setId string, reqEditors ...RequestEditorFn) (*RetrieveStopwordsSetResponse, error)

	// UpsertStopwordsSetWithBodyWithResponse request with any body
	UpsertStopwordsSetWithBodyWithResponse(ctx context.Context, setId string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*UpsertStopwordsSetResponse, error)

	UpsertStopwordsSetWithResponse(ctx context.Context, setId string, body UpsertStopwordsSetJSONRequestBody, reqEditors ...RequestEditorFn) (*UpsertStopwordsSetResponse, error)
}

type GetAliasesResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *CollectionAliasesResponse
}

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

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

type DeleteAliasResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *CollectionAlias
	JSON404      *ApiResponse
}

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

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

type GetAliasResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *CollectionAlias
	JSON404      *ApiResponse
}

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

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

type UpsertAliasResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *CollectionAlias
	JSON400      *ApiResponse
	JSON404      *ApiResponse
}

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

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

type CreateAnalyticsEventResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON201      *AnalyticsEventCreateResponse
	JSON400      *ApiResponse
}

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

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

type RetrieveAnalyticsRulesResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *AnalyticsRulesRetrieveSchema
}

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

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

type CreateAnalyticsRuleResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON201      *AnalyticsRuleSchema
	JSON400      *ApiResponse
}

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

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

type DeleteAnalyticsRuleResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *AnalyticsRuleDeleteResponse
	JSON404      *ApiResponse
}

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

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

type RetrieveAnalyticsRuleResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *AnalyticsRuleSchema
	JSON404      *ApiResponse
}

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

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

type UpsertAnalyticsRuleResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *AnalyticsRuleSchema
	JSON400      *ApiResponse
}

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

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

type GetCollectionsResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *[]*CollectionResponse
}

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

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

type CreateCollectionResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON201      *CollectionResponse
	JSON400      *ApiResponse
	JSON409      *ApiResponse
}

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

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

type DeleteCollectionResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *CollectionResponse
	JSON404      *ApiResponse
}

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

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

type GetCollectionResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *CollectionResponse
	JSON404      *ApiResponse
}

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

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

type UpdateCollectionResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *CollectionUpdateSchema
	JSON400      *ApiResponse
	JSON404      *ApiResponse
}

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

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

type DeleteDocumentsResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *struct {
		NumDeleted int `json:"num_deleted"`
	}
	JSON404 *ApiResponse
}

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

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

type UpdateDocumentsResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *struct {
		// NumUpdated The number of documents that have been updated
		NumUpdated int `json:"num_updated"`
	}
	JSON400 *ApiResponse
	JSON404 *ApiResponse
}

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

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

type IndexDocumentResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON201      *map[string]interface{}
	JSON404      *ApiResponse
}

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

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

type ExportDocumentsResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON404      *ApiResponse
}

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

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

type ImportDocumentsResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON400      *ApiResponse
	JSON404      *ApiResponse
}

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

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

type SearchCollectionResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *SearchResult
	JSON400      *ApiResponse
	JSON404      *ApiResponse
}

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

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

type DeleteDocumentResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *map[string]interface{}
	JSON404      *ApiResponse
}

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

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

type GetDocumentResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *map[string]interface{}
	JSON404      *ApiResponse
}

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

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

type UpdateDocumentResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *map[string]interface{}
	JSON404      *ApiResponse
}

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

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

type GetSearchOverridesResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *SearchOverridesResponse
}

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

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

type DeleteSearchOverrideResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *SearchOverrideDeleteResponse
	JSON404      *ApiResponse
}

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

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

type GetSearchOverrideResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *SearchOverride
}

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

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

type UpsertSearchOverrideResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *SearchOverride
	JSON404      *ApiResponse
}

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

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

type GetSearchSynonymsResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *SearchSynonymsResponse
	JSON404      *ApiResponse
}

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

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

type DeleteSearchSynonymResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *SearchSynonymDeleteResponse
	JSON404      *ApiResponse
}

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

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

type GetSearchSynonymResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *SearchSynonym
	JSON404      *ApiResponse
}

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

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

type UpsertSearchSynonymResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *SearchSynonym
	JSON404      *ApiResponse
}

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

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

type RetrieveAllConversationModelsResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *[]*ConversationModelSchema
}

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

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

type CreateConversationModelResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ConversationModelSchema
	JSON400      *ApiResponse
}

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

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

type DeleteConversationModelResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ConversationModelSchema
}

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

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

type RetrieveConversationModelResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ConversationModelSchema
}

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

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

type UpdateConversationModelResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ConversationModelSchema
}

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

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

type DebugResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *struct {
		Version *string `json:"version,omitempty"`
	}
}

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

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

type HealthResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *HealthStatus
}

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

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

type GetKeysResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ApiKeysResponse
}

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

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

type CreateKeyResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON201      *ApiKey
	JSON400      *ApiResponse
	JSON409      *ApiResponse
}

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

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

type DeleteKeyResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ApiKeyDeleteResponse
	JSON400      *ApiResponse
	JSON404      *ApiResponse
}

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

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

type GetKeyResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ApiKey
	JSON404      *ApiResponse
}

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

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

type RetrieveMetricsResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *map[string]interface{}
}

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

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

type MultiSearchResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *MultiSearchResult
	JSON400      *ApiResponse
}

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

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

type RetrieveAllNLSearchModelsResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *[]NLSearchModelSchema
}

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

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

type CreateNLSearchModelResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON201      *NLSearchModelSchema
	JSON400      *ApiResponse
}

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

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

type DeleteNLSearchModelResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *NLSearchModelDeleteSchema
	JSON404      *ApiResponse
}

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

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

type RetrieveNLSearchModelResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *NLSearchModelSchema
	JSON404      *ApiResponse
}

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

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

type UpdateNLSearchModelResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *NLSearchModelSchema
	JSON400      *ApiResponse
	JSON404      *ApiResponse
}

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

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

type GetSchemaChangesResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *[]SchemaChangeStatus
}

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

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

type TakeSnapshotResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON201      *SuccessStatus
}

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

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

type VoteResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *SuccessStatus
}

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

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

type RetrieveAllPresetsResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *PresetsRetrieveSchema
}

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

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

type DeletePresetResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *PresetDeleteSchema
	JSON404      *ApiResponse
}

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

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

type RetrievePresetResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *PresetSchema
	JSON404      *ApiResponse
}

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

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

type UpsertPresetResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *PresetSchema
	JSON400      *ApiResponse
}

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

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

type RetrieveAPIStatsResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *APIStatsResponse
}

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

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

type ListStemmingDictionariesResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *struct {
		Dictionaries *[]string `json:"dictionaries,omitempty"`
	}
}

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

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

type ImportStemmingDictionaryResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON400      *ApiResponse
}

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

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

type GetStemmingDictionaryResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *StemmingDictionary
	JSON404      *ApiResponse
}

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

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

type RetrieveStopwordsSetsResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *StopwordsSetsRetrieveAllSchema
}

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

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

type DeleteStopwordsSetResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *struct {
		Id string `json:"id"`
	}
	JSON404 *ApiResponse
}

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

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

type RetrieveStopwordsSetResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *StopwordsSetRetrieveSchema
	JSON404      *ApiResponse
}

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

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

type UpsertStopwordsSetResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *StopwordsSetSchema
	JSON400      *ApiResponse
}

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

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

// GetAliasesWithResponse request returning *GetAliasesResponse
func (c *ClientWithResponses) GetAliasesWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetAliasesResponse, error) {
	rsp, err := c.GetAliases(ctx, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetAliasesResponse(rsp)
}

// DeleteAliasWithResponse request returning *DeleteAliasResponse
func (c *ClientWithResponses) DeleteAliasWithResponse(ctx context.Context, aliasName string, reqEditors ...RequestEditorFn) (*DeleteAliasResponse, error) {
	rsp, err := c.DeleteAlias(ctx, aliasName, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDeleteAliasResponse(rsp)
}

// GetAliasWithResponse request returning *GetAliasResponse
func (c *ClientWithResponses) GetAliasWithResponse(ctx context.Context, aliasName string, reqEditors ...RequestEditorFn) (*GetAliasResponse, error) {
	rsp, err := c.GetAlias(ctx, aliasName, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetAliasResponse(rsp)
}

// UpsertAliasWithBodyWithResponse request with arbitrary body returning *UpsertAliasResponse
func (c *ClientWithResponses) UpsertAliasWithBodyWithResponse(ctx context.Context, aliasName string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*UpsertAliasResponse, error) {
	rsp, err := c.UpsertAliasWithBody(ctx, aliasName, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseUpsertAliasResponse(rsp)
}

func (c *ClientWithResponses) UpsertAliasWithResponse(ctx context.Context, aliasName string, body UpsertAliasJSONRequestBody, reqEditors ...RequestEditorFn) (*UpsertAliasResponse, error) {
	rsp, err := c.UpsertAlias(ctx, aliasName, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseUpsertAliasResponse(rsp)
}

// CreateAnalyticsEventWithBodyWithResponse request with arbitrary body returning *CreateAnalyticsEventResponse
func (c *ClientWithResponses) CreateAnalyticsEventWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*CreateAnalyticsEventResponse, error) {
	rsp, err := c.CreateAnalyticsEventWithBody(ctx, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseCreateAnalyticsEventResponse(rsp)
}

func (c *ClientWithResponses) CreateAnalyticsEventWithResponse(ctx context.Context, body CreateAnalyticsEventJSONRequestBody, reqEditors ...RequestEditorFn) (*CreateAnalyticsEventResponse, error) {
	rsp, err := c.CreateAnalyticsEvent(ctx, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseCreateAnalyticsEventResponse(rsp)
}

// RetrieveAnalyticsRulesWithResponse request returning *RetrieveAnalyticsRulesResponse
func (c *ClientWithResponses) RetrieveAnalyticsRulesWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*RetrieveAnalyticsRulesResponse, error) {
	rsp, err := c.RetrieveAnalyticsRules(ctx, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseRetrieveAnalyticsRulesResponse(rsp)
}

// CreateAnalyticsRuleWithBodyWithResponse request with arbitrary body returning *CreateAnalyticsRuleResponse
func (c *ClientWithResponses) CreateAnalyticsRuleWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*CreateAnalyticsRuleResponse, error) {
	rsp, err := c.CreateAnalyticsRuleWithBody(ctx, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseCreateAnalyticsRuleResponse(rsp)
}

func (c *ClientWithResponses) CreateAnalyticsRuleWithResponse(ctx context.Context, body CreateAnalyticsRuleJSONRequestBody, reqEditors ...RequestEditorFn) (*CreateAnalyticsRuleResponse, error) {
	rsp, err := c.CreateAnalyticsRule(ctx, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseCreateAnalyticsRuleResponse(rsp)
}

// DeleteAnalyticsRuleWithResponse request returning *DeleteAnalyticsRuleResponse
func (c *ClientWithResponses) DeleteAnalyticsRuleWithResponse(ctx context.Context, ruleName string, reqEditors ...RequestEditorFn) (*DeleteAnalyticsRuleResponse, error) {
	rsp, err := c.DeleteAnalyticsRule(ctx, ruleName, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDeleteAnalyticsRuleResponse(rsp)
}

// RetrieveAnalyticsRuleWithResponse request returning *RetrieveAnalyticsRuleResponse
func (c *ClientWithResponses) RetrieveAnalyticsRuleWithResponse(ctx context.Context, ruleName string, reqEditors ...RequestEditorFn) (*RetrieveAnalyticsRuleResponse, error) {
	rsp, err := c.RetrieveAnalyticsRule(ctx, ruleName, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseRetrieveAnalyticsRuleResponse(rsp)
}

// UpsertAnalyticsRuleWithBodyWithResponse request with arbitrary body returning *UpsertAnalyticsRuleResponse
func (c *ClientWithResponses) UpsertAnalyticsRuleWithBodyWithResponse(ctx context.Context, ruleName string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*UpsertAnalyticsRuleResponse, error) {
	rsp, err := c.UpsertAnalyticsRuleWithBody(ctx, ruleName, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseUpsertAnalyticsRuleResponse(rsp)
}

func (c *ClientWithResponses) UpsertAnalyticsRuleWithResponse(ctx context.Context, ruleName string, body UpsertAnalyticsRuleJSONRequestBody, reqEditors ...RequestEditorFn) (*UpsertAnalyticsRuleResponse, error) {
	rsp, err := c.UpsertAnalyticsRule(ctx, ruleName, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseUpsertAnalyticsRuleResponse(rsp)
}

// GetCollectionsWithResponse request returning *GetCollectionsResponse
func (c *ClientWithResponses) GetCollectionsWithResponse(ctx context.Context, params *GetCollectionsParams, reqEditors ...RequestEditorFn) (*GetCollectionsResponse, error) {
	rsp, err := c.GetCollections(ctx, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetCollectionsResponse(rsp)
}

// CreateCollectionWithBodyWithResponse request with arbitrary body returning *CreateCollectionResponse
func (c *ClientWithResponses) CreateCollectionWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*CreateCollectionResponse, error) {
	rsp, err := c.CreateCollectionWithBody(ctx, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseCreateCollectionResponse(rsp)
}

func (c *ClientWithResponses) CreateCollectionWithResponse(ctx context.Context, body CreateCollectionJSONRequestBody, reqEditors ...RequestEditorFn) (*CreateCollectionResponse, error) {
	rsp, err := c.CreateCollection(ctx, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseCreateCollectionResponse(rsp)
}

// DeleteCollectionWithResponse request returning *DeleteCollectionResponse
func (c *ClientWithResponses) DeleteCollectionWithResponse(ctx context.Context, collectionName string, reqEditors ...RequestEditorFn) (*DeleteCollectionResponse, error) {
	rsp, err := c.DeleteCollection(ctx, collectionName, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDeleteCollectionResponse(rsp)
}

// GetCollectionWithResponse request returning *GetCollectionResponse
func (c *ClientWithResponses) GetCollectionWithResponse(ctx context.Context, collectionName string, reqEditors ...RequestEditorFn) (*GetCollectionResponse, error) {
	rsp, err := c.GetCollection(ctx, collectionName, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetCollectionResponse(rsp)
}

// UpdateCollectionWithBodyWithResponse request with arbitrary body returning *UpdateCollectionResponse
func (c *ClientWithResponses) UpdateCollectionWithBodyWithResponse(ctx context.Context, collectionName string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*UpdateCollectionResponse, error) {
	rsp, err := c.UpdateCollectionWithBody(ctx, collectionName, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseUpdateCollectionResponse(rsp)
}

func (c *ClientWithResponses) UpdateCollectionWithResponse(ctx context.Context, collectionName string, body UpdateCollectionJSONRequestBody, reqEditors ...RequestEditorFn) (*UpdateCollectionResponse, error) {
	rsp, err := c.UpdateCollection(ctx, collectionName, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseUpdateCollectionResponse(rsp)
}

// DeleteDocumentsWithResponse request returning *DeleteDocumentsResponse
func (c *ClientWithResponses) DeleteDocumentsWithResponse(ctx context.Context, collectionName string, params *DeleteDocumentsParams, reqEditors ...RequestEditorFn) (*DeleteDocumentsResponse, error) {
	rsp, err := c.DeleteDocuments(ctx, collectionName, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDeleteDocumentsResponse(rsp)
}

// UpdateDocumentsWithBodyWithResponse request with arbitrary body returning *UpdateDocumentsResponse
func (c *ClientWithResponses) UpdateDocumentsWithBodyWithResponse(ctx context.Context, collectionName string, params *UpdateDocumentsParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*UpdateDocumentsResponse, error) {
	rsp, err := c.UpdateDocumentsWithBody(ctx, collectionName, params, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseUpdateDocumentsResponse(rsp)
}

func (c *ClientWithResponses) UpdateDocumentsWithResponse(ctx context.Context, collectionName string, params *UpdateDocumentsParams, body UpdateDocumentsJSONRequestBody, reqEditors ...RequestEditorFn) (*UpdateDocumentsResponse, error) {
	rsp, err := c.UpdateDocuments(ctx, collectionName, params, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseUpdateDocumentsResponse(rsp)
}

// IndexDocumentWithBodyWithResponse request with arbitrary body returning *IndexDocumentResponse
func (c *ClientWithResponses) IndexDocumentWithBodyWithResponse(ctx context.Context, collectionName string, params *IndexDocumentParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*IndexDocumentResponse, error) {
	rsp, err := c.IndexDocumentWithBody(ctx, collectionName, params, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseIndexDocumentResponse(rsp)
}

func (c *ClientWithResponses) IndexDocumentWithResponse(ctx context.Context, collectionName string, params *IndexDocumentParams, body IndexDocumentJSONRequestBody, reqEditors ...RequestEditorFn) (*IndexDocumentResponse, error) {
	rsp, err := c.IndexDocument(ctx, collectionName, params, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseIndexDocumentResponse(rsp)
}

// ExportDocumentsWithResponse request returning *ExportDocumentsResponse
func (c *ClientWithResponses) ExportDocumentsWithResponse(ctx context.Context, collectionName string, params *ExportDocumentsParams, reqEditors ...RequestEditorFn) (*ExportDocumentsResponse, error) {
	rsp, err := c.ExportDocuments(ctx, collectionName, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseExportDocumentsResponse(rsp)
}

// ImportDocumentsWithBodyWithResponse request with arbitrary body returning *ImportDocumentsResponse
func (c *ClientWithResponses) ImportDocumentsWithBodyWithResponse(ctx context.Context, collectionName string, params *ImportDocumentsParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*ImportDocumentsResponse, error) {
	rsp, err := c.ImportDocumentsWithBody(ctx, collectionName, params, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseImportDocumentsResponse(rsp)
}

// SearchCollectionWithResponse request returning *SearchCollectionResponse
func (c *ClientWithResponses) SearchCollectionWithResponse(ctx context.Context, collectionName string, params *SearchCollectionParams, reqEditors ...RequestEditorFn) (*SearchCollectionResponse, error) {
	rsp, err := c.SearchCollection(ctx, collectionName, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseSearchCollectionResponse(rsp)
}

// DeleteDocumentWithResponse request returning *DeleteDocumentResponse
func (c *ClientWithResponses) DeleteDocumentWithResponse(ctx context.Context, collectionName string, documentId string, reqEditors ...RequestEditorFn) (*DeleteDocumentResponse, error) {
	rsp, err := c.DeleteDocument(ctx, collectionName, documentId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDeleteDocumentResponse(rsp)
}

// GetDocumentWithResponse request returning *GetDocumentResponse
func (c *ClientWithResponses) GetDocumentWithResponse(ctx context.Context, collectionName string, documentId string, reqEditors ...RequestEditorFn) (*GetDocumentResponse, error) {
	rsp, err := c.GetDocument(ctx, collectionName, documentId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetDocumentResponse(rsp)
}

// UpdateDocumentWithBodyWithResponse request with arbitrary body returning *UpdateDocumentResponse
func (c *ClientWithResponses) UpdateDocumentWithBodyWithResponse(ctx context.Context, collectionName string, documentId string, params *UpdateDocumentParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*UpdateDocumentResponse, error) {
	rsp, err := c.UpdateDocumentWithBody(ctx, collectionName, documentId, params, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseUpdateDocumentResponse(rsp)
}

func (c *ClientWithResponses) UpdateDocumentWithResponse(ctx context.Context, collectionName string, documentId string, params *UpdateDocumentParams, body UpdateDocumentJSONRequestBody, reqEditors ...RequestEditorFn) (*UpdateDocumentResponse, error) {
	rsp, err := c.UpdateDocument(ctx, collectionName, documentId, params, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseUpdateDocumentResponse(rsp)
}

// GetSearchOverridesWithResponse request returning *GetSearchOverridesResponse
func (c *ClientWithResponses) GetSearchOverridesWithResponse(ctx context.Context, collectionName string, reqEditors ...RequestEditorFn) (*GetSearchOverridesResponse, error) {
	rsp, err := c.GetSearchOverrides(ctx, collectionName, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetSearchOverridesResponse(rsp)
}

// DeleteSearchOverrideWithResponse request returning *DeleteSearchOverrideResponse
func (c *ClientWithResponses) DeleteSearchOverrideWithResponse(ctx context.Context, collectionName string, overrideId string, reqEditors ...RequestEditorFn) (*DeleteSearchOverrideResponse, error) {
	rsp, err := c.DeleteSearchOverride(ctx, collectionName, overrideId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDeleteSearchOverrideResponse(rsp)
}

// GetSearchOverrideWithResponse request returning *GetSearchOverrideResponse
func (c *ClientWithResponses) GetSearchOverrideWithResponse(ctx context.Context, collectionName string, overrideId string, reqEditors ...RequestEditorFn) (*GetSearchOverrideResponse, error) {
	rsp, err := c.GetSearchOverride(ctx, collectionName, overrideId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetSearchOverrideResponse(rsp)
}

// UpsertSearchOverrideWithBodyWithResponse request with arbitrary body returning *UpsertSearchOverrideResponse
func (c *ClientWithResponses) UpsertSearchOverrideWithBodyWithResponse(ctx context.Context, collectionName string, overrideId string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*UpsertSearchOverrideResponse, error) {
	rsp, err := c.UpsertSearchOverrideWithBody(ctx, collectionName, overrideId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseUpsertSearchOverrideResponse(rsp)
}

func (c *ClientWithResponses) UpsertSearchOverrideWithResponse(ctx context.Context, collectionName string, overrideId string, body UpsertSearchOverrideJSONRequestBody, reqEditors ...RequestEditorFn) (*UpsertSearchOverrideResponse, error) {
	rsp, err := c.UpsertSearchOverride(ctx, collectionName, overrideId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseUpsertSearchOverrideResponse(rsp)
}

// GetSearchSynonymsWithResponse request returning *GetSearchSynonymsResponse
func (c *ClientWithResponses) GetSearchSynonymsWithResponse(ctx context.Context, collectionName string, reqEditors ...RequestEditorFn) (*GetSearchSynonymsResponse, error) {
	rsp, err := c.GetSearchSynonyms(ctx, collectionName, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetSearchSynonymsResponse(rsp)
}

// DeleteSearchSynonymWithResponse request returning *DeleteSearchSynonymResponse
func (c *ClientWithResponses) DeleteSearchSynonymWithResponse(ctx context.Context, collectionName string, synonymId string, reqEditors ...RequestEditorFn) (*DeleteSearchSynonymResponse, error) {
	rsp, err := c.DeleteSearchSynonym(ctx, collectionName, synonymId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDeleteSearchSynonymResponse(rsp)
}

// GetSearchSynonymWithResponse request returning *GetSearchSynonymResponse
func (c *ClientWithResponses) GetSearchSynonymWithResponse(ctx context.Context, collectionName string, synonymId string, reqEditors ...RequestEditorFn) (*GetSearchSynonymResponse, error) {
	rsp, err := c.GetSearchSynonym(ctx, collectionName, synonymId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetSearchSynonymResponse(rsp)
}

// UpsertSearchSynonymWithBodyWithResponse request with arbitrary body returning *UpsertSearchSynonymResponse
func (c *ClientWithResponses) UpsertSearchSynonymWithBodyWithResponse(ctx context.Context, collectionName string, synonymId string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*UpsertSearchSynonymResponse, error) {
	rsp, err := c.UpsertSearchSynonymWithBody(ctx, collectionName, synonymId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseUpsertSearchSynonymResponse(rsp)
}

func (c *ClientWithResponses) UpsertSearchSynonymWithResponse(ctx context.Context, collectionName string, synonymId string, body UpsertSearchSynonymJSONRequestBody, reqEditors ...RequestEditorFn) (*UpsertSearchSynonymResponse, error) {
	rsp, err := c.UpsertSearchSynonym(ctx, collectionName, synonymId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseUpsertSearchSynonymResponse(rsp)
}

// RetrieveAllConversationModelsWithResponse request returning *RetrieveAllConversationModelsResponse
func (c *ClientWithResponses) RetrieveAllConversationModelsWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*RetrieveAllConversationModelsResponse, error) {
	rsp, err := c.RetrieveAllConversationModels(ctx, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseRetrieveAllConversationModelsResponse(rsp)
}

// CreateConversationModelWithBodyWithResponse request with arbitrary body returning *CreateConversationModelResponse
func (c *ClientWithResponses) CreateConversationModelWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*CreateConversationModelResponse, error) {
	rsp, err := c.CreateConversationModelWithBody(ctx, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseCreateConversationModelResponse(rsp)
}

func (c *ClientWithResponses) CreateConversationModelWithResponse(ctx context.Context, body CreateConversationModelJSONRequestBody, reqEditors ...RequestEditorFn) (*CreateConversationModelResponse, error) {
	rsp, err := c.CreateConversationModel(ctx, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseCreateConversationModelResponse(rsp)
}

// DeleteConversationModelWithResponse request returning *DeleteConversationModelResponse
func (c *ClientWithResponses) DeleteConversationModelWithResponse(ctx context.Context, modelId string, reqEditors ...RequestEditorFn) (*DeleteConversationModelResponse, error) {
	rsp, err := c.DeleteConversationModel(ctx, modelId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDeleteConversationModelResponse(rsp)
}

// RetrieveConversationModelWithResponse request returning *RetrieveConversationModelResponse
func (c *ClientWithResponses) RetrieveConversationModelWithResponse(ctx context.Context, modelId string, reqEditors ...RequestEditorFn) (*RetrieveConversationModelResponse, error) {
	rsp, err := c.RetrieveConversationModel(ctx, modelId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseRetrieveConversationModelResponse(rsp)
}

// UpdateConversationModelWithBodyWithResponse request with arbitrary body returning *UpdateConversationModelResponse
func (c *ClientWithResponses) UpdateConversationModelWithBodyWithResponse(ctx context.Context, modelId string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*UpdateConversationModelResponse, error) {
	rsp, err := c.UpdateConversationModelWithBody(ctx, modelId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseUpdateConversationModelResponse(rsp)
}

func (c *ClientWithResponses) UpdateConversationModelWithResponse(ctx context.Context, modelId string, body UpdateConversationModelJSONRequestBody, reqEditors ...RequestEditorFn) (*UpdateConversationModelResponse, error) {
	rsp, err := c.UpdateConversationModel(ctx, modelId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseUpdateConversationModelResponse(rsp)
}

// DebugWithResponse request returning *DebugResponse
func (c *ClientWithResponses) DebugWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*DebugResponse, error) {
	rsp, err := c.Debug(ctx, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDebugResponse(rsp)
}

// HealthWithResponse request returning *HealthResponse
func (c *ClientWithResponses) HealthWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*HealthResponse, error) {
	rsp, err := c.Health(ctx, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseHealthResponse(rsp)
}

// GetKeysWithResponse request returning *GetKeysResponse
func (c *ClientWithResponses) GetKeysWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetKeysResponse, error) {
	rsp, err := c.GetKeys(ctx, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetKeysResponse(rsp)
}

// CreateKeyWithBodyWithResponse request with arbitrary body returning *CreateKeyResponse
func (c *ClientWithResponses) CreateKeyWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*CreateKeyResponse, error) {
	rsp, err := c.CreateKeyWithBody(ctx, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseCreateKeyResponse(rsp)
}

func (c *ClientWithResponses) CreateKeyWithResponse(ctx context.Context, body CreateKeyJSONRequestBody, reqEditors ...RequestEditorFn) (*CreateKeyResponse, error) {
	rsp, err := c.CreateKey(ctx, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseCreateKeyResponse(rsp)
}

// DeleteKeyWithResponse request returning *DeleteKeyResponse
func (c *ClientWithResponses) DeleteKeyWithResponse(ctx context.Context, keyId int64, reqEditors ...RequestEditorFn) (*DeleteKeyResponse, error) {
	rsp, err := c.DeleteKey(ctx, keyId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDeleteKeyResponse(rsp)
}

// GetKeyWithResponse request returning *GetKeyResponse
func (c *ClientWithResponses) GetKeyWithResponse(ctx context.Context, keyId int64, reqEditors ...RequestEditorFn) (*GetKeyResponse, error) {
	rsp, err := c.GetKey(ctx, keyId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetKeyResponse(rsp)
}

// RetrieveMetricsWithResponse request returning *RetrieveMetricsResponse
func (c *ClientWithResponses) RetrieveMetricsWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*RetrieveMetricsResponse, error) {
	rsp, err := c.RetrieveMetrics(ctx, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseRetrieveMetricsResponse(rsp)
}

// MultiSearchWithBodyWithResponse request with arbitrary body returning *MultiSearchResponse
func (c *ClientWithResponses) MultiSearchWithBodyWithResponse(ctx context.Context, params *MultiSearchParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*MultiSearchResponse, error) {
	rsp, err := c.MultiSearchWithBody(ctx, params, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseMultiSearchResponse(rsp)
}

func (c *ClientWithResponses) MultiSearchWithResponse(ctx context.Context, params *MultiSearchParams, body MultiSearchJSONRequestBody, reqEditors ...RequestEditorFn) (*MultiSearchResponse, error) {
	rsp, err := c.MultiSearch(ctx, params, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseMultiSearchResponse(rsp)
}

// RetrieveAllNLSearchModelsWithResponse request returning *RetrieveAllNLSearchModelsResponse
func (c *ClientWithResponses) RetrieveAllNLSearchModelsWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*RetrieveAllNLSearchModelsResponse, error) {
	rsp, err := c.RetrieveAllNLSearchModels(ctx, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseRetrieveAllNLSearchModelsResponse(rsp)
}

// CreateNLSearchModelWithBodyWithResponse request with arbitrary body returning *CreateNLSearchModelResponse
func (c *ClientWithResponses) CreateNLSearchModelWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*CreateNLSearchModelResponse, error) {
	rsp, err := c.CreateNLSearchModelWithBody(ctx, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseCreateNLSearchModelResponse(rsp)
}

func (c *ClientWithResponses) CreateNLSearchModelWithResponse(ctx context.Context, body CreateNLSearchModelJSONRequestBody, reqEditors ...RequestEditorFn) (*CreateNLSearchModelResponse, error) {
	rsp, err := c.CreateNLSearchModel(ctx, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseCreateNLSearchModelResponse(rsp)
}

// DeleteNLSearchModelWithResponse request returning *DeleteNLSearchModelResponse
func (c *ClientWithResponses) DeleteNLSearchModelWithResponse(ctx context.Context, modelId string, reqEditors ...RequestEditorFn) (*DeleteNLSearchModelResponse, error) {
	rsp, err := c.DeleteNLSearchModel(ctx, modelId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDeleteNLSearchModelResponse(rsp)
}

// RetrieveNLSearchModelWithResponse request returning *RetrieveNLSearchModelResponse
func (c *ClientWithResponses) RetrieveNLSearchModelWithResponse(ctx context.Context, modelId string, reqEditors ...RequestEditorFn) (*RetrieveNLSearchModelResponse, error) {
	rsp, err := c.RetrieveNLSearchModel(ctx, modelId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseRetrieveNLSearchModelResponse(rsp)
}

// UpdateNLSearchModelWithBodyWithResponse request with arbitrary body returning *UpdateNLSearchModelResponse
func (c *ClientWithResponses) UpdateNLSearchModelWithBodyWithResponse(ctx context.Context, modelId string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*UpdateNLSearchModelResponse, error) {
	rsp, err := c.UpdateNLSearchModelWithBody(ctx, modelId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseUpdateNLSearchModelResponse(rsp)
}

func (c *ClientWithResponses) UpdateNLSearchModelWithResponse(ctx context.Context, modelId string, body UpdateNLSearchModelJSONRequestBody, reqEditors ...RequestEditorFn) (*UpdateNLSearchModelResponse, error) {
	rsp, err := c.UpdateNLSearchModel(ctx, modelId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseUpdateNLSearchModelResponse(rsp)
}

// GetSchemaChangesWithResponse request returning *GetSchemaChangesResponse
func (c *ClientWithResponses) GetSchemaChangesWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetSchemaChangesResponse, error) {
	rsp, err := c.GetSchemaChanges(ctx, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetSchemaChangesResponse(rsp)
}

// TakeSnapshotWithResponse request returning *TakeSnapshotResponse
func (c *ClientWithResponses) TakeSnapshotWithResponse(ctx context.Context, params *TakeSnapshotParams, reqEditors ...RequestEditorFn) (*TakeSnapshotResponse, error) {
	rsp, err := c.TakeSnapshot(ctx, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseTakeSnapshotResponse(rsp)
}

// VoteWithResponse request returning *VoteResponse
func (c *ClientWithResponses) VoteWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*VoteResponse, error) {
	rsp, err := c.Vote(ctx, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseVoteResponse(rsp)
}

// RetrieveAllPresetsWithResponse request returning *RetrieveAllPresetsResponse
func (c *ClientWithResponses) RetrieveAllPresetsWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*RetrieveAllPresetsResponse, error) {
	rsp, err := c.RetrieveAllPresets(ctx, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseRetrieveAllPresetsResponse(rsp)
}

// DeletePresetWithResponse request returning *DeletePresetResponse
func (c *ClientWithResponses) DeletePresetWithResponse(ctx context.Context, presetId string, reqEditors ...RequestEditorFn) (*DeletePresetResponse, error) {
	rsp, err := c.DeletePreset(ctx, presetId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDeletePresetResponse(rsp)
}

// RetrievePresetWithResponse request returning *RetrievePresetResponse
func (c *ClientWithResponses) RetrievePresetWithResponse(ctx context.Context, presetId string, reqEditors ...RequestEditorFn) (*RetrievePresetResponse, error) {
	rsp, err := c.RetrievePreset(ctx, presetId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseRetrievePresetResponse(rsp)
}

// UpsertPresetWithBodyWithResponse request with arbitrary body returning *UpsertPresetResponse
func (c *ClientWithResponses) UpsertPresetWithBodyWithResponse(ctx context.Context, presetId string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*UpsertPresetResponse, error) {
	rsp, err := c.UpsertPresetWithBody(ctx, presetId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseUpsertPresetResponse(rsp)
}

func (c *ClientWithResponses) UpsertPresetWithResponse(ctx context.Context, presetId string, body UpsertPresetJSONRequestBody, reqEditors ...RequestEditorFn) (*UpsertPresetResponse, error) {
	rsp, err := c.UpsertPreset(ctx, presetId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseUpsertPresetResponse(rsp)
}

// RetrieveAPIStatsWithResponse request returning *RetrieveAPIStatsResponse
func (c *ClientWithResponses) RetrieveAPIStatsWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*RetrieveAPIStatsResponse, error) {
	rsp, err := c.RetrieveAPIStats(ctx, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseRetrieveAPIStatsResponse(rsp)
}

// ListStemmingDictionariesWithResponse request returning *ListStemmingDictionariesResponse
func (c *ClientWithResponses) ListStemmingDictionariesWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*ListStemmingDictionariesResponse, error) {
	rsp, err := c.ListStemmingDictionaries(ctx, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseListStemmingDictionariesResponse(rsp)
}

// ImportStemmingDictionaryWithBodyWithResponse request with arbitrary body returning *ImportStemmingDictionaryResponse
func (c *ClientWithResponses) ImportStemmingDictionaryWithBodyWithResponse(ctx context.Context, params *ImportStemmingDictionaryParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*ImportStemmingDictionaryResponse, error) {
	rsp, err := c.ImportStemmingDictionaryWithBody(ctx, params, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseImportStemmingDictionaryResponse(rsp)
}

func (c *ClientWithResponses) ImportStemmingDictionaryWithResponse(ctx context.Context, params *ImportStemmingDictionaryParams, body ImportStemmingDictionaryJSONRequestBody, reqEditors ...RequestEditorFn) (*ImportStemmingDictionaryResponse, error) {
	rsp, err := c.ImportStemmingDictionary(ctx, params, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseImportStemmingDictionaryResponse(rsp)
}

// GetStemmingDictionaryWithResponse request returning *GetStemmingDictionaryResponse
func (c *ClientWithResponses) GetStemmingDictionaryWithResponse(ctx context.Context, dictionaryId string, reqEditors ...RequestEditorFn) (*GetStemmingDictionaryResponse, error) {
	rsp, err := c.GetStemmingDictionary(ctx, dictionaryId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetStemmingDictionaryResponse(rsp)
}

// RetrieveStopwordsSetsWithResponse request returning *RetrieveStopwordsSetsResponse
func (c *ClientWithResponses) RetrieveStopwordsSetsWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*RetrieveStopwordsSetsResponse, error) {
	rsp, err := c.RetrieveStopwordsSets(ctx, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseRetrieveStopwordsSetsResponse(rsp)
}

// DeleteStopwordsSetWithResponse request returning *DeleteStopwordsSetResponse
func (c *ClientWithResponses) DeleteStopwordsSetWithResponse(ctx context.Context, setId string, reqEditors ...RequestEditorFn) (*DeleteStopwordsSetResponse, error) {
	rsp, err := c.DeleteStopwordsSet(ctx, setId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDeleteStopwordsSetResponse(rsp)
}

// RetrieveStopwordsSetWithResponse request returning *RetrieveStopwordsSetResponse
func (c *ClientWithResponses) RetrieveStopwordsSetWithResponse(ctx context.Context, setId string, reqEditors ...RequestEditorFn) (*RetrieveStopwordsSetResponse, error) {
	rsp, err := c.RetrieveStopwordsSet(ctx, setId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseRetrieveStopwordsSetResponse(rsp)
}

// UpsertStopwordsSetWithBodyWithResponse request with arbitrary body returning *UpsertStopwordsSetResponse
func (c *ClientWithResponses) UpsertStopwordsSetWithBodyWithResponse(ctx context.Context, setId string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*UpsertStopwordsSetResponse, error) {
	rsp, err := c.UpsertStopwordsSetWithBody(ctx, setId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseUpsertStopwordsSetResponse(rsp)
}

func (c *ClientWithResponses) UpsertStopwordsSetWithResponse(ctx context.Context, setId string, body UpsertStopwordsSetJSONRequestBody, reqEditors ...RequestEditorFn) (*UpsertStopwordsSetResponse, error) {
	rsp, err := c.UpsertStopwordsSet(ctx, setId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseUpsertStopwordsSetResponse(rsp)
}

// ParseGetAliasesResponse parses an HTTP response from a GetAliasesWithResponse call
func ParseGetAliasesResponse(rsp *http.Response) (*GetAliasesResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &GetAliasesResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest CollectionAliasesResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseDeleteAliasResponse parses an HTTP response from a DeleteAliasWithResponse call
func ParseDeleteAliasResponse(rsp *http.Response) (*DeleteAliasResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &DeleteAliasResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest CollectionAlias
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest ApiResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseGetAliasResponse parses an HTTP response from a GetAliasWithResponse call
func ParseGetAliasResponse(rsp *http.Response) (*GetAliasResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &GetAliasResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest CollectionAlias
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest ApiResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseUpsertAliasResponse parses an HTTP response from a UpsertAliasWithResponse call
func ParseUpsertAliasResponse(rsp *http.Response) (*UpsertAliasResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &UpsertAliasResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest CollectionAlias
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest ApiResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest ApiResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseCreateAnalyticsEventResponse parses an HTTP response from a CreateAnalyticsEventWithResponse call
func ParseCreateAnalyticsEventResponse(rsp *http.Response) (*CreateAnalyticsEventResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &CreateAnalyticsEventResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 201:
		var dest AnalyticsEventCreateResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON201 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest ApiResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	}

	return response, nil
}

// ParseRetrieveAnalyticsRulesResponse parses an HTTP response from a RetrieveAnalyticsRulesWithResponse call
func ParseRetrieveAnalyticsRulesResponse(rsp *http.Response) (*RetrieveAnalyticsRulesResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &RetrieveAnalyticsRulesResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest AnalyticsRulesRetrieveSchema
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseCreateAnalyticsRuleResponse parses an HTTP response from a CreateAnalyticsRuleWithResponse call
func ParseCreateAnalyticsRuleResponse(rsp *http.Response) (*CreateAnalyticsRuleResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &CreateAnalyticsRuleResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 201:
		var dest AnalyticsRuleSchema
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON201 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest ApiResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	}

	return response, nil
}

// ParseDeleteAnalyticsRuleResponse parses an HTTP response from a DeleteAnalyticsRuleWithResponse call
func ParseDeleteAnalyticsRuleResponse(rsp *http.Response) (*DeleteAnalyticsRuleResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &DeleteAnalyticsRuleResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest AnalyticsRuleDeleteResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest ApiResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseRetrieveAnalyticsRuleResponse parses an HTTP response from a RetrieveAnalyticsRuleWithResponse call
func ParseRetrieveAnalyticsRuleResponse(rsp *http.Response) (*RetrieveAnalyticsRuleResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &RetrieveAnalyticsRuleResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest AnalyticsRuleSchema
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest ApiResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseUpsertAnalyticsRuleResponse parses an HTTP response from a UpsertAnalyticsRuleWithResponse call
func ParseUpsertAnalyticsRuleResponse(rsp *http.Response) (*UpsertAnalyticsRuleResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &UpsertAnalyticsRuleResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest AnalyticsRuleSchema
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest ApiResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	}

	return response, nil
}

// ParseGetCollectionsResponse parses an HTTP response from a GetCollectionsWithResponse call
func ParseGetCollectionsResponse(rsp *http.Response) (*GetCollectionsResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &GetCollectionsResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest []*CollectionResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseCreateCollectionResponse parses an HTTP response from a CreateCollectionWithResponse call
func ParseCreateCollectionResponse(rsp *http.Response) (*CreateCollectionResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &CreateCollectionResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 201:
		var dest CollectionResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON201 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest ApiResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 409:
		var dest ApiResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON409 = &dest

	}

	return response, nil
}

// ParseDeleteCollectionResponse parses an HTTP response from a DeleteCollectionWithResponse call
func ParseDeleteCollectionResponse(rsp *http.Response) (*DeleteCollectionResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &DeleteCollectionResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest CollectionResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest ApiResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseGetCollectionResponse parses an HTTP response from a GetCollectionWithResponse call
func ParseGetCollectionResponse(rsp *http.Response) (*GetCollectionResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &GetCollectionResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest CollectionResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest ApiResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseUpdateCollectionResponse parses an HTTP response from a UpdateCollectionWithResponse call
func ParseUpdateCollectionResponse(rsp *http.Response) (*UpdateCollectionResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &UpdateCollectionResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest CollectionUpdateSchema
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest ApiResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest ApiResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseDeleteDocumentsResponse parses an HTTP response from a DeleteDocumentsWithResponse call
func ParseDeleteDocumentsResponse(rsp *http.Response) (*DeleteDocumentsResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &DeleteDocumentsResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest struct {
			NumDeleted int `json:"num_deleted"`
		}
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest ApiResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseUpdateDocumentsResponse parses an HTTP response from a UpdateDocumentsWithResponse call
func ParseUpdateDocumentsResponse(rsp *http.Response) (*UpdateDocumentsResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &UpdateDocumentsResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest struct {
			// NumUpdated The number of documents that have been updated
			NumUpdated int `json:"num_updated"`
		}
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest ApiResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest ApiResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseIndexDocumentResponse parses an HTTP response from a IndexDocumentWithResponse call
func ParseIndexDocumentResponse(rsp *http.Response) (*IndexDocumentResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &IndexDocumentResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 201:
		var dest map[string]interface{}
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON201 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest ApiResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseExportDocumentsResponse parses an HTTP response from a ExportDocumentsWithResponse call
func ParseExportDocumentsResponse(rsp *http.Response) (*ExportDocumentsResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &ExportDocumentsResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest ApiResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseImportDocumentsResponse parses an HTTP response from a ImportDocumentsWithResponse call
func ParseImportDocumentsResponse(rsp *http.Response) (*ImportDocumentsResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &ImportDocumentsResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest ApiResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest ApiResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseSearchCollectionResponse parses an HTTP response from a SearchCollectionWithResponse call
func ParseSearchCollectionResponse(rsp *http.Response) (*SearchCollectionResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &SearchCollectionResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest SearchResult
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest ApiResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest ApiResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseDeleteDocumentResponse parses an HTTP response from a DeleteDocumentWithResponse call
func ParseDeleteDocumentResponse(rsp *http.Response) (*DeleteDocumentResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &DeleteDocumentResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest map[string]interface{}
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest ApiResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseGetDocumentResponse parses an HTTP response from a GetDocumentWithResponse call
func ParseGetDocumentResponse(rsp *http.Response) (*GetDocumentResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &GetDocumentResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest map[string]interface{}
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest ApiResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseUpdateDocumentResponse parses an HTTP response from a UpdateDocumentWithResponse call
func ParseUpdateDocumentResponse(rsp *http.Response) (*UpdateDocumentResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &UpdateDocumentResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest map[string]interface{}
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest ApiResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseGetSearchOverridesResponse parses an HTTP response from a GetSearchOverridesWithResponse call
func ParseGetSearchOverridesResponse(rsp *http.Response) (*GetSearchOverridesResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &GetSearchOverridesResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest SearchOverridesResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseDeleteSearchOverrideResponse parses an HTTP response from a DeleteSearchOverrideWithResponse call
func ParseDeleteSearchOverrideResponse(rsp *http.Response) (*DeleteSearchOverrideResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &DeleteSearchOverrideResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest SearchOverrideDeleteResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest ApiResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseGetSearchOverrideResponse parses an HTTP response from a GetSearchOverrideWithResponse call
func ParseGetSearchOverrideResponse(rsp *http.Response) (*GetSearchOverrideResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &GetSearchOverrideResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest SearchOverride
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseUpsertSearchOverrideResponse parses an HTTP response from a UpsertSearchOverrideWithResponse call
func ParseUpsertSearchOverrideResponse(rsp *http.Response) (*UpsertSearchOverrideResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &UpsertSearchOverrideResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest SearchOverride
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest ApiResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseGetSearchSynonymsResponse parses an HTTP response from a GetSearchSynonymsWithResponse call
func ParseGetSearchSynonymsResponse(rsp *http.Response) (*GetSearchSynonymsResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &GetSearchSynonymsResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest SearchSynonymsResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest ApiResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseDeleteSearchSynonymResponse parses an HTTP response from a DeleteSearchSynonymWithResponse call
func ParseDeleteSearchSynonymResponse(rsp *http.Response) (*DeleteSearchSynonymResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &DeleteSearchSynonymResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest SearchSynonymDeleteResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest ApiResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseGetSearchSynonymResponse parses an HTTP response from a GetSearchSynonymWithResponse call
func ParseGetSearchSynonymResponse(rsp *http.Response) (*GetSearchSynonymResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &GetSearchSynonymResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest SearchSynonym
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest ApiResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseUpsertSearchSynonymResponse parses an HTTP response from a UpsertSearchSynonymWithResponse call
func ParseUpsertSearchSynonymResponse(rsp *http.Response) (*UpsertSearchSynonymResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &UpsertSearchSynonymResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest SearchSynonym
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest ApiResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseRetrieveAllConversationModelsResponse parses an HTTP response from a RetrieveAllConversationModelsWithResponse call
func ParseRetrieveAllConversationModelsResponse(rsp *http.Response) (*RetrieveAllConversationModelsResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &RetrieveAllConversationModelsResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest []*ConversationModelSchema
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseCreateConversationModelResponse parses an HTTP response from a CreateConversationModelWithResponse call
func ParseCreateConversationModelResponse(rsp *http.Response) (*CreateConversationModelResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &CreateConversationModelResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest ConversationModelSchema
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest ApiResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	}

	return response, nil
}

// ParseDeleteConversationModelResponse parses an HTTP response from a DeleteConversationModelWithResponse call
func ParseDeleteConversationModelResponse(rsp *http.Response) (*DeleteConversationModelResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &DeleteConversationModelResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest ConversationModelSchema
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseRetrieveConversationModelResponse parses an HTTP response from a RetrieveConversationModelWithResponse call
func ParseRetrieveConversationModelResponse(rsp *http.Response) (*RetrieveConversationModelResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &RetrieveConversationModelResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest ConversationModelSchema
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseUpdateConversationModelResponse parses an HTTP response from a UpdateConversationModelWithResponse call
func ParseUpdateConversationModelResponse(rsp *http.Response) (*UpdateConversationModelResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &UpdateConversationModelResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest ConversationModelSchema
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseDebugResponse parses an HTTP response from a DebugWithResponse call
func ParseDebugResponse(rsp *http.Response) (*DebugResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &DebugResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest struct {
			Version *string `json:"version,omitempty"`
		}
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseHealthResponse parses an HTTP response from a HealthWithResponse call
func ParseHealthResponse(rsp *http.Response) (*HealthResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &HealthResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest HealthStatus
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseGetKeysResponse parses an HTTP response from a GetKeysWithResponse call
func ParseGetKeysResponse(rsp *http.Response) (*GetKeysResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &GetKeysResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest ApiKeysResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseCreateKeyResponse parses an HTTP response from a CreateKeyWithResponse call
func ParseCreateKeyResponse(rsp *http.Response) (*CreateKeyResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &CreateKeyResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 201:
		var dest ApiKey
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON201 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest ApiResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 409:
		var dest ApiResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON409 = &dest

	}

	return response, nil
}

// ParseDeleteKeyResponse parses an HTTP response from a DeleteKeyWithResponse call
func ParseDeleteKeyResponse(rsp *http.Response) (*DeleteKeyResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &DeleteKeyResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest ApiKeyDeleteResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest ApiResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest ApiResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseGetKeyResponse parses an HTTP response from a GetKeyWithResponse call
func ParseGetKeyResponse(rsp *http.Response) (*GetKeyResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &GetKeyResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest ApiKey
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest ApiResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseRetrieveMetricsResponse parses an HTTP response from a RetrieveMetricsWithResponse call
func ParseRetrieveMetricsResponse(rsp *http.Response) (*RetrieveMetricsResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &RetrieveMetricsResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest map[string]interface{}
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseMultiSearchResponse parses an HTTP response from a MultiSearchWithResponse call
func ParseMultiSearchResponse(rsp *http.Response) (*MultiSearchResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &MultiSearchResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest MultiSearchResult
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest ApiResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	}

	return response, nil
}

// ParseRetrieveAllNLSearchModelsResponse parses an HTTP response from a RetrieveAllNLSearchModelsWithResponse call
func ParseRetrieveAllNLSearchModelsResponse(rsp *http.Response) (*RetrieveAllNLSearchModelsResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &RetrieveAllNLSearchModelsResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest []NLSearchModelSchema
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseCreateNLSearchModelResponse parses an HTTP response from a CreateNLSearchModelWithResponse call
func ParseCreateNLSearchModelResponse(rsp *http.Response) (*CreateNLSearchModelResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &CreateNLSearchModelResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && (rsp.StatusCode == 200 || rsp.StatusCode == 201):
		var dest NLSearchModelSchema
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON201 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest ApiResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	}

	return response, nil
}

// ParseDeleteNLSearchModelResponse parses an HTTP response from a DeleteNLSearchModelWithResponse call
func ParseDeleteNLSearchModelResponse(rsp *http.Response) (*DeleteNLSearchModelResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &DeleteNLSearchModelResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest NLSearchModelDeleteSchema
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest ApiResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseRetrieveNLSearchModelResponse parses an HTTP response from a RetrieveNLSearchModelWithResponse call
func ParseRetrieveNLSearchModelResponse(rsp *http.Response) (*RetrieveNLSearchModelResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &RetrieveNLSearchModelResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest NLSearchModelSchema
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest ApiResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseUpdateNLSearchModelResponse parses an HTTP response from a UpdateNLSearchModelWithResponse call
func ParseUpdateNLSearchModelResponse(rsp *http.Response) (*UpdateNLSearchModelResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &UpdateNLSearchModelResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest NLSearchModelSchema
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest ApiResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest ApiResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseGetSchemaChangesResponse parses an HTTP response from a GetSchemaChangesWithResponse call
func ParseGetSchemaChangesResponse(rsp *http.Response) (*GetSchemaChangesResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &GetSchemaChangesResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest []SchemaChangeStatus
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseTakeSnapshotResponse parses an HTTP response from a TakeSnapshotWithResponse call
func ParseTakeSnapshotResponse(rsp *http.Response) (*TakeSnapshotResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &TakeSnapshotResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 201:
		var dest SuccessStatus
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON201 = &dest

	}

	return response, nil
}

// ParseVoteResponse parses an HTTP response from a VoteWithResponse call
func ParseVoteResponse(rsp *http.Response) (*VoteResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &VoteResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest SuccessStatus
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseRetrieveAllPresetsResponse parses an HTTP response from a RetrieveAllPresetsWithResponse call
func ParseRetrieveAllPresetsResponse(rsp *http.Response) (*RetrieveAllPresetsResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &RetrieveAllPresetsResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest PresetsRetrieveSchema
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseDeletePresetResponse parses an HTTP response from a DeletePresetWithResponse call
func ParseDeletePresetResponse(rsp *http.Response) (*DeletePresetResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &DeletePresetResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest PresetDeleteSchema
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest ApiResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseRetrievePresetResponse parses an HTTP response from a RetrievePresetWithResponse call
func ParseRetrievePresetResponse(rsp *http.Response) (*RetrievePresetResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &RetrievePresetResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest PresetSchema
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest ApiResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseUpsertPresetResponse parses an HTTP response from a UpsertPresetWithResponse call
func ParseUpsertPresetResponse(rsp *http.Response) (*UpsertPresetResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &UpsertPresetResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest PresetSchema
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest ApiResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	}

	return response, nil
}

// ParseRetrieveAPIStatsResponse parses an HTTP response from a RetrieveAPIStatsWithResponse call
func ParseRetrieveAPIStatsResponse(rsp *http.Response) (*RetrieveAPIStatsResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &RetrieveAPIStatsResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest APIStatsResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseListStemmingDictionariesResponse parses an HTTP response from a ListStemmingDictionariesWithResponse call
func ParseListStemmingDictionariesResponse(rsp *http.Response) (*ListStemmingDictionariesResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &ListStemmingDictionariesResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest struct {
			Dictionaries *[]string `json:"dictionaries,omitempty"`
		}
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseImportStemmingDictionaryResponse parses an HTTP response from a ImportStemmingDictionaryWithResponse call
func ParseImportStemmingDictionaryResponse(rsp *http.Response) (*ImportStemmingDictionaryResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &ImportStemmingDictionaryResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest ApiResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	}

	return response, nil
}

// ParseGetStemmingDictionaryResponse parses an HTTP response from a GetStemmingDictionaryWithResponse call
func ParseGetStemmingDictionaryResponse(rsp *http.Response) (*GetStemmingDictionaryResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &GetStemmingDictionaryResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest StemmingDictionary
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest ApiResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseRetrieveStopwordsSetsResponse parses an HTTP response from a RetrieveStopwordsSetsWithResponse call
func ParseRetrieveStopwordsSetsResponse(rsp *http.Response) (*RetrieveStopwordsSetsResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &RetrieveStopwordsSetsResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest StopwordsSetsRetrieveAllSchema
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseDeleteStopwordsSetResponse parses an HTTP response from a DeleteStopwordsSetWithResponse call
func ParseDeleteStopwordsSetResponse(rsp *http.Response) (*DeleteStopwordsSetResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &DeleteStopwordsSetResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest struct {
			Id string `json:"id"`
		}
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest ApiResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseRetrieveStopwordsSetResponse parses an HTTP response from a RetrieveStopwordsSetWithResponse call
func ParseRetrieveStopwordsSetResponse(rsp *http.Response) (*RetrieveStopwordsSetResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &RetrieveStopwordsSetResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest StopwordsSetRetrieveSchema
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest ApiResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseUpsertStopwordsSetResponse parses an HTTP response from a UpsertStopwordsSetWithResponse call
func ParseUpsertStopwordsSetResponse(rsp *http.Response) (*UpsertStopwordsSetResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &UpsertStopwordsSetResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest StopwordsSetSchema
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest ApiResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	}

	return response, nil
}