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

3244 lines
111 KiB
Go
Raw Normal View History

2023-03-28 17:47:34 +00:00
// 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
}