// Code generated by go-swagger; DO NOT EDIT.

package operations

// This file was generated by the swagger tool.
// Editing this file might prove futile when you re-run the swagger generate command

import (
	"fmt"
	"io"

	"github.com/go-openapi/runtime"
	httptransport "github.com/go-openapi/runtime/client"
	"github.com/go-openapi/strfmt"
)

// New creates a new operations API client.
func New(transport runtime.ClientTransport, formats strfmt.Registry) ClientService {
	return &Client{transport: transport, formats: formats}
}

// New creates a new operations API client with basic auth credentials.
// It takes the following parameters:
// - host: http host (github.com).
// - basePath: any base path for the API client ("/v1", "/v3").
// - scheme: http scheme ("http", "https").
// - user: user for basic authentication header.
// - password: password for basic authentication header.
func NewClientWithBasicAuth(host, basePath, scheme, user, password string) ClientService {
	transport := httptransport.New(host, basePath, []string{scheme})
	transport.DefaultAuthentication = httptransport.BasicAuth(user, password)
	return &Client{transport: transport, formats: strfmt.Default}
}

// New creates a new operations API client with a bearer token for authentication.
// It takes the following parameters:
// - host: http host (github.com).
// - basePath: any base path for the API client ("/v1", "/v3").
// - scheme: http scheme ("http", "https").
// - bearerToken: bearer token for Bearer authentication header.
func NewClientWithBearerToken(host, basePath, scheme, bearerToken string) ClientService {
	transport := httptransport.New(host, basePath, []string{scheme})
	transport.DefaultAuthentication = httptransport.BearerToken(bearerToken)
	return &Client{transport: transport, formats: strfmt.Default}
}

/*
Client for operations API
*/
type Client struct {
	transport runtime.ClientTransport
	formats   strfmt.Registry
}

// ClientOption may be used to customize the behavior of Client methods.
type ClientOption func(*runtime.ClientOperation)

// This client is generated with a few options you might find useful for your swagger spec.
//
// Feel free to add you own set of options.

// WithAccept allows the client to force the Accept header
// to negotiate a specific Producer from the server.
//
// You may use this option to set arbitrary extensions to your MIME media type.
func WithAccept(mime string) ClientOption {
	return func(r *runtime.ClientOperation) {
		r.ProducesMediaTypes = []string{mime}
	}
}

// WithAcceptApplicationJSON sets the Accept header to "application/json".
func WithAcceptApplicationJSON(r *runtime.ClientOperation) {
	r.ProducesMediaTypes = []string{"application/json"}
}

// WithAcceptApplicationOctetStream sets the Accept header to "application/octet-stream".
func WithAcceptApplicationOctetStream(r *runtime.ClientOperation) {
	r.ProducesMediaTypes = []string{"application/octet-stream"}
}

// ClientService is the interface for Client methods
type ClientService interface {
	DeleteApitoken(params *DeleteApitokenParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteApitokenOK, error)

	DeleteCarupdate(params *DeleteCarupdateParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteCarupdateOK, error)

	DeleteFlashpackVersion(params *DeleteFlashpackVersionParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteFlashpackVersionOK, error)

	DeleteFleetName(params *DeleteFleetNameParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteFleetNameOK, error)

	DeleteFleetNameFilterID(params *DeleteFleetNameFilterIDParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteFleetNameFilterIDOK, error)

	DeleteIssuesID(params *DeleteIssuesIDParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteIssuesIDOK, error)

	DeleteManifest(params *DeleteManifestParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteManifestOK, error)

	DeleteManifestSumsVersion(params *DeleteManifestSumsVersionParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteManifestSumsVersionOK, error)

	DeleteManifestSumsVersionRxswinsRxswin(params *DeleteManifestSumsVersionRxswinsRxswinParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteManifestSumsVersionRxswinsRxswinOK, error)

	DeleteSubscription(params *DeleteSubscriptionParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteSubscriptionOK, error)

	DeleteSubscriptionconfig(params *DeleteSubscriptionconfigParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteSubscriptionconfigOK, error)

	DeleteSubscriptionfeature(params *DeleteSubscriptionfeatureParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteSubscriptionfeatureOK, error)

	DeleteSubscriptionpackage(params *DeleteSubscriptionpackageParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteSubscriptionpackageOK, error)

	DeleteSupplierEmail(params *DeleteSupplierEmailParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteSupplierEmailOK, error)

	DeleteVehicleVin(params *DeleteVehicleVinParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteVehicleVinOK, error)

	DeleteVehicleVinFilterID(params *DeleteVehicleVinFilterIDParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteVehicleVinFilterIDOK, error)

	DeleteVehiclecommandImmobilize(params *DeleteVehiclecommandImmobilizeParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteVehiclecommandImmobilizeOK, error)

	GetApicalls(params *GetApicallsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetApicallsOK, error)

	GetApitokens(params *GetApitokensParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetApitokensOK, error)

	GetCanSignalsDbc(params *GetCanSignalsDbcParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetCanSignalsDbcOK, error)

	GetCanSignalsExport(params *GetCanSignalsExportParams, authInfo runtime.ClientAuthInfoWriter, writer io.Writer, opts ...ClientOption) (*GetCanSignalsExportOK, error)

	GetCanSignalsList(params *GetCanSignalsListParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetCanSignalsListOK, error)

	GetCansignalsVin(params *GetCansignalsVinParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetCansignalsVinOK, error)

	GetCarConfigVin(params *GetCarConfigVinParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetCarConfigVinOK, error)

	GetCarslocations(params *GetCarslocationsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetCarslocationsOK, error)

	GetCarstate(params *GetCarstateParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetCarstateOK, error)

	GetCarupdates(params *GetCarupdatesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetCarupdatesOK, error)

	GetCarupdateslog(params *GetCarupdateslogParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetCarupdateslogOK, error)

	GetCarupdatesstatuses(params *GetCarupdatesstatusesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetCarupdatesstatusesOK, error)

	GetDashboardEmbeddedDashboards(params *GetDashboardEmbeddedDashboardsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) error

	GetDashboardGuestToken(params *GetDashboardGuestTokenParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetDashboardGuestTokenOK, error)

	GetDittoCarstate(params *GetDittoCarstateParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetDittoCarstateOK, error)

	GetEcuStats(params *GetEcuStatsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetEcuStatsOK, error)

	GetEcuStatsVinDbc(params *GetEcuStatsVinDbcParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetEcuStatsVinDbcOK, error)

	GetFlashpackVersionEcuMappingsModelTrimYearFlashpack(params *GetFlashpackVersionEcuMappingsModelTrimYearFlashpackParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetFlashpackVersionEcuMappingsModelTrimYearFlashpackOK, error)

	GetFlashpackVersionInfoVin(params *GetFlashpackVersionInfoVinParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetFlashpackVersionInfoVinOK, error)

	GetFlashpackVersionsModelTrimYear(params *GetFlashpackVersionsModelTrimYearParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetFlashpackVersionsModelTrimYearOK, error)

	GetFleetName(params *GetFleetNameParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetFleetNameOK, error)

	GetFleetNameFilters(params *GetFleetNameFiltersParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetFleetNameFiltersOK, error)

	GetFleetNameVehicles(params *GetFleetNameVehiclesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetFleetNameVehiclesOK, error)

	GetFleets(params *GetFleetsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetFleetsOK, error)

	GetIssueID(params *GetIssueIDParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetIssueIDOK, error)

	GetIssues(params *GetIssuesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetIssuesOK, error)

	GetManifest(params *GetManifestParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetManifestOK, error)

	GetManifestSums(params *GetManifestSumsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetManifestSumsOK, error)

	GetManifestSumsVersionRxswins(params *GetManifestSumsVersionRxswinsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetManifestSumsVersionRxswinsOK, error)

	GetManifestmigrateVersion(params *GetManifestmigrateVersionParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetManifestmigrateVersionOK, error)

	GetManifests(params *GetManifestsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetManifestsOK, error)

	GetManifestsManifestIDVehicles(params *GetManifestsManifestIDVehiclesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetManifestsManifestIDVehiclesOK, error)

	GetSubscriptionconfigs(params *GetSubscriptionconfigsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetSubscriptionconfigsOK, error)

	GetSubscriptionfeature(params *GetSubscriptionfeatureParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetSubscriptionfeatureOK, error)

	GetSubscriptionfeatures(params *GetSubscriptionfeaturesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetSubscriptionfeaturesOK, error)

	GetSubscriptionpackage(params *GetSubscriptionpackageParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetSubscriptionpackageOK, error)

	GetSubscriptionpackages(params *GetSubscriptionpackagesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetSubscriptionpackagesOK, error)

	GetSuppliers(params *GetSuppliersParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetSuppliersOK, error)

	GetVehicleVin(params *GetVehicleVinParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetVehicleVinOK, error)

	GetVehicleVinFilters(params *GetVehicleVinFiltersParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetVehicleVinFiltersOK, error)

	GetVehicleVinFleets(params *GetVehicleVinFleetsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetVehicleVinFleetsOK, error)

	GetVehicleVinTrexLogs(params *GetVehicleVinTrexLogsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetVehicleVinTrexLogsOK, error)

	GetVehicleVinTrexLogsLink(params *GetVehicleVinTrexLogsLinkParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetVehicleVinTrexLogsLinkOK, error)

	GetVehicleVinVersion(params *GetVehicleVinVersionParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetVehicleVinVersionOK, error)

	GetVehicleVinVersionLogs(params *GetVehicleVinVersionLogsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetVehicleVinVersionLogsOK, error)

	GetVehiclecommandImmobilize(params *GetVehiclecommandImmobilizeParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetVehiclecommandImmobilizeOK, error)

	GetVehicleecus(params *GetVehicleecusParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetVehicleecusOK, error)

	GetVehiclemodels(params *GetVehiclemodelsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetVehiclemodelsOK, error)

	GetVehicles(params *GetVehiclesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetVehiclesOK, error)

	GetVehicleyears(params *GetVehicleyearsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetVehicleyearsOK, error)

	PostApitoken(params *PostApitokenParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostApitokenOK, error)

	PostCarConfigVin(params *PostCarConfigVinParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostCarConfigVinOK, error)

	PostCarsconnected(params *PostCarsconnectedParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostCarsconnectedOK, error)

	PostCarstateMulti(params *PostCarstateMultiParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostCarstateMultiOK, error)

	PostCarupdate(params *PostCarupdateParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostCarupdateOK, error)

	PostCarupdateIDCancel(params *PostCarupdateIDCancelParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostCarupdateIDCancelOK, error)

	PostCarupdateIDDeploy(params *PostCarupdateIDDeployParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostCarupdateIDDeployOK, error)

	PostCarupdateIDVehicleCancel(params *PostCarupdateIDVehicleCancelParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostCarupdateIDVehicleCancelOK, error)

	PostFlashpackVersion(params *PostFlashpackVersionParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostFlashpackVersionOK, error)

	PostFleet(params *PostFleetParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostFleetOK, error)

	PostFleetNameFilter(params *PostFleetNameFilterParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostFleetNameFilterOK, error)

	PostFleetNameVehiclesAdd(params *PostFleetNameVehiclesAddParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostFleetNameVehiclesAddOK, error)

	PostFleetNameVehiclesDelete(params *PostFleetNameVehiclesDeleteParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostFleetNameVehiclesDeleteOK, error)

	PostFleetupdate(params *PostFleetupdateParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostFleetupdateOK, error)

	PostManifest(params *PostManifestParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostManifestOK, error)

	PostManifestSums(params *PostManifestSumsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostManifestSumsOK, error)

	PostManifestSumsVersionRxswins(params *PostManifestSumsVersionRxswinsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostManifestSumsVersionRxswinsOK, error)

	PostManifestecu(params *PostManifestecuParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostManifestecuOK, error)

	PostManifestfile(params *PostManifestfileParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostManifestfileOK, error)

	PostManifestmigrate(params *PostManifestmigrateParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostManifestmigrateOK, error)

	PostManifestmigrateManifestID(params *PostManifestmigrateManifestIDParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostManifestmigrateManifestIDOK, error)

	PostManufactureCerts(params *PostManufactureCertsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostManufactureCertsOK, error)

	PostSms(params *PostSmsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostSmsOK, error)

	PostSubscriptionconfig(params *PostSubscriptionconfigParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostSubscriptionconfigOK, error)

	PostSubscriptionfeature(params *PostSubscriptionfeatureParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostSubscriptionfeatureOK, error)

	PostSubscriptionpackage(params *PostSubscriptionpackageParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostSubscriptionpackageOK, error)

	PostSubscriptionpackagefeature(params *PostSubscriptionpackagefeatureParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostSubscriptionpackagefeatureOK, error)

	PostSupplierActivateEmail(params *PostSupplierActivateEmailParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostSupplierActivateEmailOK, error)

	PostTags(params *PostTagsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostTagsOK, error)

	PostVehicle(params *PostVehicleParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostVehicleOK, error)

	PostVehiclePaths(params *PostVehiclePathsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostVehiclePathsOK, error)

	PostVehicleVinFilter(params *PostVehicleVinFilterParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostVehicleVinFilterOK, error)

	PostVehiclecommand(params *PostVehiclecommandParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostVehiclecommandOK, error)

	PostVehiclecommandImmobilize(params *PostVehiclecommandImmobilizeParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostVehiclecommandImmobilizeOK, error)

	PostVehiclediagnosticcommand(params *PostVehiclediagnosticcommandParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostVehiclediagnosticcommandOK, error)

	PutApitoken(params *PutApitokenParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PutApitokenOK, error)

	PutCustomerOtaEmails(params *PutCustomerOtaEmailsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PutCustomerOtaEmailsOK, error)

	PutFleetName(params *PutFleetNameParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PutFleetNameOK, error)

	PutFleetNameFilterID(params *PutFleetNameFilterIDParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PutFleetNameFilterIDOK, error)

	PutManifest(params *PutManifestParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PutManifestOK, error)

	PutManifestsArchive(params *PutManifestsArchiveParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PutManifestsArchiveOK, error)

	PutManifestsIDSums(params *PutManifestsIDSumsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PutManifestsIDSumsOK, error)

	PutSubscriptionconfig(params *PutSubscriptionconfigParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PutSubscriptionconfigOK, error)

	PutSubscriptionfeature(params *PutSubscriptionfeatureParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PutSubscriptionfeatureOK, error)

	PutSubscriptionpackage(params *PutSubscriptionpackageParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PutSubscriptionpackageOK, error)

	PutSupplierEmail(params *PutSupplierEmailParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PutSupplierEmailOK, error)

	PutTags(params *PutTagsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PutTagsOK, error)

	PutVehicleVin(params *PutVehicleVinParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PutVehicleVinOK, error)

	PutVehicleVinFilterID(params *PutVehicleVinFilterIDParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PutVehicleVinFilterIDOK, error)

	SetTransport(transport runtime.ClientTransport)
}

/*
DeleteApitoken deletes API token

Delete API token. Requires delete permissions
*/
func (a *Client) DeleteApitoken(params *DeleteApitokenParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteApitokenOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteApitokenParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "DeleteApitoken",
		Method:             "DELETE",
		PathPattern:        "/apitoken",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &DeleteApitokenReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*DeleteApitokenOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for DeleteApitoken: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
DeleteCarupdate deletes car update

Delete car update. Requires delete permissions
*/
func (a *Client) DeleteCarupdate(params *DeleteCarupdateParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteCarupdateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteCarupdateParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "DeleteCarupdate",
		Method:             "DELETE",
		PathPattern:        "/carupdate",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &DeleteCarupdateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*DeleteCarupdateOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for DeleteCarupdate: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
DeleteFlashpackVersion deletes a flashpack version

Delete a flashpack version
*/
func (a *Client) DeleteFlashpackVersion(params *DeleteFlashpackVersionParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteFlashpackVersionOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteFlashpackVersionParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "DeleteFlashpackVersion",
		Method:             "DELETE",
		PathPattern:        "/flashpack_version",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &DeleteFlashpackVersionReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*DeleteFlashpackVersionOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for DeleteFlashpackVersion: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
DeleteFleetName deletes fleet

Delete fleet
*/
func (a *Client) DeleteFleetName(params *DeleteFleetNameParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteFleetNameOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteFleetNameParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "DeleteFleetName",
		Method:             "DELETE",
		PathPattern:        "/fleet/{name}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &DeleteFleetNameReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*DeleteFleetNameOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for DeleteFleetName: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
DeleteFleetNameFilterID deletes filter from fleet

Delete filter from fleet
*/
func (a *Client) DeleteFleetNameFilterID(params *DeleteFleetNameFilterIDParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteFleetNameFilterIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteFleetNameFilterIDParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "DeleteFleetNameFilterID",
		Method:             "DELETE",
		PathPattern:        "/fleet/{name}/filter/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &DeleteFleetNameFilterIDReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*DeleteFleetNameFilterIDOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for DeleteFleetNameFilterID: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
DeleteIssuesID deletes an issue by ID

Deletes an Issue by its ID
*/
func (a *Client) DeleteIssuesID(params *DeleteIssuesIDParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteIssuesIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteIssuesIDParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "DeleteIssuesID",
		Method:             "DELETE",
		PathPattern:        "/issues/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &DeleteIssuesIDReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*DeleteIssuesIDOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for DeleteIssuesID: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
DeleteManifest deletes update manifest

Delete update manifest data. Requires delete permissions
*/
func (a *Client) DeleteManifest(params *DeleteManifestParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteManifestOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteManifestParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "DeleteManifest",
		Method:             "DELETE",
		PathPattern:        "/manifest",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &DeleteManifestReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*DeleteManifestOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for DeleteManifest: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
DeleteManifestSumsVersion deletes a s u m s version number

Delete a SUMS version number
*/
func (a *Client) DeleteManifestSumsVersion(params *DeleteManifestSumsVersionParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteManifestSumsVersionOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteManifestSumsVersionParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "DeleteManifestSumsVersion",
		Method:             "DELETE",
		PathPattern:        "/manifest/sums/{version}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &DeleteManifestSumsVersionReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*DeleteManifestSumsVersionOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for DeleteManifestSumsVersion: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
DeleteManifestSumsVersionRxswinsRxswin deletes a r x software ID numbers rx s w i ns for given sum version and rxswin

Delete a RX Software ID Number (RxSWIN) for a given manifest update manifest sum version and rxswin number
*/
func (a *Client) DeleteManifestSumsVersionRxswinsRxswin(params *DeleteManifestSumsVersionRxswinsRxswinParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteManifestSumsVersionRxswinsRxswinOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteManifestSumsVersionRxswinsRxswinParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "DeleteManifestSumsVersionRxswinsRxswin",
		Method:             "DELETE",
		PathPattern:        "/manifest/sums/{version}/rxswins/{rxswin}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &DeleteManifestSumsVersionRxswinsRxswinReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*DeleteManifestSumsVersionRxswinsRxswinOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for DeleteManifestSumsVersionRxswinsRxswin: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
DeleteSubscription deletes subscription

Delete subscription data. Requires delete permissions
*/
func (a *Client) DeleteSubscription(params *DeleteSubscriptionParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteSubscriptionOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteSubscriptionParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "DeleteSubscription",
		Method:             "DELETE",
		PathPattern:        "/subscription",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &DeleteSubscriptionReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*DeleteSubscriptionOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for DeleteSubscription: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
DeleteSubscriptionconfig deletes subscription configuration

Delete subscription configuration data. Requires delete permissions
*/
func (a *Client) DeleteSubscriptionconfig(params *DeleteSubscriptionconfigParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteSubscriptionconfigOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteSubscriptionconfigParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "DeleteSubscriptionconfig",
		Method:             "DELETE",
		PathPattern:        "/subscriptionconfig",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &DeleteSubscriptionconfigReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*DeleteSubscriptionconfigOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for DeleteSubscriptionconfig: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
DeleteSubscriptionfeature deletes subscription feature

Delete subscription feature data. Requires delete permissions
*/
func (a *Client) DeleteSubscriptionfeature(params *DeleteSubscriptionfeatureParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteSubscriptionfeatureOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteSubscriptionfeatureParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "DeleteSubscriptionfeature",
		Method:             "DELETE",
		PathPattern:        "/subscriptionfeature",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &DeleteSubscriptionfeatureReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*DeleteSubscriptionfeatureOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for DeleteSubscriptionfeature: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
DeleteSubscriptionpackage deletes subscription package

Delete subscription package data. Requires delete permissions
*/
func (a *Client) DeleteSubscriptionpackage(params *DeleteSubscriptionpackageParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteSubscriptionpackageOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteSubscriptionpackageParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "DeleteSubscriptionpackage",
		Method:             "DELETE",
		PathPattern:        "/subscriptionpackage",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &DeleteSubscriptionpackageReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*DeleteSubscriptionpackageOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for DeleteSubscriptionpackage: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
DeleteSupplierEmail deletes filter from vehicle

Delete filter from vehicle
*/
func (a *Client) DeleteSupplierEmail(params *DeleteSupplierEmailParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteSupplierEmailOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteSupplierEmailParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "DeleteSupplierEmail",
		Method:             "DELETE",
		PathPattern:        "/supplier/{email}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &DeleteSupplierEmailReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*DeleteSupplierEmailOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for DeleteSupplierEmail: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
DeleteVehicleVin deletes vehicle

Delete vehicle data. Requires delete permissions
*/
func (a *Client) DeleteVehicleVin(params *DeleteVehicleVinParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteVehicleVinOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteVehicleVinParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "DeleteVehicleVin",
		Method:             "DELETE",
		PathPattern:        "/vehicle/{vin}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &DeleteVehicleVinReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*DeleteVehicleVinOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for DeleteVehicleVin: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
DeleteVehicleVinFilterID deletes filter from vehicle

Delete filter from vehicle
*/
func (a *Client) DeleteVehicleVinFilterID(params *DeleteVehicleVinFilterIDParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteVehicleVinFilterIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteVehicleVinFilterIDParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "DeleteVehicleVinFilterID",
		Method:             "DELETE",
		PathPattern:        "/vehicle/{vin}/filter/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &DeleteVehicleVinFilterIDReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*DeleteVehicleVinFilterIDOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for DeleteVehicleVinFilterID: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
DeleteVehiclecommandImmobilize deletes vehicles from immobilizer list
*/
func (a *Client) DeleteVehiclecommandImmobilize(params *DeleteVehiclecommandImmobilizeParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteVehiclecommandImmobilizeOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteVehiclecommandImmobilizeParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "DeleteVehiclecommandImmobilize",
		Method:             "DELETE",
		PathPattern:        "/vehiclecommand/immobilize",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &DeleteVehiclecommandImmobilizeReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*DeleteVehiclecommandImmobilizeOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for DeleteVehiclecommandImmobilize: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetApicalls searches API calls

Get API calls filtered by method, user, path and date.
*/
func (a *Client) GetApicalls(params *GetApicallsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetApicallsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetApicallsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetApicalls",
		Method:             "GET",
		PathPattern:        "/apicalls",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetApicallsReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetApicallsOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for GetApicalls: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetApitokens lists API tokens

List API tokens. Requires API token permission
*/
func (a *Client) GetApitokens(params *GetApitokensParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetApitokensOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetApitokensParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetApitokens",
		Method:             "GET",
		PathPattern:        "/apitokens",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetApitokensReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetApitokensOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for GetApitokens: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetCanSignalsDbc lists API tokens

List API tokens. Requires API token permission
*/
func (a *Client) GetCanSignalsDbc(params *GetCanSignalsDbcParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetCanSignalsDbcOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetCanSignalsDbcParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetCanSignalsDbc",
		Method:             "GET",
		PathPattern:        "/can_signals/{dbc}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetCanSignalsDbcReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetCanSignalsDbcOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for GetCanSignalsDbc: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetCanSignalsExport exports c a n signals for a specific v i n

Exports CAN signals for a specific VIN based on specified time range and CAN signals. Requires API token permission.
*/
func (a *Client) GetCanSignalsExport(params *GetCanSignalsExportParams, authInfo runtime.ClientAuthInfoWriter, writer io.Writer, opts ...ClientOption) (*GetCanSignalsExportOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetCanSignalsExportParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetCanSignalsExport",
		Method:             "GET",
		PathPattern:        "/can_signals_export",
		ProducesMediaTypes: []string{"application/octet-stream"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetCanSignalsExportReader{formats: a.formats, writer: writer},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetCanSignalsExportOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for GetCanSignalsExport: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetCanSignalsList lists of can signals used in feature table

Returns a list of can signals Requires API token permission.
*/
func (a *Client) GetCanSignalsList(params *GetCanSignalsListParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetCanSignalsListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetCanSignalsListParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetCanSignalsList",
		Method:             "GET",
		PathPattern:        "/can_signals_list",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetCanSignalsListReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetCanSignalsListOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for GetCanSignalsList: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetCansignalsVin gets locations of cars

Returns car locations
*/
func (a *Client) GetCansignalsVin(params *GetCansignalsVinParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetCansignalsVinOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetCansignalsVinParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetCansignalsVin",
		Method:             "GET",
		PathPattern:        "/cansignals/{vin}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetCansignalsVinReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetCansignalsVinOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for GetCansignalsVin: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetCarConfigVin gets the vod and cds for car does not generate a usable to send to the car

Get all sap codes for a car, transform them to VOD and CDS, then return it to the user
*/
func (a *Client) GetCarConfigVin(params *GetCarConfigVinParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetCarConfigVinOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetCarConfigVinParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetCarConfigVin",
		Method:             "GET",
		PathPattern:        "/car_config/{vin}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetCarConfigVinReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetCarConfigVinOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for GetCarConfigVin: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetCarslocations gets locations of cars

Returns car locations
*/
func (a *Client) GetCarslocations(params *GetCarslocationsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetCarslocationsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetCarslocationsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetCarslocations",
		Method:             "GET",
		PathPattern:        "/carslocations",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetCarslocationsReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetCarslocationsOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for GetCarslocations: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetCarstate gets state of car

Returns the state of the car derived from CAN bus messages.
*/
func (a *Client) GetCarstate(params *GetCarstateParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetCarstateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetCarstateParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetCarstate",
		Method:             "GET",
		PathPattern:        "/carstate",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetCarstateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetCarstateOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for GetCarstate: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetCarupdates searches car updates

Get car updates filtered by id, car id, and update package id
*/
func (a *Client) GetCarupdates(params *GetCarupdatesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetCarupdatesOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetCarupdatesParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetCarupdates",
		Method:             "GET",
		PathPattern:        "/carupdates",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetCarupdatesReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetCarupdatesOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for GetCarupdates: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetCarupdateslog gets log of car update statuses

Returns array of car update statuses
*/
func (a *Client) GetCarupdateslog(params *GetCarupdateslogParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetCarupdateslogOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetCarupdateslogParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetCarupdateslog",
		Method:             "GET",
		PathPattern:        "/carupdateslog",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetCarupdateslogReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetCarupdateslogOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for GetCarupdateslog: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetCarupdatesstatuses gets statuses for car update by car update ids

Returns array of car update statuses
*/
func (a *Client) GetCarupdatesstatuses(params *GetCarupdatesstatusesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetCarupdatesstatusesOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetCarupdatesstatusesParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetCarupdatesstatuses",
		Method:             "GET",
		PathPattern:        "/carupdatesstatuses",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetCarupdatesstatusesReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetCarupdatesstatusesOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for GetCarupdatesstatuses: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetDashboardEmbeddedDashboards deprecateds get the list of embeddable superset dashboards

Returns list of dashboard embedding id and their title
*/
func (a *Client) GetDashboardEmbeddedDashboards(params *GetDashboardEmbeddedDashboardsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) error {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetDashboardEmbeddedDashboardsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetDashboardEmbeddedDashboards",
		Method:             "GET",
		PathPattern:        "/dashboard/embedded-dashboards",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetDashboardEmbeddedDashboardsReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	_, err := a.transport.Submit(op)
	if err != nil {
		return err
	}
	return nil
}

/*
GetDashboardGuestToken gets token for accessing dashboard

Returns token
*/
func (a *Client) GetDashboardGuestToken(params *GetDashboardGuestTokenParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetDashboardGuestTokenOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetDashboardGuestTokenParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetDashboardGuestToken",
		Method:             "GET",
		PathPattern:        "/dashboard/guest-token",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetDashboardGuestTokenReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetDashboardGuestTokenOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for GetDashboardGuestToken: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetDittoCarstate lists signals with updated timestamp

Returns list of state with last updated timestamp.
*/
func (a *Client) GetDittoCarstate(params *GetDittoCarstateParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetDittoCarstateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetDittoCarstateParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetDittoCarstate",
		Method:             "GET",
		PathPattern:        "/ditto/carstate",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetDittoCarstateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetDittoCarstateOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for GetDittoCarstate: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetEcuStats lists API tokens

List API tokens. Requires API token permission
*/
func (a *Client) GetEcuStats(params *GetEcuStatsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetEcuStatsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetEcuStatsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetEcuStats",
		Method:             "GET",
		PathPattern:        "/ecu_stats",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetEcuStatsReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetEcuStatsOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for GetEcuStats: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetEcuStatsVinDbc lists API tokens

List API tokens. Requires API token permission
*/
func (a *Client) GetEcuStatsVinDbc(params *GetEcuStatsVinDbcParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetEcuStatsVinDbcOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetEcuStatsVinDbcParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetEcuStatsVinDbc",
		Method:             "GET",
		PathPattern:        "/ecu_stats/{vin}/{dbc}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetEcuStatsVinDbcReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetEcuStatsVinDbcOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for GetEcuStatsVinDbc: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetFlashpackVersionEcuMappingsModelTrimYearFlashpack gets mappings between a flashpack and ecu versions

Get mappings between a flashpack and ecu versions
*/
func (a *Client) GetFlashpackVersionEcuMappingsModelTrimYearFlashpack(params *GetFlashpackVersionEcuMappingsModelTrimYearFlashpackParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetFlashpackVersionEcuMappingsModelTrimYearFlashpackOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetFlashpackVersionEcuMappingsModelTrimYearFlashpackParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetFlashpackVersionEcuMappingsModelTrimYearFlashpack",
		Method:             "GET",
		PathPattern:        "/flashpack_version_ecu_mappings/{model}/{trim}/{year}/{flashpack}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetFlashpackVersionEcuMappingsModelTrimYearFlashpackReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetFlashpackVersionEcuMappingsModelTrimYearFlashpackOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for GetFlashpackVersionEcuMappingsModelTrimYearFlashpack: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetFlashpackVersionInfoVin gets flashpack version info for a car

Get flashpack version info (version number, ECUs to be updated for next version) for a car
*/
func (a *Client) GetFlashpackVersionInfoVin(params *GetFlashpackVersionInfoVinParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetFlashpackVersionInfoVinOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetFlashpackVersionInfoVinParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetFlashpackVersionInfoVin",
		Method:             "GET",
		PathPattern:        "/flashpack_version_info/{vin}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetFlashpackVersionInfoVinReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetFlashpackVersionInfoVinOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for GetFlashpackVersionInfoVin: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetFlashpackVersionsModelTrimYear gets all flashpacks

Get all flashpacks
*/
func (a *Client) GetFlashpackVersionsModelTrimYear(params *GetFlashpackVersionsModelTrimYearParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetFlashpackVersionsModelTrimYearOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetFlashpackVersionsModelTrimYearParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetFlashpackVersionsModelTrimYear",
		Method:             "GET",
		PathPattern:        "/flashpack_versions/{model}/{trim}/{year}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetFlashpackVersionsModelTrimYearReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetFlashpackVersionsModelTrimYearOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for GetFlashpackVersionsModelTrimYear: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetFleetName gets fleet

Get fleet
*/
func (a *Client) GetFleetName(params *GetFleetNameParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetFleetNameOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetFleetNameParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetFleetName",
		Method:             "GET",
		PathPattern:        "/fleet/{name}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetFleetNameReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetFleetNameOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for GetFleetName: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetFleetNameFilters gets filters for fleet

Get filters for fleet
*/
func (a *Client) GetFleetNameFilters(params *GetFleetNameFiltersParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetFleetNameFiltersOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetFleetNameFiltersParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetFleetNameFilters",
		Method:             "GET",
		PathPattern:        "/fleet/{name}/filters",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetFleetNameFiltersReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetFleetNameFiltersOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for GetFleetNameFilters: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetFleetNameVehicles gets vehicles for fleet

Get vehicles for fleet
*/
func (a *Client) GetFleetNameVehicles(params *GetFleetNameVehiclesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetFleetNameVehiclesOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetFleetNameVehiclesParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetFleetNameVehicles",
		Method:             "GET",
		PathPattern:        "/fleet/{name}/vehicles",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetFleetNameVehiclesReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetFleetNameVehiclesOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for GetFleetNameVehicles: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetFleets gets list of fleets

Get list of fleets
*/
func (a *Client) GetFleets(params *GetFleetsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetFleetsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetFleetsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetFleets",
		Method:             "GET",
		PathPattern:        "/fleets",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetFleetsReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetFleetsOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for GetFleets: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetIssueID searches issue by ID

Returns all Issue related to the issue id
*/
func (a *Client) GetIssueID(params *GetIssueIDParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetIssueIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetIssueIDParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetIssueID",
		Method:             "GET",
		PathPattern:        "/issue/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetIssueIDReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetIssueIDOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for GetIssueID: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetIssues searches issues

Returns all Issues
*/
func (a *Client) GetIssues(params *GetIssuesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetIssuesOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetIssuesParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetIssues",
		Method:             "GET",
		PathPattern:        "/issues",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetIssuesReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetIssuesOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for GetIssues: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetManifest gets update manifest

Get update manifest by id
*/
func (a *Client) GetManifest(params *GetManifestParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetManifestOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetManifestParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetManifest",
		Method:             "GET",
		PathPattern:        "/manifest",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetManifestReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetManifestOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for GetManifest: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetManifestSums gets all update manifest versions

Get all update manifest versions
*/
func (a *Client) GetManifestSums(params *GetManifestSumsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetManifestSumsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetManifestSumsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetManifestSums",
		Method:             "GET",
		PathPattern:        "/manifest/sums",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetManifestSumsReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetManifestSumsOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for GetManifestSums: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetManifestSumsVersionRxswins gets all r x software ID numbers rx s w i ns for a given manifest update manifest version

Get and return all RX Software ID Numbers (RxSWINs) for a given manifest update manifest version
*/
func (a *Client) GetManifestSumsVersionRxswins(params *GetManifestSumsVersionRxswinsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetManifestSumsVersionRxswinsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetManifestSumsVersionRxswinsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetManifestSumsVersionRxswins",
		Method:             "GET",
		PathPattern:        "/manifest/sums/{version}/rxswins",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetManifestSumsVersionRxswinsReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetManifestSumsVersionRxswinsOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for GetManifestSumsVersionRxswins: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetManifestmigrateVersion returns the version of manifest migrate that this service is running
*/
func (a *Client) GetManifestmigrateVersion(params *GetManifestmigrateVersionParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetManifestmigrateVersionOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetManifestmigrateVersionParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetManifestmigrateVersion",
		Method:             "GET",
		PathPattern:        "/manifestmigrate-version",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetManifestmigrateVersionReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetManifestmigrateVersionOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for GetManifestmigrateVersion: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetManifests searches update manifests

Get update manifests filtered by id, name, version, description
*/
func (a *Client) GetManifests(params *GetManifestsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetManifestsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetManifestsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetManifests",
		Method:             "GET",
		PathPattern:        "/manifests",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetManifestsReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetManifestsOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for GetManifests: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetManifestsManifestIDVehicles gets cars by manifest

Returns list of cars selected by manifest id
*/
func (a *Client) GetManifestsManifestIDVehicles(params *GetManifestsManifestIDVehiclesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetManifestsManifestIDVehiclesOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetManifestsManifestIDVehiclesParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetManifestsManifestIDVehicles",
		Method:             "GET",
		PathPattern:        "/manifests/{manifest_id}/vehicles",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetManifestsManifestIDVehiclesReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetManifestsManifestIDVehiclesOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for GetManifestsManifestIDVehicles: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetSubscriptionconfigs searches subscription features

Get subscription features filtered by id or name
*/
func (a *Client) GetSubscriptionconfigs(params *GetSubscriptionconfigsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetSubscriptionconfigsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetSubscriptionconfigsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetSubscriptionconfigs",
		Method:             "GET",
		PathPattern:        "/subscriptionconfigs",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetSubscriptionconfigsReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetSubscriptionconfigsOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for GetSubscriptionconfigs: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetSubscriptionfeature gets update manifest

Get update manifest by id
*/
func (a *Client) GetSubscriptionfeature(params *GetSubscriptionfeatureParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetSubscriptionfeatureOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetSubscriptionfeatureParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetSubscriptionfeature",
		Method:             "GET",
		PathPattern:        "/subscriptionfeature",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetSubscriptionfeatureReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetSubscriptionfeatureOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for GetSubscriptionfeature: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetSubscriptionfeatures searches subscription features

Get subscription features filtered by id or name
*/
func (a *Client) GetSubscriptionfeatures(params *GetSubscriptionfeaturesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetSubscriptionfeaturesOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetSubscriptionfeaturesParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetSubscriptionfeatures",
		Method:             "GET",
		PathPattern:        "/subscriptionfeatures",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetSubscriptionfeaturesReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetSubscriptionfeaturesOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for GetSubscriptionfeatures: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetSubscriptionpackage gets update manifest

Get update manifest by id
*/
func (a *Client) GetSubscriptionpackage(params *GetSubscriptionpackageParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetSubscriptionpackageOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetSubscriptionpackageParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetSubscriptionpackage",
		Method:             "GET",
		PathPattern:        "/subscriptionpackage",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetSubscriptionpackageReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetSubscriptionpackageOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for GetSubscriptionpackage: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetSubscriptionpackages searches subscription packages

Get subscription packages filtered by id, name
*/
func (a *Client) GetSubscriptionpackages(params *GetSubscriptionpackagesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetSubscriptionpackagesOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetSubscriptionpackagesParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetSubscriptionpackages",
		Method:             "GET",
		PathPattern:        "/subscriptionpackages",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetSubscriptionpackagesReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetSubscriptionpackagesOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for GetSubscriptionpackages: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetSuppliers searches supplier accounts

Get supplier accounts filtered by id or email
*/
func (a *Client) GetSuppliers(params *GetSuppliersParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetSuppliersOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetSuppliersParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetSuppliers",
		Method:             "GET",
		PathPattern:        "/suppliers",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetSuppliersReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetSuppliersOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for GetSuppliers: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetVehicleVin gets vehicle

Get vehicle
*/
func (a *Client) GetVehicleVin(params *GetVehicleVinParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetVehicleVinOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetVehicleVinParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetVehicleVin",
		Method:             "GET",
		PathPattern:        "/vehicle/{vin}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetVehicleVinReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetVehicleVinOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for GetVehicleVin: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetVehicleVinFilters gets filters for car

Get filters for a car
*/
func (a *Client) GetVehicleVinFilters(params *GetVehicleVinFiltersParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetVehicleVinFiltersOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetVehicleVinFiltersParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetVehicleVinFilters",
		Method:             "GET",
		PathPattern:        "/vehicle/{vin}/filters",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetVehicleVinFiltersReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetVehicleVinFiltersOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for GetVehicleVinFilters: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetVehicleVinFleets gets fleets of car

Get fleets of a car
*/
func (a *Client) GetVehicleVinFleets(params *GetVehicleVinFleetsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetVehicleVinFleetsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetVehicleVinFleetsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetVehicleVinFleets",
		Method:             "GET",
		PathPattern:        "/vehicle/{vin}/fleets",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetVehicleVinFleetsReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetVehicleVinFleetsOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for GetVehicleVinFleets: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetVehicleVinTrexLogs retrieves t rex logs

Get T.Rex logs for specific day
*/
func (a *Client) GetVehicleVinTrexLogs(params *GetVehicleVinTrexLogsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetVehicleVinTrexLogsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetVehicleVinTrexLogsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetVehicleVinTrexLogs",
		Method:             "GET",
		PathPattern:        "/vehicle/{vin}/trex-logs",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetVehicleVinTrexLogsReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetVehicleVinTrexLogsOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for GetVehicleVinTrexLogs: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetVehicleVinTrexLogsLink retrieves t rex logs

Get T.Rex logs for specific day
*/
func (a *Client) GetVehicleVinTrexLogsLink(params *GetVehicleVinTrexLogsLinkParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetVehicleVinTrexLogsLinkOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetVehicleVinTrexLogsLinkParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetVehicleVinTrexLogsLink",
		Method:             "GET",
		PathPattern:        "/vehicle/{vin}/trex-logs-link",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetVehicleVinTrexLogsLinkReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetVehicleVinTrexLogsLinkOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for GetVehicleVinTrexLogsLink: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetVehicleVinVersion returns versions for v i n

Returns versions for VIN at a point in time
*/
func (a *Client) GetVehicleVinVersion(params *GetVehicleVinVersionParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetVehicleVinVersionOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetVehicleVinVersionParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetVehicleVinVersion",
		Method:             "GET",
		PathPattern:        "/vehicle/{vin}/version",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetVehicleVinVersionReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetVehicleVinVersionOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for GetVehicleVinVersion: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetVehicleVinVersionLogs returns version change logs by v i n

Returns version change logs by VIN.
*/
func (a *Client) GetVehicleVinVersionLogs(params *GetVehicleVinVersionLogsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetVehicleVinVersionLogsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetVehicleVinVersionLogsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetVehicleVinVersionLogs",
		Method:             "GET",
		PathPattern:        "/vehicle/{vin}/version/logs",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetVehicleVinVersionLogsReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetVehicleVinVersionLogsOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for GetVehicleVinVersionLogs: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetVehiclecommandImmobilize lists vehicles in immobilizer list
*/
func (a *Client) GetVehiclecommandImmobilize(params *GetVehiclecommandImmobilizeParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetVehiclecommandImmobilizeOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetVehiclecommandImmobilizeParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetVehiclecommandImmobilize",
		Method:             "GET",
		PathPattern:        "/vehiclecommand/immobilize",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetVehiclecommandImmobilizeReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetVehiclecommandImmobilizeOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for GetVehiclecommandImmobilize: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetVehicleecus gets car e c us

Returns ECUs for car
*/
func (a *Client) GetVehicleecus(params *GetVehicleecusParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetVehicleecusOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetVehicleecusParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetVehicleecus",
		Method:             "GET",
		PathPattern:        "/vehicleecus",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetVehicleecusReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetVehicleecusOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for GetVehicleecus: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetVehiclemodels returns vehicle models

Returns vehicle models
*/
func (a *Client) GetVehiclemodels(params *GetVehiclemodelsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetVehiclemodelsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetVehiclemodelsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetVehiclemodels",
		Method:             "GET",
		PathPattern:        "/vehiclemodels",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetVehiclemodelsReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetVehiclemodelsOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for GetVehiclemodels: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetVehicles searches cars

Returns cars filtered by id, model, year, and vin
*/
func (a *Client) GetVehicles(params *GetVehiclesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetVehiclesOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetVehiclesParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetVehicles",
		Method:             "GET",
		PathPattern:        "/vehicles",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetVehiclesReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetVehiclesOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for GetVehicles: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetVehicleyears returns vehicle years

Returns vehicle years
*/
func (a *Client) GetVehicleyears(params *GetVehicleyearsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetVehicleyearsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetVehicleyearsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetVehicleyears",
		Method:             "GET",
		PathPattern:        "/vehicleyears",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetVehicleyearsReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetVehicleyearsOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for GetVehicleyears: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
PostApitoken adds API token

Create API token. Requires API token permission
*/
func (a *Client) PostApitoken(params *PostApitokenParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostApitokenOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostApitokenParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "PostApitoken",
		Method:             "POST",
		PathPattern:        "/apitoken",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PostApitokenReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*PostApitokenOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for PostApitoken: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
PostCarConfigVin sends v o d and c d s to car

Get all sap codes for a car, transform them to VOD and CDS, then send it to the car
*/
func (a *Client) PostCarConfigVin(params *PostCarConfigVinParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostCarConfigVinOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostCarConfigVinParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "PostCarConfigVin",
		Method:             "POST",
		PathPattern:        "/car_config/{vin}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PostCarConfigVinReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*PostCarConfigVinOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for PostCarConfigVin: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
PostCarsconnected gets connection statuses car vins

Returns hash object of car connection statuses
*/
func (a *Client) PostCarsconnected(params *PostCarsconnectedParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostCarsconnectedOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostCarsconnectedParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "PostCarsconnected",
		Method:             "POST",
		PathPattern:        "/carsconnected",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PostCarsconnectedReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*PostCarsconnectedOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for PostCarsconnected: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
PostCarstateMulti gets state of a list of cars

Returns the states from a set of vins. Some vins may be missing in redis, or be invalid, but the other vins will still be successfully returned. Broken vin will be in the error list
*/
func (a *Client) PostCarstateMulti(params *PostCarstateMultiParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostCarstateMultiOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostCarstateMultiParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "PostCarstateMulti",
		Method:             "POST",
		PathPattern:        "/carstate_multi",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PostCarstateMultiReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*PostCarstateMultiOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for PostCarstateMulti: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
PostCarupdate adds car updates

Create car updates assigning manifest package to cars, and send notifications
*/
func (a *Client) PostCarupdate(params *PostCarupdateParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostCarupdateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostCarupdateParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "PostCarupdate",
		Method:             "POST",
		PathPattern:        "/carupdate",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PostCarupdateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*PostCarupdateOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for PostCarupdate: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
PostCarupdateIDCancel cancels car update

Cancels car update and send notifications
*/
func (a *Client) PostCarupdateIDCancel(params *PostCarupdateIDCancelParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostCarupdateIDCancelOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostCarupdateIDCancelParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "PostCarupdateIDCancel",
		Method:             "POST",
		PathPattern:        "/carupdate/{id}/cancel",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PostCarupdateIDCancelReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*PostCarupdateIDCancelOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for PostCarupdateIDCancel: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
PostCarupdateIDDeploy deploys car update

Deploys car update and send notifications
*/
func (a *Client) PostCarupdateIDDeploy(params *PostCarupdateIDDeployParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostCarupdateIDDeployOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostCarupdateIDDeployParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "PostCarupdateIDDeploy",
		Method:             "POST",
		PathPattern:        "/carupdate/{id}/deploy",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PostCarupdateIDDeployReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*PostCarupdateIDDeployOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for PostCarupdateIDDeploy: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
PostCarupdateIDVehicleCancel cancels car update on vehicle

Cancel a rogue car update on a vehicle that's not found on cloud.
*/
func (a *Client) PostCarupdateIDVehicleCancel(params *PostCarupdateIDVehicleCancelParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostCarupdateIDVehicleCancelOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostCarupdateIDVehicleCancelParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "PostCarupdateIDVehicleCancel",
		Method:             "POST",
		PathPattern:        "/carupdate/{id}/vehicle-cancel",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PostCarupdateIDVehicleCancelReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*PostCarupdateIDVehicleCancelOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for PostCarupdateIDVehicleCancel: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
PostFlashpackVersion adds a flashpack version

Add a flashpack version
*/
func (a *Client) PostFlashpackVersion(params *PostFlashpackVersionParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostFlashpackVersionOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostFlashpackVersionParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "PostFlashpackVersion",
		Method:             "POST",
		PathPattern:        "/flashpack_version",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PostFlashpackVersionReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*PostFlashpackVersionOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for PostFlashpackVersion: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
PostFleet adds a fleet

Add a fleet
*/
func (a *Client) PostFleet(params *PostFleetParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostFleetOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostFleetParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "PostFleet",
		Method:             "POST",
		PathPattern:        "/fleet",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PostFleetReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*PostFleetOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for PostFleet: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
PostFleetNameFilter adds c a n filter for fleet

Add CAN filter for fleet
*/
func (a *Client) PostFleetNameFilter(params *PostFleetNameFilterParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostFleetNameFilterOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostFleetNameFilterParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "PostFleetNameFilter",
		Method:             "POST",
		PathPattern:        "/fleet/{name}/filter",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PostFleetNameFilterReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*PostFleetNameFilterOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for PostFleetNameFilter: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
PostFleetNameVehiclesAdd adds vehicle to fleet

Add vehicle to fleet
*/
func (a *Client) PostFleetNameVehiclesAdd(params *PostFleetNameVehiclesAddParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostFleetNameVehiclesAddOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostFleetNameVehiclesAddParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "PostFleetNameVehiclesAdd",
		Method:             "POST",
		PathPattern:        "/fleet/{name}/vehicles/add",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PostFleetNameVehiclesAddReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*PostFleetNameVehiclesAddOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for PostFleetNameVehiclesAdd: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
PostFleetNameVehiclesDelete deletes vehicle from fleet

Delete vehicle from fleet
*/
func (a *Client) PostFleetNameVehiclesDelete(params *PostFleetNameVehiclesDeleteParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostFleetNameVehiclesDeleteOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostFleetNameVehiclesDeleteParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "PostFleetNameVehiclesDelete",
		Method:             "POST",
		PathPattern:        "/fleet/{name}/vehicles/delete",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PostFleetNameVehiclesDeleteReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*PostFleetNameVehiclesDeleteOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for PostFleetNameVehiclesDelete: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
PostFleetupdate adds car updates by fleet

Create car updates assigning update package to cars, and send notifications
*/
func (a *Client) PostFleetupdate(params *PostFleetupdateParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostFleetupdateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostFleetupdateParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "PostFleetupdate",
		Method:             "POST",
		PathPattern:        "/fleetupdate",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PostFleetupdateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*PostFleetupdateOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for PostFleetupdate: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
PostManifest adds update manifest

Upload update manifest
*/
func (a *Client) PostManifest(params *PostManifestParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostManifestOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostManifestParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "PostManifest",
		Method:             "POST",
		PathPattern:        "/manifest",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PostManifestReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*PostManifestOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for PostManifest: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
PostManifestSums creates new update manifest versions

Create and save new update manifest versions, and return them
*/
func (a *Client) PostManifestSums(params *PostManifestSumsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostManifestSumsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostManifestSumsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "PostManifestSums",
		Method:             "POST",
		PathPattern:        "/manifest/sums",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PostManifestSumsReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*PostManifestSumsOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for PostManifestSums: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
PostManifestSumsVersionRxswins adds one or more r x software ID numbers rx s w i ns for an update manifest version

Add one or more RX Software ID Numbers (RxSWINs) for an update manifest version and return them
*/
func (a *Client) PostManifestSumsVersionRxswins(params *PostManifestSumsVersionRxswinsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostManifestSumsVersionRxswinsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostManifestSumsVersionRxswinsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "PostManifestSumsVersionRxswins",
		Method:             "POST",
		PathPattern:        "/manifest/sums/{version}/rxswins",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PostManifestSumsVersionRxswinsReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*PostManifestSumsVersionRxswinsOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for PostManifestSumsVersionRxswins: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
PostManifestecu adds update manifest ecu

Create update manifest ECU
*/
func (a *Client) PostManifestecu(params *PostManifestecuParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostManifestecuOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostManifestecuParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "PostManifestecu",
		Method:             "POST",
		PathPattern:        "/manifestecu",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PostManifestecuReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*PostManifestecuOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for PostManifestecu: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
PostManifestfile adds update manifest

Upload update manifest
*/
func (a *Client) PostManifestfile(params *PostManifestfileParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostManifestfileOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostManifestfileParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "PostManifestfile",
		Method:             "POST",
		PathPattern:        "/manifestfile",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PostManifestfileReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*PostManifestfileOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for PostManifestfile: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
PostManifestmigrate receives the raw information and load it into the database

Get update manifest by id, without modifying anything from the database
*/
func (a *Client) PostManifestmigrate(params *PostManifestmigrateParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostManifestmigrateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostManifestmigrateParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "PostManifestmigrate",
		Method:             "POST",
		PathPattern:        "/manifestmigrate",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PostManifestmigrateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*PostManifestmigrateOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for PostManifestmigrate: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
PostManifestmigrateManifestID pushes update manifest from this environment to a higher one
*/
func (a *Client) PostManifestmigrateManifestID(params *PostManifestmigrateManifestIDParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostManifestmigrateManifestIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostManifestmigrateManifestIDParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "PostManifestmigrateManifestID",
		Method:             "POST",
		PathPattern:        "/manifestmigrate/{manifest_id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PostManifestmigrateManifestIDReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*PostManifestmigrateManifestIDOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for PostManifestmigrateManifestID: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
PostManufactureCerts generates public and private certificates for security dll

Generates public and private certificates for security dll to access manufacture/secaccess API
*/
func (a *Client) PostManufactureCerts(params *PostManufactureCertsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostManufactureCertsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostManufactureCertsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "PostManufactureCerts",
		Method:             "POST",
		PathPattern:        "/manufacture-certs",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PostManufactureCertsReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*PostManufactureCertsOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for PostManufactureCerts: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
PostSms sends s m s

Send SMS using SMS service
*/
func (a *Client) PostSms(params *PostSmsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostSmsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostSmsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "PostSms",
		Method:             "POST",
		PathPattern:        "/sms",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PostSmsReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*PostSmsOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for PostSms: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
PostSubscriptionconfig adds subscription config

Create subscription config
*/
func (a *Client) PostSubscriptionconfig(params *PostSubscriptionconfigParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostSubscriptionconfigOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostSubscriptionconfigParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "PostSubscriptionconfig",
		Method:             "POST",
		PathPattern:        "/subscriptionconfig",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PostSubscriptionconfigReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*PostSubscriptionconfigOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for PostSubscriptionconfig: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
PostSubscriptionfeature adds subscription feature

Create subscription feature
*/
func (a *Client) PostSubscriptionfeature(params *PostSubscriptionfeatureParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostSubscriptionfeatureOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostSubscriptionfeatureParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "PostSubscriptionfeature",
		Method:             "POST",
		PathPattern:        "/subscriptionfeature",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PostSubscriptionfeatureReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*PostSubscriptionfeatureOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for PostSubscriptionfeature: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
PostSubscriptionpackage adds subscription package

Create subscription package
*/
func (a *Client) PostSubscriptionpackage(params *PostSubscriptionpackageParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostSubscriptionpackageOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostSubscriptionpackageParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "PostSubscriptionpackage",
		Method:             "POST",
		PathPattern:        "/subscriptionpackage",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PostSubscriptionpackageReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*PostSubscriptionpackageOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for PostSubscriptionpackage: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
PostSubscriptionpackagefeature assigns feature to package

Assign feature to package
*/
func (a *Client) PostSubscriptionpackagefeature(params *PostSubscriptionpackagefeatureParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostSubscriptionpackagefeatureOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostSubscriptionpackagefeatureParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "PostSubscriptionpackagefeature",
		Method:             "POST",
		PathPattern:        "/subscriptionpackagefeature",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PostSubscriptionpackagefeatureReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*PostSubscriptionpackagefeatureOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for PostSubscriptionpackagefeature: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
PostSupplierActivateEmail activates supplier account

Updates the activated date for the supplier
*/
func (a *Client) PostSupplierActivateEmail(params *PostSupplierActivateEmailParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostSupplierActivateEmailOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostSupplierActivateEmailParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "PostSupplierActivateEmail",
		Method:             "POST",
		PathPattern:        "/supplier/activate/{email}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PostSupplierActivateEmailReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*PostSupplierActivateEmailOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for PostSupplierActivateEmail: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
PostTags appends tags for cars

Append tags for the provided set of car VINs.
*/
func (a *Client) PostTags(params *PostTagsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostTagsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostTagsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "PostTags",
		Method:             "POST",
		PathPattern:        "/tags",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PostTagsReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*PostTagsOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for PostTags: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
PostVehicle adds vehicle

Creates vehicle data
*/
func (a *Client) PostVehicle(params *PostVehicleParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostVehicleOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostVehicleParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "PostVehicle",
		Method:             "POST",
		PathPattern:        "/vehicle",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PostVehicleReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*PostVehicleOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for PostVehicle: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
PostVehiclePaths gets paths of vehicles

Returns vehicle paths
*/
func (a *Client) PostVehiclePaths(params *PostVehiclePathsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostVehiclePathsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostVehiclePathsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "PostVehiclePaths",
		Method:             "POST",
		PathPattern:        "/vehicle_paths",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PostVehiclePathsReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*PostVehiclePathsOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for PostVehiclePaths: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
PostVehicleVinFilter adds c a n filter for vehicle

Add CAN filter for vehicle
*/
func (a *Client) PostVehicleVinFilter(params *PostVehicleVinFilterParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostVehicleVinFilterOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostVehicleVinFilterParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "PostVehicleVinFilter",
		Method:             "POST",
		PathPattern:        "/vehicle/{vin}/filter",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PostVehicleVinFilterReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*PostVehicleVinFilterOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for PostVehicleVinFilter: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
PostVehiclecommand sends command to car

Send command to car
*/
func (a *Client) PostVehiclecommand(params *PostVehiclecommandParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostVehiclecommandOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostVehiclecommandParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "PostVehiclecommand",
		Method:             "POST",
		PathPattern:        "/vehiclecommand",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PostVehiclecommandReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*PostVehiclecommandOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for PostVehiclecommand: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
PostVehiclecommandImmobilize adds vehicles to immobilizer list
*/
func (a *Client) PostVehiclecommandImmobilize(params *PostVehiclecommandImmobilizeParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostVehiclecommandImmobilizeOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostVehiclecommandImmobilizeParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "PostVehiclecommandImmobilize",
		Method:             "POST",
		PathPattern:        "/vehiclecommand/immobilize",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PostVehiclecommandImmobilizeReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*PostVehiclecommandImmobilizeOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for PostVehiclecommandImmobilize: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
PostVehiclediagnosticcommand sends diagnostic command to car

Send diagnostic command to car
*/
func (a *Client) PostVehiclediagnosticcommand(params *PostVehiclediagnosticcommandParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostVehiclediagnosticcommandOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostVehiclediagnosticcommandParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "PostVehiclediagnosticcommand",
		Method:             "POST",
		PathPattern:        "/vehiclediagnosticcommand",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PostVehiclediagnosticcommandReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*PostVehiclediagnosticcommandOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for PostVehiclediagnosticcommand: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
PutApitoken updates API token

Update API token. Requires API token permission
*/
func (a *Client) PutApitoken(params *PutApitokenParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PutApitokenOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPutApitokenParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "PutApitoken",
		Method:             "PUT",
		PathPattern:        "/apitoken",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PutApitokenReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*PutApitokenOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for PutApitoken: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
PutCustomerOtaEmails sends customer emails by list of vins

Sends OTA notification emails to all emails associated with vins in request body
*/
func (a *Client) PutCustomerOtaEmails(params *PutCustomerOtaEmailsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PutCustomerOtaEmailsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPutCustomerOtaEmailsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "PutCustomerOtaEmails",
		Method:             "PUT",
		PathPattern:        "/customer_ota_emails",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PutCustomerOtaEmailsReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*PutCustomerOtaEmailsOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for PutCustomerOtaEmails: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
PutFleetName updates fleet

Update fleet
*/
func (a *Client) PutFleetName(params *PutFleetNameParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PutFleetNameOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPutFleetNameParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "PutFleetName",
		Method:             "PUT",
		PathPattern:        "/fleet/{name}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PutFleetNameReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*PutFleetNameOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for PutFleetName: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
PutFleetNameFilterID updates a fleet filter

Update a fleet filter
*/
func (a *Client) PutFleetNameFilterID(params *PutFleetNameFilterIDParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PutFleetNameFilterIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPutFleetNameFilterIDParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "PutFleetNameFilterID",
		Method:             "PUT",
		PathPattern:        "/fleet/{name}/filter/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PutFleetNameFilterIDReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*PutFleetNameFilterIDOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for PutFleetNameFilterID: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
PutManifest updates update manifest

Update update manifest data
*/
func (a *Client) PutManifest(params *PutManifestParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PutManifestOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPutManifestParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "PutManifest",
		Method:             "PUT",
		PathPattern:        "/manifest",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PutManifestReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*PutManifestOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for PutManifest: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
PutManifestsArchive archives update manifests

Archive update manifests
*/
func (a *Client) PutManifestsArchive(params *PutManifestsArchiveParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PutManifestsArchiveOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPutManifestsArchiveParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "PutManifestsArchive",
		Method:             "PUT",
		PathPattern:        "/manifests/archive",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PutManifestsArchiveReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*PutManifestsArchiveOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for PutManifestsArchive: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
PutManifestsIDSums updates update manifest sums version

Update update manifest data
*/
func (a *Client) PutManifestsIDSums(params *PutManifestsIDSumsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PutManifestsIDSumsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPutManifestsIDSumsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "PutManifestsIDSums",
		Method:             "PUT",
		PathPattern:        "/manifests/{id}/sums",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PutManifestsIDSumsReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*PutManifestsIDSumsOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for PutManifestsIDSums: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
PutSubscriptionconfig updates subscription package

Update subscription package
*/
func (a *Client) PutSubscriptionconfig(params *PutSubscriptionconfigParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PutSubscriptionconfigOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPutSubscriptionconfigParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "PutSubscriptionconfig",
		Method:             "PUT",
		PathPattern:        "/subscriptionconfig",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PutSubscriptionconfigReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*PutSubscriptionconfigOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for PutSubscriptionconfig: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
PutSubscriptionfeature adds subscription package

Create subscription package
*/
func (a *Client) PutSubscriptionfeature(params *PutSubscriptionfeatureParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PutSubscriptionfeatureOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPutSubscriptionfeatureParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "PutSubscriptionfeature",
		Method:             "PUT",
		PathPattern:        "/subscriptionfeature",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PutSubscriptionfeatureReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*PutSubscriptionfeatureOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for PutSubscriptionfeature: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
PutSubscriptionpackage updates subscription package

Update subscription package
*/
func (a *Client) PutSubscriptionpackage(params *PutSubscriptionpackageParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PutSubscriptionpackageOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPutSubscriptionpackageParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "PutSubscriptionpackage",
		Method:             "PUT",
		PathPattern:        "/subscriptionpackage",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PutSubscriptionpackageReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*PutSubscriptionpackageOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for PutSubscriptionpackage: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
PutSupplierEmail approves supplier account

Approve supplier account with Azure AD oid
*/
func (a *Client) PutSupplierEmail(params *PutSupplierEmailParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PutSupplierEmailOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPutSupplierEmailParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "PutSupplierEmail",
		Method:             "PUT",
		PathPattern:        "/supplier/{email}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PutSupplierEmailReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*PutSupplierEmailOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for PutSupplierEmail: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
PutTags updates tags for cars

Replace the tags for the provided set of car VINs.
*/
func (a *Client) PutTags(params *PutTagsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PutTagsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPutTagsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "PutTags",
		Method:             "PUT",
		PathPattern:        "/tags",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PutTagsReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*PutTagsOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for PutTags: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
PutVehicleVin modifies vehicle

Modify vehicle requires vehicle id
*/
func (a *Client) PutVehicleVin(params *PutVehicleVinParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PutVehicleVinOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPutVehicleVinParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "PutVehicleVin",
		Method:             "PUT",
		PathPattern:        "/vehicle/{vin}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PutVehicleVinReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*PutVehicleVinOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for PutVehicleVin: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
PutVehicleVinFilterID updates a vehicle filter

Update a vehicle filter
*/
func (a *Client) PutVehicleVinFilterID(params *PutVehicleVinFilterIDParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PutVehicleVinFilterIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPutVehicleVinFilterIDParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "PutVehicleVinFilterID",
		Method:             "PUT",
		PathPattern:        "/vehicle/{vin}/filter/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PutVehicleVinFilterIDReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*PutVehicleVinFilterIDOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for PutVehicleVinFilterID: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

// SetTransport changes the transport on the client
func (a *Client) SetTransport(transport runtime.ClientTransport) {
	a.transport = transport
}
