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

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 {
	// ListEnrichmentsApiV1EnrichmentsGet request
	ListEnrichmentsApiV1EnrichmentsGet(ctx context.Context, params *ListEnrichmentsApiV1EnrichmentsGetParams, reqEditors ...RequestEditorFn) (*http.Response, error)

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

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

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

	UpdateEnrichmentApiV1EnrichmentsEnrichmentIdPatch(ctx context.Context, enrichmentId string, body UpdateEnrichmentApiV1EnrichmentsEnrichmentIdPatchJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

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

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

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

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

	CreateRepositoryApiV1RepositoriesPost(ctx context.Context, body CreateRepositoryApiV1RepositoriesPostJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

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

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

	// ListRepositoryCommitsApiV1RepositoriesRepoIdCommitsGet request
	ListRepositoryCommitsApiV1RepositoriesRepoIdCommitsGet(ctx context.Context, repoId string, params *ListRepositoryCommitsApiV1RepositoriesRepoIdCommitsGetParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetRepositoryCommitApiV1RepositoriesRepoIdCommitsCommitShaGet request
	GetRepositoryCommitApiV1RepositoriesRepoIdCommitsCommitShaGet(ctx context.Context, repoId string, commitSha string, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ListCommitEmbeddingsApiV1RepositoriesRepoIdCommitsCommitShaEmbeddingsGet request
	ListCommitEmbeddingsApiV1RepositoriesRepoIdCommitsCommitShaEmbeddingsGet(ctx context.Context, repoId string, commitSha string, params *ListCommitEmbeddingsApiV1RepositoriesRepoIdCommitsCommitShaEmbeddingsGetParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DeleteAllCommitEnrichmentsApiV1RepositoriesRepoIdCommitsCommitShaEnrichmentsDelete request
	DeleteAllCommitEnrichmentsApiV1RepositoriesRepoIdCommitsCommitShaEnrichmentsDelete(ctx context.Context, repoId string, commitSha string, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ListCommitEnrichmentsApiV1RepositoriesRepoIdCommitsCommitShaEnrichmentsGet request
	ListCommitEnrichmentsApiV1RepositoriesRepoIdCommitsCommitShaEnrichmentsGet(ctx context.Context, repoId string, commitSha string, params *ListCommitEnrichmentsApiV1RepositoriesRepoIdCommitsCommitShaEnrichmentsGetParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DeleteCommitEnrichmentApiV1RepositoriesRepoIdCommitsCommitShaEnrichmentsEnrichmentIdDelete request
	DeleteCommitEnrichmentApiV1RepositoriesRepoIdCommitsCommitShaEnrichmentsEnrichmentIdDelete(ctx context.Context, repoId string, commitSha string, enrichmentId int, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ListCommitFilesApiV1RepositoriesRepoIdCommitsCommitShaFilesGet request
	ListCommitFilesApiV1RepositoriesRepoIdCommitsCommitShaFilesGet(ctx context.Context, repoId string, commitSha string, params *ListCommitFilesApiV1RepositoriesRepoIdCommitsCommitShaFilesGetParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetCommitFileApiV1RepositoriesRepoIdCommitsCommitShaFilesBlobShaGet request
	GetCommitFileApiV1RepositoriesRepoIdCommitsCommitShaFilesBlobShaGet(ctx context.Context, repoId string, commitSha string, blobSha string, reqEditors ...RequestEditorFn) (*http.Response, error)

	// RescanCommitApiV1RepositoriesRepoIdCommitsCommitShaRescanPost request
	RescanCommitApiV1RepositoriesRepoIdCommitsCommitShaRescanPost(ctx context.Context, repoId string, commitSha string, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ListCommitSnippetsApiV1RepositoriesRepoIdCommitsCommitShaSnippetsGet request
	ListCommitSnippetsApiV1RepositoriesRepoIdCommitsCommitShaSnippetsGet(ctx context.Context, repoId string, commitSha string, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ListRepositoryEnrichmentsApiV1RepositoriesRepoIdEnrichmentsGet request
	ListRepositoryEnrichmentsApiV1RepositoriesRepoIdEnrichmentsGet(ctx context.Context, repoId string, params *ListRepositoryEnrichmentsApiV1RepositoriesRepoIdEnrichmentsGetParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetIndexStatusApiV1RepositoriesRepoIdStatusGet request
	GetIndexStatusApiV1RepositoriesRepoIdStatusGet(ctx context.Context, repoId int, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetStatusSummaryApiV1RepositoriesRepoIdStatusSummaryGet request
	GetStatusSummaryApiV1RepositoriesRepoIdStatusSummaryGet(ctx context.Context, repoId int, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	// GetRepositoryTagApiV1RepositoriesRepoIdTagsTagIdGet request
	GetRepositoryTagApiV1RepositoriesRepoIdTagsTagIdGet(ctx context.Context, repoId string, tagId string, reqEditors ...RequestEditorFn) (*http.Response, error)

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

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

	UpdateTrackingConfigApiV1RepositoriesRepoIdTrackingConfigPut(ctx context.Context, repoId string, body UpdateTrackingConfigApiV1RepositoriesRepoIdTrackingConfigPutJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	SearchSnippetsApiV1SearchPost(ctx context.Context, body SearchSnippetsApiV1SearchPostJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

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

func (c *Client) ListEnrichmentsApiV1EnrichmentsGet(ctx context.Context, params *ListEnrichmentsApiV1EnrichmentsGetParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewListEnrichmentsApiV1EnrichmentsGetRequest(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) DeleteEnrichmentApiV1EnrichmentsEnrichmentIdDelete(ctx context.Context, enrichmentId string, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDeleteEnrichmentApiV1EnrichmentsEnrichmentIdDeleteRequest(c.Server, enrichmentId)
	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) GetEnrichmentApiV1EnrichmentsEnrichmentIdGet(ctx context.Context, enrichmentId string, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetEnrichmentApiV1EnrichmentsEnrichmentIdGetRequest(c.Server, enrichmentId)
	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) UpdateEnrichmentApiV1EnrichmentsEnrichmentIdPatchWithBody(ctx context.Context, enrichmentId string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewUpdateEnrichmentApiV1EnrichmentsEnrichmentIdPatchRequestWithBody(c.Server, enrichmentId, 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) UpdateEnrichmentApiV1EnrichmentsEnrichmentIdPatch(ctx context.Context, enrichmentId string, body UpdateEnrichmentApiV1EnrichmentsEnrichmentIdPatchJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewUpdateEnrichmentApiV1EnrichmentsEnrichmentIdPatchRequest(c.Server, enrichmentId, 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) ListQueueTasksApiV1QueueGet(ctx context.Context, params *ListQueueTasksApiV1QueueGetParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewListQueueTasksApiV1QueueGetRequest(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) GetQueueTaskApiV1QueueTaskIdGet(ctx context.Context, taskId string, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetQueueTaskApiV1QueueTaskIdGetRequest(c.Server, taskId)
	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) ListRepositoriesApiV1RepositoriesGet(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewListRepositoriesApiV1RepositoriesGetRequest(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) CreateRepositoryApiV1RepositoriesPostWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewCreateRepositoryApiV1RepositoriesPostRequestWithBody(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) CreateRepositoryApiV1RepositoriesPost(ctx context.Context, body CreateRepositoryApiV1RepositoriesPostJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewCreateRepositoryApiV1RepositoriesPostRequest(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) DeleteRepositoryApiV1RepositoriesRepoIdDelete(ctx context.Context, repoId string, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDeleteRepositoryApiV1RepositoriesRepoIdDeleteRequest(c.Server, repoId)
	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) GetRepositoryApiV1RepositoriesRepoIdGet(ctx context.Context, repoId string, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetRepositoryApiV1RepositoriesRepoIdGetRequest(c.Server, repoId)
	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) ListRepositoryCommitsApiV1RepositoriesRepoIdCommitsGet(ctx context.Context, repoId string, params *ListRepositoryCommitsApiV1RepositoriesRepoIdCommitsGetParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewListRepositoryCommitsApiV1RepositoriesRepoIdCommitsGetRequest(c.Server, repoId, 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) GetRepositoryCommitApiV1RepositoriesRepoIdCommitsCommitShaGet(ctx context.Context, repoId string, commitSha string, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetRepositoryCommitApiV1RepositoriesRepoIdCommitsCommitShaGetRequest(c.Server, repoId, commitSha)
	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) ListCommitEmbeddingsApiV1RepositoriesRepoIdCommitsCommitShaEmbeddingsGet(ctx context.Context, repoId string, commitSha string, params *ListCommitEmbeddingsApiV1RepositoriesRepoIdCommitsCommitShaEmbeddingsGetParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewListCommitEmbeddingsApiV1RepositoriesRepoIdCommitsCommitShaEmbeddingsGetRequest(c.Server, repoId, commitSha, 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) DeleteAllCommitEnrichmentsApiV1RepositoriesRepoIdCommitsCommitShaEnrichmentsDelete(ctx context.Context, repoId string, commitSha string, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDeleteAllCommitEnrichmentsApiV1RepositoriesRepoIdCommitsCommitShaEnrichmentsDeleteRequest(c.Server, repoId, commitSha)
	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) ListCommitEnrichmentsApiV1RepositoriesRepoIdCommitsCommitShaEnrichmentsGet(ctx context.Context, repoId string, commitSha string, params *ListCommitEnrichmentsApiV1RepositoriesRepoIdCommitsCommitShaEnrichmentsGetParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewListCommitEnrichmentsApiV1RepositoriesRepoIdCommitsCommitShaEnrichmentsGetRequest(c.Server, repoId, commitSha, 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) DeleteCommitEnrichmentApiV1RepositoriesRepoIdCommitsCommitShaEnrichmentsEnrichmentIdDelete(ctx context.Context, repoId string, commitSha string, enrichmentId int, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDeleteCommitEnrichmentApiV1RepositoriesRepoIdCommitsCommitShaEnrichmentsEnrichmentIdDeleteRequest(c.Server, repoId, commitSha, enrichmentId)
	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) ListCommitFilesApiV1RepositoriesRepoIdCommitsCommitShaFilesGet(ctx context.Context, repoId string, commitSha string, params *ListCommitFilesApiV1RepositoriesRepoIdCommitsCommitShaFilesGetParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewListCommitFilesApiV1RepositoriesRepoIdCommitsCommitShaFilesGetRequest(c.Server, repoId, commitSha, 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) GetCommitFileApiV1RepositoriesRepoIdCommitsCommitShaFilesBlobShaGet(ctx context.Context, repoId string, commitSha string, blobSha string, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetCommitFileApiV1RepositoriesRepoIdCommitsCommitShaFilesBlobShaGetRequest(c.Server, repoId, commitSha, blobSha)
	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) RescanCommitApiV1RepositoriesRepoIdCommitsCommitShaRescanPost(ctx context.Context, repoId string, commitSha string, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewRescanCommitApiV1RepositoriesRepoIdCommitsCommitShaRescanPostRequest(c.Server, repoId, commitSha)
	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) ListCommitSnippetsApiV1RepositoriesRepoIdCommitsCommitShaSnippetsGet(ctx context.Context, repoId string, commitSha string, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewListCommitSnippetsApiV1RepositoriesRepoIdCommitsCommitShaSnippetsGetRequest(c.Server, repoId, commitSha)
	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) ListRepositoryEnrichmentsApiV1RepositoriesRepoIdEnrichmentsGet(ctx context.Context, repoId string, params *ListRepositoryEnrichmentsApiV1RepositoriesRepoIdEnrichmentsGetParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewListRepositoryEnrichmentsApiV1RepositoriesRepoIdEnrichmentsGetRequest(c.Server, repoId, 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) GetIndexStatusApiV1RepositoriesRepoIdStatusGet(ctx context.Context, repoId int, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetIndexStatusApiV1RepositoriesRepoIdStatusGetRequest(c.Server, repoId)
	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) GetStatusSummaryApiV1RepositoriesRepoIdStatusSummaryGet(ctx context.Context, repoId int, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetStatusSummaryApiV1RepositoriesRepoIdStatusSummaryGetRequest(c.Server, repoId)
	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) ListRepositoryTagsApiV1RepositoriesRepoIdTagsGet(ctx context.Context, repoId string, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewListRepositoryTagsApiV1RepositoriesRepoIdTagsGetRequest(c.Server, repoId)
	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) GetRepositoryTagApiV1RepositoriesRepoIdTagsTagIdGet(ctx context.Context, repoId string, tagId string, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetRepositoryTagApiV1RepositoriesRepoIdTagsTagIdGetRequest(c.Server, repoId, tagId)
	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) GetTrackingConfigApiV1RepositoriesRepoIdTrackingConfigGet(ctx context.Context, repoId string, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetTrackingConfigApiV1RepositoriesRepoIdTrackingConfigGetRequest(c.Server, repoId)
	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) UpdateTrackingConfigApiV1RepositoriesRepoIdTrackingConfigPutWithBody(ctx context.Context, repoId string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewUpdateTrackingConfigApiV1RepositoriesRepoIdTrackingConfigPutRequestWithBody(c.Server, repoId, 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) UpdateTrackingConfigApiV1RepositoriesRepoIdTrackingConfigPut(ctx context.Context, repoId string, body UpdateTrackingConfigApiV1RepositoriesRepoIdTrackingConfigPutJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewUpdateTrackingConfigApiV1RepositoriesRepoIdTrackingConfigPutRequest(c.Server, repoId, 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) SearchSnippetsApiV1SearchPostWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewSearchSnippetsApiV1SearchPostRequestWithBody(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) SearchSnippetsApiV1SearchPost(ctx context.Context, body SearchSnippetsApiV1SearchPostJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewSearchSnippetsApiV1SearchPostRequest(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) HealthzHealthzGet(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewHealthzHealthzGetRequest(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)
}

// NewListEnrichmentsApiV1EnrichmentsGetRequest generates requests for ListEnrichmentsApiV1EnrichmentsGet
func NewListEnrichmentsApiV1EnrichmentsGetRequest(server string, params *ListEnrichmentsApiV1EnrichmentsGetParams) (*http.Request, error) {
	var err error

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

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

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

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

		if params.EnrichmentType != nil {

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

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

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

// NewDeleteEnrichmentApiV1EnrichmentsEnrichmentIdDeleteRequest generates requests for DeleteEnrichmentApiV1EnrichmentsEnrichmentIdDelete
func NewDeleteEnrichmentApiV1EnrichmentsEnrichmentIdDeleteRequest(server string, enrichmentId string) (*http.Request, error) {
	var err error

	var pathParam0 string

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

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

	operationPath := fmt.Sprintf("/api/v1/enrichments/%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
}

// NewGetEnrichmentApiV1EnrichmentsEnrichmentIdGetRequest generates requests for GetEnrichmentApiV1EnrichmentsEnrichmentIdGet
func NewGetEnrichmentApiV1EnrichmentsEnrichmentIdGetRequest(server string, enrichmentId string) (*http.Request, error) {
	var err error

	var pathParam0 string

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

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

	operationPath := fmt.Sprintf("/api/v1/enrichments/%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
}

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

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

	var pathParam0 string

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

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

	operationPath := fmt.Sprintf("/api/v1/enrichments/%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
}

// NewListQueueTasksApiV1QueueGetRequest generates requests for ListQueueTasksApiV1QueueGet
func NewListQueueTasksApiV1QueueGetRequest(server string, params *ListQueueTasksApiV1QueueGetParams) (*http.Request, error) {
	var err error

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

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

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

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

		if params.TaskType != nil {

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

// NewGetQueueTaskApiV1QueueTaskIdGetRequest generates requests for GetQueueTaskApiV1QueueTaskIdGet
func NewGetQueueTaskApiV1QueueTaskIdGetRequest(server string, taskId string) (*http.Request, error) {
	var err error

	var pathParam0 string

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

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

	operationPath := fmt.Sprintf("/api/v1/queue/%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
}

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

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

	operationPath := fmt.Sprintf("/api/v1/repositories")
	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
}

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

// NewCreateRepositoryApiV1RepositoriesPostRequestWithBody generates requests for CreateRepositoryApiV1RepositoriesPost with any type of body
func NewCreateRepositoryApiV1RepositoriesPostRequestWithBody(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("/api/v1/repositories")
	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
}

// NewDeleteRepositoryApiV1RepositoriesRepoIdDeleteRequest generates requests for DeleteRepositoryApiV1RepositoriesRepoIdDelete
func NewDeleteRepositoryApiV1RepositoriesRepoIdDeleteRequest(server string, repoId string) (*http.Request, error) {
	var err error

	var pathParam0 string

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

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

	operationPath := fmt.Sprintf("/api/v1/repositories/%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
}

// NewGetRepositoryApiV1RepositoriesRepoIdGetRequest generates requests for GetRepositoryApiV1RepositoriesRepoIdGet
func NewGetRepositoryApiV1RepositoriesRepoIdGetRequest(server string, repoId string) (*http.Request, error) {
	var err error

	var pathParam0 string

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

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

	operationPath := fmt.Sprintf("/api/v1/repositories/%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
}

// NewListRepositoryCommitsApiV1RepositoriesRepoIdCommitsGetRequest generates requests for ListRepositoryCommitsApiV1RepositoriesRepoIdCommitsGet
func NewListRepositoryCommitsApiV1RepositoriesRepoIdCommitsGetRequest(server string, repoId string, params *ListRepositoryCommitsApiV1RepositoriesRepoIdCommitsGetParams) (*http.Request, error) {
	var err error

	var pathParam0 string

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

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

	operationPath := fmt.Sprintf("/api/v1/repositories/%s/commits", 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.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.PageSize != nil {

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

// NewGetRepositoryCommitApiV1RepositoriesRepoIdCommitsCommitShaGetRequest generates requests for GetRepositoryCommitApiV1RepositoriesRepoIdCommitsCommitShaGet
func NewGetRepositoryCommitApiV1RepositoriesRepoIdCommitsCommitShaGetRequest(server string, repoId string, commitSha string) (*http.Request, error) {
	var err error

	var pathParam0 string

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

	var pathParam1 string

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

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

	operationPath := fmt.Sprintf("/api/v1/repositories/%s/commits/%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
}

// NewListCommitEmbeddingsApiV1RepositoriesRepoIdCommitsCommitShaEmbeddingsGetRequest generates requests for ListCommitEmbeddingsApiV1RepositoriesRepoIdCommitsCommitShaEmbeddingsGet
func NewListCommitEmbeddingsApiV1RepositoriesRepoIdCommitsCommitShaEmbeddingsGetRequest(server string, repoId string, commitSha string, params *ListCommitEmbeddingsApiV1RepositoriesRepoIdCommitsCommitShaEmbeddingsGetParams) (*http.Request, error) {
	var err error

	var pathParam0 string

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

	var pathParam1 string

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

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

	operationPath := fmt.Sprintf("/api/v1/repositories/%s/commits/%s/embeddings", 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.Full != nil {

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

// NewDeleteAllCommitEnrichmentsApiV1RepositoriesRepoIdCommitsCommitShaEnrichmentsDeleteRequest generates requests for DeleteAllCommitEnrichmentsApiV1RepositoriesRepoIdCommitsCommitShaEnrichmentsDelete
func NewDeleteAllCommitEnrichmentsApiV1RepositoriesRepoIdCommitsCommitShaEnrichmentsDeleteRequest(server string, repoId string, commitSha string) (*http.Request, error) {
	var err error

	var pathParam0 string

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

	var pathParam1 string

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

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

	operationPath := fmt.Sprintf("/api/v1/repositories/%s/commits/%s/enrichments", 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
}

// NewListCommitEnrichmentsApiV1RepositoriesRepoIdCommitsCommitShaEnrichmentsGetRequest generates requests for ListCommitEnrichmentsApiV1RepositoriesRepoIdCommitsCommitShaEnrichmentsGet
func NewListCommitEnrichmentsApiV1RepositoriesRepoIdCommitsCommitShaEnrichmentsGetRequest(server string, repoId string, commitSha string, params *ListCommitEnrichmentsApiV1RepositoriesRepoIdCommitsCommitShaEnrichmentsGetParams) (*http.Request, error) {
	var err error

	var pathParam0 string

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

	var pathParam1 string

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

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

	operationPath := fmt.Sprintf("/api/v1/repositories/%s/commits/%s/enrichments", 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.EnrichmentType != nil {

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

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

// NewDeleteCommitEnrichmentApiV1RepositoriesRepoIdCommitsCommitShaEnrichmentsEnrichmentIdDeleteRequest generates requests for DeleteCommitEnrichmentApiV1RepositoriesRepoIdCommitsCommitShaEnrichmentsEnrichmentIdDelete
func NewDeleteCommitEnrichmentApiV1RepositoriesRepoIdCommitsCommitShaEnrichmentsEnrichmentIdDeleteRequest(server string, repoId string, commitSha string, enrichmentId int) (*http.Request, error) {
	var err error

	var pathParam0 string

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

	var pathParam1 string

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

	var pathParam2 string

	pathParam2, err = runtime.StyleParamWithLocation("simple", false, "enrichment_id", runtime.ParamLocationPath, enrichmentId)
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/api/v1/repositories/%s/commits/%s/enrichments/%s", pathParam0, pathParam1, pathParam2)
	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
}

// NewListCommitFilesApiV1RepositoriesRepoIdCommitsCommitShaFilesGetRequest generates requests for ListCommitFilesApiV1RepositoriesRepoIdCommitsCommitShaFilesGet
func NewListCommitFilesApiV1RepositoriesRepoIdCommitsCommitShaFilesGetRequest(server string, repoId string, commitSha string, params *ListCommitFilesApiV1RepositoriesRepoIdCommitsCommitShaFilesGetParams) (*http.Request, error) {
	var err error

	var pathParam0 string

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

	var pathParam1 string

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

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

	operationPath := fmt.Sprintf("/api/v1/repositories/%s/commits/%s/files", 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.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.PageSize != nil {

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

// NewGetCommitFileApiV1RepositoriesRepoIdCommitsCommitShaFilesBlobShaGetRequest generates requests for GetCommitFileApiV1RepositoriesRepoIdCommitsCommitShaFilesBlobShaGet
func NewGetCommitFileApiV1RepositoriesRepoIdCommitsCommitShaFilesBlobShaGetRequest(server string, repoId string, commitSha string, blobSha string) (*http.Request, error) {
	var err error

	var pathParam0 string

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

	var pathParam1 string

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

	var pathParam2 string

	pathParam2, err = runtime.StyleParamWithLocation("simple", false, "blob_sha", runtime.ParamLocationPath, blobSha)
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/api/v1/repositories/%s/commits/%s/files/%s", pathParam0, pathParam1, pathParam2)
	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
}

// NewRescanCommitApiV1RepositoriesRepoIdCommitsCommitShaRescanPostRequest generates requests for RescanCommitApiV1RepositoriesRepoIdCommitsCommitShaRescanPost
func NewRescanCommitApiV1RepositoriesRepoIdCommitsCommitShaRescanPostRequest(server string, repoId string, commitSha string) (*http.Request, error) {
	var err error

	var pathParam0 string

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

	var pathParam1 string

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

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

	operationPath := fmt.Sprintf("/api/v1/repositories/%s/commits/%s/rescan", pathParam0, pathParam1)
	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
}

// NewListCommitSnippetsApiV1RepositoriesRepoIdCommitsCommitShaSnippetsGetRequest generates requests for ListCommitSnippetsApiV1RepositoriesRepoIdCommitsCommitShaSnippetsGet
func NewListCommitSnippetsApiV1RepositoriesRepoIdCommitsCommitShaSnippetsGetRequest(server string, repoId string, commitSha string) (*http.Request, error) {
	var err error

	var pathParam0 string

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

	var pathParam1 string

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

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

	operationPath := fmt.Sprintf("/api/v1/repositories/%s/commits/%s/snippets", 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
}

// NewListRepositoryEnrichmentsApiV1RepositoriesRepoIdEnrichmentsGetRequest generates requests for ListRepositoryEnrichmentsApiV1RepositoriesRepoIdEnrichmentsGet
func NewListRepositoryEnrichmentsApiV1RepositoriesRepoIdEnrichmentsGetRequest(server string, repoId string, params *ListRepositoryEnrichmentsApiV1RepositoriesRepoIdEnrichmentsGetParams) (*http.Request, error) {
	var err error

	var pathParam0 string

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

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

	operationPath := fmt.Sprintf("/api/v1/repositories/%s/enrichments", 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.EnrichmentType != nil {

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

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

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

// NewGetIndexStatusApiV1RepositoriesRepoIdStatusGetRequest generates requests for GetIndexStatusApiV1RepositoriesRepoIdStatusGet
func NewGetIndexStatusApiV1RepositoriesRepoIdStatusGetRequest(server string, repoId int) (*http.Request, error) {
	var err error

	var pathParam0 string

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

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

	operationPath := fmt.Sprintf("/api/v1/repositories/%s/status", 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
}

// NewGetStatusSummaryApiV1RepositoriesRepoIdStatusSummaryGetRequest generates requests for GetStatusSummaryApiV1RepositoriesRepoIdStatusSummaryGet
func NewGetStatusSummaryApiV1RepositoriesRepoIdStatusSummaryGetRequest(server string, repoId int) (*http.Request, error) {
	var err error

	var pathParam0 string

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

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

	operationPath := fmt.Sprintf("/api/v1/repositories/%s/status/summary", 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
}

// NewListRepositoryTagsApiV1RepositoriesRepoIdTagsGetRequest generates requests for ListRepositoryTagsApiV1RepositoriesRepoIdTagsGet
func NewListRepositoryTagsApiV1RepositoriesRepoIdTagsGetRequest(server string, repoId string) (*http.Request, error) {
	var err error

	var pathParam0 string

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

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

	operationPath := fmt.Sprintf("/api/v1/repositories/%s/tags", 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
}

// NewGetRepositoryTagApiV1RepositoriesRepoIdTagsTagIdGetRequest generates requests for GetRepositoryTagApiV1RepositoriesRepoIdTagsTagIdGet
func NewGetRepositoryTagApiV1RepositoriesRepoIdTagsTagIdGetRequest(server string, repoId string, tagId string) (*http.Request, error) {
	var err error

	var pathParam0 string

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

	var pathParam1 string

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

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

	operationPath := fmt.Sprintf("/api/v1/repositories/%s/tags/%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
}

// NewGetTrackingConfigApiV1RepositoriesRepoIdTrackingConfigGetRequest generates requests for GetTrackingConfigApiV1RepositoriesRepoIdTrackingConfigGet
func NewGetTrackingConfigApiV1RepositoriesRepoIdTrackingConfigGetRequest(server string, repoId string) (*http.Request, error) {
	var err error

	var pathParam0 string

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

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

	operationPath := fmt.Sprintf("/api/v1/repositories/%s/tracking-config", 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
}

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

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

	var pathParam0 string

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

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

	operationPath := fmt.Sprintf("/api/v1/repositories/%s/tracking-config", 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
}

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

// NewSearchSnippetsApiV1SearchPostRequestWithBody generates requests for SearchSnippetsApiV1SearchPost with any type of body
func NewSearchSnippetsApiV1SearchPostRequestWithBody(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("/api/v1/search")
	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
}

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

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

	operationPath := fmt.Sprintf("/healthz")
	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
}

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 {
	// ListEnrichmentsApiV1EnrichmentsGetWithResponse request
	ListEnrichmentsApiV1EnrichmentsGetWithResponse(ctx context.Context, params *ListEnrichmentsApiV1EnrichmentsGetParams, reqEditors ...RequestEditorFn) (*ListEnrichmentsApiV1EnrichmentsGetResponse, error)

	// DeleteEnrichmentApiV1EnrichmentsEnrichmentIdDeleteWithResponse request
	DeleteEnrichmentApiV1EnrichmentsEnrichmentIdDeleteWithResponse(ctx context.Context, enrichmentId string, reqEditors ...RequestEditorFn) (*DeleteEnrichmentApiV1EnrichmentsEnrichmentIdDeleteResponse, error)

	// GetEnrichmentApiV1EnrichmentsEnrichmentIdGetWithResponse request
	GetEnrichmentApiV1EnrichmentsEnrichmentIdGetWithResponse(ctx context.Context, enrichmentId string, reqEditors ...RequestEditorFn) (*GetEnrichmentApiV1EnrichmentsEnrichmentIdGetResponse, error)

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

	UpdateEnrichmentApiV1EnrichmentsEnrichmentIdPatchWithResponse(ctx context.Context, enrichmentId string, body UpdateEnrichmentApiV1EnrichmentsEnrichmentIdPatchJSONRequestBody, reqEditors ...RequestEditorFn) (*UpdateEnrichmentApiV1EnrichmentsEnrichmentIdPatchResponse, error)

	// ListQueueTasksApiV1QueueGetWithResponse request
	ListQueueTasksApiV1QueueGetWithResponse(ctx context.Context, params *ListQueueTasksApiV1QueueGetParams, reqEditors ...RequestEditorFn) (*ListQueueTasksApiV1QueueGetResponse, error)

	// GetQueueTaskApiV1QueueTaskIdGetWithResponse request
	GetQueueTaskApiV1QueueTaskIdGetWithResponse(ctx context.Context, taskId string, reqEditors ...RequestEditorFn) (*GetQueueTaskApiV1QueueTaskIdGetResponse, error)

	// ListRepositoriesApiV1RepositoriesGetWithResponse request
	ListRepositoriesApiV1RepositoriesGetWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*ListRepositoriesApiV1RepositoriesGetResponse, error)

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

	CreateRepositoryApiV1RepositoriesPostWithResponse(ctx context.Context, body CreateRepositoryApiV1RepositoriesPostJSONRequestBody, reqEditors ...RequestEditorFn) (*CreateRepositoryApiV1RepositoriesPostResponse, error)

	// DeleteRepositoryApiV1RepositoriesRepoIdDeleteWithResponse request
	DeleteRepositoryApiV1RepositoriesRepoIdDeleteWithResponse(ctx context.Context, repoId string, reqEditors ...RequestEditorFn) (*DeleteRepositoryApiV1RepositoriesRepoIdDeleteResponse, error)

	// GetRepositoryApiV1RepositoriesRepoIdGetWithResponse request
	GetRepositoryApiV1RepositoriesRepoIdGetWithResponse(ctx context.Context, repoId string, reqEditors ...RequestEditorFn) (*GetRepositoryApiV1RepositoriesRepoIdGetResponse, error)

	// ListRepositoryCommitsApiV1RepositoriesRepoIdCommitsGetWithResponse request
	ListRepositoryCommitsApiV1RepositoriesRepoIdCommitsGetWithResponse(ctx context.Context, repoId string, params *ListRepositoryCommitsApiV1RepositoriesRepoIdCommitsGetParams, reqEditors ...RequestEditorFn) (*ListRepositoryCommitsApiV1RepositoriesRepoIdCommitsGetResponse, error)

	// GetRepositoryCommitApiV1RepositoriesRepoIdCommitsCommitShaGetWithResponse request
	GetRepositoryCommitApiV1RepositoriesRepoIdCommitsCommitShaGetWithResponse(ctx context.Context, repoId string, commitSha string, reqEditors ...RequestEditorFn) (*GetRepositoryCommitApiV1RepositoriesRepoIdCommitsCommitShaGetResponse, error)

	// ListCommitEmbeddingsApiV1RepositoriesRepoIdCommitsCommitShaEmbeddingsGetWithResponse request
	ListCommitEmbeddingsApiV1RepositoriesRepoIdCommitsCommitShaEmbeddingsGetWithResponse(ctx context.Context, repoId string, commitSha string, params *ListCommitEmbeddingsApiV1RepositoriesRepoIdCommitsCommitShaEmbeddingsGetParams, reqEditors ...RequestEditorFn) (*ListCommitEmbeddingsApiV1RepositoriesRepoIdCommitsCommitShaEmbeddingsGetResponse, error)

	// DeleteAllCommitEnrichmentsApiV1RepositoriesRepoIdCommitsCommitShaEnrichmentsDeleteWithResponse request
	DeleteAllCommitEnrichmentsApiV1RepositoriesRepoIdCommitsCommitShaEnrichmentsDeleteWithResponse(ctx context.Context, repoId string, commitSha string, reqEditors ...RequestEditorFn) (*DeleteAllCommitEnrichmentsApiV1RepositoriesRepoIdCommitsCommitShaEnrichmentsDeleteResponse, error)

	// ListCommitEnrichmentsApiV1RepositoriesRepoIdCommitsCommitShaEnrichmentsGetWithResponse request
	ListCommitEnrichmentsApiV1RepositoriesRepoIdCommitsCommitShaEnrichmentsGetWithResponse(ctx context.Context, repoId string, commitSha string, params *ListCommitEnrichmentsApiV1RepositoriesRepoIdCommitsCommitShaEnrichmentsGetParams, reqEditors ...RequestEditorFn) (*ListCommitEnrichmentsApiV1RepositoriesRepoIdCommitsCommitShaEnrichmentsGetResponse, error)

	// DeleteCommitEnrichmentApiV1RepositoriesRepoIdCommitsCommitShaEnrichmentsEnrichmentIdDeleteWithResponse request
	DeleteCommitEnrichmentApiV1RepositoriesRepoIdCommitsCommitShaEnrichmentsEnrichmentIdDeleteWithResponse(ctx context.Context, repoId string, commitSha string, enrichmentId int, reqEditors ...RequestEditorFn) (*DeleteCommitEnrichmentApiV1RepositoriesRepoIdCommitsCommitShaEnrichmentsEnrichmentIdDeleteResponse, error)

	// ListCommitFilesApiV1RepositoriesRepoIdCommitsCommitShaFilesGetWithResponse request
	ListCommitFilesApiV1RepositoriesRepoIdCommitsCommitShaFilesGetWithResponse(ctx context.Context, repoId string, commitSha string, params *ListCommitFilesApiV1RepositoriesRepoIdCommitsCommitShaFilesGetParams, reqEditors ...RequestEditorFn) (*ListCommitFilesApiV1RepositoriesRepoIdCommitsCommitShaFilesGetResponse, error)

	// GetCommitFileApiV1RepositoriesRepoIdCommitsCommitShaFilesBlobShaGetWithResponse request
	GetCommitFileApiV1RepositoriesRepoIdCommitsCommitShaFilesBlobShaGetWithResponse(ctx context.Context, repoId string, commitSha string, blobSha string, reqEditors ...RequestEditorFn) (*GetCommitFileApiV1RepositoriesRepoIdCommitsCommitShaFilesBlobShaGetResponse, error)

	// RescanCommitApiV1RepositoriesRepoIdCommitsCommitShaRescanPostWithResponse request
	RescanCommitApiV1RepositoriesRepoIdCommitsCommitShaRescanPostWithResponse(ctx context.Context, repoId string, commitSha string, reqEditors ...RequestEditorFn) (*RescanCommitApiV1RepositoriesRepoIdCommitsCommitShaRescanPostResponse, error)

	// ListCommitSnippetsApiV1RepositoriesRepoIdCommitsCommitShaSnippetsGetWithResponse request
	ListCommitSnippetsApiV1RepositoriesRepoIdCommitsCommitShaSnippetsGetWithResponse(ctx context.Context, repoId string, commitSha string, reqEditors ...RequestEditorFn) (*ListCommitSnippetsApiV1RepositoriesRepoIdCommitsCommitShaSnippetsGetResponse, error)

	// ListRepositoryEnrichmentsApiV1RepositoriesRepoIdEnrichmentsGetWithResponse request
	ListRepositoryEnrichmentsApiV1RepositoriesRepoIdEnrichmentsGetWithResponse(ctx context.Context, repoId string, params *ListRepositoryEnrichmentsApiV1RepositoriesRepoIdEnrichmentsGetParams, reqEditors ...RequestEditorFn) (*ListRepositoryEnrichmentsApiV1RepositoriesRepoIdEnrichmentsGetResponse, error)

	// GetIndexStatusApiV1RepositoriesRepoIdStatusGetWithResponse request
	GetIndexStatusApiV1RepositoriesRepoIdStatusGetWithResponse(ctx context.Context, repoId int, reqEditors ...RequestEditorFn) (*GetIndexStatusApiV1RepositoriesRepoIdStatusGetResponse, error)

	// GetStatusSummaryApiV1RepositoriesRepoIdStatusSummaryGetWithResponse request
	GetStatusSummaryApiV1RepositoriesRepoIdStatusSummaryGetWithResponse(ctx context.Context, repoId int, reqEditors ...RequestEditorFn) (*GetStatusSummaryApiV1RepositoriesRepoIdStatusSummaryGetResponse, error)

	// ListRepositoryTagsApiV1RepositoriesRepoIdTagsGetWithResponse request
	ListRepositoryTagsApiV1RepositoriesRepoIdTagsGetWithResponse(ctx context.Context, repoId string, reqEditors ...RequestEditorFn) (*ListRepositoryTagsApiV1RepositoriesRepoIdTagsGetResponse, error)

	// GetRepositoryTagApiV1RepositoriesRepoIdTagsTagIdGetWithResponse request
	GetRepositoryTagApiV1RepositoriesRepoIdTagsTagIdGetWithResponse(ctx context.Context, repoId string, tagId string, reqEditors ...RequestEditorFn) (*GetRepositoryTagApiV1RepositoriesRepoIdTagsTagIdGetResponse, error)

	// GetTrackingConfigApiV1RepositoriesRepoIdTrackingConfigGetWithResponse request
	GetTrackingConfigApiV1RepositoriesRepoIdTrackingConfigGetWithResponse(ctx context.Context, repoId string, reqEditors ...RequestEditorFn) (*GetTrackingConfigApiV1RepositoriesRepoIdTrackingConfigGetResponse, error)

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

	UpdateTrackingConfigApiV1RepositoriesRepoIdTrackingConfigPutWithResponse(ctx context.Context, repoId string, body UpdateTrackingConfigApiV1RepositoriesRepoIdTrackingConfigPutJSONRequestBody, reqEditors ...RequestEditorFn) (*UpdateTrackingConfigApiV1RepositoriesRepoIdTrackingConfigPutResponse, error)

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

	SearchSnippetsApiV1SearchPostWithResponse(ctx context.Context, body SearchSnippetsApiV1SearchPostJSONRequestBody, reqEditors ...RequestEditorFn) (*SearchSnippetsApiV1SearchPostResponse, error)

	// HealthzHealthzGetWithResponse request
	HealthzHealthzGetWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*HealthzHealthzGetResponse, error)
}

type ListEnrichmentsApiV1EnrichmentsGetResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *EnrichmentListResponse
}

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

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

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

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

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

type GetEnrichmentApiV1EnrichmentsEnrichmentIdGetResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *EnrichmentResponse
}

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

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

type UpdateEnrichmentApiV1EnrichmentsEnrichmentIdPatchResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *EnrichmentResponse
}

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

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

type ListQueueTasksApiV1QueueGetResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *TaskListResponse
}

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

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

type GetQueueTaskApiV1QueueTaskIdGetResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *TaskResponse
}

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

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

type ListRepositoriesApiV1RepositoriesGetResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *RepositoryListResponse
}

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

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

type CreateRepositoryApiV1RepositoriesPostResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *RepositoryResponse
}

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

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

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

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

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

type GetRepositoryApiV1RepositoriesRepoIdGetResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *RepositoryDetailsResponse
}

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

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

type ListRepositoryCommitsApiV1RepositoriesRepoIdCommitsGetResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *CommitListResponse
}

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

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

type GetRepositoryCommitApiV1RepositoriesRepoIdCommitsCommitShaGetResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *CommitResponse
}

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

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

type ListCommitEmbeddingsApiV1RepositoriesRepoIdCommitsCommitShaEmbeddingsGetResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *EmbeddingListResponse
}

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

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

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

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

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

type ListCommitEnrichmentsApiV1RepositoriesRepoIdCommitsCommitShaEnrichmentsGetResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *EnrichmentListResponse
}

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

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

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

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

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

type ListCommitFilesApiV1RepositoriesRepoIdCommitsCommitShaFilesGetResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *FileListResponse
}

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

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

type GetCommitFileApiV1RepositoriesRepoIdCommitsCommitShaFilesBlobShaGetResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *FileResponse
}

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

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

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

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

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

type ListCommitSnippetsApiV1RepositoriesRepoIdCommitsCommitShaSnippetsGetResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *interface{}
}

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

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

type ListRepositoryEnrichmentsApiV1RepositoriesRepoIdEnrichmentsGetResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *EnrichmentListResponse
}

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

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

type GetIndexStatusApiV1RepositoriesRepoIdStatusGetResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *TaskStatusListResponse
}

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

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

type GetStatusSummaryApiV1RepositoriesRepoIdStatusSummaryGetResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *RepositoryStatusSummaryResponse
}

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

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

type ListRepositoryTagsApiV1RepositoriesRepoIdTagsGetResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *TagListResponse
}

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

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

type GetRepositoryTagApiV1RepositoriesRepoIdTagsTagIdGetResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *TagResponse
}

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

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

type GetTrackingConfigApiV1RepositoriesRepoIdTrackingConfigGetResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *TrackingConfigResponse
}

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

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

type UpdateTrackingConfigApiV1RepositoriesRepoIdTrackingConfigPutResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *TrackingConfigResponse
}

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

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

type SearchSnippetsApiV1SearchPostResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *SearchResponse
	JSON422      *HTTPValidationError
}

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

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

type HealthzHealthzGetResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *interface{}
}

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

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

// ListEnrichmentsApiV1EnrichmentsGetWithResponse request returning *ListEnrichmentsApiV1EnrichmentsGetResponse
func (c *ClientWithResponses) ListEnrichmentsApiV1EnrichmentsGetWithResponse(ctx context.Context, params *ListEnrichmentsApiV1EnrichmentsGetParams, reqEditors ...RequestEditorFn) (*ListEnrichmentsApiV1EnrichmentsGetResponse, error) {
	rsp, err := c.ListEnrichmentsApiV1EnrichmentsGet(ctx, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseListEnrichmentsApiV1EnrichmentsGetResponse(rsp)
}

// DeleteEnrichmentApiV1EnrichmentsEnrichmentIdDeleteWithResponse request returning *DeleteEnrichmentApiV1EnrichmentsEnrichmentIdDeleteResponse
func (c *ClientWithResponses) DeleteEnrichmentApiV1EnrichmentsEnrichmentIdDeleteWithResponse(ctx context.Context, enrichmentId string, reqEditors ...RequestEditorFn) (*DeleteEnrichmentApiV1EnrichmentsEnrichmentIdDeleteResponse, error) {
	rsp, err := c.DeleteEnrichmentApiV1EnrichmentsEnrichmentIdDelete(ctx, enrichmentId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDeleteEnrichmentApiV1EnrichmentsEnrichmentIdDeleteResponse(rsp)
}

// GetEnrichmentApiV1EnrichmentsEnrichmentIdGetWithResponse request returning *GetEnrichmentApiV1EnrichmentsEnrichmentIdGetResponse
func (c *ClientWithResponses) GetEnrichmentApiV1EnrichmentsEnrichmentIdGetWithResponse(ctx context.Context, enrichmentId string, reqEditors ...RequestEditorFn) (*GetEnrichmentApiV1EnrichmentsEnrichmentIdGetResponse, error) {
	rsp, err := c.GetEnrichmentApiV1EnrichmentsEnrichmentIdGet(ctx, enrichmentId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetEnrichmentApiV1EnrichmentsEnrichmentIdGetResponse(rsp)
}

// UpdateEnrichmentApiV1EnrichmentsEnrichmentIdPatchWithBodyWithResponse request with arbitrary body returning *UpdateEnrichmentApiV1EnrichmentsEnrichmentIdPatchResponse
func (c *ClientWithResponses) UpdateEnrichmentApiV1EnrichmentsEnrichmentIdPatchWithBodyWithResponse(ctx context.Context, enrichmentId string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*UpdateEnrichmentApiV1EnrichmentsEnrichmentIdPatchResponse, error) {
	rsp, err := c.UpdateEnrichmentApiV1EnrichmentsEnrichmentIdPatchWithBody(ctx, enrichmentId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseUpdateEnrichmentApiV1EnrichmentsEnrichmentIdPatchResponse(rsp)
}

func (c *ClientWithResponses) UpdateEnrichmentApiV1EnrichmentsEnrichmentIdPatchWithResponse(ctx context.Context, enrichmentId string, body UpdateEnrichmentApiV1EnrichmentsEnrichmentIdPatchJSONRequestBody, reqEditors ...RequestEditorFn) (*UpdateEnrichmentApiV1EnrichmentsEnrichmentIdPatchResponse, error) {
	rsp, err := c.UpdateEnrichmentApiV1EnrichmentsEnrichmentIdPatch(ctx, enrichmentId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseUpdateEnrichmentApiV1EnrichmentsEnrichmentIdPatchResponse(rsp)
}

// ListQueueTasksApiV1QueueGetWithResponse request returning *ListQueueTasksApiV1QueueGetResponse
func (c *ClientWithResponses) ListQueueTasksApiV1QueueGetWithResponse(ctx context.Context, params *ListQueueTasksApiV1QueueGetParams, reqEditors ...RequestEditorFn) (*ListQueueTasksApiV1QueueGetResponse, error) {
	rsp, err := c.ListQueueTasksApiV1QueueGet(ctx, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseListQueueTasksApiV1QueueGetResponse(rsp)
}

// GetQueueTaskApiV1QueueTaskIdGetWithResponse request returning *GetQueueTaskApiV1QueueTaskIdGetResponse
func (c *ClientWithResponses) GetQueueTaskApiV1QueueTaskIdGetWithResponse(ctx context.Context, taskId string, reqEditors ...RequestEditorFn) (*GetQueueTaskApiV1QueueTaskIdGetResponse, error) {
	rsp, err := c.GetQueueTaskApiV1QueueTaskIdGet(ctx, taskId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetQueueTaskApiV1QueueTaskIdGetResponse(rsp)
}

// ListRepositoriesApiV1RepositoriesGetWithResponse request returning *ListRepositoriesApiV1RepositoriesGetResponse
func (c *ClientWithResponses) ListRepositoriesApiV1RepositoriesGetWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*ListRepositoriesApiV1RepositoriesGetResponse, error) {
	rsp, err := c.ListRepositoriesApiV1RepositoriesGet(ctx, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseListRepositoriesApiV1RepositoriesGetResponse(rsp)
}

// CreateRepositoryApiV1RepositoriesPostWithBodyWithResponse request with arbitrary body returning *CreateRepositoryApiV1RepositoriesPostResponse
func (c *ClientWithResponses) CreateRepositoryApiV1RepositoriesPostWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*CreateRepositoryApiV1RepositoriesPostResponse, error) {
	rsp, err := c.CreateRepositoryApiV1RepositoriesPostWithBody(ctx, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseCreateRepositoryApiV1RepositoriesPostResponse(rsp)
}

func (c *ClientWithResponses) CreateRepositoryApiV1RepositoriesPostWithResponse(ctx context.Context, body CreateRepositoryApiV1RepositoriesPostJSONRequestBody, reqEditors ...RequestEditorFn) (*CreateRepositoryApiV1RepositoriesPostResponse, error) {
	rsp, err := c.CreateRepositoryApiV1RepositoriesPost(ctx, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseCreateRepositoryApiV1RepositoriesPostResponse(rsp)
}

// DeleteRepositoryApiV1RepositoriesRepoIdDeleteWithResponse request returning *DeleteRepositoryApiV1RepositoriesRepoIdDeleteResponse
func (c *ClientWithResponses) DeleteRepositoryApiV1RepositoriesRepoIdDeleteWithResponse(ctx context.Context, repoId string, reqEditors ...RequestEditorFn) (*DeleteRepositoryApiV1RepositoriesRepoIdDeleteResponse, error) {
	rsp, err := c.DeleteRepositoryApiV1RepositoriesRepoIdDelete(ctx, repoId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDeleteRepositoryApiV1RepositoriesRepoIdDeleteResponse(rsp)
}

// GetRepositoryApiV1RepositoriesRepoIdGetWithResponse request returning *GetRepositoryApiV1RepositoriesRepoIdGetResponse
func (c *ClientWithResponses) GetRepositoryApiV1RepositoriesRepoIdGetWithResponse(ctx context.Context, repoId string, reqEditors ...RequestEditorFn) (*GetRepositoryApiV1RepositoriesRepoIdGetResponse, error) {
	rsp, err := c.GetRepositoryApiV1RepositoriesRepoIdGet(ctx, repoId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetRepositoryApiV1RepositoriesRepoIdGetResponse(rsp)
}

// ListRepositoryCommitsApiV1RepositoriesRepoIdCommitsGetWithResponse request returning *ListRepositoryCommitsApiV1RepositoriesRepoIdCommitsGetResponse
func (c *ClientWithResponses) ListRepositoryCommitsApiV1RepositoriesRepoIdCommitsGetWithResponse(ctx context.Context, repoId string, params *ListRepositoryCommitsApiV1RepositoriesRepoIdCommitsGetParams, reqEditors ...RequestEditorFn) (*ListRepositoryCommitsApiV1RepositoriesRepoIdCommitsGetResponse, error) {
	rsp, err := c.ListRepositoryCommitsApiV1RepositoriesRepoIdCommitsGet(ctx, repoId, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseListRepositoryCommitsApiV1RepositoriesRepoIdCommitsGetResponse(rsp)
}

// GetRepositoryCommitApiV1RepositoriesRepoIdCommitsCommitShaGetWithResponse request returning *GetRepositoryCommitApiV1RepositoriesRepoIdCommitsCommitShaGetResponse
func (c *ClientWithResponses) GetRepositoryCommitApiV1RepositoriesRepoIdCommitsCommitShaGetWithResponse(ctx context.Context, repoId string, commitSha string, reqEditors ...RequestEditorFn) (*GetRepositoryCommitApiV1RepositoriesRepoIdCommitsCommitShaGetResponse, error) {
	rsp, err := c.GetRepositoryCommitApiV1RepositoriesRepoIdCommitsCommitShaGet(ctx, repoId, commitSha, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetRepositoryCommitApiV1RepositoriesRepoIdCommitsCommitShaGetResponse(rsp)
}

// ListCommitEmbeddingsApiV1RepositoriesRepoIdCommitsCommitShaEmbeddingsGetWithResponse request returning *ListCommitEmbeddingsApiV1RepositoriesRepoIdCommitsCommitShaEmbeddingsGetResponse
func (c *ClientWithResponses) ListCommitEmbeddingsApiV1RepositoriesRepoIdCommitsCommitShaEmbeddingsGetWithResponse(ctx context.Context, repoId string, commitSha string, params *ListCommitEmbeddingsApiV1RepositoriesRepoIdCommitsCommitShaEmbeddingsGetParams, reqEditors ...RequestEditorFn) (*ListCommitEmbeddingsApiV1RepositoriesRepoIdCommitsCommitShaEmbeddingsGetResponse, error) {
	rsp, err := c.ListCommitEmbeddingsApiV1RepositoriesRepoIdCommitsCommitShaEmbeddingsGet(ctx, repoId, commitSha, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseListCommitEmbeddingsApiV1RepositoriesRepoIdCommitsCommitShaEmbeddingsGetResponse(rsp)
}

// DeleteAllCommitEnrichmentsApiV1RepositoriesRepoIdCommitsCommitShaEnrichmentsDeleteWithResponse request returning *DeleteAllCommitEnrichmentsApiV1RepositoriesRepoIdCommitsCommitShaEnrichmentsDeleteResponse
func (c *ClientWithResponses) DeleteAllCommitEnrichmentsApiV1RepositoriesRepoIdCommitsCommitShaEnrichmentsDeleteWithResponse(ctx context.Context, repoId string, commitSha string, reqEditors ...RequestEditorFn) (*DeleteAllCommitEnrichmentsApiV1RepositoriesRepoIdCommitsCommitShaEnrichmentsDeleteResponse, error) {
	rsp, err := c.DeleteAllCommitEnrichmentsApiV1RepositoriesRepoIdCommitsCommitShaEnrichmentsDelete(ctx, repoId, commitSha, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDeleteAllCommitEnrichmentsApiV1RepositoriesRepoIdCommitsCommitShaEnrichmentsDeleteResponse(rsp)
}

// ListCommitEnrichmentsApiV1RepositoriesRepoIdCommitsCommitShaEnrichmentsGetWithResponse request returning *ListCommitEnrichmentsApiV1RepositoriesRepoIdCommitsCommitShaEnrichmentsGetResponse
func (c *ClientWithResponses) ListCommitEnrichmentsApiV1RepositoriesRepoIdCommitsCommitShaEnrichmentsGetWithResponse(ctx context.Context, repoId string, commitSha string, params *ListCommitEnrichmentsApiV1RepositoriesRepoIdCommitsCommitShaEnrichmentsGetParams, reqEditors ...RequestEditorFn) (*ListCommitEnrichmentsApiV1RepositoriesRepoIdCommitsCommitShaEnrichmentsGetResponse, error) {
	rsp, err := c.ListCommitEnrichmentsApiV1RepositoriesRepoIdCommitsCommitShaEnrichmentsGet(ctx, repoId, commitSha, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseListCommitEnrichmentsApiV1RepositoriesRepoIdCommitsCommitShaEnrichmentsGetResponse(rsp)
}

// DeleteCommitEnrichmentApiV1RepositoriesRepoIdCommitsCommitShaEnrichmentsEnrichmentIdDeleteWithResponse request returning *DeleteCommitEnrichmentApiV1RepositoriesRepoIdCommitsCommitShaEnrichmentsEnrichmentIdDeleteResponse
func (c *ClientWithResponses) DeleteCommitEnrichmentApiV1RepositoriesRepoIdCommitsCommitShaEnrichmentsEnrichmentIdDeleteWithResponse(ctx context.Context, repoId string, commitSha string, enrichmentId int, reqEditors ...RequestEditorFn) (*DeleteCommitEnrichmentApiV1RepositoriesRepoIdCommitsCommitShaEnrichmentsEnrichmentIdDeleteResponse, error) {
	rsp, err := c.DeleteCommitEnrichmentApiV1RepositoriesRepoIdCommitsCommitShaEnrichmentsEnrichmentIdDelete(ctx, repoId, commitSha, enrichmentId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDeleteCommitEnrichmentApiV1RepositoriesRepoIdCommitsCommitShaEnrichmentsEnrichmentIdDeleteResponse(rsp)
}

// ListCommitFilesApiV1RepositoriesRepoIdCommitsCommitShaFilesGetWithResponse request returning *ListCommitFilesApiV1RepositoriesRepoIdCommitsCommitShaFilesGetResponse
func (c *ClientWithResponses) ListCommitFilesApiV1RepositoriesRepoIdCommitsCommitShaFilesGetWithResponse(ctx context.Context, repoId string, commitSha string, params *ListCommitFilesApiV1RepositoriesRepoIdCommitsCommitShaFilesGetParams, reqEditors ...RequestEditorFn) (*ListCommitFilesApiV1RepositoriesRepoIdCommitsCommitShaFilesGetResponse, error) {
	rsp, err := c.ListCommitFilesApiV1RepositoriesRepoIdCommitsCommitShaFilesGet(ctx, repoId, commitSha, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseListCommitFilesApiV1RepositoriesRepoIdCommitsCommitShaFilesGetResponse(rsp)
}

// GetCommitFileApiV1RepositoriesRepoIdCommitsCommitShaFilesBlobShaGetWithResponse request returning *GetCommitFileApiV1RepositoriesRepoIdCommitsCommitShaFilesBlobShaGetResponse
func (c *ClientWithResponses) GetCommitFileApiV1RepositoriesRepoIdCommitsCommitShaFilesBlobShaGetWithResponse(ctx context.Context, repoId string, commitSha string, blobSha string, reqEditors ...RequestEditorFn) (*GetCommitFileApiV1RepositoriesRepoIdCommitsCommitShaFilesBlobShaGetResponse, error) {
	rsp, err := c.GetCommitFileApiV1RepositoriesRepoIdCommitsCommitShaFilesBlobShaGet(ctx, repoId, commitSha, blobSha, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetCommitFileApiV1RepositoriesRepoIdCommitsCommitShaFilesBlobShaGetResponse(rsp)
}

// RescanCommitApiV1RepositoriesRepoIdCommitsCommitShaRescanPostWithResponse request returning *RescanCommitApiV1RepositoriesRepoIdCommitsCommitShaRescanPostResponse
func (c *ClientWithResponses) RescanCommitApiV1RepositoriesRepoIdCommitsCommitShaRescanPostWithResponse(ctx context.Context, repoId string, commitSha string, reqEditors ...RequestEditorFn) (*RescanCommitApiV1RepositoriesRepoIdCommitsCommitShaRescanPostResponse, error) {
	rsp, err := c.RescanCommitApiV1RepositoriesRepoIdCommitsCommitShaRescanPost(ctx, repoId, commitSha, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseRescanCommitApiV1RepositoriesRepoIdCommitsCommitShaRescanPostResponse(rsp)
}

// ListCommitSnippetsApiV1RepositoriesRepoIdCommitsCommitShaSnippetsGetWithResponse request returning *ListCommitSnippetsApiV1RepositoriesRepoIdCommitsCommitShaSnippetsGetResponse
func (c *ClientWithResponses) ListCommitSnippetsApiV1RepositoriesRepoIdCommitsCommitShaSnippetsGetWithResponse(ctx context.Context, repoId string, commitSha string, reqEditors ...RequestEditorFn) (*ListCommitSnippetsApiV1RepositoriesRepoIdCommitsCommitShaSnippetsGetResponse, error) {
	rsp, err := c.ListCommitSnippetsApiV1RepositoriesRepoIdCommitsCommitShaSnippetsGet(ctx, repoId, commitSha, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseListCommitSnippetsApiV1RepositoriesRepoIdCommitsCommitShaSnippetsGetResponse(rsp)
}

// ListRepositoryEnrichmentsApiV1RepositoriesRepoIdEnrichmentsGetWithResponse request returning *ListRepositoryEnrichmentsApiV1RepositoriesRepoIdEnrichmentsGetResponse
func (c *ClientWithResponses) ListRepositoryEnrichmentsApiV1RepositoriesRepoIdEnrichmentsGetWithResponse(ctx context.Context, repoId string, params *ListRepositoryEnrichmentsApiV1RepositoriesRepoIdEnrichmentsGetParams, reqEditors ...RequestEditorFn) (*ListRepositoryEnrichmentsApiV1RepositoriesRepoIdEnrichmentsGetResponse, error) {
	rsp, err := c.ListRepositoryEnrichmentsApiV1RepositoriesRepoIdEnrichmentsGet(ctx, repoId, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseListRepositoryEnrichmentsApiV1RepositoriesRepoIdEnrichmentsGetResponse(rsp)
}

// GetIndexStatusApiV1RepositoriesRepoIdStatusGetWithResponse request returning *GetIndexStatusApiV1RepositoriesRepoIdStatusGetResponse
func (c *ClientWithResponses) GetIndexStatusApiV1RepositoriesRepoIdStatusGetWithResponse(ctx context.Context, repoId int, reqEditors ...RequestEditorFn) (*GetIndexStatusApiV1RepositoriesRepoIdStatusGetResponse, error) {
	rsp, err := c.GetIndexStatusApiV1RepositoriesRepoIdStatusGet(ctx, repoId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetIndexStatusApiV1RepositoriesRepoIdStatusGetResponse(rsp)
}

// GetStatusSummaryApiV1RepositoriesRepoIdStatusSummaryGetWithResponse request returning *GetStatusSummaryApiV1RepositoriesRepoIdStatusSummaryGetResponse
func (c *ClientWithResponses) GetStatusSummaryApiV1RepositoriesRepoIdStatusSummaryGetWithResponse(ctx context.Context, repoId int, reqEditors ...RequestEditorFn) (*GetStatusSummaryApiV1RepositoriesRepoIdStatusSummaryGetResponse, error) {
	rsp, err := c.GetStatusSummaryApiV1RepositoriesRepoIdStatusSummaryGet(ctx, repoId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetStatusSummaryApiV1RepositoriesRepoIdStatusSummaryGetResponse(rsp)
}

// ListRepositoryTagsApiV1RepositoriesRepoIdTagsGetWithResponse request returning *ListRepositoryTagsApiV1RepositoriesRepoIdTagsGetResponse
func (c *ClientWithResponses) ListRepositoryTagsApiV1RepositoriesRepoIdTagsGetWithResponse(ctx context.Context, repoId string, reqEditors ...RequestEditorFn) (*ListRepositoryTagsApiV1RepositoriesRepoIdTagsGetResponse, error) {
	rsp, err := c.ListRepositoryTagsApiV1RepositoriesRepoIdTagsGet(ctx, repoId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseListRepositoryTagsApiV1RepositoriesRepoIdTagsGetResponse(rsp)
}

// GetRepositoryTagApiV1RepositoriesRepoIdTagsTagIdGetWithResponse request returning *GetRepositoryTagApiV1RepositoriesRepoIdTagsTagIdGetResponse
func (c *ClientWithResponses) GetRepositoryTagApiV1RepositoriesRepoIdTagsTagIdGetWithResponse(ctx context.Context, repoId string, tagId string, reqEditors ...RequestEditorFn) (*GetRepositoryTagApiV1RepositoriesRepoIdTagsTagIdGetResponse, error) {
	rsp, err := c.GetRepositoryTagApiV1RepositoriesRepoIdTagsTagIdGet(ctx, repoId, tagId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetRepositoryTagApiV1RepositoriesRepoIdTagsTagIdGetResponse(rsp)
}

// GetTrackingConfigApiV1RepositoriesRepoIdTrackingConfigGetWithResponse request returning *GetTrackingConfigApiV1RepositoriesRepoIdTrackingConfigGetResponse
func (c *ClientWithResponses) GetTrackingConfigApiV1RepositoriesRepoIdTrackingConfigGetWithResponse(ctx context.Context, repoId string, reqEditors ...RequestEditorFn) (*GetTrackingConfigApiV1RepositoriesRepoIdTrackingConfigGetResponse, error) {
	rsp, err := c.GetTrackingConfigApiV1RepositoriesRepoIdTrackingConfigGet(ctx, repoId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetTrackingConfigApiV1RepositoriesRepoIdTrackingConfigGetResponse(rsp)
}

// UpdateTrackingConfigApiV1RepositoriesRepoIdTrackingConfigPutWithBodyWithResponse request with arbitrary body returning *UpdateTrackingConfigApiV1RepositoriesRepoIdTrackingConfigPutResponse
func (c *ClientWithResponses) UpdateTrackingConfigApiV1RepositoriesRepoIdTrackingConfigPutWithBodyWithResponse(ctx context.Context, repoId string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*UpdateTrackingConfigApiV1RepositoriesRepoIdTrackingConfigPutResponse, error) {
	rsp, err := c.UpdateTrackingConfigApiV1RepositoriesRepoIdTrackingConfigPutWithBody(ctx, repoId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseUpdateTrackingConfigApiV1RepositoriesRepoIdTrackingConfigPutResponse(rsp)
}

func (c *ClientWithResponses) UpdateTrackingConfigApiV1RepositoriesRepoIdTrackingConfigPutWithResponse(ctx context.Context, repoId string, body UpdateTrackingConfigApiV1RepositoriesRepoIdTrackingConfigPutJSONRequestBody, reqEditors ...RequestEditorFn) (*UpdateTrackingConfigApiV1RepositoriesRepoIdTrackingConfigPutResponse, error) {
	rsp, err := c.UpdateTrackingConfigApiV1RepositoriesRepoIdTrackingConfigPut(ctx, repoId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseUpdateTrackingConfigApiV1RepositoriesRepoIdTrackingConfigPutResponse(rsp)
}

// SearchSnippetsApiV1SearchPostWithBodyWithResponse request with arbitrary body returning *SearchSnippetsApiV1SearchPostResponse
func (c *ClientWithResponses) SearchSnippetsApiV1SearchPostWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*SearchSnippetsApiV1SearchPostResponse, error) {
	rsp, err := c.SearchSnippetsApiV1SearchPostWithBody(ctx, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseSearchSnippetsApiV1SearchPostResponse(rsp)
}

func (c *ClientWithResponses) SearchSnippetsApiV1SearchPostWithResponse(ctx context.Context, body SearchSnippetsApiV1SearchPostJSONRequestBody, reqEditors ...RequestEditorFn) (*SearchSnippetsApiV1SearchPostResponse, error) {
	rsp, err := c.SearchSnippetsApiV1SearchPost(ctx, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseSearchSnippetsApiV1SearchPostResponse(rsp)
}

// HealthzHealthzGetWithResponse request returning *HealthzHealthzGetResponse
func (c *ClientWithResponses) HealthzHealthzGetWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*HealthzHealthzGetResponse, error) {
	rsp, err := c.HealthzHealthzGet(ctx, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseHealthzHealthzGetResponse(rsp)
}

// ParseListEnrichmentsApiV1EnrichmentsGetResponse parses an HTTP response from a ListEnrichmentsApiV1EnrichmentsGetWithResponse call
func ParseListEnrichmentsApiV1EnrichmentsGetResponse(rsp *http.Response) (*ListEnrichmentsApiV1EnrichmentsGetResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &ListEnrichmentsApiV1EnrichmentsGetResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest EnrichmentListResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseDeleteEnrichmentApiV1EnrichmentsEnrichmentIdDeleteResponse parses an HTTP response from a DeleteEnrichmentApiV1EnrichmentsEnrichmentIdDeleteWithResponse call
func ParseDeleteEnrichmentApiV1EnrichmentsEnrichmentIdDeleteResponse(rsp *http.Response) (*DeleteEnrichmentApiV1EnrichmentsEnrichmentIdDeleteResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &DeleteEnrichmentApiV1EnrichmentsEnrichmentIdDeleteResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	return response, nil
}

// ParseGetEnrichmentApiV1EnrichmentsEnrichmentIdGetResponse parses an HTTP response from a GetEnrichmentApiV1EnrichmentsEnrichmentIdGetWithResponse call
func ParseGetEnrichmentApiV1EnrichmentsEnrichmentIdGetResponse(rsp *http.Response) (*GetEnrichmentApiV1EnrichmentsEnrichmentIdGetResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &GetEnrichmentApiV1EnrichmentsEnrichmentIdGetResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest EnrichmentResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseUpdateEnrichmentApiV1EnrichmentsEnrichmentIdPatchResponse parses an HTTP response from a UpdateEnrichmentApiV1EnrichmentsEnrichmentIdPatchWithResponse call
func ParseUpdateEnrichmentApiV1EnrichmentsEnrichmentIdPatchResponse(rsp *http.Response) (*UpdateEnrichmentApiV1EnrichmentsEnrichmentIdPatchResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &UpdateEnrichmentApiV1EnrichmentsEnrichmentIdPatchResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest EnrichmentResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseListQueueTasksApiV1QueueGetResponse parses an HTTP response from a ListQueueTasksApiV1QueueGetWithResponse call
func ParseListQueueTasksApiV1QueueGetResponse(rsp *http.Response) (*ListQueueTasksApiV1QueueGetResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &ListQueueTasksApiV1QueueGetResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest TaskListResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseGetQueueTaskApiV1QueueTaskIdGetResponse parses an HTTP response from a GetQueueTaskApiV1QueueTaskIdGetWithResponse call
func ParseGetQueueTaskApiV1QueueTaskIdGetResponse(rsp *http.Response) (*GetQueueTaskApiV1QueueTaskIdGetResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &GetQueueTaskApiV1QueueTaskIdGetResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest TaskResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseListRepositoriesApiV1RepositoriesGetResponse parses an HTTP response from a ListRepositoriesApiV1RepositoriesGetWithResponse call
func ParseListRepositoriesApiV1RepositoriesGetResponse(rsp *http.Response) (*ListRepositoriesApiV1RepositoriesGetResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &ListRepositoriesApiV1RepositoriesGetResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest RepositoryListResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseCreateRepositoryApiV1RepositoriesPostResponse parses an HTTP response from a CreateRepositoryApiV1RepositoriesPostWithResponse call
func ParseCreateRepositoryApiV1RepositoriesPostResponse(rsp *http.Response) (*CreateRepositoryApiV1RepositoriesPostResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &CreateRepositoryApiV1RepositoriesPostResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest RepositoryResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseDeleteRepositoryApiV1RepositoriesRepoIdDeleteResponse parses an HTTP response from a DeleteRepositoryApiV1RepositoriesRepoIdDeleteWithResponse call
func ParseDeleteRepositoryApiV1RepositoriesRepoIdDeleteResponse(rsp *http.Response) (*DeleteRepositoryApiV1RepositoriesRepoIdDeleteResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &DeleteRepositoryApiV1RepositoriesRepoIdDeleteResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	return response, nil
}

// ParseGetRepositoryApiV1RepositoriesRepoIdGetResponse parses an HTTP response from a GetRepositoryApiV1RepositoriesRepoIdGetWithResponse call
func ParseGetRepositoryApiV1RepositoriesRepoIdGetResponse(rsp *http.Response) (*GetRepositoryApiV1RepositoriesRepoIdGetResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &GetRepositoryApiV1RepositoriesRepoIdGetResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest RepositoryDetailsResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseListRepositoryCommitsApiV1RepositoriesRepoIdCommitsGetResponse parses an HTTP response from a ListRepositoryCommitsApiV1RepositoriesRepoIdCommitsGetWithResponse call
func ParseListRepositoryCommitsApiV1RepositoriesRepoIdCommitsGetResponse(rsp *http.Response) (*ListRepositoryCommitsApiV1RepositoriesRepoIdCommitsGetResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &ListRepositoryCommitsApiV1RepositoriesRepoIdCommitsGetResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest CommitListResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseGetRepositoryCommitApiV1RepositoriesRepoIdCommitsCommitShaGetResponse parses an HTTP response from a GetRepositoryCommitApiV1RepositoriesRepoIdCommitsCommitShaGetWithResponse call
func ParseGetRepositoryCommitApiV1RepositoriesRepoIdCommitsCommitShaGetResponse(rsp *http.Response) (*GetRepositoryCommitApiV1RepositoriesRepoIdCommitsCommitShaGetResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &GetRepositoryCommitApiV1RepositoriesRepoIdCommitsCommitShaGetResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest CommitResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseListCommitEmbeddingsApiV1RepositoriesRepoIdCommitsCommitShaEmbeddingsGetResponse parses an HTTP response from a ListCommitEmbeddingsApiV1RepositoriesRepoIdCommitsCommitShaEmbeddingsGetWithResponse call
func ParseListCommitEmbeddingsApiV1RepositoriesRepoIdCommitsCommitShaEmbeddingsGetResponse(rsp *http.Response) (*ListCommitEmbeddingsApiV1RepositoriesRepoIdCommitsCommitShaEmbeddingsGetResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &ListCommitEmbeddingsApiV1RepositoriesRepoIdCommitsCommitShaEmbeddingsGetResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest EmbeddingListResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseDeleteAllCommitEnrichmentsApiV1RepositoriesRepoIdCommitsCommitShaEnrichmentsDeleteResponse parses an HTTP response from a DeleteAllCommitEnrichmentsApiV1RepositoriesRepoIdCommitsCommitShaEnrichmentsDeleteWithResponse call
func ParseDeleteAllCommitEnrichmentsApiV1RepositoriesRepoIdCommitsCommitShaEnrichmentsDeleteResponse(rsp *http.Response) (*DeleteAllCommitEnrichmentsApiV1RepositoriesRepoIdCommitsCommitShaEnrichmentsDeleteResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &DeleteAllCommitEnrichmentsApiV1RepositoriesRepoIdCommitsCommitShaEnrichmentsDeleteResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	return response, nil
}

// ParseListCommitEnrichmentsApiV1RepositoriesRepoIdCommitsCommitShaEnrichmentsGetResponse parses an HTTP response from a ListCommitEnrichmentsApiV1RepositoriesRepoIdCommitsCommitShaEnrichmentsGetWithResponse call
func ParseListCommitEnrichmentsApiV1RepositoriesRepoIdCommitsCommitShaEnrichmentsGetResponse(rsp *http.Response) (*ListCommitEnrichmentsApiV1RepositoriesRepoIdCommitsCommitShaEnrichmentsGetResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &ListCommitEnrichmentsApiV1RepositoriesRepoIdCommitsCommitShaEnrichmentsGetResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest EnrichmentListResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseDeleteCommitEnrichmentApiV1RepositoriesRepoIdCommitsCommitShaEnrichmentsEnrichmentIdDeleteResponse parses an HTTP response from a DeleteCommitEnrichmentApiV1RepositoriesRepoIdCommitsCommitShaEnrichmentsEnrichmentIdDeleteWithResponse call
func ParseDeleteCommitEnrichmentApiV1RepositoriesRepoIdCommitsCommitShaEnrichmentsEnrichmentIdDeleteResponse(rsp *http.Response) (*DeleteCommitEnrichmentApiV1RepositoriesRepoIdCommitsCommitShaEnrichmentsEnrichmentIdDeleteResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &DeleteCommitEnrichmentApiV1RepositoriesRepoIdCommitsCommitShaEnrichmentsEnrichmentIdDeleteResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	return response, nil
}

// ParseListCommitFilesApiV1RepositoriesRepoIdCommitsCommitShaFilesGetResponse parses an HTTP response from a ListCommitFilesApiV1RepositoriesRepoIdCommitsCommitShaFilesGetWithResponse call
func ParseListCommitFilesApiV1RepositoriesRepoIdCommitsCommitShaFilesGetResponse(rsp *http.Response) (*ListCommitFilesApiV1RepositoriesRepoIdCommitsCommitShaFilesGetResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &ListCommitFilesApiV1RepositoriesRepoIdCommitsCommitShaFilesGetResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest FileListResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseGetCommitFileApiV1RepositoriesRepoIdCommitsCommitShaFilesBlobShaGetResponse parses an HTTP response from a GetCommitFileApiV1RepositoriesRepoIdCommitsCommitShaFilesBlobShaGetWithResponse call
func ParseGetCommitFileApiV1RepositoriesRepoIdCommitsCommitShaFilesBlobShaGetResponse(rsp *http.Response) (*GetCommitFileApiV1RepositoriesRepoIdCommitsCommitShaFilesBlobShaGetResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &GetCommitFileApiV1RepositoriesRepoIdCommitsCommitShaFilesBlobShaGetResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest FileResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseRescanCommitApiV1RepositoriesRepoIdCommitsCommitShaRescanPostResponse parses an HTTP response from a RescanCommitApiV1RepositoriesRepoIdCommitsCommitShaRescanPostWithResponse call
func ParseRescanCommitApiV1RepositoriesRepoIdCommitsCommitShaRescanPostResponse(rsp *http.Response) (*RescanCommitApiV1RepositoriesRepoIdCommitsCommitShaRescanPostResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &RescanCommitApiV1RepositoriesRepoIdCommitsCommitShaRescanPostResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	return response, nil
}

// ParseListCommitSnippetsApiV1RepositoriesRepoIdCommitsCommitShaSnippetsGetResponse parses an HTTP response from a ListCommitSnippetsApiV1RepositoriesRepoIdCommitsCommitShaSnippetsGetWithResponse call
func ParseListCommitSnippetsApiV1RepositoriesRepoIdCommitsCommitShaSnippetsGetResponse(rsp *http.Response) (*ListCommitSnippetsApiV1RepositoriesRepoIdCommitsCommitShaSnippetsGetResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &ListCommitSnippetsApiV1RepositoriesRepoIdCommitsCommitShaSnippetsGetResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest interface{}
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseListRepositoryEnrichmentsApiV1RepositoriesRepoIdEnrichmentsGetResponse parses an HTTP response from a ListRepositoryEnrichmentsApiV1RepositoriesRepoIdEnrichmentsGetWithResponse call
func ParseListRepositoryEnrichmentsApiV1RepositoriesRepoIdEnrichmentsGetResponse(rsp *http.Response) (*ListRepositoryEnrichmentsApiV1RepositoriesRepoIdEnrichmentsGetResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &ListRepositoryEnrichmentsApiV1RepositoriesRepoIdEnrichmentsGetResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest EnrichmentListResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseGetIndexStatusApiV1RepositoriesRepoIdStatusGetResponse parses an HTTP response from a GetIndexStatusApiV1RepositoriesRepoIdStatusGetWithResponse call
func ParseGetIndexStatusApiV1RepositoriesRepoIdStatusGetResponse(rsp *http.Response) (*GetIndexStatusApiV1RepositoriesRepoIdStatusGetResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &GetIndexStatusApiV1RepositoriesRepoIdStatusGetResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest TaskStatusListResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseGetStatusSummaryApiV1RepositoriesRepoIdStatusSummaryGetResponse parses an HTTP response from a GetStatusSummaryApiV1RepositoriesRepoIdStatusSummaryGetWithResponse call
func ParseGetStatusSummaryApiV1RepositoriesRepoIdStatusSummaryGetResponse(rsp *http.Response) (*GetStatusSummaryApiV1RepositoriesRepoIdStatusSummaryGetResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &GetStatusSummaryApiV1RepositoriesRepoIdStatusSummaryGetResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest RepositoryStatusSummaryResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseListRepositoryTagsApiV1RepositoriesRepoIdTagsGetResponse parses an HTTP response from a ListRepositoryTagsApiV1RepositoriesRepoIdTagsGetWithResponse call
func ParseListRepositoryTagsApiV1RepositoriesRepoIdTagsGetResponse(rsp *http.Response) (*ListRepositoryTagsApiV1RepositoriesRepoIdTagsGetResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &ListRepositoryTagsApiV1RepositoriesRepoIdTagsGetResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest TagListResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseGetRepositoryTagApiV1RepositoriesRepoIdTagsTagIdGetResponse parses an HTTP response from a GetRepositoryTagApiV1RepositoriesRepoIdTagsTagIdGetWithResponse call
func ParseGetRepositoryTagApiV1RepositoriesRepoIdTagsTagIdGetResponse(rsp *http.Response) (*GetRepositoryTagApiV1RepositoriesRepoIdTagsTagIdGetResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &GetRepositoryTagApiV1RepositoriesRepoIdTagsTagIdGetResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest TagResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseGetTrackingConfigApiV1RepositoriesRepoIdTrackingConfigGetResponse parses an HTTP response from a GetTrackingConfigApiV1RepositoriesRepoIdTrackingConfigGetWithResponse call
func ParseGetTrackingConfigApiV1RepositoriesRepoIdTrackingConfigGetResponse(rsp *http.Response) (*GetTrackingConfigApiV1RepositoriesRepoIdTrackingConfigGetResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &GetTrackingConfigApiV1RepositoriesRepoIdTrackingConfigGetResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest TrackingConfigResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseUpdateTrackingConfigApiV1RepositoriesRepoIdTrackingConfigPutResponse parses an HTTP response from a UpdateTrackingConfigApiV1RepositoriesRepoIdTrackingConfigPutWithResponse call
func ParseUpdateTrackingConfigApiV1RepositoriesRepoIdTrackingConfigPutResponse(rsp *http.Response) (*UpdateTrackingConfigApiV1RepositoriesRepoIdTrackingConfigPutResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &UpdateTrackingConfigApiV1RepositoriesRepoIdTrackingConfigPutResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest TrackingConfigResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseSearchSnippetsApiV1SearchPostResponse parses an HTTP response from a SearchSnippetsApiV1SearchPostWithResponse call
func ParseSearchSnippetsApiV1SearchPostResponse(rsp *http.Response) (*SearchSnippetsApiV1SearchPostResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &SearchSnippetsApiV1SearchPostResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest SearchResponse
		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 == 422:
		var dest HTTPValidationError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON422 = &dest

	}

	return response, nil
}

// ParseHealthzHealthzGetResponse parses an HTTP response from a HealthzHealthzGetWithResponse call
func ParseHealthzHealthzGetResponse(rsp *http.Response) (*HealthzHealthzGetResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &HealthzHealthzGetResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest interface{}
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}
