lib/api/members/members_client/operations/operations_client.go

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

// (c) 2012-2020 by Taxnexus, Inc.
// All rights reserved worldwide.
// Proprietary product; unlicensed use is not allowed

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"

	"github.com/go-openapi/runtime"
	"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}
}

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

// ClientOption is the option for Client methods
type ClientOption func(*runtime.ClientOperation)

// ClientService is the interface for Client methods
type ClientService interface {
	CreateAttendee(params *CreateAttendeeParams, opts ...ClientOption) (*CreateAttendeeCreated, error)

	CreateCertificate(params *CreateCertificateParams, opts ...ClientOption) (*CreateCertificateCreated, error)

	CreateCourse(params *CreateCourseParams, opts ...ClientOption) (*CreateCourseCreated, error)

	CreateCourseLesson(params *CreateCourseLessonParams, opts ...ClientOption) (*CreateCourseLessonCreated, error)

	CreateCourseSection(params *CreateCourseSectionParams, opts ...ClientOption) (*CreateCourseSectionCreated, error)

	CreateEnrollment(params *CreateEnrollmentParams, opts ...ClientOption) (*CreateEnrollmentCreated, error)

	CreateEvent(params *CreateEventParams, opts ...ClientOption) (*CreateEventCreated, error)

	CreateEventCategory(params *CreateEventCategoryParams, opts ...ClientOption) (*CreateEventCategoryCreated, error)

	CreateEventCategoryAssignment(params *CreateEventCategoryAssignmentParams, opts ...ClientOption) (*CreateEventCategoryAssignmentCreated, error)

	CreateFavorite(params *CreateFavoriteParams, opts ...ClientOption) (*CreateFavoriteCreated, error)

	CreateInvoice(params *CreateInvoiceParams, opts ...ClientOption) (*CreateInvoiceCreated, error)

	CreateIssuedCertificate(params *CreateIssuedCertificateParams, opts ...ClientOption) (*CreateIssuedCertificateCreated, error)

	CreateLessonProgress(params *CreateLessonProgressParams, opts ...ClientOption) (*CreateLessonProgressCreated, error)

	CreateOrder(params *CreateOrderParams, opts ...ClientOption) (*CreateOrderCreated, error)

	CreatePaymentMethod(params *CreatePaymentMethodParams, opts ...ClientOption) (*CreatePaymentMethodCreated, error)

	CreateResearchProject(params *CreateResearchProjectParams, opts ...ClientOption) (*CreateResearchProjectCreated, error)

	CreateResearchProjectCompany(params *CreateResearchProjectCompanyParams, opts ...ClientOption) (*CreateResearchProjectCompanyCreated, error)

	CreateResearchProjectTopic(params *CreateResearchProjectTopicParams, opts ...ClientOption) (*CreateResearchProjectTopicCreated, error)

	CreateTicket(params *CreateTicketParams, opts ...ClientOption) (*CreateTicketCreated, error)

	CreateTransaction(params *CreateTransactionParams, opts ...ClientOption) (*CreateTransactionCreated, error)

	DeleteAttendee(params *DeleteAttendeeParams, opts ...ClientOption) (*DeleteAttendeeNoContent, error)

	DeleteCertificate(params *DeleteCertificateParams, opts ...ClientOption) (*DeleteCertificateNoContent, error)

	DeleteCourse(params *DeleteCourseParams, opts ...ClientOption) (*DeleteCourseNoContent, error)

	DeleteCourseLesson(params *DeleteCourseLessonParams, opts ...ClientOption) (*DeleteCourseLessonNoContent, error)

	DeleteCourseSection(params *DeleteCourseSectionParams, opts ...ClientOption) (*DeleteCourseSectionNoContent, error)

	DeleteEnrollment(params *DeleteEnrollmentParams, opts ...ClientOption) (*DeleteEnrollmentNoContent, error)

	DeleteEvent(params *DeleteEventParams, opts ...ClientOption) (*DeleteEventNoContent, error)

	DeleteEventCategory(params *DeleteEventCategoryParams, opts ...ClientOption) (*DeleteEventCategoryNoContent, error)

	DeleteEventCategoryAssignment(params *DeleteEventCategoryAssignmentParams, opts ...ClientOption) (*DeleteEventCategoryAssignmentNoContent, error)

	DeleteFavorite(params *DeleteFavoriteParams, opts ...ClientOption) (*DeleteFavoriteNoContent, error)

	DeleteInvoice(params *DeleteInvoiceParams, opts ...ClientOption) (*DeleteInvoiceNoContent, error)

	DeleteIssuedCertificate(params *DeleteIssuedCertificateParams, opts ...ClientOption) (*DeleteIssuedCertificateNoContent, error)

	DeleteLessonProgress(params *DeleteLessonProgressParams, opts ...ClientOption) (*DeleteLessonProgressNoContent, error)

	DeleteOrder(params *DeleteOrderParams, opts ...ClientOption) (*DeleteOrderNoContent, error)

	DeletePaymentMethod(params *DeletePaymentMethodParams, opts ...ClientOption) (*DeletePaymentMethodNoContent, error)

	DeleteResearchProject(params *DeleteResearchProjectParams, opts ...ClientOption) (*DeleteResearchProjectNoContent, error)

	DeleteResearchProjectCompany(params *DeleteResearchProjectCompanyParams, opts ...ClientOption) (*DeleteResearchProjectCompanyNoContent, error)

	DeleteResearchProjectTopic(params *DeleteResearchProjectTopicParams, opts ...ClientOption) (*DeleteResearchProjectTopicNoContent, error)

	DeleteTicket(params *DeleteTicketParams, opts ...ClientOption) (*DeleteTicketNoContent, error)

	DeleteTransaction(params *DeleteTransactionParams, opts ...ClientOption) (*DeleteTransactionNoContent, error)

	GetAttendees(params *GetAttendeesParams, opts ...ClientOption) (*GetAttendeesOK, error)

	GetCertificates(params *GetCertificatesParams, opts ...ClientOption) (*GetCertificatesOK, error)

	GetCourseLessons(params *GetCourseLessonsParams, opts ...ClientOption) (*GetCourseLessonsOK, error)

	GetCourseSections(params *GetCourseSectionsParams, opts ...ClientOption) (*GetCourseSectionsOK, error)

	GetCourses(params *GetCoursesParams, opts ...ClientOption) (*GetCoursesOK, error)

	GetEnrollments(params *GetEnrollmentsParams, opts ...ClientOption) (*GetEnrollmentsOK, error)

	GetEventCategoryassignments(params *GetEventCategoryassignmentsParams, opts ...ClientOption) (*GetEventCategoryassignmentsOK, error)

	GetEventCategorys(params *GetEventCategorysParams, opts ...ClientOption) (*GetEventCategorysOK, error)

	GetEvents(params *GetEventsParams, opts ...ClientOption) (*GetEventsOK, error)

	GetFavorites(params *GetFavoritesParams, opts ...ClientOption) (*GetFavoritesOK, error)

	GetInvoices(params *GetInvoicesParams, opts ...ClientOption) (*GetInvoicesOK, error)

	GetIssuedcertificates(params *GetIssuedcertificatesParams, opts ...ClientOption) (*GetIssuedcertificatesOK, error)

	GetLessonProgress(params *GetLessonProgressParams, opts ...ClientOption) (*GetLessonProgressOK, error)

	GetOrders(params *GetOrdersParams, opts ...ClientOption) (*GetOrdersOK, error)

	GetPaymentMethods(params *GetPaymentMethodsParams, opts ...ClientOption) (*GetPaymentMethodsOK, error)

	GetResearchProjectCompanys(params *GetResearchProjectCompanysParams, opts ...ClientOption) (*GetResearchProjectCompanysOK, error)

	GetResearchProjectTopics(params *GetResearchProjectTopicsParams, opts ...ClientOption) (*GetResearchProjectTopicsOK, error)

	GetResearchProjects(params *GetResearchProjectsParams, opts ...ClientOption) (*GetResearchProjectsOK, error)

	GetTickets(params *GetTicketsParams, opts ...ClientOption) (*GetTicketsOK, error)

	GetTransactions(params *GetTransactionsParams, opts ...ClientOption) (*GetTransactionsOK, error)

	UpdateAttendee(params *UpdateAttendeeParams, opts ...ClientOption) (*UpdateAttendeeOK, error)

	UpdateCertificate(params *UpdateCertificateParams, opts ...ClientOption) (*UpdateCertificateOK, error)

	UpdateCourse(params *UpdateCourseParams, opts ...ClientOption) (*UpdateCourseOK, error)

	UpdateCourseLesson(params *UpdateCourseLessonParams, opts ...ClientOption) (*UpdateCourseLessonOK, error)

	UpdateCourseSection(params *UpdateCourseSectionParams, opts ...ClientOption) (*UpdateCourseSectionOK, error)

	UpdateEnrollment(params *UpdateEnrollmentParams, opts ...ClientOption) (*UpdateEnrollmentOK, error)

	UpdateEvent(params *UpdateEventParams, opts ...ClientOption) (*UpdateEventOK, error)

	UpdateEventCategory(params *UpdateEventCategoryParams, opts ...ClientOption) (*UpdateEventCategoryOK, error)

	UpdateEventCategoryAssignment(params *UpdateEventCategoryAssignmentParams, opts ...ClientOption) (*UpdateEventCategoryAssignmentOK, error)

	UpdateFavorite(params *UpdateFavoriteParams, opts ...ClientOption) (*UpdateFavoriteOK, error)

	UpdateInvoice(params *UpdateInvoiceParams, opts ...ClientOption) (*UpdateInvoiceOK, error)

	UpdateIssuedCertificate(params *UpdateIssuedCertificateParams, opts ...ClientOption) (*UpdateIssuedCertificateOK, error)

	UpdateLessonProgress(params *UpdateLessonProgressParams, opts ...ClientOption) (*UpdateLessonProgressOK, error)

	UpdateOrder(params *UpdateOrderParams, opts ...ClientOption) (*UpdateOrderOK, error)

	UpdatePaymentMethod(params *UpdatePaymentMethodParams, opts ...ClientOption) (*UpdatePaymentMethodOK, error)

	UpdateResearchProject(params *UpdateResearchProjectParams, opts ...ClientOption) (*UpdateResearchProjectOK, error)

	UpdateResearchProjectCompany(params *UpdateResearchProjectCompanyParams, opts ...ClientOption) (*UpdateResearchProjectCompanyOK, error)

	UpdateResearchProjectTopic(params *UpdateResearchProjectTopicParams, opts ...ClientOption) (*UpdateResearchProjectTopicOK, error)

	UpdateTicket(params *UpdateTicketParams, opts ...ClientOption) (*UpdateTicketOK, error)

	UpdateTransaction(params *UpdateTransactionParams, opts ...ClientOption) (*UpdateTransactionOK, error)

	SetTransport(transport runtime.ClientTransport)
}

/*
CreateAttendee creates a new attendee
*/
func (a *Client) CreateAttendee(params *CreateAttendeeParams, opts ...ClientOption) (*CreateAttendeeCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateAttendeeParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "createAttendee",
		Method:             "POST",
		PathPattern:        "/attendees",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &CreateAttendeeReader{formats: a.formats},
		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.(*CreateAttendeeCreated)
	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 createAttendee: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
CreateCertificate creates a new certificate
*/
func (a *Client) CreateCertificate(params *CreateCertificateParams, opts ...ClientOption) (*CreateCertificateCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateCertificateParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "createCertificate",
		Method:             "POST",
		PathPattern:        "/certificates",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &CreateCertificateReader{formats: a.formats},
		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.(*CreateCertificateCreated)
	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 createCertificate: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
CreateCourse creates a new course
*/
func (a *Client) CreateCourse(params *CreateCourseParams, opts ...ClientOption) (*CreateCourseCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateCourseParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "createCourse",
		Method:             "POST",
		PathPattern:        "/courses",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &CreateCourseReader{formats: a.formats},
		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.(*CreateCourseCreated)
	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 createCourse: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
CreateCourseLesson creates a new course lesson
*/
func (a *Client) CreateCourseLesson(params *CreateCourseLessonParams, opts ...ClientOption) (*CreateCourseLessonCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateCourseLessonParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "createCourseLesson",
		Method:             "POST",
		PathPattern:        "/courselessons",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &CreateCourseLessonReader{formats: a.formats},
		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.(*CreateCourseLessonCreated)
	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 createCourseLesson: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
CreateCourseSection creates a new course section
*/
func (a *Client) CreateCourseSection(params *CreateCourseSectionParams, opts ...ClientOption) (*CreateCourseSectionCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateCourseSectionParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "createCourseSection",
		Method:             "POST",
		PathPattern:        "/coursesections",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &CreateCourseSectionReader{formats: a.formats},
		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.(*CreateCourseSectionCreated)
	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 createCourseSection: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
CreateEnrollment creates a new enrollment
*/
func (a *Client) CreateEnrollment(params *CreateEnrollmentParams, opts ...ClientOption) (*CreateEnrollmentCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateEnrollmentParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "createEnrollment",
		Method:             "POST",
		PathPattern:        "/enrollments",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &CreateEnrollmentReader{formats: a.formats},
		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.(*CreateEnrollmentCreated)
	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 createEnrollment: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
CreateEvent creates a new event
*/
func (a *Client) CreateEvent(params *CreateEventParams, opts ...ClientOption) (*CreateEventCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateEventParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "createEvent",
		Method:             "POST",
		PathPattern:        "/events",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &CreateEventReader{formats: a.formats},
		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.(*CreateEventCreated)
	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 createEvent: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
CreateEventCategory creates a new event category
*/
func (a *Client) CreateEventCategory(params *CreateEventCategoryParams, opts ...ClientOption) (*CreateEventCategoryCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateEventCategoryParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "createEventCategory",
		Method:             "POST",
		PathPattern:        "/eventcategorys",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &CreateEventCategoryReader{formats: a.formats},
		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.(*CreateEventCategoryCreated)
	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 createEventCategory: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
CreateEventCategoryAssignment creates a new event category assignment
*/
func (a *Client) CreateEventCategoryAssignment(params *CreateEventCategoryAssignmentParams, opts ...ClientOption) (*CreateEventCategoryAssignmentCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateEventCategoryAssignmentParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "createEventCategoryAssignment",
		Method:             "POST",
		PathPattern:        "/eventcategoryassignments",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &CreateEventCategoryAssignmentReader{formats: a.formats},
		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.(*CreateEventCategoryAssignmentCreated)
	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 createEventCategoryAssignment: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
CreateFavorite creates a new favorite
*/
func (a *Client) CreateFavorite(params *CreateFavoriteParams, opts ...ClientOption) (*CreateFavoriteCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateFavoriteParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "createFavorite",
		Method:             "POST",
		PathPattern:        "/favorites",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &CreateFavoriteReader{formats: a.formats},
		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.(*CreateFavoriteCreated)
	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 createFavorite: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
CreateInvoice creates a new invoice
*/
func (a *Client) CreateInvoice(params *CreateInvoiceParams, opts ...ClientOption) (*CreateInvoiceCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateInvoiceParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "createInvoice",
		Method:             "POST",
		PathPattern:        "/invoices",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &CreateInvoiceReader{formats: a.formats},
		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.(*CreateInvoiceCreated)
	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 createInvoice: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
CreateIssuedCertificate creates a new issued certificate
*/
func (a *Client) CreateIssuedCertificate(params *CreateIssuedCertificateParams, opts ...ClientOption) (*CreateIssuedCertificateCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateIssuedCertificateParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "createIssuedCertificate",
		Method:             "POST",
		PathPattern:        "/issuedcertificates",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &CreateIssuedCertificateReader{formats: a.formats},
		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.(*CreateIssuedCertificateCreated)
	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 createIssuedCertificate: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
CreateLessonProgress creates a new lesson progress
*/
func (a *Client) CreateLessonProgress(params *CreateLessonProgressParams, opts ...ClientOption) (*CreateLessonProgressCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateLessonProgressParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "createLessonProgress",
		Method:             "POST",
		PathPattern:        "/lessonprogress",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &CreateLessonProgressReader{formats: a.formats},
		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.(*CreateLessonProgressCreated)
	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 createLessonProgress: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
CreateOrder creates a new order
*/
func (a *Client) CreateOrder(params *CreateOrderParams, opts ...ClientOption) (*CreateOrderCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateOrderParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "createOrder",
		Method:             "POST",
		PathPattern:        "/orders",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &CreateOrderReader{formats: a.formats},
		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.(*CreateOrderCreated)
	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 createOrder: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
CreatePaymentMethod creates a new payment method
*/
func (a *Client) CreatePaymentMethod(params *CreatePaymentMethodParams, opts ...ClientOption) (*CreatePaymentMethodCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreatePaymentMethodParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "createPaymentMethod",
		Method:             "POST",
		PathPattern:        "/paymentmethods",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &CreatePaymentMethodReader{formats: a.formats},
		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.(*CreatePaymentMethodCreated)
	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 createPaymentMethod: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
CreateResearchProject creates a new research project
*/
func (a *Client) CreateResearchProject(params *CreateResearchProjectParams, opts ...ClientOption) (*CreateResearchProjectCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateResearchProjectParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "createResearchProject",
		Method:             "POST",
		PathPattern:        "/researchprojects",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &CreateResearchProjectReader{formats: a.formats},
		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.(*CreateResearchProjectCreated)
	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 createResearchProject: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
CreateResearchProjectCompany creates a new research project company
*/
func (a *Client) CreateResearchProjectCompany(params *CreateResearchProjectCompanyParams, opts ...ClientOption) (*CreateResearchProjectCompanyCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateResearchProjectCompanyParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "createResearchProjectCompany",
		Method:             "POST",
		PathPattern:        "/researchprojectcompanys",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &CreateResearchProjectCompanyReader{formats: a.formats},
		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.(*CreateResearchProjectCompanyCreated)
	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 createResearchProjectCompany: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
CreateResearchProjectTopic creates a new research project topic
*/
func (a *Client) CreateResearchProjectTopic(params *CreateResearchProjectTopicParams, opts ...ClientOption) (*CreateResearchProjectTopicCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateResearchProjectTopicParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "createResearchProjectTopic",
		Method:             "POST",
		PathPattern:        "/researchprojecttopics",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &CreateResearchProjectTopicReader{formats: a.formats},
		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.(*CreateResearchProjectTopicCreated)
	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 createResearchProjectTopic: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
CreateTicket creates a new ticket
*/
func (a *Client) CreateTicket(params *CreateTicketParams, opts ...ClientOption) (*CreateTicketCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateTicketParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "createTicket",
		Method:             "POST",
		PathPattern:        "/tickets",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &CreateTicketReader{formats: a.formats},
		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.(*CreateTicketCreated)
	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 createTicket: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
CreateTransaction creates a new transaction
*/
func (a *Client) CreateTransaction(params *CreateTransactionParams, opts ...ClientOption) (*CreateTransactionCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateTransactionParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "createTransaction",
		Method:             "POST",
		PathPattern:        "/transactions",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &CreateTransactionReader{formats: a.formats},
		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.(*CreateTransactionCreated)
	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 createTransaction: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
DeleteAttendee deletes a attendee
*/
func (a *Client) DeleteAttendee(params *DeleteAttendeeParams, opts ...ClientOption) (*DeleteAttendeeNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteAttendeeParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "deleteAttendee",
		Method:             "DELETE",
		PathPattern:        "/attendees",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DeleteAttendeeReader{formats: a.formats},
		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.(*DeleteAttendeeNoContent)
	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 deleteAttendee: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
DeleteCertificate deletes a certificate
*/
func (a *Client) DeleteCertificate(params *DeleteCertificateParams, opts ...ClientOption) (*DeleteCertificateNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteCertificateParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "deleteCertificate",
		Method:             "DELETE",
		PathPattern:        "/certificates",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DeleteCertificateReader{formats: a.formats},
		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.(*DeleteCertificateNoContent)
	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 deleteCertificate: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
DeleteCourse deletes a course
*/
func (a *Client) DeleteCourse(params *DeleteCourseParams, opts ...ClientOption) (*DeleteCourseNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteCourseParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "deleteCourse",
		Method:             "DELETE",
		PathPattern:        "/courses",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DeleteCourseReader{formats: a.formats},
		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.(*DeleteCourseNoContent)
	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 deleteCourse: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
DeleteCourseLesson deletes a course lesson
*/
func (a *Client) DeleteCourseLesson(params *DeleteCourseLessonParams, opts ...ClientOption) (*DeleteCourseLessonNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteCourseLessonParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "deleteCourseLesson",
		Method:             "DELETE",
		PathPattern:        "/courselessons",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DeleteCourseLessonReader{formats: a.formats},
		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.(*DeleteCourseLessonNoContent)
	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 deleteCourseLesson: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
DeleteCourseSection deletes a course section
*/
func (a *Client) DeleteCourseSection(params *DeleteCourseSectionParams, opts ...ClientOption) (*DeleteCourseSectionNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteCourseSectionParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "deleteCourseSection",
		Method:             "DELETE",
		PathPattern:        "/coursesections",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DeleteCourseSectionReader{formats: a.formats},
		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.(*DeleteCourseSectionNoContent)
	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 deleteCourseSection: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
DeleteEnrollment deletes a enrollment
*/
func (a *Client) DeleteEnrollment(params *DeleteEnrollmentParams, opts ...ClientOption) (*DeleteEnrollmentNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteEnrollmentParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "deleteEnrollment",
		Method:             "DELETE",
		PathPattern:        "/enrollments",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DeleteEnrollmentReader{formats: a.formats},
		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.(*DeleteEnrollmentNoContent)
	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 deleteEnrollment: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
DeleteEvent deletes a event
*/
func (a *Client) DeleteEvent(params *DeleteEventParams, opts ...ClientOption) (*DeleteEventNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteEventParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "deleteEvent",
		Method:             "DELETE",
		PathPattern:        "/events",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DeleteEventReader{formats: a.formats},
		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.(*DeleteEventNoContent)
	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 deleteEvent: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
DeleteEventCategory deletes a event category
*/
func (a *Client) DeleteEventCategory(params *DeleteEventCategoryParams, opts ...ClientOption) (*DeleteEventCategoryNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteEventCategoryParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "deleteEventCategory",
		Method:             "DELETE",
		PathPattern:        "/eventcategorys",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DeleteEventCategoryReader{formats: a.formats},
		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.(*DeleteEventCategoryNoContent)
	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 deleteEventCategory: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
DeleteEventCategoryAssignment deletes a event category assignment
*/
func (a *Client) DeleteEventCategoryAssignment(params *DeleteEventCategoryAssignmentParams, opts ...ClientOption) (*DeleteEventCategoryAssignmentNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteEventCategoryAssignmentParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "deleteEventCategoryAssignment",
		Method:             "DELETE",
		PathPattern:        "/eventcategoryassignments",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DeleteEventCategoryAssignmentReader{formats: a.formats},
		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.(*DeleteEventCategoryAssignmentNoContent)
	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 deleteEventCategoryAssignment: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
DeleteFavorite deletes a favorite
*/
func (a *Client) DeleteFavorite(params *DeleteFavoriteParams, opts ...ClientOption) (*DeleteFavoriteNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteFavoriteParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "deleteFavorite",
		Method:             "DELETE",
		PathPattern:        "/favorites",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DeleteFavoriteReader{formats: a.formats},
		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.(*DeleteFavoriteNoContent)
	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 deleteFavorite: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
DeleteInvoice deletes a invoice
*/
func (a *Client) DeleteInvoice(params *DeleteInvoiceParams, opts ...ClientOption) (*DeleteInvoiceNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteInvoiceParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "deleteInvoice",
		Method:             "DELETE",
		PathPattern:        "/invoices",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DeleteInvoiceReader{formats: a.formats},
		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.(*DeleteInvoiceNoContent)
	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 deleteInvoice: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
DeleteIssuedCertificate deletes a issued certificate
*/
func (a *Client) DeleteIssuedCertificate(params *DeleteIssuedCertificateParams, opts ...ClientOption) (*DeleteIssuedCertificateNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteIssuedCertificateParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "deleteIssuedCertificate",
		Method:             "DELETE",
		PathPattern:        "/issuedcertificates",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DeleteIssuedCertificateReader{formats: a.formats},
		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.(*DeleteIssuedCertificateNoContent)
	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 deleteIssuedCertificate: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
DeleteLessonProgress deletes a lesson progress
*/
func (a *Client) DeleteLessonProgress(params *DeleteLessonProgressParams, opts ...ClientOption) (*DeleteLessonProgressNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteLessonProgressParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "deleteLessonProgress",
		Method:             "DELETE",
		PathPattern:        "/lessonprogress",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DeleteLessonProgressReader{formats: a.formats},
		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.(*DeleteLessonProgressNoContent)
	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 deleteLessonProgress: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
DeleteOrder deletes a order
*/
func (a *Client) DeleteOrder(params *DeleteOrderParams, opts ...ClientOption) (*DeleteOrderNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteOrderParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "deleteOrder",
		Method:             "DELETE",
		PathPattern:        "/orders",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DeleteOrderReader{formats: a.formats},
		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.(*DeleteOrderNoContent)
	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 deleteOrder: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
DeletePaymentMethod deletes a payment method
*/
func (a *Client) DeletePaymentMethod(params *DeletePaymentMethodParams, opts ...ClientOption) (*DeletePaymentMethodNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeletePaymentMethodParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "deletePaymentMethod",
		Method:             "DELETE",
		PathPattern:        "/paymentmethods",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DeletePaymentMethodReader{formats: a.formats},
		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.(*DeletePaymentMethodNoContent)
	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 deletePaymentMethod: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
DeleteResearchProject deletes a research project
*/
func (a *Client) DeleteResearchProject(params *DeleteResearchProjectParams, opts ...ClientOption) (*DeleteResearchProjectNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteResearchProjectParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "deleteResearchProject",
		Method:             "DELETE",
		PathPattern:        "/researchprojects",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DeleteResearchProjectReader{formats: a.formats},
		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.(*DeleteResearchProjectNoContent)
	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 deleteResearchProject: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
DeleteResearchProjectCompany deletes a research project company
*/
func (a *Client) DeleteResearchProjectCompany(params *DeleteResearchProjectCompanyParams, opts ...ClientOption) (*DeleteResearchProjectCompanyNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteResearchProjectCompanyParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "deleteResearchProjectCompany",
		Method:             "DELETE",
		PathPattern:        "/researchprojectcompanys",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DeleteResearchProjectCompanyReader{formats: a.formats},
		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.(*DeleteResearchProjectCompanyNoContent)
	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 deleteResearchProjectCompany: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
DeleteResearchProjectTopic deletes a research project topic
*/
func (a *Client) DeleteResearchProjectTopic(params *DeleteResearchProjectTopicParams, opts ...ClientOption) (*DeleteResearchProjectTopicNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteResearchProjectTopicParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "deleteResearchProjectTopic",
		Method:             "DELETE",
		PathPattern:        "/researchprojecttopics",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DeleteResearchProjectTopicReader{formats: a.formats},
		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.(*DeleteResearchProjectTopicNoContent)
	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 deleteResearchProjectTopic: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
DeleteTicket deletes a ticket
*/
func (a *Client) DeleteTicket(params *DeleteTicketParams, opts ...ClientOption) (*DeleteTicketNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteTicketParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "deleteTicket",
		Method:             "DELETE",
		PathPattern:        "/tickets",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DeleteTicketReader{formats: a.formats},
		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.(*DeleteTicketNoContent)
	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 deleteTicket: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
DeleteTransaction deletes a transaction
*/
func (a *Client) DeleteTransaction(params *DeleteTransactionParams, opts ...ClientOption) (*DeleteTransactionNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteTransactionParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "deleteTransaction",
		Method:             "DELETE",
		PathPattern:        "/transactions",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DeleteTransactionReader{formats: a.formats},
		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.(*DeleteTransactionNoContent)
	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 deleteTransaction: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetAttendees gets a list of attendees
*/
func (a *Client) GetAttendees(params *GetAttendeesParams, opts ...ClientOption) (*GetAttendeesOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetAttendeesParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getAttendees",
		Method:             "GET",
		PathPattern:        "/attendees",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetAttendeesReader{formats: a.formats},
		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.(*GetAttendeesOK)
	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 getAttendees: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetCertificates gets a list of certificates
*/
func (a *Client) GetCertificates(params *GetCertificatesParams, opts ...ClientOption) (*GetCertificatesOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetCertificatesParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getCertificates",
		Method:             "GET",
		PathPattern:        "/certificates",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetCertificatesReader{formats: a.formats},
		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.(*GetCertificatesOK)
	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 getCertificates: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetCourseLessons gets a list of course lessons
*/
func (a *Client) GetCourseLessons(params *GetCourseLessonsParams, opts ...ClientOption) (*GetCourseLessonsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetCourseLessonsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getCourseLessons",
		Method:             "GET",
		PathPattern:        "/courselessons",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetCourseLessonsReader{formats: a.formats},
		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.(*GetCourseLessonsOK)
	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 getCourseLessons: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetCourseSections gets a list of course sections
*/
func (a *Client) GetCourseSections(params *GetCourseSectionsParams, opts ...ClientOption) (*GetCourseSectionsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetCourseSectionsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getCourseSections",
		Method:             "GET",
		PathPattern:        "/coursesections",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetCourseSectionsReader{formats: a.formats},
		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.(*GetCourseSectionsOK)
	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 getCourseSections: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetCourses gets a list of courses
*/
func (a *Client) GetCourses(params *GetCoursesParams, opts ...ClientOption) (*GetCoursesOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetCoursesParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getCourses",
		Method:             "GET",
		PathPattern:        "/courses",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetCoursesReader{formats: a.formats},
		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.(*GetCoursesOK)
	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 getCourses: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetEnrollments gets a list of enrollments
*/
func (a *Client) GetEnrollments(params *GetEnrollmentsParams, opts ...ClientOption) (*GetEnrollmentsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetEnrollmentsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getEnrollments",
		Method:             "GET",
		PathPattern:        "/enrollments",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetEnrollmentsReader{formats: a.formats},
		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.(*GetEnrollmentsOK)
	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 getEnrollments: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetEventCategoryassignments gets a list of event categoryassignments
*/
func (a *Client) GetEventCategoryassignments(params *GetEventCategoryassignmentsParams, opts ...ClientOption) (*GetEventCategoryassignmentsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetEventCategoryassignmentsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getEventCategoryassignments",
		Method:             "GET",
		PathPattern:        "/eventcategoryassignments",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetEventCategoryassignmentsReader{formats: a.formats},
		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.(*GetEventCategoryassignmentsOK)
	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 getEventCategoryassignments: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetEventCategorys gets a list of event categorys
*/
func (a *Client) GetEventCategorys(params *GetEventCategorysParams, opts ...ClientOption) (*GetEventCategorysOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetEventCategorysParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getEventCategorys",
		Method:             "GET",
		PathPattern:        "/eventcategorys",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetEventCategorysReader{formats: a.formats},
		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.(*GetEventCategorysOK)
	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 getEventCategorys: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetEvents gets a list of events
*/
func (a *Client) GetEvents(params *GetEventsParams, opts ...ClientOption) (*GetEventsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetEventsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getEvents",
		Method:             "GET",
		PathPattern:        "/events",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetEventsReader{formats: a.formats},
		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.(*GetEventsOK)
	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 getEvents: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetFavorites gets a list of favorites
*/
func (a *Client) GetFavorites(params *GetFavoritesParams, opts ...ClientOption) (*GetFavoritesOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetFavoritesParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getFavorites",
		Method:             "GET",
		PathPattern:        "/favorites",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetFavoritesReader{formats: a.formats},
		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.(*GetFavoritesOK)
	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 getFavorites: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetInvoices gets a list of invoices
*/
func (a *Client) GetInvoices(params *GetInvoicesParams, opts ...ClientOption) (*GetInvoicesOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetInvoicesParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getInvoices",
		Method:             "GET",
		PathPattern:        "/invoices",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetInvoicesReader{formats: a.formats},
		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.(*GetInvoicesOK)
	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 getInvoices: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetIssuedcertificates gets a list of issuedcertificates
*/
func (a *Client) GetIssuedcertificates(params *GetIssuedcertificatesParams, opts ...ClientOption) (*GetIssuedcertificatesOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetIssuedcertificatesParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getIssuedcertificates",
		Method:             "GET",
		PathPattern:        "/issuedcertificates",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetIssuedcertificatesReader{formats: a.formats},
		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.(*GetIssuedcertificatesOK)
	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 getIssuedcertificates: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetLessonProgress gets a list of lesson progress
*/
func (a *Client) GetLessonProgress(params *GetLessonProgressParams, opts ...ClientOption) (*GetLessonProgressOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetLessonProgressParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getLessonProgress",
		Method:             "GET",
		PathPattern:        "/lessonprogress",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetLessonProgressReader{formats: a.formats},
		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.(*GetLessonProgressOK)
	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 getLessonProgress: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetOrders gets a list of orders
*/
func (a *Client) GetOrders(params *GetOrdersParams, opts ...ClientOption) (*GetOrdersOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetOrdersParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getOrders",
		Method:             "GET",
		PathPattern:        "/orders",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetOrdersReader{formats: a.formats},
		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.(*GetOrdersOK)
	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 getOrders: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetPaymentMethods gets a list of payment methods
*/
func (a *Client) GetPaymentMethods(params *GetPaymentMethodsParams, opts ...ClientOption) (*GetPaymentMethodsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetPaymentMethodsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getPaymentMethods",
		Method:             "GET",
		PathPattern:        "/paymentmethods",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetPaymentMethodsReader{formats: a.formats},
		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.(*GetPaymentMethodsOK)
	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 getPaymentMethods: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetResearchProjectCompanys gets a list of research project companys
*/
func (a *Client) GetResearchProjectCompanys(params *GetResearchProjectCompanysParams, opts ...ClientOption) (*GetResearchProjectCompanysOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetResearchProjectCompanysParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getResearchProjectCompanys",
		Method:             "GET",
		PathPattern:        "/researchprojectcompanys",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetResearchProjectCompanysReader{formats: a.formats},
		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.(*GetResearchProjectCompanysOK)
	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 getResearchProjectCompanys: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetResearchProjectTopics gets a list of research project topics
*/
func (a *Client) GetResearchProjectTopics(params *GetResearchProjectTopicsParams, opts ...ClientOption) (*GetResearchProjectTopicsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetResearchProjectTopicsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getResearchProjectTopics",
		Method:             "GET",
		PathPattern:        "/researchprojecttopics",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetResearchProjectTopicsReader{formats: a.formats},
		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.(*GetResearchProjectTopicsOK)
	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 getResearchProjectTopics: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetResearchProjects gets a list of research projects
*/
func (a *Client) GetResearchProjects(params *GetResearchProjectsParams, opts ...ClientOption) (*GetResearchProjectsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetResearchProjectsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getResearchProjects",
		Method:             "GET",
		PathPattern:        "/researchprojects",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetResearchProjectsReader{formats: a.formats},
		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.(*GetResearchProjectsOK)
	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 getResearchProjects: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetTickets gets a list of tickets
*/
func (a *Client) GetTickets(params *GetTicketsParams, opts ...ClientOption) (*GetTicketsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetTicketsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getTickets",
		Method:             "GET",
		PathPattern:        "/tickets",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetTicketsReader{formats: a.formats},
		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.(*GetTicketsOK)
	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 getTickets: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetTransactions gets a list of transactions
*/
func (a *Client) GetTransactions(params *GetTransactionsParams, opts ...ClientOption) (*GetTransactionsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetTransactionsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getTransactions",
		Method:             "GET",
		PathPattern:        "/transactions",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetTransactionsReader{formats: a.formats},
		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.(*GetTransactionsOK)
	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 getTransactions: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateAttendee updates an existing attendee
*/
func (a *Client) UpdateAttendee(params *UpdateAttendeeParams, opts ...ClientOption) (*UpdateAttendeeOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateAttendeeParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateAttendee",
		Method:             "PUT",
		PathPattern:        "/attendees",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &UpdateAttendeeReader{formats: a.formats},
		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.(*UpdateAttendeeOK)
	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 updateAttendee: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateCertificate updates an existing certificate
*/
func (a *Client) UpdateCertificate(params *UpdateCertificateParams, opts ...ClientOption) (*UpdateCertificateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateCertificateParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateCertificate",
		Method:             "PUT",
		PathPattern:        "/certificates",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &UpdateCertificateReader{formats: a.formats},
		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.(*UpdateCertificateOK)
	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 updateCertificate: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateCourse updates an existing course
*/
func (a *Client) UpdateCourse(params *UpdateCourseParams, opts ...ClientOption) (*UpdateCourseOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateCourseParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateCourse",
		Method:             "PUT",
		PathPattern:        "/courses",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &UpdateCourseReader{formats: a.formats},
		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.(*UpdateCourseOK)
	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 updateCourse: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateCourseLesson updates an existing course lesson
*/
func (a *Client) UpdateCourseLesson(params *UpdateCourseLessonParams, opts ...ClientOption) (*UpdateCourseLessonOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateCourseLessonParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateCourseLesson",
		Method:             "PUT",
		PathPattern:        "/courselessons",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &UpdateCourseLessonReader{formats: a.formats},
		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.(*UpdateCourseLessonOK)
	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 updateCourseLesson: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateCourseSection updates an existing course section
*/
func (a *Client) UpdateCourseSection(params *UpdateCourseSectionParams, opts ...ClientOption) (*UpdateCourseSectionOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateCourseSectionParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateCourseSection",
		Method:             "PUT",
		PathPattern:        "/coursesections",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &UpdateCourseSectionReader{formats: a.formats},
		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.(*UpdateCourseSectionOK)
	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 updateCourseSection: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateEnrollment updates an existing enrollment
*/
func (a *Client) UpdateEnrollment(params *UpdateEnrollmentParams, opts ...ClientOption) (*UpdateEnrollmentOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateEnrollmentParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateEnrollment",
		Method:             "PUT",
		PathPattern:        "/enrollments",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &UpdateEnrollmentReader{formats: a.formats},
		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.(*UpdateEnrollmentOK)
	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 updateEnrollment: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateEvent updates an existing event
*/
func (a *Client) UpdateEvent(params *UpdateEventParams, opts ...ClientOption) (*UpdateEventOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateEventParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateEvent",
		Method:             "PUT",
		PathPattern:        "/events",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &UpdateEventReader{formats: a.formats},
		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.(*UpdateEventOK)
	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 updateEvent: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateEventCategory updates an existing event category
*/
func (a *Client) UpdateEventCategory(params *UpdateEventCategoryParams, opts ...ClientOption) (*UpdateEventCategoryOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateEventCategoryParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateEventCategory",
		Method:             "PUT",
		PathPattern:        "/eventcategorys",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &UpdateEventCategoryReader{formats: a.formats},
		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.(*UpdateEventCategoryOK)
	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 updateEventCategory: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateEventCategoryAssignment updates an existing event category assignment
*/
func (a *Client) UpdateEventCategoryAssignment(params *UpdateEventCategoryAssignmentParams, opts ...ClientOption) (*UpdateEventCategoryAssignmentOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateEventCategoryAssignmentParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateEventCategoryAssignment",
		Method:             "PUT",
		PathPattern:        "/eventcategoryassignments",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &UpdateEventCategoryAssignmentReader{formats: a.formats},
		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.(*UpdateEventCategoryAssignmentOK)
	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 updateEventCategoryAssignment: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateFavorite updates an existing favorite
*/
func (a *Client) UpdateFavorite(params *UpdateFavoriteParams, opts ...ClientOption) (*UpdateFavoriteOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateFavoriteParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateFavorite",
		Method:             "PUT",
		PathPattern:        "/favorites",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &UpdateFavoriteReader{formats: a.formats},
		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.(*UpdateFavoriteOK)
	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 updateFavorite: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateInvoice updates an existing invoice
*/
func (a *Client) UpdateInvoice(params *UpdateInvoiceParams, opts ...ClientOption) (*UpdateInvoiceOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateInvoiceParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateInvoice",
		Method:             "PUT",
		PathPattern:        "/invoices",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &UpdateInvoiceReader{formats: a.formats},
		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.(*UpdateInvoiceOK)
	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 updateInvoice: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateIssuedCertificate updates an existing issued certificate
*/
func (a *Client) UpdateIssuedCertificate(params *UpdateIssuedCertificateParams, opts ...ClientOption) (*UpdateIssuedCertificateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateIssuedCertificateParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateIssuedCertificate",
		Method:             "PUT",
		PathPattern:        "/issuedcertificates",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &UpdateIssuedCertificateReader{formats: a.formats},
		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.(*UpdateIssuedCertificateOK)
	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 updateIssuedCertificate: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateLessonProgress updates an existing lesson progress
*/
func (a *Client) UpdateLessonProgress(params *UpdateLessonProgressParams, opts ...ClientOption) (*UpdateLessonProgressOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateLessonProgressParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateLessonProgress",
		Method:             "PUT",
		PathPattern:        "/lessonprogress",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &UpdateLessonProgressReader{formats: a.formats},
		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.(*UpdateLessonProgressOK)
	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 updateLessonProgress: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateOrder updates an existing order
*/
func (a *Client) UpdateOrder(params *UpdateOrderParams, opts ...ClientOption) (*UpdateOrderOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateOrderParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateOrder",
		Method:             "PUT",
		PathPattern:        "/orders",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &UpdateOrderReader{formats: a.formats},
		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.(*UpdateOrderOK)
	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 updateOrder: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdatePaymentMethod updates an existing payment method
*/
func (a *Client) UpdatePaymentMethod(params *UpdatePaymentMethodParams, opts ...ClientOption) (*UpdatePaymentMethodOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdatePaymentMethodParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "updatePaymentMethod",
		Method:             "PUT",
		PathPattern:        "/paymentmethods",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &UpdatePaymentMethodReader{formats: a.formats},
		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.(*UpdatePaymentMethodOK)
	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 updatePaymentMethod: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateResearchProject updates an existing research project
*/
func (a *Client) UpdateResearchProject(params *UpdateResearchProjectParams, opts ...ClientOption) (*UpdateResearchProjectOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateResearchProjectParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateResearchProject",
		Method:             "PUT",
		PathPattern:        "/researchprojects",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &UpdateResearchProjectReader{formats: a.formats},
		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.(*UpdateResearchProjectOK)
	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 updateResearchProject: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateResearchProjectCompany updates an existing research project company
*/
func (a *Client) UpdateResearchProjectCompany(params *UpdateResearchProjectCompanyParams, opts ...ClientOption) (*UpdateResearchProjectCompanyOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateResearchProjectCompanyParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateResearchProjectCompany",
		Method:             "PUT",
		PathPattern:        "/researchprojectcompanys",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &UpdateResearchProjectCompanyReader{formats: a.formats},
		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.(*UpdateResearchProjectCompanyOK)
	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 updateResearchProjectCompany: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateResearchProjectTopic updates an existing research project topic
*/
func (a *Client) UpdateResearchProjectTopic(params *UpdateResearchProjectTopicParams, opts ...ClientOption) (*UpdateResearchProjectTopicOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateResearchProjectTopicParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateResearchProjectTopic",
		Method:             "PUT",
		PathPattern:        "/researchprojecttopics",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &UpdateResearchProjectTopicReader{formats: a.formats},
		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.(*UpdateResearchProjectTopicOK)
	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 updateResearchProjectTopic: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateTicket updates an existing ticket
*/
func (a *Client) UpdateTicket(params *UpdateTicketParams, opts ...ClientOption) (*UpdateTicketOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateTicketParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateTicket",
		Method:             "PUT",
		PathPattern:        "/tickets",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &UpdateTicketReader{formats: a.formats},
		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.(*UpdateTicketOK)
	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 updateTicket: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateTransaction updates an existing transaction
*/
func (a *Client) UpdateTransaction(params *UpdateTransactionParams, opts ...ClientOption) (*UpdateTransactionOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateTransactionParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateTransaction",
		Method:             "PUT",
		PathPattern:        "/transactions",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &UpdateTransactionReader{formats: a.formats},
		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.(*UpdateTransactionOK)
	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 updateTransaction: 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
}